diff --git a/addons/account/static/src/components/account_move_form/account_move_form.js b/addons/account/static/src/components/account_move_form/account_move_form.js
index d0189f65f20..b6c12f81881 100644
--- a/addons/account/static/src/components/account_move_form/account_move_form.js
+++ b/addons/account/static/src/components/account_move_form/account_move_form.js
@@ -37,7 +37,7 @@ AccountMoveFormNotebook.props = {
 }
 export class AccountMoveFormRenderer extends FormRenderer {
     async saveBeforeTabChange() {
-        if (this.props.record.mode === "edit" && this.props.record.isDirty) {
+        if (this.props.record.mode === "edit" && await this.props.record.isDirty()) {
             const contentEl = document.querySelector('.o_content');
             const scrollPos = contentEl.scrollTop;
             await this.props.record.save({
diff --git a/addons/account/static/src/components/account_payment_field/account_payment_field.js b/addons/account/static/src/components/account_payment_field/account_payment_field.js
index 5da2d3b00d9..f356c6bd599 100644
--- a/addons/account/static/src/components/account_payment_field/account_payment_field.js
+++ b/addons/account/static/src/components/account_payment_field/account_payment_field.js
@@ -35,7 +35,7 @@ export class AccountPaymentField extends Component {
             content: [],
             outstanding: false,
             title: "",
-            move_id: this.props.record.data.id,
+            move_id: this.props.record.resId,
         };
         for (let [key, value] of Object.entries(info.content)) {
             value.index = key;
diff --git a/addons/account/static/src/components/mail_attachments/mail_attachments.js b/addons/account/static/src/components/mail_attachments/mail_attachments.js
index a8d46ac5c56..3e68a8f0111 100644
--- a/addons/account/static/src/components/mail_attachments/mail_attachments.js
+++ b/addons/account/static/src/components/mail_attachments/mail_attachments.js
@@ -64,7 +64,7 @@ export class MailAttachments extends Component {
 
     async onWillUnmount(){
         // Unlink added attachments if the wizard is not saved.
-        if(!this.props.record.data.id){
+        if(!this.props.record.resId){
             this.getValue().forEach((item) => {
                 if(item.manual){
                     this.attachmentIdsToUnlink.add(item.id);
diff --git a/addons/account/static/src/components/tax_totals/tax_totals.js b/addons/account/static/src/components/tax_totals/tax_totals.js
index 282ecb60891..1072dd5277f 100644
--- a/addons/account/static/src/components/tax_totals/tax_totals.js
+++ b/addons/account/static/src/components/tax_totals/tax_totals.js
@@ -6,7 +6,7 @@ import { standardFieldProps } from "@web/views/fields/standard_field_props";
 import { registry } from "@web/core/registry";
 import { getCurrency } from "@web/core/currency";
 
-const { Component, onPatched, onWillUpdateProps, useRef, useState } = owl;
+const { Component, onPatched, onWillUpdateProps, onWillRender, toRaw, useRef, useState } = owl;
 
 /**
  A line of some TaxTotalsComponent, giving the values of a tax group.
@@ -108,9 +108,7 @@ export class TaxTotalsComponent extends Component {
     setup() {
         this.totals = {};
         this.formatData(this.props);
-        onWillUpdateProps((nextProps) => {
-            this.formatData(nextProps);
-        });
+        onWillRender(() => this.formatData(this.props));
     }
 
     get readonly() {
@@ -143,7 +141,7 @@ export class TaxTotalsComponent extends Component {
     }
 
     formatData(props) {
-        let totals = JSON.parse(JSON.stringify(props.record.data[this.props.name]));
+        let totals = JSON.parse(JSON.stringify(toRaw(props.record.data[this.props.name])));
         const currencyFmtOpts = { currencyId: props.record.data.currency_id && props.record.data.currency_id[0] };
 
         let amount_untaxed = totals.amount_untaxed;
diff --git a/addons/analytic/static/src/components/analytic_distribution/analytic_distribution.js b/addons/analytic/static/src/components/analytic_distribution/analytic_distribution.js
index a140b66fde3..51822ebb110 100644
--- a/addons/analytic/static/src/components/analytic_distribution/analytic_distribution.js
+++ b/addons/analytic/static/src/components/analytic_distribution/analytic_distribution.js
@@ -10,6 +10,7 @@ import { shallowEqual } from "@web/core/utils/arrays";
 import { sprintf } from "@web/core/utils/strings";
 import { _lt } from "@web/core/l10n/translation";
 import { AutoComplete } from "@web/core/autocomplete/autocomplete";
+import { useRecordObserver } from "@web/model/relational_model/utils";
 
 import { standardFieldProps } from "@web/views/fields/standard_field_props";
 import { TagsList } from "@web/core/tags_list/tags_list";
@@ -18,7 +19,7 @@ import { parseFloat as oParseFloat } from "@web/views/fields/parsers";
 import { formatPercentage } from "@web/views/fields/formatters";
 import { SelectCreateDialog } from "@web/views/view_dialogs/select_create_dialog";
 
-const { Component, useState, useRef, useExternalListener, onWillUpdateProps, onWillStart, onPatched } = owl;
+const { Component, useState, useRef, useExternalListener, onWillStart, onPatched } = owl;
 
 const PLAN_APPLICABILITY = {
     mandatory: _lt("Mandatory"),
@@ -50,7 +51,7 @@ export class AnalyticDistribution extends Component {
         this.currentValue = this.props.record.data[this.props.name];
 
         onWillStart(this.willStart);
-        onWillUpdateProps(this.willUpdate);
+        useRecordObserver(this.willUpdateRecord.bind(this));
         onPatched(this.patched);
 
         useExternalListener(window, "click", this.onWindowClick, true);
@@ -83,43 +84,44 @@ export class AnalyticDistribution extends Component {
     // Lifecycle
     async willStart() {
         if (this.editingRecord) {
-            await this.fetchAllPlans(this.props);
+            await this.fetchAllPlans();
         }
-        await this.formatData(this.props);
+        await this.formatData();
     }
 
-    async willUpdate(nextProps) {
+    async willUpdateRecord(record) {
         // Unless force_applicability, Plans need to be retrieved again as the product or account might have changed
         // and thus different applicabilities apply
         // or a model applies that contains unavailable plans
         // This should only execute when these fields have changed, therefore we use the `_field` props.
         const valueChanged =
             JSON.stringify(this.currentValue) !==
-            JSON.stringify(nextProps.record.data[nextProps.name]);
-        const currentAccount = this.props.account_field && this.props.record.data[this.props.account_field] || false;
-        const currentProduct = this.props.product_field && this.props.record.data[this.props.product_field] || false;
+            JSON.stringify(record.data[this.props.name]);
+        const currentAccount = this.props.account_field && record.data[this.props.account_field] || false;
+        const currentProduct = this.props.product_field && record.data[this.props.product_field] || false;
         const accountChanged = !shallowEqual(this.lastAccount, currentAccount);
         const productChanged = !shallowEqual(this.lastProduct, currentProduct);
         if (valueChanged || accountChanged || productChanged) {
             if (!this.props.force_applicability) {
-                await this.fetchAllPlans(nextProps);
+                await this.fetchAllPlans();
             }
             this.lastAccount = accountChanged && currentAccount || this.lastAccount;
             this.lastProduct = productChanged && currentProduct || this.lastProduct;
-            await this.formatData(nextProps);
+            await this.formatData();
         }
-        this.currentValue = nextProps.record.data[nextProps.name];
+        this.currentValue = record.data[this.props.name];
     }
 
     patched() {
         this.focusToSelector();
     }
 
-    async formatData(nextProps) {
-        const data = nextProps.record.data[nextProps.name];
+    async formatData() {
+        const { record, name } = this.props;
+        const data = record.data[name];
         const analytic_account_ids = Object.keys(data).map((id) => parseInt(id));
         const records = analytic_account_ids.length ? await this.fetchAnalyticAccounts([["id", "in", analytic_account_ids]]) : [];
-        let widgetData = Object.assign({}, ...this.allPlans.map((plan) => ({[plan.id]: {...plan, distribution: []}})));
+        const widgetData = Object.assign({}, ...this.allPlans.map((plan) => ({ [plan.id]: { ...plan, distribution: [] } })));
         records.map((record) => {
             if (!widgetData[record.root_plan_id[0]]) {
                 // plans might not have been retrieved
@@ -144,36 +146,37 @@ export class AnalyticDistribution extends Component {
     }
 
     // ORM
-    fetchPlansArgs(nextProps) {
+    fetchPlansArgs() {
+        const { record, name } = this.props;
         let args = {};
         if (this.props.business_domain_compute) {
-            args['business_domain'] = evaluateExpr(this.props.business_domain_compute, this.props.record.evalContext);
+            args['business_domain'] = evaluateExpr(this.props.business_domain_compute, record.evalContext);
         }
         if (this.props.business_domain) {
             args['business_domain'] = this.props.business_domain;
         }
-        if (this.props.product_field && this.props.record.data[this.props.product_field]) {
-            args['product'] = this.props.record.data[this.props.product_field][0];
+        if (this.props.product_field && record.data[this.props.product_field]) {
+            args['product'] = record.data[this.props.product_field][0];
         }
-        if (this.props.account_field && this.props.record.data[this.props.account_field]) {
-            args['account'] = this.props.record.data[this.props.account_field][0];
+        if (this.props.account_field && record.data[this.props.account_field]) {
+            args['account'] = record.data[this.props.account_field][0];
         }
         if (this.props.force_applicability) {
             args['applicability'] = this.props.force_applicability;
         }
-        const existing_account_ids = Object.keys(nextProps.record.data[nextProps.name]).map((i) => parseInt(i));
+        const existing_account_ids = Object.keys(record.data[name]).map((i) => parseInt(i));
         if (existing_account_ids.length) {
             args['existing_account_ids'] = existing_account_ids;
         }
-        if (this.props.record.data.company_id) {
-            args['company_id'] = this.props.record.data.company_id[0];
+        if (record.data.company_id) {
+            args['company_id'] = record.data.company_id[0];
         }
         return args;
     }
 
-    async fetchAllPlans(nextProps) {
+    async fetchAllPlans() {
         // TODO: Optimize to execute once for all records when `force_applicability` is set
-        const argsPlan =  this.fetchPlansArgs(nextProps);
+        const argsPlan = this.fetchPlansArgs();
         this.allPlans = await this.orm.call("account.analytic.plan", "get_relevant_plans", [], argsPlan);
     }
 
@@ -530,8 +533,8 @@ export class AnalyticDistribution extends Component {
 
     async openAnalyticEditor() {
         if (!this.allPlans.length) {
-            await this.fetchAllPlans(this.props);
-            await this.formatData(this.props);
+            await this.fetchAllPlans();
+            await this.formatData();
         }
         this.autoFill();
         const incompletePlan = this.firstIncompletePlanId;
diff --git a/addons/analytic/static/tests/analytic_distribution_tests.js b/addons/analytic/static/tests/analytic_distribution_tests.js
index 54ac36a70d2..46f7ad38b21 100644
--- a/addons/analytic/static/tests/analytic_distribution_tests.js
+++ b/addons/analytic/static/tests/analytic_distribution_tests.js
@@ -74,6 +74,7 @@ QUnit.module("Analytic", (hooks) => {
                         amount: { string: "Amount", type: "float" },
                         analytic_distribution: { string: "Analytic", type: "json" },
                         move_id: { string: "Account Move", type: "many2one", relation: "move" },
+                        analytic_precision: { string: "Analytic Precision", type: "integer" },
                     },
                     records: [
                         { id: 1, label: "Developer Time", amount: 100.00, analytic_distribution: {"1": 30.3, "3": 69.7}},
@@ -140,7 +141,7 @@ QUnit.module("Analytic", (hooks) => {
                         </group>
                     </sheet>
                 </form>`,
-            mockRPC(route, { kwargs, method, model }) {
+            mockRPC(route, { method, model }) {
                 if (method === "get_relevant_plans" && model === "account.analytic.plan") {
                     return Promise.resolve(
                         serverData.models['plan'].records.filter((r) => !r.parent_id && r.applicability !== "unavailable")
@@ -333,6 +334,7 @@ QUnit.module("Analytic", (hooks) => {
         // apply the changes to both move lines
         triggerHotkey("Escape");
         await nextTick();
+        await nextTick();
         await click(target.querySelector(".modal-dialog .btn-primary"));
         assert.containsN(target, ".badge", 10, "should contain 2 rows of 5 tags each");
 
diff --git a/addons/auth_totp/wizard/auth_totp_wizard_views.xml b/addons/auth_totp/wizard/auth_totp_wizard_views.xml
index 76b967acf21..2c11bb26bdc 100644
--- a/addons/auth_totp/wizard/auth_totp_wizard_views.xml
+++ b/addons/auth_totp/wizard/auth_totp_wizard_views.xml
@@ -40,7 +40,7 @@
 
                             <!-- Desktop version -->
                             <div class="text-center d-none d-md-block">
-                                <field name="qrcode" readonly="True" widget="image"/>
+                                <field name="qrcode" readonly="True" widget="image" options="{'no_reload': true }"/>
 
                                 <h3 class="fw-bold"><a data-bs-toggle="collapse"
                                    href="#collapseTotpSecret" role="button" aria-expanded="false"
diff --git a/addons/barcodes/static/tests/basic/float_scannable_field_test.js b/addons/barcodes/static/tests/basic/float_scannable_field_test.js
index 403a994883d..200899074f5 100644
--- a/addons/barcodes/static/tests/basic/float_scannable_field_test.js
+++ b/addons/barcodes/static/tests/basic/float_scannable_field_test.js
@@ -119,15 +119,15 @@ QUnit.module("Fields", (hooks) => {
                 </form>
             `,
             mockRPC(_route, args) {
-                if (args.method === "read") {
-                    assert.step("read");
+                if (args.method === "web_read") {
+                    assert.step("web_read");
                 }
             },
             resId: 1,
             resIds: [1, 2],
         });
 
-        assert.verifySteps(["read"], "update should not have been called yet");
+        assert.verifySteps(["web_read"], "update should not have been called yet");
 
         // switch to next record
         simulateBarCode(
@@ -137,6 +137,6 @@ QUnit.module("Fields", (hooks) => {
         await nextTick();
         // a first update is done to reload the data (thus followed by a read), but
         // update shouldn't be called afterwards
-        assert.verifySteps(["update", "read"]);
+        assert.verifySteps(["update", "web_read"]);
     });
 });
diff --git a/addons/board/static/tests/board_test.js b/addons/board/static/tests/board_test.js
index 6dc805a20aa..b3296d94aae 100644
--- a/addons/board/static/tests/board_test.js
+++ b/addons/board/static/tests/board_test.js
@@ -101,15 +101,15 @@ QUnit.module("Board", (hooks) => {
                         </column>
                     </board>
                 </form>`,
-            mockRPC(route, args) {
+            async mockRPC(route, args) {
                 if (route === "/web/action/load") {
                     assert.step("load action");
-                    return Promise.resolve({
+                    return {
                         res_model: "partner",
                         views: [[4, "list"]],
-                    });
+                    };
                 }
-                if (route === "/web/dataset/call_kw/partner/web_search_read") {
+                if (route === "/web/dataset/call_kw/partner/unity_web_search_read") {
                     assert.deepEqual(
                         args.kwargs.domain,
                         [["foo", "!=", "False"]],
@@ -128,7 +128,7 @@ QUnit.module("Board", (hooks) => {
                 }
                 if (route === "/web/view/edit_custom") {
                     assert.step("edit custom");
-                    return Promise.resolve(true);
+                    return true;
                 }
                 if (args.method === "get_views" && args.model == "partner") {
                     assert.deepEqual(
diff --git a/addons/calendar/models/res_partner.py b/addons/calendar/models/res_partner.py
index 692a1689521..b0fa9f2e737 100644
--- a/addons/calendar/models/res_partner.py
+++ b/addons/calendar/models/res_partner.py
@@ -58,7 +58,7 @@ class Partner(models.Model):
     def get_attendee_detail(self, meeting_ids):
         """ Return a list of dict of the given meetings with the attendees details
             Used by:
-                - base_calendar.js : Many2ManyAttendee
+                - many2many_attendee.js: Many2ManyAttendee
                 - calendar_model.js (calendar.CalendarModel)
         """
         attendees_details = []
diff --git a/addons/calendar/static/src/js/base_calendar.js b/addons/calendar/static/src/js/base_calendar.js
deleted file mode 100644
index 7408e97ac17..00000000000
--- a/addons/calendar/static/src/js/base_calendar.js
+++ /dev/null
@@ -1,25 +0,0 @@
-/** @odoo-module **/
-
-import BasicModel from 'web.BasicModel';
-
-BasicModel.include({
-    /**
-     * @private
-     * @param {Object} record
-     * @param {string} fieldName
-     * @returns {Promise}
-     */
-    _fetchSpecialAttendeeStatus: function (record, fieldName) {
-        var context = record.getContext({fieldName: fieldName});
-        var attendeeIDs = record.data[fieldName] ? this.localData[record.data[fieldName]].res_ids : [];
-        var meetingID = Number.isFinite(record.res_id) ? record.res_id : false;
-        return this._rpc({
-            model: 'res.partner',
-            method: 'get_attendee_detail',
-            args: [attendeeIDs, [meetingID]],
-            context: context,
-        }).then(function (result) {
-            return result;
-        });
-    },
-});
diff --git a/addons/calendar/static/src/views/calendar_form/calendar_quick_create.js b/addons/calendar/static/src/views/calendar_form/calendar_quick_create.js
index 0fda6d3b87f..74c1747f957 100644
--- a/addons/calendar/static/src/views/calendar_form/calendar_quick_create.js
+++ b/addons/calendar/static/src/views/calendar_form/calendar_quick_create.js
@@ -25,7 +25,7 @@ function getDefaultValuesFromRecord(data) {
             let value = data[fieldName];
             const { type } = QUICK_CREATE_CALENDAR_EVENT_FIELDS[fieldName]
             if (type === 'many2many') {
-                value = value.records.map(record => record.data.id)
+                value = value.records.map((record) => record.resId);
             } else if (type === 'date') {
                 value = value && serializeDate(value);
             } else if (type === "datetime") {
diff --git a/addons/calendar/static/src/views/fields/many2many_attendee.js b/addons/calendar/static/src/views/fields/many2many_attendee.js
index 624a8f4483e..e1c6a474b01 100644
--- a/addons/calendar/static/src/views/fields/many2many_attendee.js
+++ b/addons/calendar/static/src/views/fields/many2many_attendee.js
@@ -5,10 +5,26 @@ import {
     Many2ManyTagsAvatarField,
     many2ManyTagsAvatarField,
 } from "@web/views/fields/many2many_tags_avatar/many2many_tags_avatar_field";
+import { useSpecialData } from "@web/views/fields/relational_utils";
 
 export class Many2ManyAttendee extends Many2ManyTagsAvatarField {
+    setup() {
+        super.setup();
+        this.specialData = useSpecialData((orm, props) => {
+            const { context, name, record } = this.props;
+            return orm.call(
+                "res.partner",
+                "get_attendee_detail",
+                [record.data[name].records.map((rec) => rec.resId), [record.resId || false]],
+                {
+                    context,
+                }
+            );
+        });
+    }
+
     get tags() {
-        const { partner_ids: partnerIds } = this.props.record.preloadedData;
+        const partnerIds = this.specialData.data;
         const tags = super.tags.map((tag) => {
             const partner = partnerIds.find((partner) => tag.resId === partner.id);
             if (partner) {
@@ -34,23 +50,6 @@ export const many2ManyAttendee = {
     ...many2ManyTagsAvatarField,
     component: Many2ManyAttendee,
     additionalClasses: ["o_field_many2many_tags_avatar", "w-100"],
-    legacySpecialData: "_fetchSpecialAttendeeStatus",
 };
 
 registry.category("fields").add("many2manyattendee", many2ManyAttendee);
-
-export function preloadMany2ManyAttendee(orm, record, fieldName, { context }) {
-    return orm.call(
-        "res.partner",
-        "get_attendee_detail",
-        [record.data[fieldName].records.map((rec) => rec.resId), [record.resId || false]],
-        {
-            context,
-        }
-    );
-}
-
-registry.category("preloadedData").add("many2manyattendee", {
-    loadOnTypes: ["many2many"],
-    preload: preloadMany2ManyAttendee,
-});
diff --git a/addons/calendar/static/src/views/fields/many2many_attendee_expandable.js b/addons/calendar/static/src/views/fields/many2many_attendee_expandable.js
index 79cf3ef9f7c..9706b66b3c4 100644
--- a/addons/calendar/static/src/views/fields/many2many_attendee_expandable.js
+++ b/addons/calendar/static/src/views/fields/many2many_attendee_expandable.js
@@ -6,7 +6,6 @@ import { reposition } from "@web/core/position_hook";
 import {
     Many2ManyAttendee,
     many2ManyAttendee,
-    preloadMany2ManyAttendee,
 } from "@calendar/views/fields/many2many_attendee";
 
 export class Many2ManyAttendeeExpandable extends Many2ManyAttendee {
@@ -39,8 +38,3 @@ export const many2ManyAttendeeExpandable = {
 };
 
 registry.category("fields").add("many2manyattendeeexpandable", many2ManyAttendeeExpandable);
-
-registry.category("preloadedData").add("many2manyattendeeexpandable", {
-    loadOnTypes: ["many2many"],
-    preload: preloadMany2ManyAttendee,
-});
diff --git a/addons/contacts/static/tests/tours/debug_menu_set_defaults.js b/addons/contacts/static/tests/tours/debug_menu_set_defaults.js
index bb2b5a0718e..fd290b4e3e1 100644
--- a/addons/contacts/static/tests/tours/debug_menu_set_defaults.js
+++ b/addons/contacts/static/tests/tours/debug_menu_set_defaults.js
@@ -51,7 +51,7 @@
                 trigger: 'button.o_form_button_cancel',
             },
             {
-                trigger: '.o_action_manager .o_kanban_view .o-kanban-button-new',
+                trigger: '.o_action_manager > .o_kanban_view .o-kanban-button-new',
             },
             {
                 content: "Check that Individual is checked instead of Company",
diff --git a/addons/crm/static/src/views/crm_form/crm_form.js b/addons/crm/static/src/views/crm_form/crm_form.js
index 6b08c6a4d62..c7aaeb1bc09 100644
--- a/addons/crm/static/src/views/crm_form/crm_form.js
+++ b/addons/crm/static/src/views/crm_form/crm_form.js
@@ -2,26 +2,10 @@
 
 import { checkRainbowmanMessage } from "@crm/views/check_rainbowman_message";
 import { registry } from "@web/core/registry";
-import { useService } from "@web/core/utils/hooks";
 import { formView } from "@web/views/form/form_view";
 
-/**
- * This Form Controller makes sure we display a rainbowman message
- * when the stage is won, even when we click on the statusbar.
- * When the stage of a lead is changed and data are saved, we check
- * if the lead is won and if a message should be displayed to the user
- * with a rainbowman like when the user click on the button "Mark Won".
- */
-
-class CrmFormController extends formView.Controller {
-    setup() {
-        super.setup();
-        this.orm = useService("orm");
-        this.effect = useService("effect");
-        this.changedStage = false;
-    }
-
-    /**
+class CrmFormRecord extends formView.Model.Record {
+     /**
      * Main method used when saving the record hitting the "Save" button.
      * We check if the stage_id field was altered and if we need to display a rainbowman
      * message.
@@ -38,54 +22,48 @@ class CrmFormController extends formView.Controller {
      *
      * @override
      */
-    async onWillSaveRecord(record) {
-        const recordID = record.__bm_handle__;
-        const localData = record.model.__bm__.localData[recordID];
-        const changes = localData._changes || {};
-
+    async _save() {
+        let changeStage = false;
         const needsSynchronizationEmail =
-            changes.partner_email_update === undefined
-                ? localData.data.partner_email_update // original value
-                : changes.partner_email_update; // new value
+            this._changes.partner_email_update === undefined
+                ? this._values.partner_email_update // original value
+                : this._changes.partner_email_update; // new value
 
         const needsSynchronizationPhone =
-            changes.partner_phone_update === undefined
-                ? localData.data.partner_phone_update // original value
-                : changes.partner_phone_update; // new value
+            this._changes.partner_phone_update === undefined
+                ? this._values.partner_phone_update // original value
+                : this._changes.partner_phone_update; // new value
 
-        if (
-            needsSynchronizationEmail &&
-            changes.email_from === undefined &&
-            localData.data.email_from
-        ) {
-            changes.email_from = localData.data.email_from;
+        if (needsSynchronizationEmail && this._changes.email_from === undefined && this._values.email_from) {
+            this._changes.email_from = this._values.email_from;
         }
-        if (needsSynchronizationPhone && changes.phone === undefined && localData.data.phone) {
-            changes.phone = localData.data.phone;
-        }
-        if (!localData._changes && Object.keys(changes).length) {
-            localData._changes = changes;
+        if (needsSynchronizationPhone && this._changes.phone === undefined && this._values.phone) {
+            this._changes.phone = this._values.phone;
         }
 
-        if ("stage_id" in changes) {
-            const bm = record.model.__bm__;
-            let oldStageId = false;
-            if (bm.localData[recordID].data.stage_id) {
-                oldStageId = bm.get(bm.localData[recordID].data.stage_id).data.id;
-            }
-            const newStageId = bm.get(bm.localData[recordID]._changes.stage_id).data.id;
-            this.changedStage = oldStageId !== newStageId;
+        if ("stage_id" in this._changes) {
+            changeStage = this._values.stage_id !== this.data.stage_id;
         }
+
+        const res = await super._save(...arguments);
+        if (changeStage) {
+            await checkRainbowmanMessage(this.model.orm, this.model.effect, this.resId);
+        }
+        return res;
     }
+}
 
-    async onRecordSaved(record) {
-        if (this.changedStage) {
-            await checkRainbowmanMessage(this.orm, this.effect, record.resId);
-        }
+class CrmFormModel extends formView.Model {
+    static Record = CrmFormRecord;
+    static services = [...formView.Model.services, "effect"];
+
+    setup(params, services) {
+        super.setup(...arguments);
+        this.effect = services.effect;
     }
 }
 
 registry.category("views").add("crm_form", {
     ...formView,
-    Controller: CrmFormController,
+    Model: CrmFormModel,
 });
diff --git a/addons/crm/static/src/views/crm_kanban/crm_kanban_model.js b/addons/crm/static/src/views/crm_kanban/crm_kanban_model.js
index b3a32cfd4dd..b064e838375 100644
--- a/addons/crm/static/src/views/crm_kanban/crm_kanban_model.js
+++ b/addons/crm/static/src/views/crm_kanban/crm_kanban_model.js
@@ -1,16 +1,16 @@
 /** @odoo-module **/
 
-import { KanbanModel } from "@web/views/kanban/kanban_model";
 import { checkRainbowmanMessage } from "@crm/views/check_rainbowman_message";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 
-export class CrmKanbanModel extends KanbanModel {
+export class CrmKanbanModel extends RelationalModel {
     setup(params, { effect }) {
         super.setup(...arguments);
         this.effect = effect;
     }
 }
 
-export class CrmKanbanDynamicGroupList extends CrmKanbanModel.DynamicGroupList {
+export class CrmKanbanDynamicGroupList extends RelationalModel.DynamicGroupList {
     /**
      * @override
      *
@@ -18,10 +18,7 @@ export class CrmKanbanDynamicGroupList extends CrmKanbanModel.DynamicGroupList {
      * a rainbowman message if that's the case.
      */
     async moveRecord(dataRecordId, dataGroupId, refId, targetGroupId) {
-        const succeeded = await super.moveRecord(...arguments);
-        if (!succeeded) {
-            return;
-        }
+        await super.moveRecord(...arguments);
         const sourceGroup = this.groups.find((g) => g.id === dataGroupId);
         const targetGroup = this.groups.find((g) => g.id === targetGroupId);
         if (
@@ -37,4 +34,4 @@ export class CrmKanbanDynamicGroupList extends CrmKanbanModel.DynamicGroupList {
 }
 
 CrmKanbanModel.DynamicGroupList = CrmKanbanDynamicGroupList;
-CrmKanbanModel.services = [...KanbanModel.services, "effect"];
+CrmKanbanModel.services = [...RelationalModel.services, "effect"];
diff --git a/addons/crm/static/src/views/forecast_kanban/forecast_kanban_model.js b/addons/crm/static/src/views/forecast_kanban/forecast_kanban_model.js
index de4824c8da6..c98bf26ba6e 100644
--- a/addons/crm/static/src/views/forecast_kanban/forecast_kanban_model.js
+++ b/addons/crm/static/src/views/forecast_kanban/forecast_kanban_model.js
@@ -1,49 +1,60 @@
 /** @odoo-module **/
 
-import { CrmKanbanModel, CrmKanbanGroup } from "@crm/views/crm_kanban/crm_kanban_model";
+import { CrmKanbanModel } from "@crm/views/crm_kanban/crm_kanban_model";
 import { deserializeDateTime } from "@web/core/l10n/dates";
 
 export class ForecastKanbanModel extends CrmKanbanModel {
     setup(params, { fillTemporalService }) {
         super.setup(...arguments);
         this.fillTemporalService = fillTemporalService;
-    }
-}
-
-export class ForecastKanbanDynamicGroupList extends ForecastKanbanModel.DynamicGroupList {
-    /**
-     * @override
-     */
-    setup(params, state) {
-        super.setup(...arguments);
-        // Detect a reload vs an initial load, initial load should forceRecompute
-        this.forceNextRecompute = !state.groups;
+        this.forceNextRecompute = !params.state?.groups;
     }
 
-    /**
-     * @override
-     *
-     * Add fill_temporal context keys to the context before loading the groups.
-     */
-    get context() {
-        const context = super.context;
-        if (!this.isForecastGroupBy()) {
-            return context;
+    async _webReadGroup(config, firstGroupByName, orderBy) {
+        if (this.isForecastGroupBy(config)) {
+            config.context = this.fillTemporalPeriod(config).getContext({
+                context: config.context,
+            });
+            config.domain = this.fillTemporalPeriod(config).getDomain({
+                        domain: config.domain,
+                        forceStartBound: false,
+                    });
         }
-        return this.fillTemporalPeriod.getContext({ context });
+        return super._webReadGroup(...arguments);
+    }
+
+    async _loadGroupedList(config) {
+        const res = await super._loadGroupedList(...arguments);
+        if (this.isForecastGroupBy(config)) {
+            const lastGroup = res.groups.filter((grp) => grp.value).slice(-1)[0];
+            if (lastGroup) {
+                this.fillTemporalPeriod(config).setEnd(deserializeDateTime(lastGroup.range.to));
+            }
+        }
+        return res;
+    }
+
+    /**
+     * @returns {Boolean} true if the view is grouped by the forecast_field
+     */
+    isForecastGroupBy(config) {
+        const forecastField = config.context.forecast_field;
+        const name = config.groupBy[0].split(":")[0];
+        return forecastField && forecastField === name;
     }
 
     /**
      * return {FillTemporalPeriod} current fillTemporalPeriod according to group by state
      */
-    get fillTemporalPeriod() {
-        const context = super.context;
-        const minGroups = (context.fill_temporal && context.fill_temporal.min_groups) || undefined;
-        const { name, type, granularity } = this.groupByField;
+    fillTemporalPeriod(config) {
+        const [groupByFieldName, granularity] = config.groupBy[0].split(":");
+        const groupByField = config.fields[groupByFieldName];
+        const minGroups = (config.context.fill_temporal && config.context.fill_temporal.min_groups) || undefined;
+        const { name, type } = groupByField;
         const forceRecompute = this.forceNextRecompute;
         this.forceNextRecompute = false;
-        return this.model.fillTemporalService.getFillTemporalPeriod({
-            modelName: this.resModel,
+        return this.fillTemporalService.getFillTemporalPeriod({
+            modelName: config.resModel,
             field: {
                 name,
                 type,
@@ -53,54 +64,6 @@ export class ForecastKanbanDynamicGroupList extends ForecastKanbanModel.DynamicG
             forceRecompute,
         });
     }
-
-    /**
-     * @returns {Boolean} true if the view is grouped by the forecast_field
-     */
-    isForecastGroupBy() {
-        const forecastField = super.context.forecast_field;
-        const { name } = this.groupByField;
-        return forecastField && forecastField === name;
-    }
-
-    /**
-     * @override
-     *
-     * At every __load/__reload, we have to check the range of the last group received from the
-     * read_group, and update the fillTemporalPeriod from the FillTemporalService accordingly
-     */
-    async load() {
-        if (!this.isForecastGroupBy()) {
-            return super.load(...arguments);
-        }
-        const result = await super.load(...arguments);
-        const lastGroup = this.groups.filter((grp) => grp.value).slice(-1)[0];
-        if (lastGroup) {
-            this.fillTemporalPeriod.setEnd(deserializeDateTime(lastGroup.range[this.groupBy[0]].to));
-        }
-        return result;
-    }
-
-    /**
-     * @override
-     *
-     * Applies the forecast logic to the domain and context if needed before the read_group.
-     */
-    async _loadGroups() {
-        if (!this.isForecastGroupBy()) {
-            return super._loadGroups(...arguments);
-        }
-        const previousDomain = this.domain;
-        this.domain = this.fillTemporalPeriod.getDomain({
-            domain: this.domain,
-            forceStartBound: false,
-        });
-        const result = await super._loadGroups(...arguments);
-        this.domain = previousDomain;
-        return result;
-    }
 }
 
 ForecastKanbanModel.services = [...CrmKanbanModel.services, "fillTemporalService"];
-ForecastKanbanModel.DynamicGroupList = ForecastKanbanDynamicGroupList;
-ForecastKanbanModel.group = CrmKanbanGroup;
diff --git a/addons/event_booth_sale/static/src/js/event_booth_configurator_controller.js b/addons/event_booth_sale/static/src/js/event_booth_configurator_controller.js
index 1e1ea6722a3..7bb7df430e0 100644
--- a/addons/event_booth_sale/static/src/js/event_booth_configurator_controller.js
+++ b/addons/event_booth_sale/static/src/js/event_booth_configurator_controller.js
@@ -18,7 +18,8 @@ class EventBoothConfiguratorController extends formView.Controller {
         this.action = useService("action");
     }
 
-    onRecordSaved(record) {
+    async onRecordSaved(record) {
+        await super.onRecordSaved(...arguments);
         const { event_id, event_booth_category_id, event_booth_ids } = record.data;
         return this.action.doAction({
             type: "ir.actions.act_window_close",
@@ -26,15 +27,7 @@ class EventBoothConfiguratorController extends formView.Controller {
                 eventBoothConfiguration: {
                     event_id,
                     event_booth_category_id,
-                    event_booth_pending_ids: {
-                        operation: "MULTI",
-                        commands: [
-                            {
-                                operation: "REPLACE_WITH",
-                                ids: event_booth_ids.currentIds,
-                            },
-                        ],
-                    },
+                    event_booth_pending_ids: event_booth_ids.currentIds,
                 },
             },
         });
diff --git a/addons/event_booth_sale/static/src/js/sale_product_field.js b/addons/event_booth_sale/static/src/js/sale_product_field.js
index 2843d16b7a6..333c706b939 100644
--- a/addons/event_booth_sale/static/src/js/sale_product_field.js
+++ b/addons/event_booth_sale/static/src/js/sale_product_field.js
@@ -39,7 +39,7 @@ patch(SaleOrderLineProductField.prototype, 'event_booth_sale', {
             if (recordData.event_booth_pending_ids) {
                 actionContext.default_event_booth_ids = recordData.event_booth_pending_ids.records.map(
                     record => {
-                        return [4, record.data.id];
+                        return [4, record.resId];
                     }
                 );
             }
@@ -58,11 +58,15 @@ patch(SaleOrderLineProductField.prototype, 'event_booth_sale', {
                             });
                         }
                     } else {
-                        const eventBoothConfiguration = closeInfo.eventBoothConfiguration;
+                        const { event_id, event_booth_category_id, event_booth_pending_ids } =
+                            closeInfo.eventBoothConfiguration;
+                        this.props.record.data.event_booth_pending_ids.replaceWith(
+                            event_booth_pending_ids,
+                            { silent: true }
+                        );
                         this.props.record.update({
-                            event_id: eventBoothConfiguration.event_id,
-                            event_booth_category_id: eventBoothConfiguration.event_booth_category_id,
-                            event_booth_pending_ids: eventBoothConfiguration.event_booth_pending_ids,
+                            event_id,
+                            event_booth_category_id,
                         });
                     }
                 }
diff --git a/addons/event_sale/static/src/js/event_configurator_controller.js b/addons/event_sale/static/src/js/event_configurator_controller.js
index fac0056c865..d5ce1e2d7dc 100644
--- a/addons/event_sale/static/src/js/event_configurator_controller.js
+++ b/addons/event_sale/static/src/js/event_configurator_controller.js
@@ -26,7 +26,8 @@ class EventConfiguratorController extends formView.Controller {
      *
      * @override
      */
-    onRecordSaved(record) {
+    async onRecordSaved(record) {
+        await super.onRecordSaved(...arguments);
         const { event_id, event_ticket_id } = record.data;
         return this.action.doAction({
             type: "ir.actions.act_window_close",
diff --git a/addons/hr/static/src/components/department_chart/department_chart.js b/addons/hr/static/src/components/department_chart/department_chart.js
index 7581dbc08be..56590348511 100644
--- a/addons/hr/static/src/components/department_chart/department_chart.js
+++ b/addons/hr/static/src/components/department_chart/department_chart.js
@@ -16,10 +16,10 @@ export class DepartmentChart extends Component {
         this.state = useState({
             hierarchy: {}
         });
-        onWillStart(async () => await this.fetchHierarchy(this.props.record.data.id));
+        onWillStart(async () => await this.fetchHierarchy(this.props.record.resId));
 
         onWillUpdateProps(async (nextProps) => {
-            await this.fetchHierarchy(nextProps.record.data.id);
+            await this.fetchHierarchy(nextProps.record.resId);
         });
     }
 
diff --git a/addons/hr/static/src/js/standalone_m2o_avatar_employee.js b/addons/hr/static/src/js/standalone_m2o_avatar_employee.js
deleted file mode 100644
index 794d38cc060..00000000000
--- a/addons/hr/static/src/js/standalone_m2o_avatar_employee.js
+++ /dev/null
@@ -1,59 +0,0 @@
-/** @odoo-module **/
-
-    import StandaloneFieldManagerMixin from 'web.StandaloneFieldManagerMixin';
-    import Widget from 'web.Widget';
-
-    import { Many2OneAvatarEmployee } from '@hr/js/m2x_avatar_employee';
-
-    const StandaloneM2OAvatarEmployee = Widget.extend(StandaloneFieldManagerMixin, {
-        className: 'o_standalone_avatar_employee',
-
-        /**
-         * @override
-         */
-        init(parent, value) {
-            this._super(...arguments);
-            StandaloneFieldManagerMixin.init.call(this);
-            this.value = value;
-        },
-        /**
-         * @override
-         */
-        willStart() {
-            return Promise.all([this._super(...arguments), this._makeAvatarWidget()]);
-        },
-        /**
-         * @override
-         */
-        start() {
-            this.avatarWidget.$el.appendTo(this.$el);
-            return this._super(...arguments);
-        },
-
-        //--------------------------------------------------------------------------
-        // Private
-        //--------------------------------------------------------------------------
-
-        /**
-         * Create a record, and initialize and start the avatar widget.
-         *
-         * @private
-         * @returns {Promise}
-         */
-        async _makeAvatarWidget() {
-            const modelName = 'hr.employee';
-            const fieldName = 'employee_id';
-            const recordId = await this.model.makeRecord(modelName, [{
-                name: fieldName,
-                relation: modelName,
-                type: 'many2one',
-                value: this.value,
-            }]);
-            const state = this.model.get(recordId);
-            this.avatarWidget = new Many2OneAvatarEmployee(this, fieldName, state);
-            this._registerWidget(recordId, fieldName, this.avatarWidget);
-            return this.avatarWidget.appendTo(document.createDocumentFragment());
-        },
-    });
-
-    export default StandaloneM2OAvatarEmployee;
diff --git a/addons/hr/static/src/views/profile_form_view.js b/addons/hr/static/src/views/profile_form_view.js
index e2b16a4f778..c89335dac45 100644
--- a/addons/hr/static/src/views/profile_form_view.js
+++ b/addons/hr/static/src/views/profile_form_view.js
@@ -11,11 +11,12 @@ export class EmployeeProfileController extends formView.Controller {
         this.mustReload = false;
     }
 
-    onWillSaveRecord(record) {
-        this.mustReload = record.isFieldDirty("lang");
+    onWillSaveRecord(record, changes) {
+        this.mustReload = "lang" in changes;
     }
 
-    onRecordSaved(record) {
+    async onRecordSaved(record) {
+        await super.onRecordSaved(...arguments);
         if (this.mustReload) {
             this.mustReload = false;
             return this.action.doAction("reload_context");
diff --git a/addons/hr/static/tests/m2x_avatar_employee_tests.js b/addons/hr/static/tests/m2x_avatar_employee_tests.js
index 1b7adcf4642..5f4cc2ae7af 100644
--- a/addons/hr/static/tests/m2x_avatar_employee_tests.js
+++ b/addons/hr/static/tests/m2x_avatar_employee_tests.js
@@ -147,8 +147,16 @@ QUnit.test(
         };
         const { openView } = await start({
             mockRPC(route, args) {
-                if (args.method === "read") {
-                    assert.step(`read ${args.model} ${args.args[0]}`);
+                if (args.method === "web_read") {
+                    assert.step(`web_read ${args.model} ${args.args[0]}`);
+                    assert.deepEqual(args.kwargs.specification, {
+                        display_name: {},
+                        employee_id: {
+                            fields: {
+                                display_name: {},
+                            },
+                        },
+                    });
                 }
             },
             serverData: { views },
@@ -173,11 +181,7 @@ QUnit.test(
         );
 
         await dom.click(document.querySelector(".o_m2o_avatar > img"));
-        assert.verifySteps([
-            `read m2x.avatar.employee ${avatarId}`,
-            `read hr.employee.public ${employeeId}`,
-            "notification",
-        ]);
+        assert.verifySteps([`web_read m2x.avatar.employee ${avatarId}`, "notification"]);
     }
 );
 
@@ -201,6 +205,9 @@ QUnit.test("many2many_avatar_employee widget in form view", async function (asse
     };
     const { openView } = await start({
         mockRPC(route, args) {
+            if (args.method === "web_read") {
+                assert.step(`web_read ${args.model} ${args.args[0]}`);
+            }
             if (args.method === "read") {
                 assert.step(`read ${args.model} ${args.args[0]}`);
             }
@@ -232,8 +239,7 @@ QUnit.test("many2many_avatar_employee widget in form view", async function (asse
         document.querySelectorAll(".o_field_many2many_avatar_employee .o_tag .o_m2m_avatar")[1]
     );
     assert.verifySteps([
-        `read m2x.avatar.employee ${avatarId_1}`,
-        `read hr.employee.public ${employeeId_1},${employeeId_2}`,
+        `web_read m2x.avatar.employee ${avatarId_1}`,
         `read hr.employee.public ${employeeId_1}`,
         `read hr.employee.public ${employeeId_2}`,
     ]);
@@ -282,10 +288,7 @@ QUnit.test("many2many_avatar_employee widget in list view", async function (asse
 
     // click on first employee badge
     await afterNextRender(() => dom.click(document.querySelector(".o_data_cell .o_m2m_avatar")));
-    assert.verifySteps([
-        `read hr.employee.public ${employeeId_1},${employeeId_2}`,
-        `read hr.employee.public ${employeeId_1}`,
-    ]);
+    assert.verifySteps([`read hr.employee.public ${employeeId_1}`]);
     assert.containsOnce(document.body, ".o-mail-ChatWindow-name");
     assert.strictEqual(document.querySelector(".o-mail-ChatWindow-name").textContent, "Mario");
 
@@ -368,7 +371,6 @@ QUnit.test("many2many_avatar_employee widget in kanban view", async function (as
     await dom.click(document.querySelectorAll('.o_kanban_record img.o_m2m_avatar')[1]);
     await dom.click(document.querySelectorAll('.o_kanban_record img.o_m2m_avatar')[0]);
     assert.verifySteps([
-        `read hr.employee.public ${employeeId_1},${employeeId_2}`,
         `read hr.employee.public ${employeeId_1}`,
         `read hr.employee.public ${employeeId_2}`,
     ]);
@@ -396,6 +398,9 @@ QUnit.test(
                 if (args.method === "read") {
                     assert.step(`read ${args.model} ${args.args[0]}`);
                 }
+                if (args.method === "web_read") {
+                    assert.step(`web_read ${args.model} ${args.args[0]}`);
+                }
             },
             serverData: { views },
             services: {
@@ -428,8 +433,7 @@ QUnit.test(
             document.querySelectorAll(".o_field_many2many_avatar_employee .o_tag .o_m2m_avatar")[1]
         );
         assert.verifySteps([
-            `read m2x.avatar.employee ${employeeId_1}`,
-            `read hr.employee.public ${employeeId_1},${employeeId_2}`,
+            `web_read m2x.avatar.employee ${employeeId_1}`,
             `read hr.employee.public ${employeeId_1}`,
             "notification",
             `read hr.employee.public ${employeeId_2}`,
diff --git a/addons/hr_expense/static/src/views/list.js b/addons/hr_expense/static/src/views/list.js
index 1340c32ccbc..091af3ab4e1 100644
--- a/addons/hr_expense/static/src/views/list.js
+++ b/addons/hr_expense/static/src/views/list.js
@@ -21,7 +21,7 @@ export class ExpenseListController extends ListController {
         this.actionService = useService('action');
         this.rpc = useService("rpc");
         this.user = useService("user");
-        this.isExpenseSheet = this.model.rootParams.resModel === "hr.expense.sheet";
+        this.isExpenseSheet = this.model.config.resModel === "hr.expense.sheet";
 
         onWillStart(async () => {
             this.userIsExpenseTeamApprover = await this.user.hasGroup("hr_expense.group_hr_expense_team_approver");
diff --git a/addons/hr_holidays/static/src/leave_stats/leave_stats.js b/addons/hr_holidays/static/src/leave_stats/leave_stats.js
index 22e66a9846d..f3dd6612ec8 100644
--- a/addons/hr_holidays/static/src/leave_stats/leave_stats.js
+++ b/addons/hr_holidays/static/src/leave_stats/leave_stats.js
@@ -1,11 +1,12 @@
 /* @odoo-module */
 
-import { useService } from '@web/core/utils/hooks';
-import { registry } from '@web/core/registry'
+import { registry } from "@web/core/registry";
+import { useService } from "@web/core/utils/hooks";
+import { useRecordObserver } from "@web/model/relational_model/utils";
 
 import { formatDate } from "@web/core/l10n/dates";
 
-const { Component, useState, onWillStart, onWillUpdateProps } = owl;
+const { Component, useState, onWillStart } = owl;
 const { DateTime } = luxon;
 
 export class LeaveStatsComponent extends Component {
@@ -25,24 +26,30 @@ export class LeaveStatsComponent extends Component {
             await this.loadLeaves(this.date, this.employee);
             await this.loadDepartmentLeaves(this.date, this.department, this.employee);
         });
-        onWillUpdateProps(async (nextProps) => {
-            const dateFrom = nextProps.record.data.date_from || DateTime.now();
+
+        useRecordObserver(async (record) => {
+            const dateFrom = record.data.date_from || DateTime.now();
             const dateChanged = this.date !== dateFrom;
-            const employee = nextProps.record.data.employee_id;
-            const department = nextProps.record.data.department_id;
+            const employee = record.data.employee_id;
+            const department = record.data.department_id;
 
-            if (dateChanged || employee && (this.employee && this.employee[0]) !== employee[0]) {
-                await this.loadLeaves(dateFrom, employee);
+            const proms = [];
+            if (dateChanged || (employee && (this.employee && this.employee[0]) !== employee[0])) {
+                proms.push(this.loadLeaves(dateFrom, employee));
             }
 
-            if (dateChanged || department && (this.department && this.department[0]) !== department[0]) {
-                await this.loadDepartmentLeaves(dateFrom, department, employee);
+            if (
+                dateChanged ||
+                (department && (this.department && this.department[0]) !== department[0])
+            ) {
+                proms.push(this.loadDepartmentLeaves(dateFrom, department, employee));
             }
+            await Promise.all(proms);
 
             this.date = dateFrom;
             this.employee = employee;
             this.department = department;
-        })
+        });
     }
 
     get thisYear() {
diff --git a/addons/hr_holidays/static/src/radio_image_field/radio_image_field.js b/addons/hr_holidays/static/src/radio_image_field/radio_image_field.js
index c9944fe6275..2b3b81adff7 100644
--- a/addons/hr_holidays/static/src/radio_image_field/radio_image_field.js
+++ b/addons/hr_holidays/static/src/radio_image_field/radio_image_field.js
@@ -1,7 +1,7 @@
 /** @odoo-module **/
 
 import { registry } from "@web/core/registry";
-import { RadioField, preloadRadio, radioField } from "@web/views/fields/radio/radio_field";
+import { RadioField, radioField } from "@web/views/fields/radio/radio_field";
 
 class RadioImageField extends RadioField {}
 RadioImageField.template = "hr_holidays.RadioImageField";
@@ -10,8 +10,3 @@ registry.category("fields").add("hr_holidays_radio_image", {
     ...radioField,
     component: RadioImageField,
 });
-
-registry.category("preloadedData").add("hr_holidays_radio_image", {
-    loadOnTypes: ["many2one"],
-    preload: preloadRadio,
-});
diff --git a/addons/hr_holidays/static/tests/leave_stats_tests.js b/addons/hr_holidays/static/tests/leave_stats_tests.js
index a2324ddd96c..e61b7de1b24 100644
--- a/addons/hr_holidays/static/tests/leave_stats_tests.js
+++ b/addons/hr_holidays/static/tests/leave_stats_tests.js
@@ -139,7 +139,7 @@ QUnit.test("leave stats renders correctly", async (assert) => {
 });
 
 QUnit.test("leave stats reload when employee/department changes", async (assert) => {
-    assert.expect(3);
+    assert.expect(2);
     await makeView({
         serverData,
         type: "form",
diff --git a/addons/hr_org_chart/static/src/fields/hr_org_chart.js b/addons/hr_org_chart/static/src/fields/hr_org_chart.js
index c11ffdaa741..160e27efc04 100644
--- a/addons/hr_org_chart/static/src/fields/hr_org_chart.js
+++ b/addons/hr_org_chart/static/src/fields/hr_org_chart.js
@@ -55,7 +55,7 @@ export class HrOrgChart extends Component {
     async handleComponentUpdate() {
         this.employee = this.props.record.data;
         // the widget is either dispayed in the context of a hr.employee form or a res.users form
-        this.state.employee_id = this.employee.employee_ids !== undefined ? this.employee.employee_ids.resIds[0] : this.employee.id;
+        this.state.employee_id = this.employee.employee_ids !== undefined ? this.employee.employee_ids.resIds[0] : this.props.record.resId;
         const manager = this.employee.parent_id || this.employee.employee_parent_id;
         const forceReload = this.lastRecord !== this.props.record || this.lastParent != manager;
         this.lastParent = manager;
diff --git a/addons/im_livechat/static/src/js/im_livechat_chatbot_script_answers_m2m.js b/addons/im_livechat/static/src/js/im_livechat_chatbot_script_answers_m2m.js
index 2c05d2462c5..c5fdc494bdb 100644
--- a/addons/im_livechat/static/src/js/im_livechat_chatbot_script_answers_m2m.js
+++ b/addons/im_livechat/static/src/js/im_livechat_chatbot_script_answers_m2m.js
@@ -16,9 +16,9 @@ export class ChatbotScriptTriggeringAnswersMany2Many extends Many2ManyTagsField
     setup() {
         super.setup();
 
-        if (this.props.record.model.root.data.id) {
+        if (this.props.record.model.root.resId) {
             this.env.services.user.updateContext({
-                force_domain_chatbot_script_id: this.props.record.model.root.data.id,
+                force_domain_chatbot_script_id: this.props.record.model.root.resId,
             });
         }
     }
diff --git a/addons/mail/static/src/core/common/thread.js b/addons/mail/static/src/core/common/thread.js
index 5cd10c9f4f5..98ad536c208 100644
--- a/addons/mail/static/src/core/common/thread.js
+++ b/addons/mail/static/src/core/common/thread.js
@@ -20,7 +20,7 @@ import {
 } from "@odoo/owl";
 
 import { Transition } from "@web/core/transition";
-import { useService } from "@web/core/utils/hooks";
+import { useBus, useService } from "@web/core/utils/hooks";
 import { escape } from "@web/core/utils/strings";
 
 export const PRESENT_THRESHOLD = 2500;
@@ -153,6 +153,12 @@ export class Thread extends Component {
             this.lastJumpPresent = this.props.jumpPresent;
             this.threadService.fetchNewMessages(this.props.thread);
         });
+        useBus(this.env.bus, "MAIL:RELOAD-THREAD", ({ detail }) => {
+            const { model, id } = this.props.thread;
+            if (detail.resModel === model && detail.resId === id) {
+                this.threadService.fetchNewMessages(this.props.thread);
+            }
+        });
         onWillUpdateProps((nextProps) => {
             if (nextProps.thread !== this.props.thread) {
                 this.lastJumpPresent = nextProps.jumpPresent;
diff --git a/addons/mail/static/src/core/web/activity_button.js b/addons/mail/static/src/core/web/activity_button.js
index 626c2b4cdc1..f523b40c0a2 100644
--- a/addons/mail/static/src/core/web/activity_button.js
+++ b/addons/mail/static/src/core/web/activity_button.js
@@ -72,7 +72,7 @@ export class ActivityButton extends Component {
             this.popover.open(this.buttonRef.el, {
                 activityIds: this.props.record.data.activity_ids.currentIds,
                 onActivityChanged: () => {
-                    this.props.record.model.load({ resId: this.props.record.resId });
+                    this.props.record.load();
                 },
                 resId: this.props.record.resId,
                 resModel: this.props.record.resModel,
diff --git a/addons/mail/static/src/core/web/chatter.js b/addons/mail/static/src/core/web/chatter.js
index 65ba02a07ef..836dbeeaf7d 100644
--- a/addons/mail/static/src/core/web/chatter.js
+++ b/addons/mail/static/src/core/web/chatter.js
@@ -300,10 +300,7 @@ export class Chatter extends Component {
     async reloadParentView() {
         await this.props.saveRecord?.();
         if (this.props.webRecord) {
-            await this.props.webRecord.model.root.load(
-                { resId: this.props.threadId },
-                { keepChanges: true }
-            );
+            await this.props.webRecord.load();
             this.props.webRecord.model.notify();
         }
     }
diff --git a/addons/mail/static/src/views/web/activity/activity_arch_parser.js b/addons/mail/static/src/views/web/activity/activity_arch_parser.js
index 830de3bce7f..fdfda4023a6 100644
--- a/addons/mail/static/src/views/web/activity/activity_arch_parser.js
+++ b/addons/mail/static/src/views/web/activity/activity_arch_parser.js
@@ -2,7 +2,6 @@
 
 import { XMLParser } from "@web/core/utils/xml";
 import { Field } from "@web/views/fields/field";
-import { addFieldDependencies } from "@web/views/utils";
 
 export class ActivityArchParser extends XMLParser {
     parse(arch, models, modelName) {
@@ -13,7 +12,6 @@ export class ActivityArchParser extends XMLParser {
         const fieldNodes = {};
         const templateDocs = {};
         const fieldNextIds = {};
-        const activeFields = {};
 
         this.visitXML(xmlDoc, (node) => {
             if (node.hasAttribute("t-name")) {
@@ -35,8 +33,6 @@ export class ActivityArchParser extends XMLParser {
                 const fieldId = `${fieldInfo.name}_${fieldNextIds[fieldInfo.name]++}`;
                 fieldNodes[fieldId] = fieldInfo;
                 node.setAttribute("field_id", fieldId);
-
-                addFieldDependencies(fieldInfo, activeFields, models[modelName]);
             }
 
             // Keep track of last update so images can be reloaded when they may have changed.
@@ -50,26 +46,9 @@ export class ActivityArchParser extends XMLParser {
                     fieldNodes.write_date_0 = { name: "write_date", type: "datetime" };
                 }
             }
-
-            // TODO: generate activeFields for the model based on fieldNodes (merge duplicated fields)
-            for (const fieldNode of Object.values(fieldNodes)) {
-                const fieldName = fieldNode.name;
-                if (activeFields[fieldName]) {
-                    const { alwaysInvisible } = fieldNode;
-                    activeFields[fieldName] = {
-                        ...fieldNode,
-                        // a field can only be considered to be always invisible
-                        // if all its nodes are always invisible
-                        alwaysInvisible: activeFields[fieldName].alwaysInvisible && alwaysInvisible,
-                    };
-                } else {
-                    activeFields[fieldName] = fieldNode;
-                }
-            }
         });
         return {
             arch,
-            activeFields,
             fieldNodes,
             templateDocs,
             title,
diff --git a/addons/mail/static/src/views/web/activity/activity_controller.js b/addons/mail/static/src/views/web/activity/activity_controller.js
index 5f835196493..e6022da9d26 100644
--- a/addons/mail/static/src/views/web/activity/activity_controller.js
+++ b/addons/mail/static/src/views/web/activity/activity_controller.js
@@ -6,10 +6,11 @@ import { Component, useState } from "@odoo/owl";
 
 import { useService } from "@web/core/utils/hooks";
 import { sprintf } from "@web/core/utils/strings";
+import { useModel } from "@web/model/model";
+import { extractFieldsFromArchInfo } from "@web/model/relational_model/utils";
 import { CogMenu } from "@web/search/cog_menu/cog_menu";
 import { Layout } from "@web/search/layout";
 import { SearchBar } from "@web/search/search_bar/search_bar";
-import { useModel } from "@web/views/model";
 import { standardViewProps } from "@web/views/standard_view_props";
 import { SelectCreateDialog } from "@web/views/view_dialogs/select_create_dialog";
 
@@ -24,18 +25,16 @@ export class ActivityController extends Component {
     static template = "mail.ActivityController";
 
     setup() {
-        const { rootState } = this.props.state || {};
-        this.model = useModel(
-            this.props.Model,
-            {
-                activeFields: this.props.archInfo.activeFields,
-                resModel: this.props.resModel,
-                fields: this.props.fields,
-                viewMode: "activity",
-                rootState,
+        const { archInfo, resModel } = this.props;
+        const { activeFields, fields } = extractFieldsFromArchInfo(archInfo, this.props.fields);
+        const modelParams = {
+            config: {
+                activeFields,
+                resModel,
+                fields,
             },
-            { ignoreUseSampleModel: true }
-        );
+        };
+        this.model = useState(useModel(this.props.Model, modelParams));
 
         this.dialog = useService("dialog");
         this.action = useService("action");
diff --git a/addons/mail/static/src/views/web/activity/activity_model.js b/addons/mail/static/src/views/web/activity/activity_model.js
index be162054875..76737e60c00 100644
--- a/addons/mail/static/src/views/web/activity/activity_model.js
+++ b/addons/mail/static/src/views/web/activity/activity_model.js
@@ -1,15 +1,9 @@
 /* @odoo-module */
 
-import { DynamicRecordList, RelationalModel } from "@web/views/relational_model";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 
-class ActivityDynamicRecordList extends DynamicRecordList {
-    setup() {
-        super.setup(...arguments);
-        this.limit = null;
-    }
-}
 export class ActivityModel extends RelationalModel {
-    static DynamicRecordList = ActivityDynamicRecordList;
+    static DEFAULT_LIMIT = null;
 
     async load(params = {}) {
         this.originalDomain = params.domain ? [...params.domain] : [];
@@ -17,13 +11,15 @@ export class ActivityModel extends RelationalModel {
         if (params && "groupBy" in params) {
             params.groupBy = [];
         }
-        this.activityData = await this.fetchActivityData(params);
-        await super.load(params);
+        const prom = this.fetchActivityData(params).then((data) => {
+            this.activityData = data;
+        });
+        await Promise.all([prom, super.load(params)]);
     }
 
     fetchActivityData(params) {
         return this.orm.call("mail.activity", "get_activity_data", [], {
-            res_model: this.rootParams.resModel,
+            res_model: this.config.resModel,
             domain: params.domain || this.env.searchModel._domain,
         });
     }
diff --git a/addons/mail/static/src/views/web/fields/assign_user_command_hook.js b/addons/mail/static/src/views/web/fields/assign_user_command_hook.js
index 26e12ca2938..6523c2cd83d 100644
--- a/addons/mail/static/src/views/web/fields/assign_user_command_hook.js
+++ b/addons/mail/static/src/views/web/fields/assign_user_command_hook.js
@@ -33,12 +33,10 @@ export function useAssignUserCommand() {
         if (type === "many2one") {
             component.props.record.update({ [component.props.name]: record });
         } else if (type === "many2many") {
-            component.props.record.update({
-                [component.props.name]: {
-                    operation: "REPLACE_WITH",
-                    resIds: [...getCurrentIds(), record[0]],
-                },
-            });
+            component.props.record.data[component.props.name].replaceWith([
+                ...getCurrentIds(),
+                record[0],
+            ]);
         }
     };
 
@@ -46,12 +44,9 @@ export function useAssignUserCommand() {
         if (type === "many2one") {
             component.props.record.update({ [component.props.name]: [] });
         } else if (type === "many2many") {
-            component.props.record.update({
-                [component.props.name]: {
-                    operation: "REPLACE_WITH",
-                    resIds: getCurrentIds().filter((id) => id !== record[0]),
-                },
-            });
+            component.props.record.data[component.props.name].replaceWith(
+                getCurrentIds().filter((id) => id !== record[0])
+            );
         }
     };
 
diff --git a/addons/mail/static/src/views/web/fields/many2many_tags_email/many2many_tags_email.js b/addons/mail/static/src/views/web/fields/many2many_tags_email/many2many_tags_email.js
index 27d3430cc2e..d320c3b8f79 100644
--- a/addons/mail/static/src/views/web/fields/many2many_tags_email/many2many_tags_email.js
+++ b/addons/mail/static/src/views/web/fields/many2many_tags_email/many2many_tags_email.js
@@ -1,6 +1,6 @@
 /* @odoo-module */
 
-import { onMounted, onWillUpdateProps } from "@odoo/owl";
+import { onMounted } from "@odoo/owl";
 
 import { _t } from "@web/core/l10n/translation";
 import { registry } from "@web/core/registry";
@@ -42,44 +42,48 @@ export class FieldMany2ManyTagsEmail extends Many2ManyTagsField {
             fieldString: this.props.string,
         });
 
-        // Using onWillStart causes an infinite loop, onMounted will handle the initial
-        // check and onWillUpdateProps handles any addition to the field.
-        onMounted(this.checkEmails.bind(this, this.props));
-        onWillUpdateProps(this.checkEmails.bind(this));
+        const update = this.update;
+        this.update = async (object) => {
+            await update(object);
+            await this.checkEmails();
+        };
+
+        onMounted(() => {
+            this.checkEmails();
+        });
     }
 
-    async checkEmails(props) {
-        const invalidRecords = props.record.data[props.name].records.filter(
-            (record) => !record.data.email
-        );
+    async checkEmails() {
+        const list = this.props.record.data[this.props.name];
+        const invalidRecords = list.records.filter((record) => !record.data.email);
         // Remove records with invalid data, open form view to edit those and readd them if they are updated correctly.
         const dialogDefs = [];
         for (const record of invalidRecords) {
             dialogDefs.push(
                 this.openMany2xRecord({
                     resId: record.resId,
-                    context: props.context,
+                    context: this.props.context,
                     title: sprintf(_t("Edit: %s"), record.data.display_name),
                 })
             );
         }
         this.openedDialogs += invalidRecords.length;
-        const invalidRecordIds = invalidRecords.map((rec) => rec.resId);
-        if (invalidRecordIds.length) {
-            this.props.record.data[this.props.name].replaceWith(
-                props.record.data[props.name].currentIds.filter(
-                    (id) => !invalidRecordIds.includes(id)
-                )
-            );
+        await Promise.all(dialogDefs);
+
+        this.openedDialogs -= invalidRecords.length;
+        if (this.openedDialogs || !this.recordsIdsToAdd.length) {
+            return;
         }
-        return Promise.all(dialogDefs).then(() => {
-            this.openedDialogs -= invalidRecords.length;
-            if (this.openedDialogs || !this.recordsIdsToAdd.length) {
-                return;
-            }
-            props.record.data[props.name].add(this.recordsIdsToAdd, { isM2M: true });
-            this.recordsIdsToAdd = [];
-        });
+
+        const invalidRecordIds = invalidRecords.map((rec) => rec.resId);
+        await list.replaceWith(
+            [
+                ...list.currentIds.filter((id) => !invalidRecordIds.includes(id)),
+                ...this.recordsIdsToAdd,
+            ],
+            { reload: true }
+        );
+        this.recordsIdsToAdd = [];
     }
 
     get tags() {
diff --git a/addons/mail/static/src/views/web/form/form_controller.js b/addons/mail/static/src/views/web/form/form_controller.js
new file mode 100644
index 00000000000..b6c8ac329e5
--- /dev/null
+++ b/addons/mail/static/src/views/web/form/form_controller.js
@@ -0,0 +1,14 @@
+/* @odoo-module */
+
+import { patch } from "@web/core/utils/patch";
+import { FormController } from "@web/views/form/form_controller";
+
+patch(FormController.prototype, "mail/views/web", {
+    onWillLoadRoot() {
+        if (this.model.root) {
+            // not first load
+            const { resModel, resId } = this.model.root;
+            this.env.bus.trigger("MAIL:RELOAD-THREAD", { resModel, resId });
+        }
+    },
+});
diff --git a/addons/mail/static/src/views/web/list_renderer.js b/addons/mail/static/src/views/web/list_renderer.js
new file mode 100644
index 00000000000..e29d2fe468a
--- /dev/null
+++ b/addons/mail/static/src/views/web/list_renderer.js
@@ -0,0 +1,18 @@
+/* @odoo-module */
+
+import { patch } from "@web/core/utils/patch";
+import { ListRenderer } from "@web/views/list/list_renderer";
+
+patch(ListRenderer.prototype, "mail/views/web", {
+    getPropertyFieldColumns(_, list) {
+        const columns = this._super(...arguments);
+        for (const column of columns) {
+            const { relation, type } = list.fields[column.name];
+            if (relation === "res.users") {
+                column.widget =
+                    type === "many2one" ? "many2one_avatar_user" : "many2many_avatar_user";
+            }
+        }
+        return columns;
+    },
+});
diff --git a/addons/mail/static/src/views/web/relational_model.js b/addons/mail/static/src/views/web/relational_model.js
deleted file mode 100644
index 2778e51b042..00000000000
--- a/addons/mail/static/src/views/web/relational_model.js
+++ /dev/null
@@ -1,13 +0,0 @@
-/* @odoo-module */
-
-import { patch } from "@web/core/utils/patch";
-import { Record } from "@web/views/relational_model";
-
-patch(Record.prototype, "mail/views/web", {
-    _getWidgetFromDefinition(definition) {
-        if (definition.comodel !== "res.users") {
-            return this._super(...arguments);
-        }
-        return definition.type === "many2one" ? "many2one_avatar_user" : "many2many_avatar_user";
-    },
-});
diff --git a/addons/mail/static/tests/web/activity/activity_widget_tests.js b/addons/mail/static/tests/web/activity/activity_widget_tests.js
index 34534e07df4..cb291521d87 100644
--- a/addons/mail/static/tests/web/activity/activity_widget_tests.js
+++ b/addons/mail/static/tests/web/activity/activity_widget_tests.js
@@ -42,7 +42,7 @@ QUnit.test("list activity widget with no activity", async (assert) => {
     });
     assert.containsOnce($, ".o-mail-ActivityButton i.text-muted");
     assert.strictEqual($(".o-mail-ListActivity-summary")[0].innerText, "");
-    assert.verifySteps(["/web/dataset/call_kw/res.users/web_search_read"]);
+    assert.verifySteps(["/web/dataset/call_kw/res.users/unity_web_search_read"]);
 });
 
 QUnit.test("list activity widget with activities", async (assert) => {
@@ -99,7 +99,7 @@ QUnit.test("list activity widget with activities", async (assert) => {
     );
     assert.containsOnce($(".o_data_row:eq(1)"), ".o-mail-ActivityButton i.text-success.fa-clock-o");
     assert.strictEqual($(".o_data_row:eq(1) .o-mail-ListActivity-summary")[0].innerText, "Type 2");
-    assert.verifySteps(["/web/dataset/call_kw/res.users/web_search_read"]);
+    assert.verifySteps(["/web/dataset/call_kw/res.users/unity_web_search_read"]);
 });
 
 QUnit.test("list activity widget with exception", async (assert) => {
@@ -142,7 +142,7 @@ QUnit.test("list activity widget with exception", async (assert) => {
     });
     assert.containsOnce($, ".o-mail-ActivityButton i.text-warning.fa-warning");
     assert.strictEqual($(".o-mail-ListActivity-summary")[0].innerText, "Warning");
-    assert.verifySteps(["/web/dataset/call_kw/res.users/web_search_read"]);
+    assert.verifySteps(["/web/dataset/call_kw/res.users/unity_web_search_read"]);
 });
 
 QUnit.test("list activity widget: open dropdown", async (assert) => {
@@ -226,12 +226,7 @@ QUnit.test("list activity widget: open dropdown", async (assert) => {
     await click(".o-mail-ActivityListPopoverItem-markAsDone"); // mark the first activity as done
     await click(".o-mail-ActivityMarkAsDone button[aria-label='Done']"); // confirm
     assert.strictEqual($(".o-mail-ListActivity-summary")[0].innerText, "Meet FP");
-    assert.verifySteps([
-        "web_search_read",
-        "activity_format",
-        "action_feedback",
-        "web_search_read",
-    ]);
+    assert.verifySteps(["unity_web_search_read", "activity_format", "action_feedback", "web_read"]);
 });
 
 QUnit.test("list activity exception widget with activity", async (assert) => {
diff --git a/addons/mail/static/tests/web/debug_menu_tests.js b/addons/mail/static/tests/web/debug_menu_tests.js
index 082e7714e91..9419fde2de1 100644
--- a/addons/mail/static/tests/web/debug_menu_tests.js
+++ b/addons/mail/static/tests/web/debug_menu_tests.js
@@ -35,7 +35,7 @@ QUnit.test("Manage Messages", async (assert) => {
         if (method === "check_access_rights") {
             return true;
         }
-        if (method === "web_search_read" && model === "mail.message") {
+        if (method === "unity_web_search_read" && model === "mail.message") {
             assert.step("message_read");
             const { context, domain } = kwargs;
             assert.strictEqual(context.default_res_id, 5);
diff --git a/addons/mail/static/tests/web/fields/many2many_tags_email_tests.js b/addons/mail/static/tests/web/fields/many2many_tags_email_tests.js
index 7bf2c3fefaa..ba129142d6f 100644
--- a/addons/mail/static/tests/web/fields/many2many_tags_email_tests.js
+++ b/addons/mail/static/tests/web/fields/many2many_tags_email_tests.js
@@ -31,9 +31,9 @@ QUnit.test("fieldmany2many tags email (edition)", async (assert) => {
     const { openView } = await start({
         serverData: { views },
         mockRPC(route, args) {
-            if (args.method === "read" && args.model === "res.partner") {
+            if (args.method === "web_read" && args.model === "res.partner") {
                 assert.step(JSON.stringify(args.args[0]));
-                assert.ok(args.args[1].includes("email"));
+                assert.ok("email" in args.kwargs.specification);
             } else if (args.method === "get_formview_id") {
                 return false;
             }
@@ -48,7 +48,7 @@ QUnit.test("fieldmany2many tags email (edition)", async (assert) => {
         { mode: "edit" }
     );
 
-    assert.verifySteps([`[${partnerId_1}]`]);
+    assert.verifySteps([]);
     assert.containsOnce(
         $,
         '.o_field_many2many_tags_email[name="partner_ids"] .badge.o_tag_color_0'
@@ -88,7 +88,7 @@ QUnit.test("fieldmany2many tags email (edition)", async (assert) => {
     assert.hasAttrValue(firstTag.querySelector(".o_badge_text"), "title", "coucou@petite.perruche");
     // should have read Partner_1 three times: when opening the dropdown, when opening the modal, and
     // after the save
-    assert.verifySteps([`[${partnerId_2}]`, `[${partnerId_2}]`, `[${partnerId_2}]`]);
+    assert.verifySteps([`[${partnerId_2}]`, `[${partnerId_2}]`, `[${partnerId_1},${partnerId_2}]`]);
 });
 
 QUnit.test("many2many_tags_email widget can load more than 40 records", async (assert) => {
diff --git a/addons/mail/static/tests/web/fields/onchange_on_keydown_tests.js b/addons/mail/static/tests/web/fields/onchange_on_keydown_tests.js
index 5586110e1d6..aabe838c580 100644
--- a/addons/mail/static/tests/web/fields/onchange_on_keydown_tests.js
+++ b/addons/mail/static/tests/web/fields/onchange_on_keydown_tests.js
@@ -44,7 +44,7 @@ QUnit.test(
                     <field name="description" onchange_on_keydown="True" keydown_debounce_delay="0"/>
                 </form>`,
             mockRPC(route, params) {
-                if (params.method === "onchange") {
+                if (params.method === "onchange2") {
                     // the onchange will be called twice: at record creation & when keydown is detected
                     // the second call should have our description value completed.
                     assert.ok(true);
@@ -54,7 +54,9 @@ QUnit.test(
                     ) {
                         assert.ok(true);
                     }
-                    return {};
+                    return {
+                        value: {},
+                    };
                 }
             },
         });
diff --git a/addons/mail/static/tests/web/follower_tests.js b/addons/mail/static/tests/web/follower_tests.js
index 6dca9228a55..6adc967f566 100644
--- a/addons/mail/static/tests/web/follower_tests.js
+++ b/addons/mail/static/tests/web/follower_tests.js
@@ -172,7 +172,7 @@ QUnit.test("remove a follower in a dirty form view", async (assert) => {
         "res.partner,false,form": `
             <form>
                 <field name="name"/>
-                <field name="channel_ids" widget="many2many_tags" options="{'color_field': 'color'}"/>
+                <field name="channel_ids" widget="many2many_tags"/>
                 <div class="oe_chatter">
                     <field name="message_ids"/>
                     <field name="message_follower_ids"/>
@@ -206,7 +206,7 @@ QUnit.test("removing a follower should reload form view", async function (assert
     });
     const { openFormView } = await start({
         async mockRPC(route, args) {
-            if (args.method === "read") {
+            if (args.method === "web_read") {
                 assert.step(`read ${args.args[0][0]}`);
             }
         },
diff --git a/addons/mass_mailing/static/src/js/mailing_m2o_filter.js b/addons/mass_mailing/static/src/js/mailing_m2o_filter.js
index 5efb631e7a2..4485dc1c2a4 100644
--- a/addons/mass_mailing/static/src/js/mailing_m2o_filter.js
+++ b/addons/mass_mailing/static/src/js/mailing_m2o_filter.js
@@ -113,7 +113,7 @@ export class FieldMany2OneMailingFilter extends Many2OneField {
         ev.target.disabled = true;
 
         await this.orm.unlink('mailing.filter', [filterId]);
-        this.update([{ id: false, name: false }]);
+        this.update(false);
         this.props.record.update({[this.props.domain_field]: mailingDomain});
     }
 
diff --git a/addons/mrp/static/src/widgets/timer.js b/addons/mrp/static/src/widgets/timer.js
index 63940a502d3..c56689bef6a 100644
--- a/addons/mrp/static/src/widgets/timer.js
+++ b/addons/mrp/static/src/widgets/timer.js
@@ -120,7 +120,7 @@ class MrpTimerField extends Component {
     }
 
     get durationFormatted() {
-        if (this.props.record.data[this.props.name] != this.duration && this.props.record.isDirty) {
+        if (this.props.record.data[this.props.name] != this.duration && this.props.record.dirty) {
             this.duration = this.props.record.data[this.props.name];
         }
         return formatMinutes(this.duration);
diff --git a/addons/mrp_subcontracting/__manifest__.py b/addons/mrp_subcontracting/__manifest__.py
index 2459f28ddd4..a7e2574d2f6 100644
--- a/addons/mrp_subcontracting/__manifest__.py
+++ b/addons/mrp_subcontracting/__manifest__.py
@@ -57,6 +57,7 @@
             'web/static/src/views/form/**/*',
             'web/static/src/views/kanban/**/*',
             'web/static/src/views/list/**/*',
+            'web/static/src/model/**/*',
             'web/static/src/views/view_button/**/*',
             'web/static/src/views/view_components/**/*',
             'web/static/src/views/view_dialogs/**/*',
@@ -115,13 +116,9 @@
             'web/static/src/legacy/js/fields/relational_fields.js',
             'web/static/src/legacy/js/fields/field_registry.js',
             'web/static/src/legacy/js/fields/field_utils.js',
-            'web/static/src/legacy/js/views/abstract_model.js',
-            'web/static/src/legacy/js/views/basic/basic_model.js',
-            'web/static/src/legacy/js/views/view_utils.js',
             'web/static/src/legacy/js/services/data_manager.js',
             'web/static/src/legacy/js/services/session.js',
             'web/static/src/legacy/js/tools/tools.js',
-            'web/static/src/legacy/js/views/**/*',
             'web/static/src/legacy/js/widgets/date_picker.js',
             'web/static/src/legacy/js/widgets/domain_selector_dialog.js',
             'web/static/src/legacy/js/widgets/domain_selector.js',
diff --git a/addons/point_of_sale/__manifest__.py b/addons/point_of_sale/__manifest__.py
index 90d7af5c558..0393ac77e6f 100644
--- a/addons/point_of_sale/__manifest__.py
+++ b/addons/point_of_sale/__manifest__.py
@@ -169,6 +169,7 @@
             'web/static/src/views/view_hook.js',
             'web/static/src/views/view_service.js',
             'web/static/src/views/view.js',
+            'web/static/src/model/relational_model/utils.js',
             'web/static/src/webclient/actions/action_container.js',
             'web/static/src/webclient/actions/action_dialog.js',
             'web/static/src/webclient/actions/action_hook.js',
diff --git a/addons/point_of_sale/static/src/app/customer_display/customer_display_service.js b/addons/point_of_sale/static/src/app/customer_display/customer_display_service.js
index 9f3288f6fc9..d5f5756839e 100644
--- a/addons/point_of_sale/static/src/app/customer_display/customer_display_service.js
+++ b/addons/point_of_sale/static/src/app/customer_display/customer_display_service.js
@@ -1,6 +1,6 @@
 /** @odoo-module */
 
-import { batched } from "@point_of_sale/utils";
+import { batched } from "@web/core/utils/timing";
 import { registry } from "@web/core/registry";
 import { pick } from "@web/core/utils/objects";
 import { Reactive, effect } from "@web/core/utils/reactive";
diff --git a/addons/point_of_sale/static/src/app/store/pos_store.js b/addons/point_of_sale/static/src/app/store/pos_store.js
index e3497ed84dd..c760f2eb585 100644
--- a/addons/point_of_sale/static/src/app/store/pos_store.js
+++ b/addons/point_of_sale/static/src/app/store/pos_store.js
@@ -8,7 +8,7 @@ import { markRaw, reactive } from "@odoo/owl";
 import { roundPrecision as round_pr, floatIsZero } from "@web/core/utils/numbers";
 import { registry } from "@web/core/registry";
 import { ConfirmPopup } from "@point_of_sale/app/utils/confirm_popup/confirm_popup";
-import { batched, deduceUrl } from "@point_of_sale/utils";
+import { deduceUrl } from "@point_of_sale/utils";
 import { Reactive } from "@web/core/utils/reactive";
 import { HWPrinter } from "@point_of_sale/app/printer/hw_printer";
 import { memoize } from "@web/core/utils/functions";
@@ -20,6 +20,7 @@ import { sprintf } from "@web/core/utils/strings";
 import { PaymentScreen } from "@point_of_sale/app/screens/payment_screen/payment_screen";
 import { ProductScreen } from "@point_of_sale/app/screens/product_screen/product_screen";
 import { renderToString } from "@web/core/utils/render";
+import { batched } from "@web/core/utils/timing";
 
 /* Returns an array containing all elements of the given
  * array corresponding to the rule function {agg} and without duplicates
diff --git a/addons/point_of_sale/static/src/utils.js b/addons/point_of_sale/static/src/utils.js
index 8a0473ad674..ff854138b7f 100644
--- a/addons/point_of_sale/static/src/utils.js
+++ b/addons/point_of_sale/static/src/utils.js
@@ -1,30 +1,5 @@
 /** @odoo-module */
 
-/**
- * Creates a batched version of a callback so that all calls to it in the same
- * microtick will only call the original callback once.
- *
- * @param callback the callback to batch
- * @returns a batched version of the original callback
- */
-export function batched(callback) {
-    let called = false;
-    return async (...args) => {
-        // This await blocks all calls to the callback here, then releases them sequentially
-        // in the next microtick. This line decides the granularity of the batch.
-        await Promise.resolve();
-        if (!called) {
-            called = true;
-            // so that only the first call to the batched function calls the original callback.
-            // Schedule this before calling the callback so that calls to the batched function
-            // within the callback will proceed only after resetting called to false, and have
-            // a chance to execute the callback again
-            Promise.resolve().then(() => (called = false));
-            callback(...args);
-        }
-    };
-}
-
 /*
  * comes from o_spreadsheet.js
  * https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
diff --git a/addons/pos_self_order/static/src/self_order_bus_service.js b/addons/pos_self_order/static/src/self_order_bus_service.js
index 1516fd8beee..40710406605 100644
--- a/addons/pos_self_order/static/src/self_order_bus_service.js
+++ b/addons/pos_self_order/static/src/self_order_bus_service.js
@@ -2,7 +2,7 @@
 
 import { registry } from "@web/core/registry";
 import { effect } from "@web/core/utils/reactive";
-import { batched } from "@point_of_sale/utils";
+import { batched } from "@web/core/utils/timing";
 
 export class SelfOrderBus {
     static serviceDependencies = ["self_order", "orm", "bus_service"];
diff --git a/addons/pos_self_order/static/src/self_order_service.js b/addons/pos_self_order/static/src/self_order_service.js
index d8d1dd52519..0b9028ee46e 100644
--- a/addons/pos_self_order/static/src/self_order_service.js
+++ b/addons/pos_self_order/static/src/self_order_service.js
@@ -10,7 +10,7 @@ import { Order } from "./models/order";
 import { Product } from "./models/product";
 import { Line } from "./models/line";
 import { ConnectionLostError, RPCError } from "@web/core/network/rpc_service";
-import { batched } from "@point_of_sale/utils";
+import { batched } from "@web/core/utils/timing";
 
 export class SelfOrder {
     constructor(...args) {
diff --git a/addons/project/__manifest__.py b/addons/project/__manifest__.py
index 9ded0f5de02..cbafebfcdd8 100644
--- a/addons/project/__manifest__.py
+++ b/addons/project/__manifest__.py
@@ -100,9 +100,10 @@
 
             'web/static/src/core/utils/transitions.scss',
             'web/static/src/core/**/*',
+            'web/static/src/model/**/*',
             'web/static/src/search/**/*',
             'web/static/src/webclient/icons.scss', # variables required in list_controller.scss
-            'web/static/src/views/*.js',
+            'web/static/src/views/**/*.js',
             'web/static/src/views/*.xml',
             'web/static/src/views/*.scss',
             'web/static/src/views/fields/**/*',
@@ -168,13 +169,9 @@
             'web/static/src/legacy/js/fields/field_registry.js',
             'web/static/src/legacy/js/fields/field_registration.js',
             'web/static/src/legacy/js/fields/field_utils.js',
-            'web/static/src/legacy/js/views/abstract_model.js',
-            'web/static/src/legacy/js/views/basic/basic_model.js',
-            'web/static/src/legacy/js/views/view_utils.js',
             'web/static/src/legacy/js/services/data_manager.js',
             'web/static/src/legacy/js/services/session.js',
             'web/static/src/legacy/js/tools/tools.js',
-            'web/static/src/legacy/js/views/**/*',
             'web/static/src/legacy/js/widgets/date_picker.js',
             'web/static/src/legacy/js/widgets/domain_selector_dialog.js',
             'web/static/src/legacy/js/widgets/domain_selector.js',
diff --git a/addons/project/static/src/components/subtask_kanban_list/subtask_kanban_list.js b/addons/project/static/src/components/subtask_kanban_list/subtask_kanban_list.js
index 073b8fddcaf..ba1ea32b549 100644
--- a/addons/project/static/src/components/subtask_kanban_list/subtask_kanban_list.js
+++ b/addons/project/static/src/components/subtask_kanban_list/subtask_kanban_list.js
@@ -61,10 +61,12 @@ export class SubtaskKanbanList extends Component {
         return {
             display_name: {},
             state: {
+                name: "state",
                 viewType: "kanban",
                 field: getFieldFromRegistry(this.fields.state.type, "project_task_state_selection", "kanban"),
             },
             user_ids: {
+                name: "user_ids",
                 field: getFieldFromRegistry(this.fields.user_ids.type, "many2many_avatar_user", "kanban"),
             },
             project_id: {
@@ -74,6 +76,12 @@ export class SubtaskKanbanList extends Component {
     }
 
     async onSubTaskSaved(subTask) {
+        const ids = this.subTasksRead.map((t) => t.id);
+        this.subTasksRead = await this.orm.searchRead(
+            this.props.record.resModel,
+            [["id", "in", ids]],
+            this.fieldNames
+        );
         const isKnownAsClosed = this.subTaskClosed.has(subTask.resId);
         const isClosed = subTask.data.state.startsWith("1_");
         if (isKnownAsClosed && !isClosed) {
@@ -84,7 +92,6 @@ export class SubtaskKanbanList extends Component {
             return;
         }
         await this.props.record.load();
-        this.props.record.model.notify();
     }
 }
 
diff --git a/addons/project/static/src/project_sharing/views/list/list_renderer.js b/addons/project/static/src/project_sharing/views/list/list_renderer.js
index 0731a1ff419..043452befbf 100644
--- a/addons/project/static/src/project_sharing/views/list/list_renderer.js
+++ b/addons/project/static/src/project_sharing/views/list/list_renderer.js
@@ -1,7 +1,7 @@
 /** @odoo-module */
 
+import { evalDomain } from "@web/core/domain";
 import { ListRenderer } from "@web/views/list/list_renderer";
-import { evalDomain } from "@web/views/utils";
 
 const { onWillUpdateProps } = owl;
 
diff --git a/addons/project/static/src/views/project_project_kanban/project_project_kanban_header.js b/addons/project/static/src/views/project_project_kanban/project_project_kanban_header.js
index 482824aa1e2..8072bb9b534 100644
--- a/addons/project/static/src/views/project_project_kanban/project_project_kanban_header.js
+++ b/addons/project/static/src/views/project_project_kanban/project_project_kanban_header.js
@@ -12,9 +12,9 @@ export class ProjectProjectKanbanHeader extends KanbanHeader {
     async deleteGroup() {
         if (this.group.groupByField.name === 'stage_id') {
             const action = await this.group.model.orm.call(
-                this.group.resModel,
+                this.group.groupByField.relation,
                 'unlink_wizard',
-                [this.group.resId],
+                [this.group.value],
                 { context: this.group.context },
             );
             this.action.doAction(action);
diff --git a/addons/project/static/src/views/project_task_kanban/project_task_kanban_dynamic_group_list.js b/addons/project/static/src/views/project_task_kanban/project_task_kanban_dynamic_group_list.js
deleted file mode 100644
index 652e88b446b..00000000000
--- a/addons/project/static/src/views/project_task_kanban/project_task_kanban_dynamic_group_list.js
+++ /dev/null
@@ -1,49 +0,0 @@
-/** @odoo-module */
-
-import { KanbanDynamicGroupList } from "@web/views/kanban/kanban_model";
-import { Domain } from '@web/core/domain';
-import { session } from '@web/session';
-
-export class ProjectTaskKanbanDynamicGroupList extends KanbanDynamicGroupList {
-    get context() {
-        const context = super.context;
-        if (context.createPersonalStageGroup) {
-            context.default_user_id = context.uid;
-            delete context.createPersonalStageGroup;
-            delete context.default_project_id;
-        }
-        return context;
-    }
-
-    get isGroupedByStage() {
-        return !!this.groupByField && this.groupByField.name === 'stage_id';
-    }
-
-    get isGroupedByPersonalStages() {
-        return !!this.groupByField && this.groupByField.name === 'personal_stage_type_ids';
-    }
-
-    async _loadGroups() {
-        if (!this.isGroupedByPersonalStages) {
-            return super._loadGroups(...arguments);
-        }
-        const previousDomain = this.domain;
-        this.domain = Domain.and([[['user_ids', 'in', session.uid]], previousDomain]).toList({});
-        const result = await super._loadGroups(...arguments);
-        this.domain = previousDomain;
-        return result;
-    }
-
-    async createGroup() {
-        if (this.isGroupedByPersonalStages) {
-            this.defaultContext = Object.assign({}, this.defaultContext || {}, {
-                createPersonalStageGroup: true,
-            });
-        }
-        const result = await super.createGroup(...arguments);
-        if (this.isGroupedByPersonalStages) {
-            delete this.defaultContext.createPersonalStageGroup;
-        }
-        return result;
-    }
-}
diff --git a/addons/project/static/src/views/project_task_kanban/project_task_kanban_header.js b/addons/project/static/src/views/project_task_kanban/project_task_kanban_header.js
index e3e84099a2f..0c1bb3c679b 100644
--- a/addons/project/static/src/views/project_task_kanban/project_task_kanban_header.js
+++ b/addons/project/static/src/views/project_task_kanban/project_task_kanban_header.js
@@ -21,7 +21,6 @@ export class ProjectTaskKanbanHeader extends KanbanHeader {
     }
 
     editGroup() {
-        const { resModel, value } = this.group;
         const groupBy = this.props.list.groupBy;
         if (groupBy.length !== 1 || groupBy[0] !== 'personal_stage_type_ids') {
             super.editGroup();
@@ -32,8 +31,8 @@ export class ProjectTaskKanbanHeader extends KanbanHeader {
         });
         this.dialog.add(FormViewDialog, {
             context,
-            resId: value,
-            resModel: resModel,
+            resId: this.group.value,
+            resModel: this.group.groupByField.relation,
             title: this.env._t('Edit Personal Stage'),
             onRecordSaved: async () => {
                 await this.props.list.load();
@@ -45,9 +44,9 @@ export class ProjectTaskKanbanHeader extends KanbanHeader {
     async deleteGroup() {
         if (this.group.groupByField.name === 'stage_id') {
             const action = await this.group.model.orm.call(
-                this.group.resModel,
+                this.group.groupByField.relation,
                 'unlink_wizard',
-                [this.group.resId],
+                [this.group.value],
                 { context: this.group.context },
             );
             this.action.doAction(action);
diff --git a/addons/project/static/src/views/project_task_kanban/project_task_kanban_model.js b/addons/project/static/src/views/project_task_kanban/project_task_kanban_model.js
index 7da3d446612..ec3b88d798b 100644
--- a/addons/project/static/src/views/project_task_kanban/project_task_kanban_model.js
+++ b/addons/project/static/src/views/project_task_kanban/project_task_kanban_model.js
@@ -1,18 +1,53 @@
 /** @odoo-module */
 
-import { KanbanModel } from "@web/views/kanban/kanban_model";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 
-import { ProjectTaskKanbanDynamicGroupList } from "./project_task_kanban_dynamic_group_list";
-import { Record } from '@web/views/relational_model';
+export class ProjectTaskKanbanDynamicGroupList extends RelationalModel.DynamicGroupList {
+    get context() {
+        const context = { ...super.context };
+        if (this.creatingPersonnalStage) {
+            context.default_user_id = context.uid;
+            delete context.default_project_id;
+        }
+        return context;
+    }
 
-export class ProjectTaskRecord extends Record {
-    async _applyChanges(changes) {
+    get isGroupedByStage() {
+        return !!this.groupByField && this.groupByField.name === "stage_id";
+    }
+
+    get isGroupedByPersonalStages() {
+        return !!this.groupByField && this.groupByField.name === "personal_stage_type_ids";
+    }
+
+    async createGroup(groupName, groupData, isFolded) {
+        if (this.isGroupedByPersonalStages) {
+            return this.model.mutex.exec(async () => {
+                this.creatingPersonnalStage = true;
+                await this._createGroup(groupName, groupData, isFolded);
+                delete this.creatingPersonnalStage;
+            });
+        }
+        return super.createGroup(...arguments);
+    }
+
+    async _unlinkGroups(groups) {
+        if (this.isGroupedByPersonalStages) {
+            const groupResIds = groups.map((g) => g.value);
+            return this.model.orm.call("project.task.type", "remove_personal_stage", groupResIds);
+        }
+        return super._deleteGroups(...arguments);
+    }
+}
+
+export class ProjectTaskRecord extends RelationalModel.Record {
+    async _update(changes, options) {
         const value = changes.personal_stage_type_ids;
         if (Array.isArray(value)) {
             delete changes.personal_stage_type_ids;
             changes.personal_stage_type_id = value;
         }
-        await super._applyChanges(changes);
+        await super._update(changes, options);
     }
 
     get context() {
@@ -26,23 +61,7 @@ export class ProjectTaskRecord extends Record {
     }
 }
 
-export class ProjectTaskKanbanGroup extends KanbanModel.Group {
-    get isPersonalStageGroup() {
-        return !!this.groupByField && this.groupByField.name === 'personal_stage_type_ids';
-    }
-
-    async delete() {
-        if (this.isPersonalStageGroup) {
-            this.deleted = true;
-            return await this.model.orm.call(this.resModel, 'remove_personal_stage', [this.resId]);
-        } else {
-            return await super.delete();
-        }
-    }
-}
-
-export class ProjectTaskKanbanModel extends KanbanModel { }
+export class ProjectTaskKanbanModel extends RelationalModel {}
 
 ProjectTaskKanbanModel.DynamicGroupList = ProjectTaskKanbanDynamicGroupList;
-ProjectTaskKanbanModel.Group = ProjectTaskKanbanGroup;
 ProjectTaskKanbanModel.Record = ProjectTaskRecord;
diff --git a/addons/project/static/tests/project_subtask_kanban_list_tests.js b/addons/project/static/tests/project_subtask_kanban_list_tests.js
index dc528262ddf..11d2b1e259f 100644
--- a/addons/project/static/tests/project_subtask_kanban_list_tests.js
+++ b/addons/project/static/tests/project_subtask_kanban_list_tests.js
@@ -110,8 +110,9 @@ QUnit.module('Subtask Kanban List tests', {
         assert.verifySteps([
             "project.task/search_read",
             "project.task/write",
-            "project.task/read",
-            "project.task/read", // read the parent task to recompute the subtask count
+            "project.task/web_read",
+            "project.task/search_read",
+            "project.task/web_read", // read the parent task to recompute the subtask count
         ]);
     });
 });
diff --git a/addons/project/static/tests/tours/project_update_tour_tests.js b/addons/project/static/tests/tours/project_update_tour_tests.js
index 74a8ad44076..23a7cafbd96 100644
--- a/addons/project/static/tests/tours/project_update_tour_tests.js
+++ b/addons/project/static/tests/tours/project_update_tour_tests.js
@@ -4,11 +4,10 @@ import { registry } from "@web/core/registry";
 import { stepUtils } from "@web_tour/tour_service/tour_utils";
 
 function openProjectUpdateAndReturnToTasks(view, viewClass) {
-    const legacyViewClass = viewClass.replace("o_", "o_legacy_");
     return [{
             trigger: '.o_project_updates_breadcrumb',
             content: 'Open Project Update from view : ' + view,
-            extra_trigger: `.${viewClass}, .${legacyViewClass}`,
+            extra_trigger: `.${viewClass}`,
         }, {
             trigger: ".o-kanban-button-new",
             content: "Create a new update from project task view : " + view,
diff --git a/addons/project/views/project_update_templates.xml b/addons/project/views/project_update_templates.xml
index 3c5c783ee50..2af01b9e706 100644
--- a/addons/project/views/project_update_templates.xml
+++ b/addons/project/views/project_update_templates.xml
@@ -29,7 +29,7 @@
 
 <ul class="o_checklist" t-if="milestones['list']">
 <t t-foreach="milestones['list']" t-as="milestone">
-<li t-attf-class="{{milestone['is_reached'] and 'o_checked' or ''}}">
+<li t-att-class="milestone['is_reached'] and 'o_checked'" t-attf-id="checkId-{{milestone_index}}">
 <t t-esc="milestone['name']"/>
 <span t-if="milestone['is_deadline_future'] and not milestone['is_reached'] and not milestone['can_be_marked_as_done']"><font style="color: rgb(190, 190, 190);"><t t-set="color_level" t-value="64"/><t t-call="project.milestone_deadline"/></font></span>
 <span t-elif="milestone['is_deadline_exceeded']"><font style="color: rgb(255, 0, 0);"><t t-call="project.milestone_deadline"/></font></span>
diff --git a/addons/purchase_product_matrix/static/src/js/purchase_product_field.js b/addons/purchase_product_matrix/static/src/js/purchase_product_field.js
index c9dc721eb08..106c68a3508 100644
--- a/addons/purchase_product_matrix/static/src/js/purchase_product_field.js
+++ b/addons/purchase_product_matrix/static/src/js/purchase_product_field.js
@@ -4,9 +4,7 @@ import { registry } from '@web/core/registry';
 import { Many2OneField, many2OneField } from '@web/views/fields/many2one/many2one_field';
 import { ProductMatrixDialog } from "@product_matrix/js/product_matrix_dialog";
 import { useService } from "@web/core/utils/hooks";
-
-const { onWillUpdateProps } = owl;
-
+import { useRecordObserver } from "@web/model/relational_model/utils";
 
 export class PurchaseOrderLineProductField extends Many2OneField {
 
@@ -15,12 +13,9 @@ export class PurchaseOrderLineProductField extends Many2OneField {
         this.dialog = useService("dialog");
         this.currentValue = this.value;
 
-        onWillUpdateProps(async (nextProps) => {
-            if (nextProps.record.mode === 'edit' && nextProps.record.data[nextProps.name]) {
-                if (
-                    !this.currentValue ||
-                    this.currentValue[0] != nextProps.record.data[nextProps.name][0]
-                ) {
+        useRecordObserver((record) => {
+            if (record.isInEdition && this.value) {
+                if (!this.currentValue || this.currentValue[0] != record.data[this.props.name][0]) {
                     // Field was updated if line was open in edit mode,
                     //      field is not emptied,
                     //      new value is different than existing value.
@@ -28,7 +23,7 @@ export class PurchaseOrderLineProductField extends Many2OneField {
                     this._onProductTemplateUpdate();
                 }
             }
-            this.currentValue = nextProps.record.data[nextProps.name];
+            this.currentValue = record.data[this.props.name];
         });
     }
 
@@ -75,10 +70,10 @@ export class PurchaseOrderLineProductField extends Many2OneField {
         if (edit) {
             // provide attributes of edited line to automatically focus on matching cell in the matrix
             for (let ptnvav of this.props.record.data.product_no_variant_attribute_value_ids.records) {
-                updatedLineAttributes.push(ptnvav.data.id);
+                updatedLineAttributes.push(ptnvav.resId);
             }
             for (let ptav of this.props.record.data.product_template_attribute_value_ids.records) {
-                updatedLineAttributes.push(ptav.data.id);
+                updatedLineAttributes.push(ptav.resId);
             }
             updatedLineAttributes.sort((a, b) => { return a - b; });
         }
@@ -91,7 +86,7 @@ export class PurchaseOrderLineProductField extends Many2OneField {
 
         if (!edit) {
             // remove new line used to open the matrix
-            PurchaseOrderRecord.data.order_line.removeRecord(this.props.record);
+            PurchaseOrderRecord.data.order_line.delete(this.props.record);
         }
     }
 
diff --git a/addons/purchase_requisition/static/src/widgets/purchase_order_alternatives_widget.js b/addons/purchase_requisition/static/src/widgets/purchase_order_alternatives_widget.js
index e02ec9b3589..98f7bac7554 100644
--- a/addons/purchase_requisition/static/src/widgets/purchase_order_alternatives_widget.js
+++ b/addons/purchase_requisition/static/src/widgets/purchase_order_alternatives_widget.js
@@ -8,7 +8,7 @@ import { ListRenderer } from "@web/views/list/list_renderer";
 
 export class FieldMany2ManyAltPOsRenderer extends ListRenderer {
    isCurrentRecord(record) {
-      return record.data.id === this.env.model.root.data.id;
+      return record.resId === this.props.list.model.root.resId;
   }
 }
 
@@ -31,8 +31,8 @@ export class FieldMany2ManyAltPOs extends X2ManyField {
     * @override
     */
    async openRecord(record) {
-      if (record.data.id !== this.props.record.data.id) {
-         const action = await this.orm.call(record.resModel, "get_formview_action", [[record.data.id]], {
+      if (record.resId !== this.props.record.resId) {
+         const action = await this.orm.call(record.resModel, "get_formview_action", [[record.resId]], {
                context: this.props.context,
          });
          await this.action.doAction(action);
diff --git a/addons/sale/static/src/js/product_catalog/kanban_model.js b/addons/sale/static/src/js/product_catalog/kanban_model.js
index b824b845654..deaa853f9cc 100644
--- a/addons/sale/static/src/js/product_catalog/kanban_model.js
+++ b/addons/sale/static/src/js/product_catalog/kanban_model.js
@@ -1,25 +1,17 @@
 /** @odoo-module */
-import { KanbanModel, KanbanDynamicRecordList } from "@web/views/kanban/kanban_model";
 
-export class ProductCatalogKanbanDynamicRecordList extends KanbanDynamicRecordList {
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 
-    async load(params = {}) {
+export class ProductCatalogKanbanModel extends RelationalModel {
+    async load() {
         await super.load(...arguments);
-        await this._loadCatalogData();
-    }
 
-    async _loadCatalogData() {
-        const saleOrderLinesInfo = await this.model.rpc("/sales/catalog/sale_order_lines_info", {
-            order_id: this.context.order_id,
-            product_ids: this.records.map((rec) => rec.resId),
+        const saleOrderLinesInfo = await this.rpc("/sales/catalog/sale_order_lines_info", {
+            order_id: this.config.context.order_id,
+            product_ids: this.root.records.map((rec) => rec.resId),
         });
-
-        for (const record of this.records) {
+        for (const record of this.root.records) {
             record.productCatalogData = saleOrderLinesInfo[record.resId];
         }
     }
 }
-
-export class ProductCatalogKanbanModel extends KanbanModel {}
-
-ProductCatalogKanbanModel.DynamicRecordList = ProductCatalogKanbanDynamicRecordList;
diff --git a/addons/sale/static/src/js/product_discount_field.js b/addons/sale/static/src/js/product_discount_field.js
index cd248f9f400..5e3a6b60c94 100644
--- a/addons/sale/static/src/js/product_discount_field.js
+++ b/addons/sale/static/src/js/product_discount_field.js
@@ -28,7 +28,7 @@ export class ProductDiscountField extends FloatField {
             return;
         }
 
-        const isFirstOrderLine = this.props.record.data.id === orderLines[0].data.id;
+        const isFirstOrderLine = this.props.record.resId === orderLines[0].data.id;
         if (isFirstOrderLine && sameValue(orderLines)) {
             this.dialogService.add(ConfirmationDialog, {
                 body: _lt("Do you want to apply this value to all lines?"),
diff --git a/addons/sale/static/tests/sale_product_field_tests.js b/addons/sale/static/tests/sale_product_field_tests.js
index deae3805b72..630c4c4682e 100644
--- a/addons/sale/static/tests/sale_product_field_tests.js
+++ b/addons/sale/static/tests/sale_product_field_tests.js
@@ -34,7 +34,13 @@ QUnit.module("Fields", (hooks) => {
                 },
                 'sale.order.line': {
                     fields: {
-                        product_template_id: { 
+                        order_id: {
+                            string: "Order Reference",
+                            type: "many2one",
+                            relation: "sale.order",
+                            relation_field: "order_line",
+                        },
+                        product_template_id: {
                             string: "Product",
                             type: "many2one",
                             relation: "product.template",
@@ -112,8 +118,8 @@ QUnit.module("Fields", (hooks) => {
         assert.containsOnce(target, ".modal:contains(Create new product as a new Product)")
         assert.verifySteps([
             "get_views",
-            "onchange",
-            "onchange",
+            "onchange2",
+            "onchange2",
             "name_search",
         ]);
 
diff --git a/addons/sale_management/views/sale_order_views.xml b/addons/sale_management/views/sale_order_views.xml
index 2549edfb809..b1c9bf0229a 100644
--- a/addons/sale_management/views/sale_order_views.xml
+++ b/addons/sale_management/views/sale_order_views.xml
@@ -10,7 +10,7 @@
                 <page string="Optional Products"
                     name="optional_products"
                     attrs="{'invisible': [('state', 'not in', ['draft', 'sent'])]}">
-                    <field name="sale_order_option_ids" mode="tree,form,kanban">
+                    <field name="sale_order_option_ids" mode="tree,kanban">
                         <form string="Optional Products">
                             <group>
                                 <field name="product_id"
diff --git a/addons/sale_product_configurator/static/src/js/product_configurator_dialog/product_configurator_dialog.js b/addons/sale_product_configurator/static/src/js/product_configurator_dialog/product_configurator_dialog.js
index 2e1d267e847..2a388ece082 100644
--- a/addons/sale_product_configurator/static/src/js/product_configurator_dialog/product_configurator_dialog.js
+++ b/addons/sale_product_configurator/static/src/js/product_configurator_dialog/product_configurator_dialog.js
@@ -368,55 +368,6 @@ export class ProductConfiguratorDialog extends Component {
         );
     }
 
-    /**
-     * Serialize the product into a format understandable by `sale.order.line`.
-     *
-     * @param {Object} product - The product to serialize.
-     * @return {Object} - The serialized product.
-     */
-    _serializeProduct(product) {
-        let serializedProduct = {
-            product_id: [product.id, product.display_name],
-            product_uom_qty: product.quantity,
-        }
-
-        // handle custom values & no variants
-        let customValuesCommands = [{ operation: "DELETE_ALL" }];
-        for (const ptal of product.attribute_lines) {
-            const selectedCustomPTAV = ptal.attribute_values.find(
-                ptav => ptav.is_custom && ptav.id === ptal.selected_attribute_value_id
-            );
-            if (selectedCustomPTAV) customValuesCommands.push({
-                operation: "CREATE",
-                context: [
-                    {
-                        default_custom_product_template_attribute_value_id: selectedCustomPTAV.id,
-                        default_custom_value: ptal.customValue,
-                    },
-                ],
-            });
-        }
-        serializedProduct.product_custom_attribute_value_ids = {
-            operation: "MULTI",
-            commands: customValuesCommands,
-        };
-
-        let noVariantCommands = [{ operation: "DELETE_ALL" }];
-        const noVariantPTAVIds = product.attribute_lines.filter(
-            ptal => ptal.create_variant === "no_variant" && ptal.attribute_values.length > 1
-        ).map(ptal => { return {id: ptal.selected_attribute_value_id}});
-        if (noVariantPTAVIds.length) noVariantCommands.push({
-            operation: "ADD_M2M",
-            ids: noVariantPTAVIds,
-        });
-        serializedProduct.product_no_variant_attribute_value_ids = {
-            operation: "MULTI",
-            commands: noVariantCommands,
-        };
-
-        return serializedProduct;
-    }
-
     /**
      * Confirm the current combination(s).
      *
@@ -435,12 +386,12 @@ export class ProductConfiguratorDialog extends Component {
             }
         }
         await this.props.save(
-            this._serializeProduct(this.state.products.find(
+            this.state.products.find(
                 p => p.product_tmpl_id === this.env.mainProductTmplId
-            )),
+            ),
             this.state.products.filter(
                 p => p.product_tmpl_id !== this.env.mainProductTmplId
-            ).map(p => this._serializeProduct(p)),
+            ),
         );
         this.props.close();
     }
diff --git a/addons/sale_product_configurator/static/src/js/sale_product_field.js b/addons/sale_product_configurator/static/src/js/sale_product_field.js
index 74560f088f8..7761df6c7fd 100644
--- a/addons/sale_product_configurator/static/src/js/sale_product_field.js
+++ b/addons/sale_product_configurator/static/src/js/sale_product_field.js
@@ -6,6 +6,36 @@ import { SaleOrderLineProductField } from '@sale/js/sale_product_field';
 import { serializeDateTime } from "@web/core/l10n/dates";
 import { ProductConfiguratorDialog } from "./product_configurator_dialog/product_configurator_dialog";
 
+async function applyProduct(record, product) {
+    // handle custom values & no variants
+    const contextRecords = [];
+    for (const ptal of product.attribute_lines) {
+        const selectedCustomPTAV = ptal.attribute_values.find(
+            ptav => ptav.is_custom && ptav.id === ptal.selected_attribute_value_id
+        );
+        if (selectedCustomPTAV) {
+            contextRecords.push({
+                default_custom_product_template_attribute_value_id: selectedCustomPTAV.id,
+                default_custom_value: ptal.customValue,
+            });
+        };
+    }
+
+    const proms = [];
+    proms.push(record.data.product_custom_attribute_value_ids.createAndReplace(contextRecords));
+
+    const noVariantPTAVIds = product.attribute_lines.filter(
+        ptal => ptal.create_variant === "no_variant" && ptal.attribute_values.length > 1
+    ).map(ptal => ptal.selected_attribute_value_id);
+
+    proms.push(record.data.product_no_variant_attribute_value_ids.replaceWith(noVariantPTAVIds, { silent: true }));
+    await Promise.all(proms);
+    await record.update({
+        product_id: [product.id, product.display_name],
+        product_uom_qty: product.quantity,
+    });
+};
+
 patch(SaleOrderLineProductField.prototype, 'sale_product_configurator', {
 
     setup() {
@@ -78,9 +108,9 @@ patch(SaleOrderLineProductField.prototype, 'sale_product_configurator', {
         this.dialog.add(ProductConfiguratorDialog, {
             productTemplateId: this.props.record.data.product_template_id[0],
             ptavIds: this.props.record.data.product_template_attribute_value_ids.records.map(
-                record => record.data.id
+                record => record.resId
             ).concat(this.props.record.data.product_no_variant_attribute_value_ids.records.map(
-                record => record.data.id
+                record => record.resId
             )),
             customAttributeValues: customAttributeValues.map(
                 data => {
@@ -98,18 +128,20 @@ patch(SaleOrderLineProductField.prototype, 'sale_product_configurator', {
             soDate: serializeDateTime(saleOrderRecord.data.date_order),
             edit: edit,
             save: async (mainProduct, optionalProducts) => {
-                await this.props.record.update(mainProduct);
+                await applyProduct(this.props.record, mainProduct);
+
                 this._onProductUpdate();
+                saleOrderRecord.data.order_line.leaveEditMode();
                 for (const optionalProduct of optionalProducts) {
-                    const line = await saleOrderRecord.data.order_line.addNew({
+                    const line = await saleOrderRecord.data.order_line.addNewRecord({
                         position: 'bottom',
+                        mode: "readonly",
                     });
-                    line.update(optionalProduct);
+                    await applyProduct(line, optionalProduct);
                 }
-                saleOrderRecord.data.order_line.unselectRecord();
             },
             discard: () => {
-                saleOrderRecord.data.order_line.removeRecord(this.props.record);
+                saleOrderRecord.data.order_line.delete(this.props.record);
             },
         });
     },
diff --git a/addons/sale_product_matrix/static/src/js/sale_product_field.js b/addons/sale_product_matrix/static/src/js/sale_product_field.js
index 008497c46bd..0c96a182819 100644
--- a/addons/sale_product_matrix/static/src/js/sale_product_field.js
+++ b/addons/sale_product_matrix/static/src/js/sale_product_field.js
@@ -26,10 +26,10 @@ patch(SaleOrderLineProductField.prototype, 'sale_product_matrix', {
         if (edit) {
             // provide attributes of edited line to automatically focus on matching cell in the matrix
             for (let ptnvav of this.props.record.data.product_no_variant_attribute_value_ids.records) {
-                updatedLineAttributes.push(ptnvav.data.id);
+                updatedLineAttributes.push(ptnvav.resId);
             }
             for (let ptav of this.props.record.data.product_template_attribute_value_ids.records) {
-                updatedLineAttributes.push(ptav.data.id);
+                updatedLineAttributes.push(ptav.resId);
             }
             updatedLineAttributes.sort((a, b) => { return a - b; });
         }
@@ -42,7 +42,7 @@ patch(SaleOrderLineProductField.prototype, 'sale_product_matrix', {
 
         if (!edit) {
             // remove new line used to open the matrix
-            saleOrderRecord.data.order_line.removeRecord(this.props.record);
+            saleOrderRecord.data.order_line.delete(this.props.record);
         }
     },
 
diff --git a/addons/sale_stock/static/src/widgets/qty_at_date_widget.js b/addons/sale_stock/static/src/widgets/qty_at_date_widget.js
index be3893c32ea..d4a90f09e15 100644
--- a/addons/sale_stock/static/src/widgets/qty_at_date_widget.js
+++ b/addons/sale_stock/static/src/widgets/qty_at_date_widget.js
@@ -19,8 +19,8 @@ export class QtyAtDatePopover extends Component {
                 active_model: 'product.product',
                 active_id: this.props.record.data.product_id[0],
                 warehouse: this.props.record.data.warehouse_id && this.props.record.data.warehouse_id[0],
-                move_to_match_ids: this.props.record.data.move_ids.records.map(record => record.data.id),
-                sale_line_to_match_id: this.props.record.data.id,
+                move_to_match_ids: this.props.record.data.move_ids.records.map(record => record.resId),
+                sale_line_to_match_id: this.props.record.resId,
             },
         });
     }
diff --git a/addons/spreadsheet/static/src/list/list_data_source.js b/addons/spreadsheet/static/src/list/list_data_source.js
index e902d52c0c0..1945d4e8403 100644
--- a/addons/spreadsheet/static/src/list/list_data_source.js
+++ b/addons/spreadsheet/static/src/list/list_data_source.js
@@ -4,13 +4,13 @@ import { OdooViewsDataSource } from "@spreadsheet/data_sources/odoo_views_data_s
 import { LoadingDataError } from "@spreadsheet/o_spreadsheet/errors";
 import { _t } from "@web/core/l10n/translation";
 import { sprintf } from "@web/core/utils/strings";
-import { orderByToString } from "@web/views/utils";
 import {
     formatDateTime,
     deserializeDateTime,
     formatDate,
     deserializeDate,
 } from "@web/core/l10n/dates";
+import { orderByToString } from "@web/search/utils/order_by";
 
 import * as spreadsheet from "@odoo/o-spreadsheet";
 
diff --git a/addons/stock/static/src/fields/stock_move_line_x2_many_field.js b/addons/stock/static/src/fields/stock_move_line_x2_many_field.js
index 137e2558da7..5db1fc24658 100644
--- a/addons/stock/static/src/fields/stock_move_line_x2_many_field.js
+++ b/addons/stock/static/src/fields/stock_move_line_x2_many_field.js
@@ -21,7 +21,7 @@ export class SMLX2ManyField extends X2ManyField {
         this.openRecord = useOpenMany2XRecord({
             resModel: "stock.quant",
             activeActions: this.activeActions,
-            onRecordSaved: (resId) => this.selectRecord([resId.data.id]),
+            onRecordSaved: (record) => this.selectRecord([record.resId]),
             onRecordDiscarted: (resId) => this.selectRecord(resId),
             fieldString: this.props.string,
             is2Many: true,
diff --git a/addons/stock/static/src/views/list/inventory_report_list_controller.js b/addons/stock/static/src/views/list/inventory_report_list_controller.js
index 6d2dee0a9d8..405d81788f6 100644
--- a/addons/stock/static/src/views/list/inventory_report_list_controller.js
+++ b/addons/stock/static/src/views/list/inventory_report_list_controller.js
@@ -1,17 +1,9 @@
 /** @odoo-module */
 
-import { useBus } from "@web/core/utils/hooks";
 import { session } from "@web/session";
 import { ListController } from "@web/views/list/list_controller";
 
 export class InventoryReportListController extends ListController {
-    setup() {
-        super.setup();
-        if (this.props.context.inventory_mode || this.props.context.inventory_report_mode) {
-            useBus(this.model.bus, "record-updated", this.recordUpdated);
-        }
-    }
-
     get actionMenuItems() {
         const actionMenus = super.actionMenuItems;
         if (
@@ -28,37 +20,6 @@ export class InventoryReportListController extends ListController {
         return actionMenus;
     }
 
-    /**
-     * Handler called when a record has been created or updated.
-     * We need to detect when the user added to the list a quant which already exists
-     * (see stock.quant.create), either already loaded or not, to warn the user
-     * the quant was updated.
-     * This is done by checking :
-     * - the record id against the 'lastCreatedRecordId' on model
-     * - the create_date against the write_date (both are equal for newly created records).
-     *
-     * @param {CustomEvent<{ record: Record, relatedRecords: Record[] }>} event
-     */
-    async recordUpdated(event) {
-        const { record, relatedRecords } = event.detail;
-        const justCreated = record.id == record.model.lastCreatedRecordId;
-        if (justCreated && record.data.create_date.diff(record.data.write_date) != 0) {
-            this.notificationService.add(
-                this.env._t(
-                    "You tried to create a record that already exists. The existing record was modified instead."
-                ),
-                { title: this.env._t("This record already exists.") }
-            );
-            if (relatedRecords.length > 0) {
-                /* more than 1 'resId' record loaded in view (user added an already loaded record) :
-                 * - both have been updated
-                 * - remove the current record (the added one)
-                 */
-                this.model.root.removeRecord(record);
-            }
-        }
-    }
-
     /**
      * Handler called when the user clicked on the 'Apply all' button.
      */
diff --git a/addons/stock/static/src/views/list/inventory_report_list_model.js b/addons/stock/static/src/views/list/inventory_report_list_model.js
index b3b41ad0f0f..6c091fdbe89 100644
--- a/addons/stock/static/src/views/list/inventory_report_list_model.js
+++ b/addons/stock/static/src/views/list/inventory_report_list_model.js
@@ -1,28 +1,68 @@
 /** @odoo-module */
 
-import { RelationalModel, DynamicRecordList } from "@web/views/relational_model";
+import { DynamicRecordList } from "@web/model/relational_model/dynamic_record_list";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 
 export class InventoryReportListModel extends RelationalModel {
-
     /**
      * Override
      */
     setup(params, { action, dialog, notification, rpc, user, view, company }) {
         // model has not created any record yet
-        this.lastCreatedRecordId = "";
+        this._lastCreatedRecordId;
         return super.setup(...arguments);
     }
+
+    /**
+     * Function called when a record has been _load (after saved).
+     * We need to detect when the user added to the list a quant which already exists
+     * (see stock.quant.create), either already loaded or not, to warn the user
+     * the quant was updated.
+     * This is done by checking :
+     * - the record id against the '_lastCreatedRecordId' on model
+     * - the create_date against the write_date (both are equal for newly created records).
+     *
+     */
+    async _updateSimilarRecords(reloadedRecord, serverValues) {
+        if (this.config.isMonoRecord) {
+            return;
+        }
+
+        const justCreated = reloadedRecord.id == this._lastCreatedRecordId;
+        if (justCreated && serverValues.create_date !== serverValues.write_date) {
+            this.notification.add(
+                this.env._t(
+                    "You tried to create a record that already exists. The existing record was modified instead."
+                ),
+                { title: this.env._t("This record already exists.") }
+            );
+            const duplicateRecords = this.root.records.filter(
+                (record) => record.resId === reloadedRecord.resId && record.id !== reloadedRecord.id
+            );
+            if (duplicateRecords.length > 0) {
+                /* more than 1 'resId' record loaded in view (user added an already loaded record) :
+                 * - both have been updated
+                 * - remove the current record (the added one)
+                 */
+                await this.root._removeRecords([reloadedRecord.id]);
+                for (const record of duplicateRecords) {
+                    record._applyValues(serverValues);
+                }
+            }
+        } else {
+            super._updateSimilarRecords(...arguments)
+        }
+    }
 }
 
 export class InventoryReportListDynamicRecordList extends DynamicRecordList {
-
     /**
      * Override
      */
-    async createRecord(params = {}, atFirstPosition = false) {
-        const record = await super.createRecord(...arguments);
+    async addNewRecord() {
+        const record = await super.addNewRecord(...arguments);
         // keep created record id on model
-        record.model.lastCreatedRecordId = record.id;
+        record.model._lastCreatedRecordId = record.id;
         return record;
     }
 }
diff --git a/addons/stock/static/src/views/picking_form/picking_form_controller.js b/addons/stock/static/src/views/picking_form/picking_form_controller.js
index 8e982f330cb..46beeb74846 100644
--- a/addons/stock/static/src/views/picking_form/picking_form_controller.js
+++ b/addons/stock/static/src/views/picking_form/picking_form_controller.js
@@ -18,7 +18,7 @@ export class StockPickingFormController extends FormController {
         let record;
         if (id) {
             record = this.model.root.data.move_ids_without_package.records.find(
-                (e) => e.data.id == id
+                (e) => e.resId == id
             );
         } else {
             const moveByIdsDesc = sortBy(
@@ -27,7 +27,7 @@ export class StockPickingFormController extends FormController {
                 "desc"
             );
             record = moveByIdsDesc.find((e) => e.data.product_id[0] == ev.detail.product_id[0]);
-            id = record.data.id;
+            id = record.resId;
         }
         const action = await this.model.orm.call("stock.move", "action_show_details", [id]);
         if (action) {
diff --git a/addons/stock/static/src/views/picking_form/picking_form_model.js b/addons/stock/static/src/views/picking_form/picking_form_model.js
index ed0e61f68f4..c9207657837 100644
--- a/addons/stock/static/src/views/picking_form/picking_form_model.js
+++ b/addons/stock/static/src/views/picking_form/picking_form_model.js
@@ -1,12 +1,9 @@
 /** @odoo-module **/
 
-import { Record, RelationalModel } from "@web/views/basic_relational_model";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
+import { Record } from "@web/model/relational_model/record";
 
 export class StockPickingAutoSaveRecord extends Record {
-    setup(params, state) {
-        super.setup(params, state);
-    }
-
     async saveAndOpenDetails() {
         await new Promise((resolve) => {
             this.model.env.bus.trigger("STOCK_MOVE:UPDATED", { resolve });
diff --git a/addons/stock/static/src/widgets/stock_pick_from.js b/addons/stock/static/src/widgets/stock_pick_from.js
index f720d9029ee..4213d31c1cf 100644
--- a/addons/stock/static/src/widgets/stock_pick_from.js
+++ b/addons/stock/static/src/widgets/stock_pick_from.js
@@ -36,7 +36,7 @@ export class StockPickFrom extends Many2OneField {
 
     _quant_display_name() {
         let name_parts = [];
-        if (this.props.record.data.id) {
+        if (this.props.record.resId) {
             // if location group is activated
             const data = this.props.record.data;
             if (this.enabledGroups?.location && data.location_id) {
diff --git a/addons/survey/static/src/question_page/question_page_list_renderer.js b/addons/survey/static/src/question_page/question_page_list_renderer.js
index c709aa91119..926d6ce456d 100644
--- a/addons/survey/static/src/question_page/question_page_list_renderer.js
+++ b/addons/survey/static/src/question_page/question_page_list_renderer.js
@@ -61,7 +61,7 @@ export class QuestionPageListRenderer extends ListRenderer {
     getSectionColumns(columns) {
         let titleColumnIndex = 0;
         let found = false;
-        let colspan = 1
+        let colspan = 1;
         for (let index = 0; index < columns.length; index++) {
             const col = columns[index];
             if (!found && col.name !== this.titleField) {
@@ -78,9 +78,11 @@ export class QuestionPageListRenderer extends ListRenderer {
             colspan += 1;
         }
 
-        const sectionColumns = columns.slice(0, titleColumnIndex + 1).concat(columns.slice(titleColumnIndex + colspan));
+        const sectionColumns = columns
+            .slice(0, titleColumnIndex + 1)
+            .concat(columns.slice(titleColumnIndex + colspan));
 
-        sectionColumns[titleColumnIndex] = {...sectionColumns[titleColumnIndex], colspan};
+        sectionColumns[titleColumnIndex] = { ...sectionColumns[titleColumnIndex], colspan };
 
         return sectionColumns;
     }
@@ -103,9 +105,9 @@ export class QuestionPageListRenderer extends ListRenderer {
      * @override
      */
     focusCell(column, forward = true) {
-        const actualColumn = column.name ? this.state.columns.find(
-            (col) => col.name === column.name
-        ) : column;
+        const actualColumn = column.name
+            ? this.state.columns.find((col) => col.name === column.name)
+            : column;
         super.focusCell(actualColumn, forward);
     }
 
@@ -114,7 +116,7 @@ export class QuestionPageListRenderer extends ListRenderer {
             case "enter":
             case "tab":
             case "shift+tab": {
-                this.props.list.unselectRecord(true);
+                this.props.list.leaveEditMode();
                 return true;
             }
         }
@@ -131,10 +133,12 @@ export class QuestionPageListRenderer extends ListRenderer {
      * @return {Promise<void>}
      */
     async onDeleteRecord(record) {
-        const triggeredRecords = this.props.list.records.filter(rec => rec.data.triggering_question_id[0] === record.data.id);
+        const triggeredRecords = this.props.list.records.filter(
+            (rec) => rec.data.triggering_question_id[0] === record.resId
+        );
         if (triggeredRecords.length) {
             const res = await super.onDeleteRecord(record);
-            await this.props.list.model.root.save({stayInEdition: true});
+            await this.props.list.model.root.save({ stayInEdition: true });
             return res;
         } else {
             return super.onDeleteRecord(record);
diff --git a/addons/survey/static/src/question_page/question_page_one2many_field.js b/addons/survey/static/src/question_page/question_page_one2many_field.js
index 93ef62b4723..d6a5519b9a0 100644
--- a/addons/survey/static/src/question_page/question_page_one2many_field.js
+++ b/addons/survey/static/src/question_page/question_page_one2many_field.js
@@ -4,7 +4,6 @@ import { QuestionPageListRenderer } from "./question_page_list_renderer";
 import { registry } from "@web/core/registry";
 import { useOpenX2ManyRecord, useX2ManyCrud, X2ManyFieldDialog } from "@web/views/fields/relational_utils";
 import { patch } from '@web/core/utils/patch';
-import { useService } from "@web/core/utils/hooks";
 import { X2ManyField, x2ManyField } from "@web/views/fields/x2many/x2many_field";
 
 const { useSubEnv } = owl;
@@ -27,13 +26,34 @@ patch(X2ManyFieldDialog.prototype, 'survey_question_chaining_with_validation', {
     }
 });
 
+
+/**
+ * For convenience, we'll prevent closing the question form dialog and
+ * stay in edit mode to make sure only valid records are saved. Therefore,
+ * in case of error occurring when saving we will replace default error
+ * modal with a notification.
+ */
+
+class SurveySaveError extends Error {}
+function SurveySaveErrorHandler(env, error, originalError) {
+    if (originalError instanceof SurveySaveError) {
+        env.services.notification.add(originalError.message, {
+            title: env._t("Validation Error"),
+            type: "danger",
+        });
+        return true;
+    }
+}
+registry
+    .category("error_handlers")
+    .add("surveySaveErrorHandler", SurveySaveErrorHandler, { sequence: 10 });
+
 class QuestionPageOneToManyField extends X2ManyField {
     setup() {
         super.setup();
         useSubEnv({
             openRecord: (record) => this.openRecord(record),
         });
-        this.notificationService = useService("notification");
 
         // Systematically and automatically save SurveyForm at each question edit/creation
         // enables checking validation parameters consistency and using questions as triggers
@@ -46,23 +66,24 @@ class QuestionPageOneToManyField extends X2ManyField {
 
         const self = this;
         const saveRecord = async (record) => {
-            const saveResponse = await superSaveRecord(record);
+            await superSaveRecord(record);
             try {
-                await self.props.record.save({stayInEdition: true, throwOnError: true});
+                await self.props.record.save();
             } catch (error) {
-                return self.handleSurveySaveError(error, record);
+                // In case of error occurring when saving.
+                // Remove erroneous question row added to the embedded list
+                await this.list.delete(record);
+                throw new SurveySaveError(error.data.message);
             }
-            return saveResponse;
         };
 
         const updateRecord = async (record) => {
-            const updateResponse = await superUpdateRecord(record);
+            await superUpdateRecord(record);
             try {
-                await self.props.record.save({stayInEdition: true, throwOnError: true});
+                await self.props.record.save();
             } catch (error) {
-                return self.handleSurveySaveError(error);
+                throw new SurveySaveError(error.data.message);
             }
-            return updateResponse;
         };
 
         const openRecord = useOpenX2ManyRecord({
@@ -74,7 +95,7 @@ class QuestionPageOneToManyField extends X2ManyField {
             updateRecord,
         });
         this._openRecord = async (params) => {
-            if (!await self.props.record.save({ stayInEdition: true })) {
+            if (!await self.props.record.save()) {
                 // do not open question form as it won't be savable either.
                 return;
             }
@@ -88,35 +109,6 @@ class QuestionPageOneToManyField extends X2ManyField {
         };
         this.canOpenRecord = true;
     }
-
-    /**
-     * For convenience, we'll prevent closing the question form dialog and
-     * stay in edit mode to make sure only valid records are saved. Therefore,
-     * two things should be cared for in case of error occurring when saving
-     * the question:
-     *   * Remove erroneous question row added to the embedded list
-     *   * Replace default error modal with a notification
-     *
-     *   @param {Error} error Error thrown when saving survey/question.
-     *   @param {Record?} recordToDelete (optional) In case the error is
-     *   thrown when saving a new question, it should be deleted from the
-     *   list.
-     */
-    async handleSurveySaveError(error, recordToDelete) {
-        error.event.preventDefault();
-        if (recordToDelete) {
-            const listRecord = this.list.records.find(r => r.__bm_handle__ === recordToDelete.__bm_handle__);
-            await this.list.delete(listRecord.id);
-        }
-        this.notificationService.add(
-            error.message.data.message, {
-                title: this.env._t("Validation Error"),
-                type: "danger"
-            }
-        );
-        // Prevent closing the question form view
-        throw error;
-    }
 }
 QuestionPageOneToManyField.components = {
     ...X2ManyField.components,
diff --git a/addons/survey/static/src/views/widgets/survey_question_trigger/survey_question_trigger.js b/addons/survey/static/src/views/widgets/survey_question_trigger/survey_question_trigger.js
index 79c0af2296f..0e5778a1929 100644
--- a/addons/survey/static/src/views/widgets/survey_question_trigger/survey_question_trigger.js
+++ b/addons/survey/static/src/views/widgets/survey_question_trigger/survey_question_trigger.js
@@ -71,7 +71,7 @@ export class SurveyQuestionTriggerWidget extends Component {
             return "";
         }
         const triggerId = record.data.triggering_question_id[0];
-        let triggerRecord = record.model.root.data.question_and_page_ids.records.find(rec => rec.data.id === triggerId);
+        let triggerRecord = record.model.root.data.question_and_page_ids.records.find(rec => rec.resId === triggerId);
 
         if (!triggerRecord) {
             return "MISSING_TRIGGER_ERROR";
@@ -80,7 +80,7 @@ export class SurveyQuestionTriggerWidget extends Component {
             return "WRONG_QUESTIONS_SELECTION_WARNING";
         }
         if (record.data.sequence < triggerRecord.data.sequence ||
-            (record.data.sequence === triggerRecord.data.sequence && record.data.id < triggerId)) {
+            (record.data.sequence === triggerRecord.data.sequence && record.resId < triggerId)) {
             return "MISPLACED_TRIGGER_WARNING";
         }
         return "";
@@ -95,5 +95,9 @@ SurveyQuestionTriggerWidget.props = {
 export const surveyQuestionTriggerWidget = {
     component: SurveyQuestionTriggerWidget,
     displayName: "Trigger",
+    fieldDependencies: [
+        { name: "triggering_question_id", type: "many2one" },
+        { name: "triggering_answer_id", type: "many2one" },
+    ],
 };
 registry.category("view_widgets").add("survey_question_trigger", surveyQuestionTriggerWidget);
diff --git a/addons/survey/static/tests/components/question_page_one2many_field_tests.js b/addons/survey/static/tests/components/question_page_one2many_field_tests.js
index 93a61c227a1..7e909ecb6d0 100644
--- a/addons/survey/static/tests/components/question_page_one2many_field_tests.js
+++ b/addons/survey/static/tests/components/question_page_one2many_field_tests.js
@@ -1,9 +1,10 @@
 /** @odoo-module */
 
+import { makeServerError } from "@web/../tests/helpers/mock_server";
 import { click, editInput, getFixture, nextTick, triggerHotkey } from "@web/../tests/helpers/utils";
 import { makeView, setupViewRegistries } from "@web/../tests/views/helpers";
-
-import { makeServerError } from "@web/../tests/helpers/mock_server";
+import { errorService } from "@web/core/errors/error_service";
+import { registry } from "@web/core/registry";
 
 QUnit.module("QuestionPageOneToManyField", (hooks) => {
     let serverData;
@@ -170,6 +171,7 @@ QUnit.module("QuestionPageOneToManyField", (hooks) => {
     });
 
     QUnit.test("A validation error from saving parent form notifies and prevents dialog from closing", async (assert) => {
+        registry.category("services").add("error", errorService);
         await makeView({
             type: "form",
             resModel: "survey",
@@ -201,8 +203,11 @@ QUnit.module("QuestionPageOneToManyField", (hooks) => {
         await editInput(target, ".o_dialog:not(.o_inactive_modal) .modal-body [name='title'] input", "Invalid RecordTitle");
         await click(target.querySelector(".o_dialog:not(.o_inactive_modal) .o_form_button_save"));
         assert.verifySteps(["save parent form"]);
+        await nextTick();
         assert.containsOnce(document.body, ".o_notification");
         assert.containsOnce(target, ".modal .o_form_view");
+        assert.containsOnce(target, ".modal-dialog .o_form_button_save");
+        assert.containsNone(target, ".modal-dialog .o_form_button_save[disabled='1']");
     });
 
     QUnit.test("can create section inline", async (assert) => {
diff --git a/addons/survey/tests/test_survey_ui_backend.py b/addons/survey/tests/test_survey_ui_backend.py
index 1a56aaacb78..c4afa0145ab 100644
--- a/addons/survey/tests/test_survey_ui_backend.py
+++ b/addons/survey/tests/test_survey_ui_backend.py
@@ -3,7 +3,6 @@
 
 from odoo.tests import HttpCase, tagged
 
-
 @tagged('post_install', '-at_install')
 class TestUi(HttpCase):
 
diff --git a/addons/test_mail/static/tests/activity_tests.js b/addons/test_mail/static/tests/activity_tests.js
index 01b8f34d0ad..d6256a759e1 100644
--- a/addons/test_mail/static/tests/activity_tests.js
+++ b/addons/test_mail/static/tests/activity_tests.js
@@ -344,7 +344,7 @@ QUnit.module("test_mail", {}, function () {
         const { openView } = await start({
             serverData,
             mockRPC: function (route, args) {
-                if (["get_activity_data", "web_search_read"].includes(args.method)) {
+                if (["get_activity_data", "unity_web_search_read"].includes(args.method)) {
                     assert.step(JSON.stringify(args.kwargs.domain));
                 }
             },
@@ -1016,8 +1016,8 @@ QUnit.module("test_mail", {}, function () {
         const { target, openView } = await start({
             serverData,
             mockRPC(route, { method, kwargs }, result) {
-                if (method === "web_search_read") {
-                    assert.deepEqual(kwargs.fields, ["write_date", "id"]);
+                if (method === "unity_web_search_read") {
+                    assert.deepEqual(Object.keys(kwargs.specification), ["write_date", "id"]);
                     return Promise.resolve({
                         length: 2,
                         records: [
diff --git a/addons/test_sale_product_configurators/static/tests/tours/event_sale_with_product_configurator_ui.js b/addons/test_sale_product_configurators/static/tests/tours/event_sale_with_product_configurator_ui.js
index ed0c787db20..84711dd35ee 100644
--- a/addons/test_sale_product_configurators/static/tests/tours/event_sale_with_product_configurator_ui.js
+++ b/addons/test_sale_product_configurators/static/tests/tours/event_sale_with_product_configurator_ui.js
@@ -49,7 +49,7 @@ registry.category("web_tour.tours").add('event_sale_with_product_configurator_to
     extra_trigger: 'td[name="price_subtotal"]:contains("16.50")',  // wait for the optional product line
 }, {
     trigger: 'div[name="product_template_id"] input',
-    extra_trigger: '[name="product_template_id"] .o_dropdown_button',
+    extra_trigger: '.o_data_row:nth-child(3)',  // wait for the new row to be created
     run: 'text event (',
 }, {
     trigger: 'ul.ui-autocomplete a:contains("Registration Event (TEST variants)")',
@@ -83,7 +83,7 @@ registry.category("web_tour.tours").add('event_sale_with_product_configurator_to
     extra_trigger: 'td[name="price_subtotal"]:contains("150.00")',  // wait for the adult tickets line
 }, {
     trigger: 'div[name="product_template_id"] input',
-    extra_trigger: '[name="product_template_id"] .o_dropdown_button',
+    extra_trigger: '.o_data_row:nth-child(4)',  // wait for the new row to be created
     run: 'text event (',
 }, {
     trigger: 'ul.ui-autocomplete a:contains("Registration Event (TEST variants)")',
diff --git a/addons/web/__manifest__.py b/addons/web/__manifest__.py
index bb58bf57d3a..87af9250a1f 100644
--- a/addons/web/__manifest__.py
+++ b/addons/web/__manifest__.py
@@ -177,6 +177,7 @@ This module provides the core of the Odoo Web Client.
 
             'web/static/src/core/utils/transitions.scss',
             'web/static/src/core/**/*',
+            'web/static/src/model/**/*',
             'web/static/src/search/**/*',
             'web/static/src/webclient/icons.scss', # variables required in list_controller.scss
             'web/static/src/views/**/*',
@@ -228,7 +229,6 @@ This module provides the core of the Odoo Web Client.
             'web/static/src/legacy/utils.js',
             'web/static/src/legacy/pseudo_web_client.js',
             'web/static/src/legacy/web_client.js',
-            'web/static/src/legacy/js/_deprecated/*',
             'web/static/src/legacy/js/chrome/*',
             'web/static/src/legacy/js/components/*',
             'web/static/src/legacy/js/control_panel/*',
@@ -241,7 +241,6 @@ This module provides the core of the Odoo Web Client.
             'web/static/src/legacy/js/services/data_manager.js',
             'web/static/src/legacy/js/services/session.js',
             'web/static/src/legacy/js/tools/tools.js',
-            'web/static/src/legacy/js/views/**/*',
             'web/static/src/legacy/js/widgets/colorpicker_dialog.js',
             'web/static/src/legacy/js/widgets/date_picker.js',
             'web/static/src/legacy/js/widgets/domain_selector_dialog.js',
diff --git a/addons/web/models/models.py b/addons/web/models/models.py
index 240eddf7b9c..b5c1e30e51d 100644
--- a/addons/web/models/models.py
+++ b/addons/web/models/models.py
@@ -104,11 +104,17 @@ class Base(models.AbstractModel):
             return vals
 
         for field_name, field_spec in specification.items():
-            if not field_spec:
+            field = self._fields.get(field_name)
+            if field is None:
                 continue
-            field = self._fields[field_name]
 
-            if field.type == 'many2one' and 'fields' in field_spec:
+            if field.type == 'many2one':
+                if 'fields' not in field_spec:
+                    for values in values_list:
+                        if isinstance(values[field_name], NewId):
+                            values[field_name] = values[field_name].origin
+                    continue
+
                 co_records = self[field_name]
                 if 'context' in field_spec:
                     co_records = co_records.with_context(**field_spec['context'])
@@ -128,9 +134,13 @@ class Base(models.AbstractModel):
                 for values in values_list:
                     if values[field_name] is False:
                         continue
-                    values[field_name] = many2one_data[values[field_name]]
+                    vals = many2one_data[values[field_name]]
+                    values[field_name] = vals['id'] and vals
 
             elif field.type in ('one2many', 'many2many'):
+                if not field_spec:
+                    continue
+
                 co_records = self[field_name]
 
                 if 'order' in field_spec and field_spec['order']:
@@ -164,6 +174,9 @@ class Base(models.AbstractModel):
                         values[field_name] = [x2many_data.get(id_) or {'id': id_} for id_ in values[field_name]]
 
             elif field.type in ('reference', 'many2one_reference'):
+                if not field_spec:
+                    continue
+
                 values_by_id = {
                     vals['id']: vals
                     for vals in values_list
diff --git a/addons/web/static/src/core/domain.js b/addons/web/static/src/core/domain.js
index bff10755bdd..889dde0b0c3 100644
--- a/addons/web/static/src/core/domain.js
+++ b/addons/web/static/src/core/domain.js
@@ -174,6 +174,18 @@ export class Domain {
     }
 }
 
+/**
+ * @param {Array[] | boolean} modifier
+ * @param {Object} evalContext
+ * @returns {boolean}
+ */
+export function evalDomain(modifier, evalContext) {
+    if (modifier && typeof modifier !== "boolean") {
+        modifier = new Domain(modifier).contains(evalContext);
+    }
+    return Boolean(modifier);
+}
+
 /** @type {Condition} */
 const TRUE_LEAF = [1, "=", 1];
 /** @type {Condition} */
diff --git a/addons/web/static/src/core/utils/reactive.js b/addons/web/static/src/core/utils/reactive.js
index c4770ebf070..ebf48988657 100644
--- a/addons/web/static/src/core/utils/reactive.js
+++ b/addons/web/static/src/core/utils/reactive.js
@@ -31,7 +31,7 @@ export class Reactive {
  * Creates a side-effect that runs based on the content of reactive objects.
  *
  * @template {object[]} T
- * @param {(...args: [...T]) => void} cb callback for the effect
+ * @param {(...args: [...T]) => X} cb callback for the effect
  * @param {[...T]} deps the reactive objects that the effect depends on
  */
 export function effect(cb, deps) {
diff --git a/addons/web/static/src/core/utils/timing.js b/addons/web/static/src/core/utils/timing.js
index 03246e2c172..1f5f43dee0a 100644
--- a/addons/web/static/src/core/utils/timing.js
+++ b/addons/web/static/src/core/utils/timing.js
@@ -3,6 +3,25 @@
 import { browser } from "@web/core/browser/browser";
 import { onWillUnmount, useComponent } from "@odoo/owl";
 
+/**
+ * Creates a batched version of a callback so that all calls to it in the same
+ * time frame will only call the original callback once.
+ * @param callback the callback to batch
+ * @param synchronize this function decides the granularity of the batch (a microtick by default)
+ * @returns a batched version of the original callback
+ */
+export function batched(callback, synchronize = () => Promise.resolve()) {
+    let scheduled = false;
+    return async (...args) => {
+        if (!scheduled) {
+            scheduled = true;
+            await synchronize();
+            scheduled = false;
+            callback(...args);
+        }
+    };
+}
+
 /**
  * Creates and returns a new debounced version of the passed function (func)
  * which will postpone its execution until after 'delay' milliseconds
diff --git a/addons/web/static/src/legacy/js/_deprecated/crash_manager_warning_dialog.js b/addons/web/static/src/legacy/js/_deprecated/crash_manager_warning_dialog.js
deleted file mode 100644
index 9697257d59f..00000000000
--- a/addons/web/static/src/legacy/js/_deprecated/crash_manager_warning_dialog.js
+++ /dev/null
@@ -1,30 +0,0 @@
-/** @odoo-module */
-import Dialog from "web.Dialog";
-import core from "web.core";
-
-/**
- * An extension of Dialog Widget to render warnings.
- */
-export const WarningDialog = Dialog.extend({
-    template: 'web.LegacyWarningDialog',
-    /**
-     * @param {Object} error
-     * @param {string} error.message    the message in Warning Dialog
-     *
-     * @constructor
-     */
-    init: function (parent, options, error) {
-        options.size = options.size || "medium";
-        this._super.apply(this, [parent, options]);
-        this.message = error.message;
-        core.bus.off('close_dialogs', this);
-    },
-    /**
-     * Focuses the ok button.
-     *
-     * @override
-     */
-    open: function () {
-        this._super({shouldFocusButtons: true});
-    },
-});
diff --git a/addons/web/static/src/legacy/js/views/abstract_model.js b/addons/web/static/src/legacy/js/views/abstract_model.js
deleted file mode 100644
index 439829eb85f..00000000000
--- a/addons/web/static/src/legacy/js/views/abstract_model.js
+++ /dev/null
@@ -1,124 +0,0 @@
-/** @odoo-module alias=web.AbstractModel **/
-
-/**
- * An AbstractModel is the M in MVC.  We tend to think of MVC more on the server
- * side, but we are talking here on the web client side.
- *
- * The duties of the Model are to fetch all relevant data, and to make them
- * available for the rest of the view.  Also, every modification to that data
- * should pass through the model.
- *
- * Note that the model is not a widget, it does not need to be rendered or
- * appended to the dom.  However, it inherits from the EventDispatcherMixin,
- * in order to be able to notify its parent by bubbling events up.
- *
- * The model is able to generate sample (fake) data when there is no actual data
- * in database.  This feature can be activated by instantiating the model with
- * param "useSampleModel" set to true.  In this case, the model instantiates a
- * duplicated version of itself, parametrized to call a SampleServer (JS)
- * instead of doing RPCs.  Here is how it works: the main model first load the
- * data normally (from database), and then checks whether the result is empty or
- * not.  If it is, it asks the sample model to load with the exact same params,
- * and it thus enters in "sample" mode.  The model keeps doing this at reload,
- * but only if the (re)load params haven't changed: as soon as a param changes,
- * the "sample" mode is left, and it never enters it again in the future (in the
- * lifetime of the model instance).  To access those sample data from the outside,
- * 'get' must be called with the option "withSampleData" set to true.  In
- * this case, if the main model is in "sample" mode, it redirects the call to the
- * sample model.
- */
-
-import fieldUtils from 'web.field_utils';
-import mvc from 'web.mvc';
-
-
-var AbstractModel = mvc.Model.extend({
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    /**
-     * @override
-     * @param {any} _
-     * @param {Object} [options]
-     */
-    get(_, options) {
-        return this.__get(...arguments);
-    },
-    /**
-     * @override
-     */
-    load(params) {
-        this.loadParams = params;
-        return this.__load(...arguments);
-    },
-    /**
-     * When something changes, the data may need to be refetched.  This is the
-     * job for this method: reloading (only if necessary) all the data and
-     * making sure that they are ready to be redisplayed.
-     *
-     * @param {any} _
-     * @param {Object} [params]
-     * @returns {Promise}
-     */
-    async reload(_, params) {
-        return this.__reload(...arguments);
-    },
-
-    //--------------------------------------------------------------------------
-    // Private
-    //--------------------------------------------------------------------------
-
-    /**
-     * @private
-     * @returns {Object}
-     */
-    __get() {
-        return {};
-    },
-    /**
-     * To override to do the initial load of the data (this function is supposed
-     * to be called only once).
-     *
-     * @private
-     * @returns {Promise}
-     */
-    async __load() {
-        return Promise.resolve();
-    },
-    /**
-     * Processes date(time) and selection field values sent by the server.
-     * Converts data(time) values to moment instances.
-     * Converts false values of selection fields to 0 if 0 is a valid key,
-     * because the server doesn't make a distinction between false and 0, and
-     * always sends false when value is 0.
-     *
-     * @param {Object} field the field description
-     * @param {*} value
-     * @returns {*} the processed value
-     */
-    _parseServerValue: function (field, value) {
-        if (field.type === 'date' || field.type === 'datetime') {
-            // process date(time): convert into a moment instance
-            value = fieldUtils.parse[field.type](value, field, {isUTC: true});
-        } else if (field.type === 'selection' && value === false) {
-            // process selection: convert false to 0, if 0 is a valid key
-            var hasKey0 = field.selection.find(option => option[0] === 0);
-            value = hasKey0 ? 0 : value;
-        }
-        return value;
-    },
-    /**
-     * To override to reload data (this function may be called several times,
-     * after the initial load has been done).
-     *
-     * @private
-     * @returns {Promise}
-     */
-    async __reload() {
-        return Promise.resolve();
-    },
-});
-
-export default AbstractModel;
diff --git a/addons/web/static/src/legacy/js/views/basic/basic_model.js b/addons/web/static/src/legacy/js/views/basic/basic_model.js
deleted file mode 100644
index 803d7591bf6..00000000000
--- a/addons/web/static/src/legacy/js/views/basic/basic_model.js
+++ /dev/null
@@ -1,5404 +0,0 @@
-/** @odoo-module alias=web.BasicModel **/
-
-/**
- * Basic Model
- *
- * This class contains all the logic necessary to communicate between the
- * python models and the web client. More specifically, its job is to give a
- * simple unified API to the rest of the web client (in particular, the views and
- * the field widgets) to query and modify actual records in db.
- *
- * From a high level perspective, BasicModel is essentially a hashmap with
- * integer keys and some data and metadata object as value.  Each object in this
- * hashmap represents a piece of data, and can be reloaded and modified by using
- * its id as key in many methods.
- *
- * Here is a description of what those data point look like:
- *   var dataPoint = {
- *      _cache: {Object|undefined}
- *      _changes: {Object|null},
- *      aggregateValues: {Object},
- *      context: {Object},
- *      count: {integer},
- *      data: {Object|Object[]},
- *      domain: {*[]},
- *      fields: {Object},
- *      fieldsInfo: {Object},
- *      getContext: {function},
- *      getDomain: {function},
- *      getFieldNames: {function},
- *      groupedBy: {string[]},
- *      id: {integer},
- *      isOpen: {boolean},
- *      loadMoreOffset: {integer},
- *      limit: {integer},
- *      model: {string},
- *      offset: {integer},
- *      openGroupByDefault: {boolean},
- *      orderedBy: {Object[]},
- *      orderedResIDs: {integer[]},
- *      parentID: {string},
- *      rawContext: {Object},
- *      relationField: {string},
- *      res_id: {integer|null},
- *      res_ids: {integer[]},
- *      specialData: {Object},
- *      _specialDataCache: {Object},
- *      static: {boolean},
- *      type: {string} 'record' | 'list'
- *      value: ?,
- *  };
- *
- * Notes:
- * - id: is totally unrelated to res_id.  id is a web client local concept
- * - res_id: if set to a number or a virtual id (a virtual id is a character
- *     string composed of an integer and has a dash and other information), it
- *     is an actual id for a record in the server database. If set to
- *    'virtual_' + number, it is a record not yet saved (so, in create mode).
- * - res_ids: if set, it represent the context in which the data point is actually
- *     used.  For example, a given record in a form view (opened from a list view)
- *     might have a res_id = 2 and res_ids = [1,2,3]
- * - offset: this is mainly used for pagination.  Useful when we need to load
- *     another page, then we can simply change the offset and reload.
- * - count is basically the number of records being manipulated.  We can't use
- *     res_ids, because we might have a very large number of records, or a
- *     domain, and the res_ids would be the current page, not the full set.
- * - model is the actual name of a (odoo) model, such as 'res.partner'
- * - fields contains the description of all the fields from the model.  Note that
- *     these properties might have been modified by a view (for example, with
- *     required=true.  So, the fields kind of depends of the context of the
- *     data point.
- * - field_names: list of some relevant field names (string).  Usually, it
- *     denotes the fields present in the view.  Only those fields should be
- *     loaded.
- * - _cache and _changes are private, they should not leak out of the basicModel
- *   and be used by anyone else.
- *
- * Commands:
- *   commands are the base commands for x2many (0 -> 6), but with a
- *   slight twist: each [0, _, values] command is augmented with a virtual id:
- *   it means that when the command is added in basicmodel, it generates an id
- *   looking like this: 'virtual_' + number, and uses this id to identify the
- *   element, so it can be edited later.
- */
-
-import { intersection, sortBy, unique } from "@web/core/utils/arrays";
-import { uniqueId } from "@web/core/utils/functions";
-import { omit, pick } from "@web/core/utils/objects";
-import { sprintf } from "@web/core/utils/strings";
-import AbstractModel from "web.AbstractModel";
-import concurrency from "web.concurrency";
-import Context from "web.Context";
-import core from "web.core";
-import Domain from "web.Domain";
-import session from "web.session";
-import utils from "web.utils";
-import viewUtils from "web.viewUtils";
-
-var _t = core._t;
-
-const SENTINEL = null;
-
-// field types that can be aggregated in grouped views
-const AGGREGATABLE_TYPES = ['float', 'integer', 'monetary'];
-
-var x2ManyCommands = {
-    // (0, virtualID, {values})
-    CREATE: 0,
-    create: function (virtualID, values) {
-        delete values.id;
-        return [x2ManyCommands.CREATE, virtualID || false, values];
-    },
-    // (1, id, {values})
-    UPDATE: 1,
-    update: function (id, values) {
-        delete values.id;
-        return [x2ManyCommands.UPDATE, id, values];
-    },
-    // (2, id[, _])
-    DELETE: 2,
-    delete: function (id) {
-        return [x2ManyCommands.DELETE, id, false];
-    },
-    // (3, id[, _]) removes relation, but not linked record itself
-    FORGET: 3,
-    forget: function (id) {
-        return [x2ManyCommands.FORGET, id, false];
-    },
-    // (4, id[, _])
-    LINK_TO: 4,
-    link_to: function (id) {
-        return [x2ManyCommands.LINK_TO, id, false];
-    },
-    // (5[, _[, _]])
-    DELETE_ALL: 5,
-    delete_all: function () {
-        return [5, false, false];
-    },
-    // (6, _, ids) replaces all linked records with provided ids
-    REPLACE_WITH: 6,
-    replace_with: function (ids) {
-        return [6, false, ids];
-    }
-};
-
-var BasicModel = AbstractModel.extend({
-    // constants
-    OPEN_GROUP_LIMIT: 10, // after this limit, groups are automatically folded
-
-    /**
-     * @override
-     */
-    init: function () {
-        // this mutex is necessary to make sure some operations are done
-        // sequentially, for example, an onchange needs to be completed before a
-        // save is performed.
-        this.mutex = new concurrency.Mutex();
-        this.bypassMutex = false; // never set this to true manually (see @executeDirectly)
-
-        // this array is used to accumulate RPC requests done in the same call
-        // stack, so that they can be batched in the minimum number of RPCs
-        this.batchedRPCsRequests = [];
-
-        this.localData = Object.create(null);
-        // used to generate dataPoint ids. Note that the counter is set to 0 for
-        // each instance, and this is mandatory for the sample data feature to
-        // work: we need both the main model and the sample model to generate the
-        // same datapoint ids for their common data (groups, when there are real
-        // groups in database), so that we can easily do the mapping between
-        // real and sample data.
-        this.__id = 0;
-        this._super.apply(this, arguments);
-    },
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    /**
-     * Add a default record to a list object. This method actually makes a new
-     * record with the _makeDefaultRecord method, then adds it to the list object.
-     * The default record is added in the data directly. This is meant to be used
-     * by list or kanban controllers (i.e. not for x2manys in form views, as in
-     * this case, we store changes as commands).
-     *
-     * @param {string} listID a valid handle for a list object
-     * @param {Object} [options]
-     * @param {string} [options.position=top] if the new record should be added
-     *   on top or on bottom of the list
-     * @returns {Promise<string>} resolves to the id of the new created record
-     */
-    addDefaultRecord: function (listID, options) {
-        var self = this;
-        var list = this.localData[listID];
-        var context = Object.assign({}, this._getDefaultContext(list), this._getContext(list));
-
-        var position = (options && options.position) || 'top';
-        var params = {
-            context: context,
-            fields: list.fields,
-            fieldsInfo: list.fieldsInfo,
-            parentID: list.id,
-            position: position,
-            viewType: list.viewType,
-        };
-        return this._makeDefaultRecord(list.model, params).then(function (id) {
-            list.count++;
-            if (position === 'top') {
-                list.data.unshift(id);
-            } else {
-                list.data.push(id);
-            }
-            var record = self.localData[id];
-            list._cache[record.res_id] = id;
-            return id;
-        });
-    },
-    /**
-     * Completes the fields and fieldsInfo of a dataPoint with the given ones.
-     * It is useful for the cases where a record element is shared between
-     * various views, such as a one2many with a tree and a form view.
-     *
-     * @param {string} datapointID a valid element ID (of type 'list' or 'record')
-     * @param {Object} viewInfo
-     * @param {Object} viewInfo.fields
-     * @param {Object} viewInfo.fieldInfo
-     * @param {string} viewInfo.viewType
-     * @returns {Promise} resolved when the fieldInfo have been set on the given
-     *   datapoint and all its children, and all rawChanges have been applied
-     */
-    addFieldsInfo: async function (dataPointID, viewInfo) {
-        var dataPoint = this.localData[dataPointID];
-        dataPoint.fields = Object.assign({}, dataPoint.fields, viewInfo.fields);
-        // complete the given fieldInfo with the fields of the main view, so
-        // that those field will be reloaded if a reload is triggered by the
-        // secondary view
-        dataPoint.fieldsInfo = dataPoint.fieldsInfo || {};
-        const mainFieldInfo = dataPoint.fieldsInfo[dataPoint[viewInfo.viewType]];
-        dataPoint.fieldsInfo[viewInfo.viewType] = Object.assign(
-            {},
-            mainFieldInfo,
-            viewInfo.fieldInfo
-        );
-
-        // Some fields in the new fields info might not be in the previous one,
-        // so we might have stored changes for them (e.g. coming from onchange
-        // RPCs), that we haven't been able to process earlier (because those
-        // fields were unknown at that time). So we now try to process them.
-        if (dataPoint.type === 'record') {
-            await this.applyRawChanges(dataPointID, viewInfo.viewType);
-        }
-            const proms = [];
-            const fieldInfo = dataPoint.fieldsInfo[viewInfo.viewType];
-            // recursively apply the new field info on sub datapoints
-            if (dataPoint.type === 'list') {
-                // case 'list': on all datapoints in the list
-                Object.values(dataPoint._cache).forEach(subDataPointID => {
-                    proms.push(this.addFieldsInfo(subDataPointID, {
-                        fields: dataPoint.fields,
-                        fieldInfo: dataPoint.fieldsInfo[viewInfo.viewType],
-                        viewType: viewInfo.viewType,
-                    }));
-                });
-            } else {
-                // case 'record': on datapoints of all x2many fields
-                const values = Object.assign({}, dataPoint.data, dataPoint._changes);
-                Object.keys(fieldInfo).forEach(fieldName => {
-                    const fieldType = dataPoint.fields[fieldName].type;
-                    if (fieldType === 'one2many' || fieldType === 'many2many') {
-                        const mode = fieldInfo[fieldName].mode;
-                        const views = fieldInfo[fieldName].views;
-                        const x2mDataPointID = values[fieldName];
-                        if (views[mode] && x2mDataPointID) {
-                            proms.push(this.addFieldsInfo(x2mDataPointID, {
-                                fields: views[mode].fields,
-                                fieldInfo: views[mode].fieldsInfo[mode],
-                                viewType: mode,
-                            }));
-                        }
-                    }
-                });
-            }
-            return Promise.all(proms);
-    },
-    /**
-     * Onchange RPCs may return values for fields that are not in the current
-     * view. Those fields might even be unknown when the onchange returns (e.g.
-     * in x2manys, we only know the fields that are used in the inner view, but
-     * not those used in the potential form view opened in a dialog when a sub-
-     * record is clicked). When this happens, we can't infer their type, so the
-     * given value can't be processed. It is instead stored in the '_rawChanges'
-     * key of the record, without any processing. Later on, if this record is
-     * displayed in another view (e.g. the user clicked on it in the x2many
-     * list, and the record opens in a dialog), those changes that were left
-     * behind must be applied. This function applies changes stored in
-     * '_rawChanges' for a given viewType.
-     *
-     * @param {string} recordID local resource id of a record
-     * @param {string} viewType the current viewType
-     * @returns {Promise<string>} resolves to the id of the record
-     */
-    applyRawChanges: function (recordID, viewType) {
-        var record = this.localData[recordID];
-        return this._applyOnChange(record._rawChanges, record, { viewType }).then(function () {
-            return record.id;
-        });
-    },
-    /**
-     * Returns true if a record can be abandoned.
-     *
-     * Case for not abandoning the record:
-     *
-     * 1. flagged as 'no abandon' (i.e. during a `default_get`, including any
-     *    `onchange` from a `default_get`)
-     * 2. registered in a list on addition
-     *
-     *    2.1. registered as non-new addition
-     *    2.2. registered as new additon on update
-     *
-     * 3. record is not new
-     *
-     * Otherwise, the record can be abandoned.
-     *
-     * This is useful when discarding changes on this record, as it means that
-     * we must keep the record even if some fields are invalids (e.g. required
-     * field is empty).
-     *
-     * @param {string} id id for a local resource
-     * @returns {boolean}
-     */
-    canBeAbandoned: function (id) {
-        // 1. no drop if flagged
-        if (this.localData[id]._noAbandon) {
-            return false;
-        }
-        // 2. no drop in a list on "ADD in some cases
-        var record = this.localData[id];
-        var parent = this.localData[record.parentID];
-        if (parent) {
-            var entry = parent._savePoint.find((p) => p.operation === "ADD" && p.id === id);
-            if (entry) {
-                // 2.1. no drop on non-new addition in list
-                if (!entry.isNew) {
-                    return false;
-                }
-                // 2.2. no drop on new addition on "UPDATE"
-                var lastEntry = parent._savePoint.at(-1);
-                if (lastEntry.operation === 'UPDATE' && lastEntry.id === id) {
-                    return false;
-                }
-            }
-        }
-        // 3. drop new records
-        return this.isNew(id);
-    },
-    /**
-     * Delete a list of records, then, if the records have a parent, reload it.
-     *
-     * @todo we should remove the deleted records from the localData
-     * @todo why can't we infer modelName? Because of grouped datapoint
-     *       --> res_id doesn't correspond to the model and we don't have the
-     *           information about the related model
-     *
-     * @param {string[]} recordIds list of local resources ids. They should all
-     *   be of type 'record', be of the same model and have the same parent.
-     * @param {string} modelName mode name used to unlink the records
-     * @returns {Promise}
-     */
-    deleteRecords: function (recordIds, modelName) {
-        var self = this;
-        var records = recordIds.map((id) => self.localData[id]);
-        var context = Object.assign(records[0].getContext(), session.user_context);
-        return this._rpc({
-                model: modelName,
-                method: 'unlink',
-                args: [records.map(r => r.res_id)],
-                context: context,
-            })
-            .then(function () {
-                records.forEach((record) => {
-                    // discard any changes to prevent creating a new record with auto-save
-                    self.discardChanges(record.id);
-                    var parent = record.parentID && self.localData[record.parentID];
-                    if (parent && parent.type === 'list') {
-                        parent.data = parent.data.filter((x) => x !== record.id);
-                        delete self.localData[record.id];
-                        // Check if we are on last page and all records are deleted from current
-                        // page i.e. if there is no state.data.length then go to previous page
-                        if (!parent.data.length && parent.offset > 0) {
-                            parent.offset = Math.max(parent.offset - parent.limit, 0);
-                        }
-                    } else {
-                        record.res_ids.splice(record.offset, 1);
-                        record.offset = Math.min(record.offset, record.res_ids.length - 1);
-                        record.res_id = record.res_ids[record.offset];
-                        record.count--;
-                    }
-                });
-            });
-    },
-    /**
-     * Discard all changes in a local resource.  Basically, it removes
-     * everything that was stored in a _changes key.
-     *
-     * @param {string} id local resource id
-     * @param {Object} [options]
-     * @param {boolean} [options.rollback=false] if true, the changes will
-     *   be reset to the last _savePoint, otherwise, they are reset to null
-     */
-    discardChanges: function (id, options) {
-        options = options || {};
-        var element = this.localData[id];
-        var isNew = this.isNew(id);
-        var rollback = 'rollback' in options ? options.rollback : isNew;
-        var initialOffset = element.offset;
-        element._domains = {};
-        this._visitChildren(element, function (elem) {
-            if (rollback && elem._savePoint) {
-                if (elem._savePoint instanceof Array) {
-                    elem._changes = elem._savePoint.slice(0);
-                } else {
-                    elem._changes = Object.assign({}, elem._savePoint);
-                }
-                elem._isDirty = !isNew;
-            } else {
-                elem._changes = null;
-                elem._isDirty = false;
-            }
-            elem.offset = 0;
-            if (elem.tempLimitIncrement) {
-                elem.limit -= elem.tempLimitIncrement;
-                delete elem.tempLimitIncrement;
-            }
-            elem.specialData = Object.assign({}, elem._specialDataSavepoint);
-        });
-        element.offset = initialOffset;
-    },
-    /**
-     * Duplicate a record (by calling the 'copy' route)
-     *
-     * @param {string} recordID id for a local resource
-     * @returns {Promise<string>} resolves to the id of duplicate record
-     */
-    duplicateRecord: function (recordID) {
-        var self = this;
-        var record = this.localData[recordID];
-        var context = this._getContext(record);
-        return this._rpc({
-                model: record.model,
-                method: 'copy',
-                args: [record.data.id],
-                context: context,
-            })
-            .then(function (res_id) {
-                var index = record.res_ids.indexOf(record.res_id);
-                record.res_ids.splice(index + 1, 0, res_id);
-                return self.load({
-                    fieldsInfo: record.fieldsInfo,
-                    fields: record.fields,
-                    modelName: record.model,
-                    res_id: res_id,
-                    res_ids: record.res_ids.slice(0),
-                    viewType: record.viewType,
-                    context: context,
-                });
-            });
-    },
-    /**
-     * This method allows to execute a callback for which '_notifyChanges' and
-     * 'save' will bypass the mutex. This is useful when we are leaving Odoo
-     * (closing tab/browser), and we want to quickly save pending changes (in
-     * an 'onbeforeunload' handler, which is mostly sync).
-     *
-     * This function should never be called except when we are leaving Odoo.
-     *
-     * @param {Function} callback
-     */
-    executeDirectly(callback) {
-        this.bypassMutex = true;
-        callback();
-        this.bypassMutex = false;
-    },
-    /**
-     * For list resources, this freezes the current records order.
-     *
-     * @param {string} listID a valid element ID of type list
-     */
-    freezeOrder: function (listID) {
-        var list = this.localData[listID];
-        if (list.type === 'record') {
-            return;
-        }
-        list = this._applyX2ManyOperations(list);
-        this._sortList(list);
-        this.localData[listID].orderedResIDs = list.res_ids;
-    },
-    /**
-     * The __get method first argument is the handle returned by the load method.
-     * It is optional (the handle can be undefined).  In some case, it makes
-     * sense to use the handle as a key, for example the BasicModel holds the
-     * data for various records, each with its local ID.
-     *
-     * synchronous method, it assumes that the resource has already been loaded.
-     *
-     * @param {string} id local id for the resource
-     * @param {any} options
-     * @param {boolean} [options.env=false] if true, will only  return res_id
-     *   (if record) or res_ids (if list)
-     * @param {boolean} [options.raw=false] if true, will not follow relations
-     * @returns {Object}
-     */
-    __get: function (id, options) {
-        var self = this;
-        options = options || {};
-
-        if (!(id in this.localData)) {
-            return null;
-        }
-
-        var element = this.localData[id];
-
-        if (options.env) {
-            var env = {
-                ids: element.res_ids ? element.res_ids.slice(0) : [],
-            };
-            if (element.type === 'record') {
-                env.currentId = this.isNew(element.id) ? undefined : element.res_id;
-            }
-            return env;
-        }
-
-        if (element.type === 'record') {
-            var data = Object.assign({}, element.data, element._changes);
-            var relDataPoint;
-            for (var fieldName in data) {
-                var field = element.fields[fieldName];
-                if (data[fieldName] === null) {
-                    data[fieldName] = false;
-                }
-                if (!field) {
-                    continue;
-                }
-
-                // get relational datapoint
-                if (field.type === 'many2one') {
-                    if (options.raw) {
-                        relDataPoint = this.localData[data[fieldName]];
-                        data[fieldName] = relDataPoint ? relDataPoint.res_id : false;
-                    } else {
-                        data[fieldName] = this.__get(data[fieldName]) || false;
-                    }
-                } else if (field.type === 'reference') {
-                    if (options.raw) {
-                        relDataPoint = this.localData[data[fieldName]];
-                        data[fieldName] = relDataPoint ?
-                            relDataPoint.model + ',' + relDataPoint.res_id :
-                            false;
-                    } else {
-                        data[fieldName] = this.__get(data[fieldName]) || false;
-                    }
-                } else if (field.type === 'one2many' || field.type === 'many2many') {
-                    if (options.raw) {
-                        if (typeof data[fieldName] === 'string') {
-                            relDataPoint = this.localData[data[fieldName]];
-                            relDataPoint = this._applyX2ManyOperations(relDataPoint);
-                            data[fieldName] = relDataPoint.res_ids;
-                        } else {
-                            // no datapoint has been created yet (because the loading of relational
-                            // data has been batched, and hasn't started yet), so the value is still
-                            // the list of ids in the relation
-                            data[fieldName] = data[fieldName] || [];
-                        }
-                    } else {
-                        data[fieldName] = this.__get(data[fieldName]) || [];
-                    }
-                }
-            }
-            var record = {
-                context: Object.assign({}, element.context),
-                count: element.count,
-                data: data,
-                domain: element.domain.slice(0),
-                evalModifiers: element.evalModifiers,
-                fields: element.fields,
-                fieldsInfo: element.fieldsInfo,
-                getContext: element.getContext,
-                getDomain: element.getDomain,
-                getFieldNames: element.getFieldNames,
-                id: element.id,
-                isDirty: element.isDirty,
-                isNew: element.isNew,
-                limit: element.limit,
-                model: element.model,
-                offset: element.offset,
-                ref: element.ref,
-                res_ids: element.res_ids.slice(0),
-                specialData: Object.assign({}, element.specialData),
-                type: 'record',
-                viewType: element.viewType,
-            };
-
-            if (!this.isNew(element.id)) {
-                record.res_id = element.res_id;
-            }
-            var evalContext;
-            Object.defineProperty(record, 'evalContext', {
-                get: function () {
-                    evalContext = evalContext || self._getEvalContext(element);
-                    return evalContext;
-                },
-            });
-            return record;
-        }
-
-        // apply potential changes (only for x2many lists)
-        element = this._applyX2ManyOperations(element);
-        this._sortList(element);
-
-        if (!element.orderedResIDs && element._changes) {
-            element._changes.forEach((change) => {
-                if (change.operation === 'ADD' && change.isNew) {
-                    element.data = element.data.filter((x) => x !== change.id);
-                    if (change.position === 'top') {
-                        element.data.unshift(change.id);
-                    } else {
-                        element.data.push(change.id);
-                    }
-                }
-            });
-        }
-
-        var list = {
-            aggregateValues: Object.assign({}, element.aggregateValues),
-            context: Object.assign({}, element.context),
-            count: element.count,
-            data: element.data.map((elemID) => {
-                return self.__get(elemID, options);
-            }),
-            domain: element.domain.slice(0),
-            fields: element.fields,
-            getContext: element.getContext,
-            getDomain: element.getDomain,
-            getFieldNames: element.getFieldNames,
-            groupedBy: element.groupedBy,
-            groupsCount: element.groupsCount,
-            groupsLimit: element.groupsLimit,
-            groupsOffset: element.groupsOffset,
-            id: element.id,
-            isDirty: element.isDirty,
-            isM2MGrouped: element.isM2MGrouped,
-            isNew: element.isNew,
-            isOpen: element.isOpen,
-            isSample: this.isSampleModel,
-            limit: element.limit,
-            model: element.model,
-            offset: element.offset,
-            orderedBy: element.orderedBy,
-            res_id: element.res_id,
-            res_ids: element.res_ids.slice(0),
-            type: 'list',
-            value: element.value,
-            range: element.range,
-            viewType: element.viewType,
-        };
-        if (element.fieldsInfo) {
-            list.fieldsInfo = element.fieldsInfo;
-        }
-        return list;
-    },
-    /**
-     * Generate default values for a given record. Those values are stored in
-     * the '_changes' key of the record. For relational fields, sub-dataPoints
-     * are created, and missing relational data is fetched.
-     * Typically, this function is called when a new record is created. It may
-     * also be called when a one2many subrecord is open in a form view (dialog),
-     * to generate the default values for the fields displayed in the o2m form
-     * view, but not in the list or kanban (mainly to correctly create
-     * sub-dataPoints for relational fields).
-     *
-     * @param {string} recordID local id for a record
-     * @param {Object} [options]
-     * @param {string} [options.viewType] current viewType. If not set, we will
-     *   assume main viewType from the record
-     * @param {Array} [options.fieldNames] list of field names for which a
-     *   default value must be generated (used to complete the values dict)
-     * @returns {Promise}
-     */
-    generateDefaultValues(recordID, options = {}) {
-        const record = this.localData[recordID];
-        const viewType = options.viewType || record.viewType;
-        const fieldNames = options.fieldNames || Object.keys(record.fieldsInfo[viewType]);
-        const numericFields = ['float', 'integer', 'monetary'];
-        const proms = [];
-        record._changes = record._changes || {};
-        fieldNames.forEach(fieldName => {
-            record.data[fieldName] = null;
-            if (!(fieldName in record._changes)) {
-                const field = record.fields[fieldName];
-                if (numericFields.includes(field.type)) {
-                    record._changes[fieldName] = 0;
-                } else if (field.type === 'one2many' || field.type === 'many2many') {
-                    proms.push(this._processX2ManyCommands(record, fieldName, [], options));
-                } else {
-                    record._changes[fieldName] = null;
-                }
-            }
-        });
-        return Promise.all(proms);
-    },
-    /**
-     * Returns the current display_name for the record.
-     *
-     * @param {string} id the localID for a valid record element
-     * @returns {string}
-     */
-    getName: function (id) {
-        var record = this.localData[id];
-        var returnValue = '';
-        if (record._changes && 'display_name' in record._changes) {
-            returnValue = record._changes.display_name;
-        }
-        else if ('display_name' in record.data) {
-            returnValue = record.data.display_name;
-        }
-        return returnValue || _t("New");
-    },
-    /**
-     * Returns true if a record is dirty. A record is considered dirty if it has
-     * some unsaved changes, marked by the _isDirty property on the record or
-     * one of its subrecords.
-     *
-     * @param {string} id - the local resource id
-     * @returns {boolean}
-     */
-    isDirty: function (id) {
-        var isDirty = false;
-        this._visitChildren(this.localData[id], function (r) {
-            if (r._isDirty) {
-                isDirty = true;
-            }
-        });
-        return isDirty;
-    },
-    /**
-     * Returns true iff the datapoint is of type list and either:
-     *   - is not grouped, and contains no records
-     *   - is grouped, and contains columns, but all columns are empty
-     * In these cases, we will generate sample data to display, instead of an
-     * empty state.
-     *
-     * @override
-     */
-    _isEmpty(dataPointID) {
-        const dataPoint = this.localData[dataPointID];
-        if (dataPoint.type === 'list') {
-            const hasRecords = dataPoint.count === 0;
-            if (dataPoint.groupedBy.length) {
-                return dataPoint.data.length > 0 && hasRecords;
-            } else {
-                return hasRecords;
-            }
-        }
-        return false;
-    },
-    /**
-     * Check if a localData is new, meaning if it is in the process of being
-     * created and no actual record exists in db. Note: if the localData is not
-     * of the "record" type, then it is always considered as not new.
-     *
-     * Note: A virtual id is a character string composed of an integer and has
-     * a dash and other information.
-     * E.g: in calendar, the recursive event have virtual id linked to a real id
-     * virtual event id "23-20170418020000" is linked to the event id 23
-     *
-     * @param {string} id id for a local resource
-     * @returns {boolean}
-     */
-    isNew: function (id) {
-        var data = this.localData[id];
-        if (data.type !== "record") {
-            return false;
-        }
-        var res_id = data.res_id;
-        if (typeof res_id === 'number') {
-            return false;
-        } else if (typeof res_id === 'string' && /^[0-9]+-/.test(res_id)) {
-            return false;
-        }
-        return true;
-    },
-    /**
-     * Main entry point, the goal of this method is to fetch and process all
-     * data (following relations if necessary) for a given record/list.
-     *
-     * @todo document all params
-     *
-     * @private
-     * @param {any} params
-     * @param {Object} [params.fieldsInfo={}] contains the fieldInfo of each field
-     * @param {Object} params.fields contains the description of each field
-     * @param {string} [params.type] 'record' or 'list'
-     * @param {string} [params.recordID] an ID for an existing resource.
-     * @returns {Promise<string>} resolves to a local id, or handle
-     */
-    __load: async function (params) {
-        await this._super(...arguments);
-        params.type = params.type || (params.res_id !== undefined ? 'record' : 'list');
-        // FIXME: the following seems only to be used by the basic_model_tests
-        // so it should probably be removed and the tests should be adapted
-        params.viewType = params.viewType || 'default';
-        if (!params.fieldsInfo) {
-            var fieldsInfo = {};
-            for (var fieldName in params.fieldNames) {
-                fieldsInfo[params.fieldNames[fieldName]] = {};
-            }
-            params.fieldsInfo = {};
-            params.fieldsInfo[params.viewType] = fieldsInfo;
-        }
-
-        if (params.type === 'record' && params.res_id === undefined) {
-            params.allowWarning = true;
-            return this._makeDefaultRecord(params.modelName, params);
-        }
-        var dataPoint = this._makeDataPoint(params);
-        return this._load(dataPoint).then(function () {
-            return dataPoint.id;
-        });
-    },
-    /**
-     * Returns the list of res_ids for a given list of local ids.
-     *
-     * @param {string[]} localIds
-     * @returns {integer[]}
-     */
-    localIdsToResIds: function (localIds) {
-        return localIds.map(localId => this.localData[localId].res_id);
-    },
-    /**
-     * This helper method is designed to help developpers that want to use a
-     * field widget outside of a view.  In that case, we want a way to create
-     * data without actually performing a fetch.
-     *
-     * @param {string} model name of the model
-     * @param {Object[]} fields a description of field properties
-     * @param {Object} [fieldInfo] various field info that we want to set
-     * @returns {Promise<string>} the local id for the created resource
-     */
-    makeRecord: function (model, fields, fieldInfo) {
-        var self = this;
-        var defs = [];
-        var record_fields = {};
-        fields.forEach((field) => {
-            record_fields[field.name] = pick(field, 'type', 'relation', 'domain', 'selection');
-        });
-        fieldInfo = fieldInfo || {};
-        var fieldsInfo = {};
-        fieldsInfo.default = {};
-        fields.forEach((field) => {
-            fieldsInfo.default[field.name] = fieldInfo[field.name] || {};
-        });
-        var record = this._makeDataPoint({
-            modelName: model,
-            fields: record_fields,
-            fieldsInfo: fieldsInfo,
-            viewType: 'default',
-        });
-        fields.forEach((field) => {
-            var dataPoint;
-            record.data[field.name] = null;
-            if (field.type === 'many2one') {
-                if (field.value) {
-                    var id = Array.isArray(field.value) ? field.value[0] : field.value;
-                    var display_name = Array.isArray(field.value) ? field.value[1] : undefined;
-                    dataPoint = self._makeDataPoint({
-                        modelName: field.relation,
-                        data: {
-                            id: id,
-                            display_name: display_name,
-                        },
-                        parentID: record.id,
-                    });
-                    record.data[field.name] = dataPoint.id;
-                    if (display_name === undefined) {
-                        defs.push(self._fetchNameGet(dataPoint));
-                    }
-                }
-            } else if (field.type === 'reference' && field.value) {
-                const ref = field.value.split(',');
-                dataPoint = self._makeDataPoint({
-                    context: record.context,
-                    data: { id: parseInt(ref[1], 10) },
-                    modelName: ref[0],
-                    parentID: record.id,
-                });
-                defs.push(self._fetchNameGet(dataPoint));
-                record.data[field.name] = dataPoint.id;
-            } else if (field.type === 'one2many' || field.type === 'many2many') {
-                var relatedFieldsInfo = {};
-                relatedFieldsInfo.default = {};
-                (field.fields || []).forEach((field) => {
-                    relatedFieldsInfo.default[field.name] = {};
-                });
-                var dpParams = {
-                    fieldsInfo: relatedFieldsInfo,
-                    modelName: field.relation,
-                    parentID: record.id,
-                    static: true,
-                    type: 'list',
-                    viewType: 'default',
-                };
-                var needLoad = false;
-                // As value, you could either pass:
-                //  - a list of ids related to the record
-                //  - a list of object
-                // We only need to load the datapoint in the first case.
-                if (field.value && field.value.length) {
-                    if (typeof field.value[0] === "object") {
-                        dpParams.res_ids = field.value.map((v) => v.id);
-                        dataPoint = self._makeDataPoint(dpParams);
-                        field.value.forEach((data) => {
-                            var recordDP = self._makeDataPoint({
-                                data: data,
-                                modelName: field.relation,
-                                parentID: dataPoint.id,
-                                type: 'record',
-                            });
-                            dataPoint.data.push(recordDP.id);
-                            dataPoint._cache[recordDP.res_id] = recordDP.id;
-                        });
-                    } else {
-                        dpParams.res_ids = field.value;
-                        dataPoint = self._makeDataPoint(dpParams);
-                        needLoad = true;
-                    }
-                } else {
-                    dpParams.res_ids = [];
-                    dataPoint = self._makeDataPoint(dpParams);
-                }
-
-                if (needLoad) {
-                    defs.push(self._load(dataPoint));
-                }
-                record.data[field.name] = dataPoint.id;
-            } else if (field.value) {
-                record.data[field.name] = field.value;
-            }
-        });
-        return Promise.all(defs).then(function () {
-            return record.id;
-        });
-    },
-    /**
-     * This is an extremely important method.  All changes in any field go
-     * through this method.  It will then apply them in the local state, check
-     * if onchanges needs to be applied, actually do them if necessary, then
-     * resolves with the list of changed fields.
-     *
-     * @param {string} record_id
-     * @param {Object} changes a map field => new value
-     * @param {Object} [options] will be transferred to the applyChange method
-     *   @see _applyChange
-     * @returns {Promise<string[]>} list of changed fields
-     */
-    notifyChanges: function (record_id, changes, options) {
-        const notifyChanges = () => this._applyChange(record_id, changes, options);
-        if (this.bypassMutex) {
-            return notifyChanges();
-        }
-        return this.mutex.exec(notifyChanges);
-    },
-    /**
-     * Reload all data for a given resource. At any time there is at most one
-     * reload operation active.
-     *
-     * @private
-     * @param {string} id local id for a resource
-     * @param {Object} [options]
-     * @param {boolean} [options.keepChanges=false] if true, doesn't discard the
-     *   changes on the record before reloading it
-     * @returns {Promise<string>} resolves to the id of the resource
-     */
-    __reload: async function (id, options) {
-        await this._super(...arguments);
-        return this.mutex.exec(this._reload.bind(this, id, options));
-    },
-    /**
-     * In some case, we may need to remove an element from a list, without going
-     * through the notifyChanges machinery.  The motivation for this is when the
-     * user click on 'Add a line' in a field one2many with a required field,
-     * then clicks somewhere else.  The new line need to be discarded, but we
-     * don't want to trigger a real notifyChanges (no need for that, and also,
-     * we don't want to rerender the UI).
-     *
-     * @param {string} elementID some valid element id. It is necessary that the
-     *   corresponding element has a parent.
-     */
-    removeLine: function (elementID) {
-        var record = this.localData[elementID];
-        var parent = this.localData[record.parentID];
-        if (parent.static) {
-            // x2Many case: the new record has been stored in _changes, as a
-            // command so we remove the command(s) related to that record
-            parent._changes = parent._changes.filter( change => {
-                if (change.id === elementID &&
-                    change.operation === 'ADD' && // For now, only an ADD command increases limits
-                    parent.tempLimitIncrement) {
-                        // The record will be deleted from the _changes.
-                        // So we won't be passing into the logic of _applyX2ManyOperations anymore
-                        // implying that we have to cancel out the effects of an ADD command here
-                        parent.tempLimitIncrement--;
-                        parent.limit--;
-                }
-                return change.id !== elementID;
-            });
-        } else {
-            // main list view case: the new record is in data
-            parent.data = parent.data.filter((x) => x !== elementID);
-            parent.count--;
-        }
-    },
-    /**
-     * Resequences records.
-     *
-     * @param {string} modelName the resIDs model
-     * @param {Array<integer>} resIDs the new sequence of ids
-     * @param {string} parentID the localID of the parent
-     * @param {object} [options]
-     * @param {integer} [options.offset]
-     * @param {string} [options.field] the field name used as sequence
-     * @returns {Promise<string>} resolves to the local id of the parent
-     */
-    resequence: function (modelName, resIDs, parentID, options) {
-        options = options || {};
-        if ((resIDs.length <= 1)) {
-            return Promise.resolve(parentID); // there is nothing to sort
-        }
-        var self = this;
-        var data = this.localData[parentID];
-        var params = {
-            model: modelName,
-            ids: resIDs,
-            context: data.getContext(),
-        };
-        if (options.offset) {
-            params.offset = options.offset;
-        }
-        if (options.field) {
-            params.field = options.field;
-        }
-        return this._rpc({
-                route: '/web/dataset/resequence',
-                params: params,
-            })
-            .then(function (wasResequenced) {
-                if (!wasResequenced) {
-                    // the field on which the resequence was triggered does not
-                    // exist, so no resequence happened server-side
-                    return Promise.resolve();
-                }
-                var field = params.field ? params.field : 'sequence';
-
-                return self._rpc({
-                    model: modelName,
-                    method: 'read',
-                    args: [resIDs, [field]],
-                    context: data.getContext(),
-                }).then(function (records) {
-                    if (data.data.length) {
-                        var dataType = self.localData[data.data[0]].type;
-                        if (dataType === 'record') {
-                            data.data.forEach((dataPoint) => {
-                                var recordData = self.localData[dataPoint].data;
-                                var inRecords = records.find(({ id }) => id === recordData.id);
-                                if (inRecords) {
-                                    recordData[field] = inRecords[field];
-                                }
-                            });
-                            data.data = sortBy(data.data, function (d) {
-                                return self.localData[d].data[field];
-                            });
-                        }
-                        if (dataType === 'list') {
-                            data.data = sortBy(data.data, function (d) {
-                                return resIDs.indexOf(self.localData[d].res_id);
-                            });
-                        }
-                    }
-                    data.res_ids = [];
-                    data.data.forEach((d) => {
-                        var dataPoint = self.localData[d];
-                        if (dataPoint.type === 'record') {
-                            data.res_ids.push(dataPoint.res_id);
-                        } else {
-                            data.res_ids = data.res_ids.concat(dataPoint.res_ids);
-                        }
-                    });
-                    self._updateParentResIDs(data);
-                    return parentID;
-                })
-            });
-    },
-    /**
-     * Save a local resource, if needed.  This is a complicated operation,
-     * - it needs to check all changes,
-     * - generate commands for x2many fields,
-     * - call the /create or /write method according to the record status
-     * - After that, it has to reload all data, in case something changed, server side.
-     *
-     * @param {string} recordID local resource
-     * @param {Object} [options]
-     * @param {boolean} [options.reload=true] if true, data will be reloaded
-     * @param {boolean} [options.savePoint=false] if true, the record will only
-     *   be 'locally' saved: its changes written in a _savePoint key that can
-     *   be restored later by call discardChanges with option rollback to true
-     * @param {string} [options.viewType] current viewType. If not set, we will
-     *   assume main viewType from the record
-     * @returns {Promise}
-     *   Resolved with the list of field names (whose value has been modified)
-     */
-    save: function (recordID, options) {
-        var self = this;
-        function _save() {
-            options = options || {};
-            var record = self.localData[recordID];
-            if (options.savePoint) {
-                self._visitChildren(record, function (rec) {
-                    var newValue = rec._changes || rec.data;
-                    if (newValue instanceof Array) {
-                        rec._savePoint = newValue.slice(0);
-                    } else {
-                        rec._savePoint = Object.assign({}, newValue);
-                    }
-                });
-
-                // save the viewType of edition, so that the correct readonly modifiers
-                // can be evaluated when the record will be saved
-                for (let fieldName in (record._changes || {})) {
-                    record._editionViewType[fieldName] = options.viewType;
-                }
-            }
-            var shouldReload = 'reload' in options ? options.reload : true;
-            var method = self.isNew(recordID) ? 'create' : 'write';
-            if (record._changes) {
-                // id never changes, and should not be written
-                delete record._changes.id;
-            }
-            var changes = self._generateChanges(record, {viewType: options.viewType, changesOnly: method !== 'create'});
-
-            // id field should never be written/changed
-            delete changes.id;
-
-            if (method === 'create') {
-                var fieldNames = record.getFieldNames();
-                fieldNames.forEach((name) => {
-                    if (changes[name] === null) {
-                        delete changes[name];
-                    }
-                });
-            }
-
-            var prom = new Promise(function (resolve, reject) {
-                var changedFields = Object.keys(changes);
-
-                if (options.savePoint) {
-                    resolve(changedFields);
-                    return;
-                }
-
-                // in the case of a write, only perform the RPC if there are changes to save
-                if (method === 'create' || changedFields.length) {
-                    var args = method === 'write' ? [[record.data.id], changes] : [changes];
-                    self._rpc({
-                            model: record.model,
-                            method: method,
-                            args: args,
-                            context: record.getContext(),
-                        }).then(function (id) {
-                            if (method === 'create') {
-                                record.res_id = id;  // create returns an id, write returns a boolean
-                                record.data.id = id;
-                                record.offset = record.res_ids.length;
-                                record.res_ids.push(id);
-                                record.count++;
-                            }
-
-                            var _changes = record._changes;
-
-                            // Erase changes as they have been applied
-                            record._changes = {};
-                            var data = Object.assign({}, record.data, record._changes);
-                            for (var fieldName in record.fields) {
-                                var type = record.fields[fieldName].type;
-                                if (type === 'many2many' || type === 'one2many') {
-                                    if (data[fieldName]) {
-                                        self.localData[data[fieldName]]._changes = [];
-                                    }
-                                }
-                            }
-
-                            self.unfreezeOrder(record.id);
-
-                            // Update the data directly or reload them
-                            if (shouldReload) {
-                                self._fetchRecord(record).then(
-                                    function () {
-                                        resolve(changedFields);
-                                    },
-                                    reject,
-                                );
-                            } else {
-                                Object.assign(record.data, _changes);
-
-                                record._changes = {};
-                                for (const fieldName in record.fields) {
-                                    if (['many2many', 'one2many'].includes(record.fields[fieldName].type) && record.data[fieldName]) {
-                                        self.localData[record.data[fieldName]]._changes = [];
-                                    }
-                                }
-                                resolve(changedFields);
-                            }
-                        }).guardedCatch(reject);
-                        
-                } else {
-                    resolve(changedFields);
-                }
-            });
-            prom.then(function () {
-                self._updateDuplicateRecords(record.id, (id) => {
-                    Object.assign(self.localData[id].data, record.data);
-                });
-                record._isDirty = false;
-            });
-            return prom;
-        }
-        if (this.bypassMutex) {
-            return _save();
-        } else {
-            return this.mutex.exec(_save);
-        }
-    },
-    /**
-     * Manually sets a resource as dirty. This is used to notify that a field
-     * has been modified, but with an invalid value. In that case, the value is
-     * not sent to the basic model, but the record should still be flagged as
-     * dirty so that it isn't discarded without any warning.
-     *
-     * @param {string} id a resource id
-     */
-    setDirty: function (id) {
-        this.localData[id]._isDirty = true;
-    },
-    /**
-     * For list resources, this changes the orderedBy key.
-     *
-     * @param {string} list_id id for the list resource
-     * @param {string} fieldName valid field name
-     * @returns {Promise}
-     */
-    setSort: function (list_id, fieldName) {
-        var list = this.localData[list_id];
-        if (list.type === 'record') {
-            return;
-        } else if (list._changes) {
-            list._changes.forEach((change) => {
-                delete change.isNew;
-            });
-        }
-        if (list.orderedBy.length === 0) {
-            list.orderedBy.push({name: fieldName, asc: true});
-        } else if (list.orderedBy[0].name === fieldName){
-            if (!list.orderedResIDs) {
-                list.orderedBy[0].asc = !list.orderedBy[0].asc;
-            }
-        } else {
-            var orderedBy = list.orderedBy.filter(o => o.name !== fieldName);
-            list.orderedBy = [{name: fieldName, asc: true}].concat(orderedBy);
-        }
-
-        list.orderedResIDs = null;
-        if (list.static) {
-            // sorting might require to fetch the field for records where the
-            // sort field is still unknown (i.e. on other pages for example)
-            return this._fetchUngroupedList(list);
-        }
-        return Promise.resolve();
-    },
-    /**
-     * For a given resource of type 'record', get the active field, if any.
-     *
-     * Since the ORM can support both `active` and `x_active` fields for
-     * the archiving mechanism, check if any such field exists and prioritize
-     * them. The `active` field should always take priority over its custom
-     * version.
-     *
-     * @param {Object} record local resource
-     * @returns {String|undefined} the field name to use for archiving purposes
-     *   ('active', 'x_active') or undefined if no such field is present
-     */
-    getActiveField: function (record) {
-        const fields = Object.keys(record.fields);
-        const has_active = fields.includes('active');
-        if (has_active) {
-            return 'active';
-        }
-        const has_x_active = fields.includes('x_active');
-        return has_x_active?'x_active':undefined
-    },
-    /**
-     * Archive the given records
-     *
-     * @param {integer[]} resIDs ids of the records to archive
-     * @param {string} parentID id of the parent resource to reload
-     * @returns {Promise<string>} resolves to the parent id
-     */
-    actionArchive: function (resIDs, parentID) {
-        var self = this;
-        var parent = this.localData[parentID];
-        return this._rpc({
-                model: parent.model,
-                method: 'action_archive',
-                args: [resIDs],
-            })
-            .then(function (action) {
-                if (Object.keys(action || {}).length > 0) {
-                    return new Promise(function (resolve, reject) {
-                        self.do_action(action, {
-                            on_close: function (result) {
-                                return self.trigger_up('reload', {
-                                    onSuccess: resolve,
-                                });
-                            }
-                        });
-                    });
-                } else {
-                    return self.reload(parentID);
-                }
-            }).then(function (datapoint) {
-                // if there are no records to display and we are not on first page(we check it
-                // by checking offset is greater than limit i.e. we are not on first page)
-                // reason for adding logic after reload to make sure there is no records after operation
-                if (parent && parent.type === 'list' && !parent.data.length && parent.offset > 0) {
-                    parent.offset = Math.max(parent.offset - parent.limit, 0);
-                    return self.reload(parentID);
-                }
-                return datapoint;
-            });
-    },
-    /**
-     * Unarchive the given records
-     *
-     * @param {integer[]} resIDs ids of the records to unarchive
-     * @param {string} parentID id of the parent resource to reload
-     * @returns {Promise<string>} resolves to the parent id
-     */
-    actionUnarchive: function (resIDs, parentID) {
-        var self = this;
-        var parent = this.localData[parentID];
-        return this._rpc({
-                model: parent.model,
-                method: 'action_unarchive',
-                args: [resIDs],
-            })
-            .then(function (action) {
-                // optionally clear the DataManager's cache
-                if (Object.keys(action || {}).length > 0) {
-                    return new Promise(function (resolve, reject) {
-                        self.do_action(action, {
-                            on_close: function () {
-                                return self.trigger_up('reload', {
-                                    onSuccess: resolve,
-                                });
-                            }
-                        });
-                    });
-                } else {
-                    return self.reload(parentID);
-                }
-            }).then(function (datapoint) {
-                // if there are no records to display and we are not on first page(we check it
-                // by checking offset is greater than limit i.e. we are not on first page)
-                // reason for adding logic after reload to make sure there is no records after operation
-                if (parent && parent.type === 'list' && !parent.data.length && parent.offset > 0) {
-                    parent.offset = Math.max(parent.offset - parent.limit, 0);
-                    return self.reload(parentID);
-                }
-                return datapoint;
-            });
-    },
-    /**
-     * Toggle (open/close) a group in a grouped list, then fetches relevant
-     * data
-     *
-     * @param {string} groupId
-     * @returns {Promise<string>} resolves to the group id
-     */
-    toggleGroup: function (groupId) {
-        var self = this;
-        var group = this.localData[groupId];
-        if (group.isOpen) {
-            group.isOpen = false;
-            group.data = [];
-            group.res_ids = [];
-            group.offset = 0;
-            this._updateParentResIDs(group);
-            return Promise.resolve(groupId);
-        }
-        if (!group.isOpen) {
-            group.isOpen = true;
-            var def;
-            if (group.count > 0) {
-                def = this._load(group).then(function () {
-                    self._updateParentResIDs(group);
-                });
-            }
-            return Promise.resolve(def).then(function () {
-                return groupId;
-            });
-        }
-    },
-    /**
-     * For a list datapoint, unfreezes the current records order and sorts it.
-     * For a record datapoint, unfreezes the x2many list datapoints.
-     *
-     * @param {string} elementID a valid element ID
-     */
-    unfreezeOrder: function (elementID) {
-        var list = this.localData[elementID];
-        if (list.type === 'record') {
-            var data = Object.assign({}, list.data, list._changes);
-            for (var fieldName in data) {
-                var field = list.fields[fieldName];
-                if (!field || !data[fieldName]) {
-                    continue;
-                }
-                if (field.type === 'one2many' || field.type === 'many2many') {
-                    var recordlist = this.localData[data[fieldName]];
-                    recordlist.orderedResIDs = null;
-                    for (var index in recordlist.data) {
-                        this.unfreezeOrder(recordlist.data[index]);
-                    }
-                }
-            }
-            return;
-        }
-        list.orderedResIDs = null;
-        this._sortList(list);
-    },
-
-    //--------------------------------------------------------------------------
-    // Private
-    //--------------------------------------------------------------------------
-
-    /**
-     * Add a default record to a list object. This method actually makes a new
-     * record with the _makeDefaultRecord method, then adds it to the list object
-     * as a 'ADD' command in its _changes. This is meant to be used x2many lists,
-     * not by list or kanban controllers.
-     *
-     * @private
-     * @param {Object} list a valid list object
-     * @param {Object} [options]
-     * @param {string} [options.position=top] if the new record should be added
-     *   on top or on bottom of the list
-     * @param {Array} [options.[context]] additional context to be merged before
-     *   calling the default_get (eg. to set default values).
-     *   If several contexts are found, multiple records are added
-     * @param {boolean} [options.allowWarning=false] if true, the default record
-     *   operation can complete, even if a warning is raised
-     * @returns {Promise<[string]>} resolves to the new records ids
-     */
-    _addX2ManyDefaultRecord: function (list, options) {
-        var self = this;
-        var position = options && options.position || 'top';
-        var params = {
-            fields: list.fields,
-            fieldsInfo: list.fieldsInfo,
-            parentID: list.id,
-            position: position,
-            viewType: options.viewType || list.viewType,
-            allowWarning: options && options.allowWarning
-        };
-
-        var additionalContexts = options && options.context;
-        var makeDefaultRecords = [];
-        if (additionalContexts){
-            additionalContexts.forEach((context) => {
-                params.context = self._getContext(list, {additionalContext: context, full: true, sanitize_default_values: true});
-                makeDefaultRecords.push(self._makeDefaultRecord(list.model, params));
-            });
-        } else {
-            params.context = self._getContext(list, {sanitize_default_values: true});
-            makeDefaultRecords.push(self._makeDefaultRecord(list.model, params));
-        }
-
-        return Promise.all(makeDefaultRecords).then(function (resultIds){
-            var ids = [];
-            resultIds.forEach((id) => {
-                ids.push(id);
-
-                list._changes.push({operation: 'ADD', id: id, position: position, isNew: true});
-                var record = self.localData[id];
-                list._cache[record.res_id] = id;
-                if (list.orderedResIDs) {
-                    var index = list.offset + (position !== 'top' ? list.limit : 0);
-                    list.orderedResIDs.splice(index, 0, record.res_id);
-                    // list could be a copy of the original one
-                    self.localData[list.id].orderedResIDs = list.orderedResIDs;
-                }
-            });
-
-            return ids;
-        });
-    },
-    /**
-     * This method is the private version of notifyChanges.  Unlike
-     * notifyChanges, it is not protected by a mutex.  Every changes from the
-     * user to the model go through this method.
-     *
-     * @param {string} recordID
-     * @param {Object} changes
-     * @param {Object} [options]
-     * @param {boolean} [options.doNotSetDirty=false] if this flag is set to
-     *   true, then we will not tag the record as dirty.  This should be avoided
-     *   for most situations.
-     * @param {boolean} [options.notifyChange=true] if this flag is set to
-     *   false, then we will not notify and not trigger the onchange, even though
-     *   it was changed.
-     * @param {string} [options.viewType] current viewType. If not set, we will assume
-     *   main viewType from the record
-     * @param {boolean} [options.allowWarning=false] if true, change
-     *   operation can complete, even if a warning is raised
-     *   (only supported by X2ManyChange)
-     * @returns {Promise} list of changed fields
-     */
-    _applyChange: function (recordID, changes, options) {
-        var self = this;
-        var record = this.localData[recordID];
-        var field;
-        var defs = [];
-        options = options || {};
-        record._changes = record._changes || {};
-        if (!options.doNotSetDirty) {
-            record._isDirty = true;
-        }
-        var initialData = {};
-        this._visitChildren(record, function (elem) {
-            initialData[elem.id] = $.extend(true, {}, pick(elem, 'data', '_changes'));
-        });
-
-        // apply changes to local data
-        for (var fieldName in changes) {
-            field = record.fields[fieldName];
-            if (field && (field.type === 'one2many' || field.type === 'many2many')) {
-                defs.push(this._applyX2ManyChange(record, fieldName, changes[fieldName], options));
-            } else if (field && (field.type === 'many2one' || field.type === 'reference')) {
-                defs.push(this._applyX2OneChange(record, fieldName, changes[fieldName], options));
-            } else {
-                record._changes[fieldName] = changes[fieldName];
-            }
-        }
-
-        if (options.notifyChange === false) {
-            return Promise.all(defs).then(function () {
-                return Promise.resolve(Object.keys(changes));
-            });
-        }
-
-        return Promise.all(defs).then(function () {
-            var onChangeFields = []; // the fields that have changed and that have an on_change
-            for (var fieldName in changes) {
-                field = record.fields[fieldName];
-                if (field && field.onChange) {
-                    var isX2Many = field.type === 'one2many' || field.type === 'many2many';
-                    if (!isX2Many || (self._isX2ManyValid(record._changes[fieldName] || record.data[fieldName]))) {
-                        onChangeFields.push(fieldName);
-                    }
-                }
-            }
-            return new Promise(function (resolve, reject) {
-                if (onChangeFields.length) {
-                    self._performOnChange(record, onChangeFields, { viewType: options.viewType })
-                    .then(function (result) {
-                        delete record._warning;
-                        resolve(Object.keys(changes).concat(Object.keys(result && result.value || {})));
-                    }).guardedCatch(function () {
-                        self._visitChildren(record, function (elem) {
-                            Object.assign(elem, initialData[elem.id]);
-                        });
-                        reject();
-                    });
-                } else {
-                    resolve(Object.keys(changes));
-                }
-            }).then(function (fieldNames) {
-                return self._fetchSpecialData(record).then(function (fieldNames2) {
-                    // Return the names of the fields that changed (onchange or
-                    // associated special data change)
-                    return fieldNames.concat(fieldNames2);
-                });
-            });
-        });
-    },
-    /**
-     * Apply an x2one (either a many2one or a reference field) change. There is
-     * a need for this function because the server only gives an id when a
-     * onchange modifies a many2one field. For this reason, we need (sometimes)
-     * to do a read of display_name.
-     *
-     * Moreover, for the many2one case, a new value can sometimes be set (i.e.
-     * a display_name is given, but no id). When this happens, we first do a
-     * name_create.
-     *
-     * @param {Object} record
-     * @param {string} fieldName
-     * @param {Object} [data]
-     * @param {Object} [options]
-     * @param {string} [options.viewType] current viewType. If not set, we will
-     *   assume main viewType from the record
-     * @returns {Promise}
-     */
-    _applyX2OneChange: async function (record, fieldName, data, options) {
-        options = options || {};
-        var self = this;
-        if (!data || (!data.id && !data.display_name)) {
-            record._changes[fieldName] = false;
-            return Promise.resolve();
-        }
-
-        const field = record.fields[fieldName];
-        const coModel = field.type === 'reference' ? data.model : field.relation;
-        const allowedTypes = ['many2one', 'reference'];
-        if (allowedTypes.includes(field.type) && !data.id && data.display_name) {
-            // only display_name given -> do a name_create
-            const result = await this._rpc({
-                model: coModel,
-                method: 'name_create',
-                args: [data.display_name],
-                context: this._getContext(record, {fieldName: fieldName, viewType: options.viewType}),
-            });
-            // Check if a record is really created. Models without defined
-            // _rec_name cannot create record based on name_create.
-            if (!result) {
-                record._changes[fieldName] = false;
-                return Promise.resolve();
-            }
-            data = {id: result[0], display_name: result[1]};
-        }
-
-        // here, we check that the many2one really changed. If the res_id is the
-        // same, we do not need to do any extra work. It can happen when the
-        // user edited a manyone (with the small form view button) with an
-        // onchange.  In that case, the onchange is triggered, but the actual
-        // value did not change.
-        var relatedID;
-        if (record._changes && fieldName in record._changes) {
-            relatedID = record._changes[fieldName];
-        } else {
-            relatedID = record.data[fieldName];
-        }
-        var relatedRecord = this.localData[relatedID];
-        if (relatedRecord && (data.id === this.localData[relatedID].res_id)) {
-            return Promise.resolve();
-        }
-        var rel_data = pick(data, 'id', 'display_name');
-
-        const viewType = options.viewType || record.viewType;
-        const fieldInfo = record.fieldsInfo[viewType][fieldName] || {};
-        const fieldOptions = fieldInfo.options || {};
-
-        // the reference field doesn't store its co-model in its field metadata
-        // but directly in the data (as the co-model isn't fixed)
-        var def;
-        if (rel_data.display_name === undefined || fieldOptions.always_reload) {
-            // TODO: refactor this to use _fetchNameGet
-            def = this._rpc({
-                    model: coModel,
-                    method: 'read',
-                    args: [data.id, ['display_name']],
-                    context: this._getContext(record, { fieldName, viewType }),
-                })
-                .then(function (result) {
-                    rel_data.display_name = result[0]['display_name'];
-                });
-        }
-        return Promise.resolve(def).then(function () {
-            var rec = self._makeDataPoint({
-                context: record.context,
-                data: rel_data,
-                fields: {},
-                fieldsInfo: {},
-                modelName: coModel,
-                parentID: record.id,
-            });
-            record._changes[fieldName] = rec.id;
-        });
-    },
-    /**
-     * Applies the result of an onchange RPC on a record.
-     *
-     * @private
-     * @param {Object} values the result of the onchange RPC (a mapping of
-     *   fieldnames to their value)
-     * @param {Object} record
-     * @param {Object} [options={}]
-     * @param {string} [options.viewType] current viewType. If not set, we will assume
-     *   main viewType from the record
-     * @param {string} [options.firstOnChange] set to true if this is the first
-     *   onchange (if so, some initialization will need to be done)
-     * @returns {Promise}
-     */
-    _applyOnChange: function (values, record, options = {}) {
-        var self = this;
-        var defs = [];
-        var rec;
-        const viewType = options.viewType || record.viewType;
-        record._changes = record._changes || {};
-
-        for (let name in (values || {})) {
-            const val = values[name];
-            var field = record.fields[name];
-            if (!field) {
-                // this field is unknown so we can't process it for now (it is not
-                // in the current view anyway, otherwise it wouldn't be unknown.
-                // we store its value without processing it, so that if we later
-                // on switch to another view in which this field is displayed,
-                // we could process it as we would know its type then.
-                // use case: an onchange sends a create command for a one2many,
-                // in the dict of values, there is a value for a field that is
-                // not in the one2many list, but that is in the one2many form.
-                record._rawChanges[name] = val;
-                // LPE TODO 1 taskid-2261084: remove this entire comment including code snippet
-                // when the change in behavior has been thoroughly tested.
-                // It is impossible to distinguish between values returned by the default_get
-                // and those returned by the onchange. Since those are not in _changes, they won't be saved.
-                // if (options.firstOnChange) {
-                //     record._changes[name] = val;
-                // }
-                continue;
-            }
-            if (record._rawChanges[name]) {
-                // if previous _rawChanges exists, clear them since the field is now knwon
-                // and restoring outdated onchange over posterious change is wrong
-                delete record._rawChanges[name];
-            }
-            var oldValue = name in record._changes ? record._changes[name] : record.data[name];
-            var id;
-            if (field.type === 'many2one') {
-                id = false;
-                // in some case, the value returned by the onchange can
-                // be false (no value), so we need to avoid creating a
-                // local record for that.
-                if (val) {
-                    // when the value isn't false, it can be either
-                    // an array [id, display_name] or just an id.
-                    var data = Array.isArray(val) ?
-                        {id: val[0], display_name: val[1]} :
-                        {id: val};
-                    if (!oldValue || (self.localData[oldValue].res_id !== data.id)) {
-                        // only register a change if the value has changed
-                        rec = self._makeDataPoint({
-                            context: record.context,
-                            data: data,
-                            modelName: field.relation,
-                            parentID: record.id,
-                        });
-                        id = rec.id;
-                        record._changes[name] = id;
-                    }
-                } else if (oldValue !== false) {
-                    // if no value is provided for a m2o,
-                    // we should only consider the field updated if it had a value before
-                    record._changes[name] = false;
-                }
-            } else if (field.type === 'reference') {
-                id = false;
-                if (val) {
-                    var ref = val.split(',');
-                    var modelName = ref[0];
-                    var resID = parseInt(ref[1]);
-                    if (!oldValue || self.localData[oldValue].res_id !== resID ||
-                        self.localData[oldValue].model !== modelName) {
-                        // only register a change if the value has changed
-                        rec = self._makeDataPoint({
-                            context: record.context,
-                            data: {id: parseInt(ref[1])},
-                            modelName: modelName,
-                            parentID: record.id,
-                        });
-                        defs.push(self._fetchNameGet(rec));
-                        id = rec.id;
-                        record._changes[name] = id;
-                    }
-                } else {
-                    record._changes[name] = id;
-                }
-            } else if (field.type === 'one2many' || field.type === 'many2many') {
-                var listId = record._changes[name] || record.data[name];
-                var list;
-                if (listId) {
-                    list = self.localData[listId];
-                } else {
-                    var fieldInfo = record.fieldsInfo[viewType][name];
-                    if (!fieldInfo) {
-                        // ignore changes of x2many not in view
-                        continue;
-                    }
-                    var view = fieldInfo.views && fieldInfo.views[fieldInfo.mode];
-                    list = self._makeDataPoint({
-                        fields: view ? view.fields : fieldInfo.relatedFields,
-                        fieldsInfo: view ? view.fieldsInfo : fieldInfo.fieldsInfo,
-                        limit: fieldInfo.limit,
-                        modelName: field.relation,
-                        parentID: record.id,
-                        static: true,
-                        type: 'list',
-                        viewType: view ? view.type : fieldInfo.viewType,
-                    });
-                }
-                // TODO: before registering the changes, verify that the x2many
-                // value has changed
-                record._changes[name] = list.id;
-                list._changes = list._changes || [];
-
-                // save it in case of a [5] which will remove the _changes
-                var oldChanges = list._changes;
-                val.forEach((command) => {
-                    var rec, recID;
-                    if (command[0] === 0 || command[0] === 1) {
-                        // CREATE or UPDATE
-                        if (command[0] === 0 && command[1]) {
-                            // updating an existing (virtual) record
-                            var previousChange = oldChanges.find(operation => {
-                                var child = self.localData[operation.id];
-                                return child && (child.ref === command[1]);
-                            });
-                            recID = previousChange && previousChange.id;
-                            rec = self.localData[recID];
-                        }
-                        if (command[0] === 1 && command[1]) {
-                            // updating an existing record
-                            rec = self.localData[list._cache[command[1]]];
-                        }
-                        if (!rec) {
-                            var params = {
-                                context: list.context,
-                                fields: list.fields,
-                                fieldsInfo: list.fieldsInfo,
-                                modelName: list.model,
-                                parentID: list.id,
-                                viewType: list.viewType,
-                                ref: command[1],
-                            };
-                            if (command[0] === 1) {
-                                params.res_id = command[1];
-                            }
-                            rec = self._makeDataPoint(params);
-                            list._cache[rec.res_id] = rec.id;
-                            if (options.firstOnChange) {
-                                // this is necessary so the fields are initialized
-                                rec.getFieldNames().forEach(fieldName => {
-                                    if (!(fieldName in rec.data)) {
-                                        rec.data[fieldName] = null;
-                                    }
-                                });
-                            }
-                        }
-                        // Do not abandon the record if it has been created
-                        // from `default_get`. The list has a savepoint only
-                        // after having fully executed `default_get`.
-                        rec._noAbandon = !list._savePoint;
-                        list._changes.push({operation: 'ADD', id: rec.id});
-                        if (command[0] === 1) {
-                            list._changes.push({operation: 'UPDATE', id: rec.id});
-                        }
-                        defs.push(self._applyOnChange(command[2], rec, {
-                            firstOnChange: options.firstOnChange,
-                        }));
-                    } else if (command[0] === 4) {
-                        // LINK TO
-                        linkRecord(list, command[1]);
-                    } else if (command[0] === 5) {
-                        // DELETE ALL
-                        list._changes = [{operation: 'REMOVE_ALL'}];
-                    } else if (command[0] === 6) {
-                        list._changes = [{operation: 'REMOVE_ALL'}];
-                        Object.values(command[2] || {}).forEach((resID) => {
-                            linkRecord(list, resID);
-                        });
-                    }
-                });
-                var def = self._readUngroupedList(list).then(function (list) {
-                    var x2ManysDef = self._fetchX2ManysBatched(list);
-                    var referencesDef = self._fetchReferencesBatched(list);
-                    return Promise.all([x2ManysDef, referencesDef]);
-                });
-                defs.push(def);
-            } else {
-                var newValue = self._parseServerValue(field, val);
-                if (newValue !== oldValue) {
-                    record._changes[name] = newValue;
-                }
-            }
-        }
-        return Promise.all(defs);
-
-        // inner function that adds a record (based on its res_id) to a list
-        // dataPoint (used for onchanges that return commands 4 (LINK TO) or
-        // commands 6 (REPLACE WITH))
-        function linkRecord (list, resID) {
-            rec = self.localData[list._cache[resID]];
-            if (rec) {
-                // modifications done on a record are discarded if the onchange
-                // uses a LINK TO or a REPLACE WITH
-                self.discardChanges(rec.id);
-            }
-            // the dataPoint id will be set when the record will be fetched (for
-            // now, this dataPoint may not exist yet)
-            list._changes.push({
-                operation: 'ADD',
-                id: rec ? rec.id : null,
-                resID: resID,
-            });
-        }
-    },
-    /**
-     * When an operation is applied to a x2many field, the field widgets
-     * generate one (or more) command, which describes the exact operation.
-     * This method tries to interpret these commands and apply them to the
-     * localData.
-     *
-     * @param {Object} record
-     * @param {string} fieldName
-     * @param {Object} command A command object.  It should have a 'operation'
-     *   key.  For example, it looks like {operation: ADD, id: 'partner_1'}
-     * @param {Object} [options]
-     * @param {string} [options.viewType] current viewType. If not set, we will assume
-     *   main viewType from the record
-     * @param {boolean} [options.allowWarning=false] if true, change
-     *   operation can complete, even if a warning is raised
-     *   (only supported by the 'CREATE' command.operation)
-     * @returns {Promise}
-     */
-    _applyX2ManyChange: async function (record, fieldName, command, options) {
-        if (command.operation === 'TRIGGER_ONCHANGE') {
-            // the purpose of this operation is to trigger an onchange RPC, so
-            // there is no need to apply any change on the record (the changes
-            // have probably been already applied and saved, usecase: many2many
-            // edition in a dialog)
-            return Promise.resolve();
-        }
-
-        var self = this;
-        var localID = (record._changes && record._changes[fieldName]) || record.data[fieldName];
-        var list = this.localData[localID];
-        var field = record.fields[fieldName];
-        var viewType = (options && options.viewType) || record.viewType;
-        var fieldInfo = record.fieldsInfo[viewType][fieldName];
-        var view = fieldInfo.views && fieldInfo.views[fieldInfo.mode];
-        var def, rec;
-        var defs = [];
-        list._changes = list._changes || [];
-
-        switch (command.operation) {
-            case 'ADD':
-                // for now, we are in the context of a one2many field
-                // the command should look like this:
-                // { operation: 'ADD', id: localID }
-                // The corresponding record may contain value for fields that
-                // are unknown in the list (e.g. fields that are in the
-                // subrecord form view but not in the kanban or list view), so
-                // to ensure that onchanges are correctly handled, we extend the
-                // list's fields with those in the created record
-                var newRecord = this.localData[command.id];
-                list.fields = Object.assign(newRecord.fields, list.fields);
-                list.fieldsInfo = Object.assign(newRecord.fieldsInfo, list.fieldsInfo);
-                newRecord.fields = list.fields;
-                newRecord.fieldsInfo = list.fieldsInfo;
-                newRecord.viewType = list.viewType;
-                list._cache[newRecord.res_id] = newRecord.id;
-                list._changes.push(command);
-                break;
-            case 'ADD_M2M':
-                // force to use link command instead of create command
-                list._forceM2MLink = true;
-                // handle multiple add: command[2] may be a dict of values (1
-                // record added) or an array of dict of values
-                var data = Array.isArray(command.ids) ? command.ids : [command.ids];
-
-                // name_create records for which there is no id (typically, could
-                // be the case of a quick_create in a many2many_tags, so data.length
-                // is 1)
-                for (const r of data) {
-                    if (!r.id && r.display_name) {
-                        const prom = this._rpc({
-                            model: field.relation,
-                            method: 'name_create',
-                            args: [r.display_name],
-                            context: this._getContext(record, {fieldName: fieldName, viewType: options.viewType}),
-                        }).then(result => {
-                            r.id = result[0];
-                            r.display_name = result[1];
-                        });
-                        defs.push(prom);
-                    }
-                }
-                await Promise.all(defs);
-
-                // Ensure the local data repository (list) boundaries can handle incoming records (data)
-                if (data.length + list.res_ids.length > list.limit) {
-                    list.limit = data.length + list.res_ids.length;
-                }
-
-                var list_records = {};
-                data.forEach((d) => {
-                    rec = self._makeDataPoint({
-                        context: record.context,
-                        modelName: field.relation,
-                        fields: view ? view.fields : fieldInfo.relatedFields,
-                        fieldsInfo: view ? view.fieldsInfo : fieldInfo.fieldsInfo,
-                        res_id: d.id,
-                        data: d,
-                        viewType: view ? view.type : fieldInfo.viewType,
-                        parentID: list.id,
-                    });
-                    list_records[d.id] = rec;
-                    list._cache[rec.res_id] = rec.id;
-                    list._changes.push({operation: 'ADD', id: rec.id});
-                });
-                // read list's records as we only have their ids and optionally their display_name
-                // (we can't use function readUngroupedList because those records are only in the
-                // _changes so this is a very specific case)
-                // this could be optimized by registering the fetched records in the list's _cache
-                // so that if a record is removed and then re-added, it won't be fetched twice
-                var fieldNames = list.getFieldNames();
-                if (fieldNames.length) {
-                    def = this._rpc({
-                        model: list.model,
-                        method: 'read',
-                        args: [data.map((d) => d.id), fieldNames],
-                        context: Object.assign({}, record.context, field.context, list.getContext()),
-                    }).then(function (records) {
-                        records.forEach((record) => {
-                            list_records[record.id].data = record;
-                            self._parseServerData(fieldNames, list, record);
-                        });
-                        return Promise.all([
-                            self._fetchX2ManysBatched(list),
-                            self._fetchReferencesBatched(list)
-                        ]);
-                    });
-                    defs.push(def);
-                }
-                break;
-            case 'CREATE':
-                var createOptions = Object.assign({
-                    context: command.context,
-                    position: command.position
-                }, options || {});
-                createOptions.viewType = fieldInfo.mode;
-
-                def = this._addX2ManyDefaultRecord(list, createOptions).then(function (ids) {
-                    ids.forEach((id) => {
-                        if (command.position === 'bottom' && list.orderedResIDs && list.orderedResIDs.length >= list.limit) {
-                            list.tempLimitIncrement = (list.tempLimitIncrement || 0) + 1;
-                            list.limit += 1;
-                        }
-                        // FIXME: hack for lunch widget, which does useless default_get and onchange
-                        if (command.data) {
-                            return self._applyChange(id, command.data);
-                        }
-                    });
-                });
-                defs.push(def);
-                break;
-            case 'UPDATE':
-                list._changes.push({operation: 'UPDATE', id: command.id});
-                if (command.data) {
-                    defs.push(this._applyChange(command.id, command.data, {
-                        viewType: view && view.type,
-                    }));
-                }
-                break;
-            case 'FORGET':
-                // Unlink the record of list.
-                list._forceM2MUnlink = true;
-            case 'DELETE':
-                // filter out existing operations involving the current
-                // dataPoint, and add a 'DELETE' or 'FORGET' operation only if there is
-                // no 'ADD' operation for that dataPoint, as it would mean
-                // that the record wasn't in the relation yet
-                var idsToRemove = command.ids;
-
-                list._changes = list._changes.filter(change => {
-                    var idInCommands = command.ids.includes(change.id);
-                    if (idInCommands && change.operation === 'ADD') {
-                        idsToRemove = idsToRemove.filter(id => id !== change.id);
-                    }
-                    return !idInCommands;
-                });
-                idsToRemove.forEach(id => {
-                    var operation = list._forceM2MUnlink ? 'FORGET': 'DELETE';
-                    list._changes.push({operation: operation, id: id});
-                });
-                break;
-            case 'DELETE_ALL':
-                // first remove all pending 'ADD' operations
-                list._changes = list._changes.filter(change => change.operation !== 'ADD');
-
-                // then apply 'DELETE' on existing records
-                return this._applyX2ManyChange(record, fieldName, {
-                    operation: 'DELETE',
-                    ids: list.res_ids
-                }, options);
-            case 'REPLACE_WITH':
-                // this is certainly not optimal... and not sure that it is
-                // correct if some ids are added and some other are removed
-                list._changes = [];
-                var newIds = command.ids.filter((x) => list.res_ids.indexOf(x) < 0);
-                var removedIds = list.res_ids.filter((x) => command.ids.indexOf(x) < 0);
-                var addDef, removedDef, values;
-                if (newIds.length) {
-                    values = newIds.map((id) => {
-                        return { id: id };
-                    });
-                    addDef = this._applyX2ManyChange(record, fieldName, {
-                        operation: 'ADD_M2M',
-                        ids: values
-                    }, options);
-                }
-                if (removedIds.length) {
-                    var listData = list.data.map((localId) => self.localData[localId]);
-                    removedDef = this._applyX2ManyChange(record, fieldName, {
-                        operation: 'DELETE',
-                        ids: removedIds.map((resID) => {
-                            if (resID in list._cache) {
-                                return list._cache[resID];
-                            }
-                            return listData.find((list) => list.res_id === resID).id;
-                        }),
-                    }, options);
-                }
-                return Promise.all([addDef, removedDef]);
-            case 'MULTI':
-                // allows batching multiple operations
-                command.commands.forEach((innerCommand) => {
-                    defs.push(self._applyX2ManyChange(
-                        record,
-                        fieldName,
-                        innerCommand,
-                        options
-                    ));
-                });
-                break;
-        }
-
-        return Promise.all(defs).then(function () {
-            // ensure to fetch up to 'limit' records (may be useful if records of
-            // the current page have been removed)
-            return self._readUngroupedList(list).then(function () {
-                return self._fetchX2ManysBatched(list);
-            });
-        });
-    },
-    /**
-     * In dataPoints of type list for x2manys, the changes are stored as a list
-     * of operations (being of type 'ADD', 'DELETE', 'FORGET', UPDATE' or 'REMOVE_ALL').
-     * This function applies the operation of such a dataPoint without altering
-     * the original dataPoint. It returns a copy of the dataPoint in which the
-     * 'count', 'data' and 'res_ids' keys have been updated.
-     *
-     * @private
-     * @param {Object} dataPoint of type list
-     * @param {Object} [options] mostly contains the range of operations to apply
-     * @param {Object} [options.from=0] the index of the first operation to apply
-     * @param {Object} [options.to=length] the index of the last operation to apply
-     * @param {Object} [options.position] if set, each new operation will be set
-     *   accordingly at the top or the bottom of the list
-     * @returns {Object} element of type list in which the commands have been
-     *   applied
-     */
-    _applyX2ManyOperations: function (list, options) {
-        if (!list.static) {
-            // this function only applies on x2many lists
-            return list;
-        }
-        var self = this;
-        list = Object.assign({}, list);
-        list.res_ids = list.res_ids.slice(0);
-        var changes = list._changes || [];
-        if (options) {
-            var to = options.to === 0 ? 0 : (options.to || changes.length);
-            changes = changes.slice(options.from || 0, to);
-        }
-        changes.forEach((change) => {
-            var relRecord;
-            if (change.id) {
-                relRecord = self.localData[change.id];
-            }
-            switch (change.operation) {
-                case 'ADD':
-                    list.count++;
-                    var resID = relRecord ? relRecord.res_id : change.resID;
-                    if (change.position === 'top' && (options ? options.position !== 'bottom' : true)) {
-                        list.res_ids.unshift(resID);
-                    } else {
-                        list.res_ids.push(resID);
-                    }
-                    break;
-                case 'FORGET':
-                case 'DELETE':
-                    list.count--;
-                    // FIXME awa: there is no "relRecord" for o2m field
-                    // seems like using change.id does the trick -> check with framework JS
-                    var deletedResID = relRecord ? relRecord.res_id : change.id;
-                    list.res_ids = list.res_ids.filter((resID) => resID !== deletedResID);
-                    break;
-                case 'REMOVE_ALL':
-                    list.count = 0;
-                    list.res_ids = [];
-                    break;
-                case 'UPDATE':
-                    // nothing to do for UPDATE commands
-                    break;
-            }
-        });
-        this._setDataInRange(list);
-        return list;
-    },
-    /**
-     * Helper method to build a 'spec', that is a description of all fields in
-     * the view that have a onchange defined on them.
-     *
-     * An onchange spec is necessary as an argument to the /onchange route. It
-     * looks like this: { field: "1", anotherField: "", relation.subField: "1"}
-     *
-     * The first onchange call will fill up the record with default values, so
-     * we need to send every field name known to us in this case.
-     *
-     * @see _performOnChange
-     *
-     * @param {Object} record resource object of type 'record'
-     * @param {string} [viewType] current viewType. If not set, we will assume
-     *   main viewType from the record
-     * @returns {Object} with two keys
-     *   - 'hasOnchange': true iff there is at least a field with onchange
-     *   - 'onchangeSpec': the onchange spec
-     */
-    _buildOnchangeSpecs: function (record, viewType) {
-        let hasOnchange = false;
-        const onchangeSpec = {};
-        var fieldsInfo = record.fieldsInfo[viewType || record.viewType];
-        generateSpecs(fieldsInfo, record.fields);
-
-        // recursively generates the onchange specs for fields in fieldsInfo,
-        // and their subviews
-        function generateSpecs(fieldsInfo, fields, prefix) {
-            prefix = prefix || '';
-            Object.keys(fieldsInfo).forEach((name) => {
-                var field = fields[name];
-                var fieldInfo = fieldsInfo[name];
-                var key = prefix + name;
-                onchangeSpec[key] = (field.onChange) || "";
-                if (field.onChange) {
-                    hasOnchange = true;
-                }
-                if (field.type === 'one2many' || field.type === 'many2many') {
-                    Object.values(fieldInfo.views || {}).forEach((view) => {
-                        generateSpecs(view.fieldsInfo[view.type], view.fields, key + '.');
-                    });
-                }
-            });
-        }
-        return { hasOnchange, onchangeSpec };
-    },
-    /**
-     * Ensures that dataPoint ids are always synchronized between the main and
-     * sample models when being in sample mode. Here, we now that __id in the
-     * sample model is always greater than __id in the main model (as it
-     * contains strictly more datapoints).
-     *
-     * @override
-     */
-    async _callSampleModel() {
-        await this._super(...arguments);
-        if (this._isInSampleMode) {
-            this.__id = this.sampleModel.__id;
-        }
-    },
-    /**
-     * Compute the default value that the handle field should take.
-     * We need to compute this in order for new lines to be added at the correct position.
-     *
-     * @private
-     * @param {Object} listID
-     * @param {string} position
-     * @return {Object} empty object if no overrie has to be done, or:
-     *  field: the name of the field to override,
-     *  value: the value to use for that field
-     */
-    _computeOverrideDefaultFields: function (listID, position) {
-        var list = this.localData[listID];
-        var handleField;
-
-        // Here listID is actually just parentID, it's not yet confirmed
-        // to be a list.
-        // If we are not in the case that interests us,
-        // listID will be undefined and this check will work.
-        if (!list) {
-            return {};
-        }
-
-        position = position || 'bottom';
-
-        // Let's find if there is a field with handle.
-        if (!list.fieldsInfo) {
-            return {};
-        }
-        for (var field in list.fieldsInfo.list) {
-            if (list.fieldsInfo.list[field].widget === 'handle') {
-                handleField = field;
-                break;
-                // If there are 2 handle fields on the same list,
-                // we take the first one we find.
-                // And that will be alphabetically on the field name...
-            }
-        }
-
-        if (!handleField) {
-            return {};
-        }
-
-        // We don't want to override the default value
-        // if the list is not ordered by the handle field.
-        var isOrderedByHandle = list.orderedBy
-            && list.orderedBy.length
-            && list.orderedBy[0].asc === true
-            && list.orderedBy[0].name === handleField;
-
-        if (!isOrderedByHandle) {
-            return {};
-        }
-
-        // We compute the list (get) to apply the pending changes before doing our work,
-        // otherwise new lines might not be taken into account.
-        // We use raw: true because we only need to load the first level of relation.
-        var computedList = this.get(list.id, {raw: true});
-
-        // We don't need to worry about the position of a new line if the list is empty.
-        if (!computedList || !computedList.data || !computedList.data.length) {
-            return {};
-        }
-
-        // If there are less elements in the list than the limit of
-        // the page then take the index of the last existing line.
-
-        // If the button is at the top, we want the new element on
-        // the first line of the page.
-
-        // If the button is at the bottom, we want the new element
-        // after the last line of the page
-        // (= theorically it will be the first element of the next page).
-
-        // We ignore list.offset because computedList.data
-        // will only have the current page elements.
-
-        var index = Math.min(
-            computedList.data.length - 1,
-            position !== 'top' ? list.limit - 1 : 0
-        );
-
-        // This positioning will almost be correct. There might just be
-        // an issue if several other lines have the same handleFieldValue.
-
-        // TODO ideally: if there is an element with the same handleFieldValue,
-        // that one and all the following elements must be incremented
-        // by 1 (at least until there is a gap in the numbering).
-
-        // We don't do it now because it's not an important case.
-        // However, we can for sure increment by 1 if we are on the last page.
-        var handleFieldValue = computedList.data[index].data[handleField];
-        if (position === 'top') {
-            handleFieldValue--;
-        } else if (list.count <= list.offset + list.limit - (list.tempLimitIncrement || 0)) {
-            handleFieldValue++;
-        }
-        return {
-            field: handleField,
-            value: handleFieldValue,
-        };
-    },
-    /**
-     * Evaluate modifiers
-     *
-     * @private
-     * @param {Object} element a valid element object, which will serve as eval
-     *   context.
-     * @param {Object} modifiers
-     * @returns {Object}
-     * @throws {Error} if one of the modifier domains is invalid
-     */
-    _evalModifiers: function (element, modifiers) {
-        let evalContext = null;
-        const evaluated = {};
-        for (const k of ['invisible', 'column_invisible', 'readonly', 'required']) {
-            const mod = modifiers[k];
-            if (mod === undefined || mod === false || mod === true) {
-                if (k in modifiers) {
-                    evaluated[k] = !!mod;
-                }
-                continue;
-            }
-            try {
-                evalContext = evalContext || this._getEvalContext(element);
-                evaluated[k] = new Domain(mod, evalContext).compute(evalContext);
-            } catch (e) {
-                throw new Error(sprintf('for modifier "%s": %s', k, e.message));
-            }
-        }
-        return evaluated;
-    },
-    /**
-     * Fetch the type of model (e.g. 'res.partner') contained in the model_field
-     * @private
-     * @param {Object} record - an element from the localData
-     * @param {Object} fieldName - the name of the field
-     * @param {Object} fieldInfo - the info of the field
-     * @returns {Promise}
-     */
-    _fetchModelFieldReference: async function (record, fieldName, fieldInfo) {
-        const modelField = fieldInfo.options.model_field;
-        const value = record._changes && record._changes[modelField] || record.data[modelField];
-        if (value) {
-            if (record.fields[modelField].type !== "many2one"
-                || record.fields[modelField].relation !== 'ir.model') {
-                throw new Error(`The model_field of the reference field
-                                 ${fieldName} must be a many2one('ir.model').`);
-            }
-            const modelId = this.localData[value].res_id;
-            const resourceRef = record.specialData[fieldName];
-            if (resourceRef && modelId === resourceRef.modelId) {
-                resourceRef.hasChanged = false;
-                return Promise.resolve(resourceRef);
-            } else {
-                const result = await this._rpc({
-                    model: 'ir.model',
-                    method: 'read',
-                    args: [modelId, ['id', 'model']],
-                });
-                // Checks the case where the data on the backend side are not synchronized
-                // (modelFieldName != referenceFieldName) when opening the edit view (!_changes).
-                // We want to avoid resynchronization in order not to modify the data 
-                // without being requested.
-                if (!record._changes && record.data[fieldName]
-                    && result[0].model !== this.localData[record.data[fieldName]].model) {
-                    const modelFieldName = record.fields[modelField].string;
-                    const referenceFieldName = record.fields[fieldName].string;
-
-                    this.displayNotification({
-                        title: sprintf(
-                            _t(`'%s' is unsynchronized with '%s'.`),
-                            referenceFieldName,
-                            modelFieldName,
-                        ),
-                        message: sprintf(
-                            _t(`If you change %s or %s, the synchronization will be reapplied and the data will be modified.`),
-                            modelFieldName,
-                            referenceFieldName,
-                        ),
-                        sticky: true,
-                        type: 'danger',
-                    });
-                    return false;
-                }
-                return {
-                    modelName: result[0].model,
-                    modelId: result[0].id,
-                    hasChanged: true,
-                };
-            }
-        }
-    },
-    /**
-     * Fetch display_name for a record datapoint.
-     *
-     * @param {Object} dataPoint
-     * @returns {Promise}
-     */
-    _fetchNameGet: function (dataPoint) {
-        return this._rpc({
-            model: dataPoint.model,
-            method: 'read',
-            args: [dataPoint.res_id, ['display_name']],
-            context: dataPoint.getContext(),
-        }).then(function (result) {
-            dataPoint.data.display_name = result[0]['display_name'];
-        });
-    },
-    /**
-     * Fetch display_name for a field of type Many2one or Reference
-     *
-     * @private
-     * @params {Object} list: must be a datapoint of type list
-     *   (for example: a datapoint representing a x2many)
-     * @params {string} fieldName: the name of a field of type Many2one or Reference
-     * @returns {Promise}
-     */
-    _fetchNameGets: function (list, fieldName) {
-        var self = this;
-        // We first get the model this way because if list.data is empty
-        // the forEach below will not make it.
-        var model = list.fields[fieldName].relation;
-        var records = [];
-        var ids = [];
-        list = this._applyX2ManyOperations(list);
-
-        list.data.forEach((localId) => {
-            var record = self.localData[localId];
-            var data = record._changes || record.data;
-            var many2oneId = data[fieldName];
-            if (!many2oneId) { return; }
-            var many2oneRecord = self.localData[many2oneId];
-            records.push(many2oneRecord);
-            ids.push(many2oneRecord.res_id);
-            // We need to calculate the model this way too because
-            // field .relation is not set for a reference field.
-            model = many2oneRecord.model;
-        });
-
-        if (!ids.length) {
-            return Promise.resolve();
-        }
-        return this._rpc({
-                model: model,
-                method: 'read',
-                args: [unique(ids), ['display_name']],
-                context: list.context,
-            })
-            .then(function (readRecords) {
-                records.forEach((record) => {
-                    const readRecord = readRecords.find(readRecord => readRecord['id'] === record.data.id);
-                    record.data.display_name = readRecord['display_name'];
-                });
-            });
-    },
-    /**
-     * For a given resource of type 'record', fetch all data.
-     *
-     * @param {Object} record local resource
-     * @param {Object} [options]
-     * @param {string[]} [options.fieldNames] the list of fields to fetch. If
-     *   not given, fetch all the fields in record.fieldNames (+ display_name)
-     * @param {string} [options.viewType] the type of view for which the record
-     *   is fetched (usefull to load the adequate fields), by defaults, uses
-     *   record.viewType
-     * @returns {Promise<Object>} resolves to the record or is rejected in
-     *   case no id given were valid ids
-     */
-    _fetchRecord: function (record, options) {
-        var self = this;
-        options = options || {};
-        var fieldNames = options.fieldNames || record.getFieldNames(options);
-        fieldNames = unique(fieldNames.concat(['display_name']));
-        return this._rpc({
-                model: record.model,
-                method: 'read',
-                args: [[record.res_id], fieldNames],
-                context: Object.assign({bin_size: true}, record.getContext()),
-            })
-            .then(function (result) {
-                if (result.length === 0) {
-                    return Promise.reject();
-                }
-                result = result[0];
-                record.data = Object.assign({}, record.data, result);
-            })
-            .then(function () {
-                self._parseServerData(fieldNames, record, record.data);
-            })
-            .then(function () {
-                return Promise.all([
-                    self._fetchX2Manys(record, options),
-                    self._fetchReferences(record, options)
-                ]).then(function () {
-                    return self._postprocess(record, options);
-                });
-            });
-    },
-    /**
-     * Fetch the `display_name` for a reference field.
-     *
-     * @private
-     * @param {Object} record
-     * @param {string} fieldName
-     * @returns {Promise}
-     */
-    _fetchReference: function (record, fieldName) {
-        var self = this;
-        var def;
-        var value = record._changes && record._changes[fieldName] || record.data[fieldName];
-        var model = value && value.split(',')[0];
-        var resID = value && parseInt(value.split(',')[1]);
-        if (model && model !== 'False' && resID) {
-            def = self._rpc({
-                model: model,
-                method: 'read',
-                args: [resID, ['display_name']],
-                context: record.getContext({fieldName: fieldName}),
-            }).then(function (result) {
-                return self._makeDataPoint({
-                    data: result[0],
-                    modelName: model,
-                    parentID: record.id,
-                });
-            });
-        }
-        return Promise.resolve(def);
-    },
-    /**
-     * Fetches data for reference fields and assigns these data to newly
-     * created datapoint.
-     * Then places datapoint reference into parent record.
-     *
-     * @param {Object} datapoints a collection of ids classed by model,
-     *   @see _getDataToFetchByModel
-     * @param {string} model
-     * @param {string} fieldName
-     * @returns {Promise}
-     */
-    _fetchReferenceData: function (datapoints, model, fieldName) {
-        var self = this;
-        var ids = Object.keys(datapoints).map((id) => parseInt(id));
-        // we need one parent for the context (they all have the same)
-        var parent = datapoints[ids[0]][0];
-        var def = self._rpc({
-            model: model,
-            method: 'read',
-            args: [ids, ['display_name']],
-            context: self.localData[parent].getContext({fieldName: fieldName, withoutRecordData: true}),
-        }).then(function (result) {
-            result.forEach((el) => {
-                var parentIDs = datapoints[el['id']];
-                parentIDs.forEach((parentID) => {
-                    var parent = self.localData[parentID];
-                    var referenceDp = self._makeDataPoint({
-                        data: el,
-                        modelName: model,
-                        parentID: parent.id,
-                    });
-                    parent.data[fieldName] = referenceDp.id;
-                });
-            });
-        });
-        return def;
-    },
-    /**
-     * Fetch the extra data (`display_name`) for the reference fields of the record
-     * model.
-     *
-     * @private
-     * @param {Object} record
-     * @returns {Promise}
-     */
-    _fetchReferences: function (record, options) {
-        var self = this;
-        var defs = [];
-        var fieldNames = options && options.fieldNames || record.getFieldNames();
-        fieldNames.forEach((fieldName) => {
-            var field = record.fields[fieldName];
-            if (field.type === 'reference') {
-                var def = self._fetchReference(record, fieldName).then(function (dataPoint) {
-                    if (dataPoint) {
-                        record.data[fieldName] = dataPoint.id;
-                    }
-                });
-                defs.push(def);
-            }
-        });
-        return Promise.all(defs);
-    },
-    /**
-     * Batch requests for one reference field in list (one request by different
-     * model in the field values).
-     *
-     * @see _fetchReferencesBatched
-     * @param {Object} list
-     * @param {string} fieldName
-     * @returns {Promise}
-     */
-    _fetchReferenceBatched: function (list, fieldName) {
-        var self = this;
-        list = this._applyX2ManyOperations(list);
-        this._sortList(list);
-
-        var toFetch = this._getDataToFetchByModel(list, fieldName);
-        var defs = [];
-        // one display_name read by model
-        Object.entries(toFetch).forEach(([model, datapoints]) => {
-            defs.push(self._fetchReferenceData(datapoints, model, fieldName));
-        });
-
-        return Promise.all(defs);
-    },
-    /**
-     * Batch requests for references for datapoint of type list.
-     *
-     * @param {Object} list
-     * @returns {Promise}
-     */
-    _fetchReferencesBatched: function (list) {
-        var defs = [];
-        var fieldNames = list.getFieldNames();
-        for (var i = 0; i < fieldNames.length; i++) {
-            var field = list.fields[fieldNames[i]];
-            if (field.type === 'reference') {
-                defs.push(this._fetchReferenceBatched(list, fieldNames[i]));
-            }
-        }
-        return Promise.all(defs);
-    },
-    /**
-     * Batch reference requests for all records in list.
-     *
-     * @see _fetchReferencesSingleBatch
-     * @param {Object} list a valid resource object
-     * @param {string} fieldName
-     * @returns {Promise}
-     */
-    _fetchReferenceSingleBatch: function (list, fieldName) {
-        var self = this;
-
-        // collect ids by model
-        var toFetch = {};
-        list.data.forEach((groupIndex) => {
-            var group = self.localData[groupIndex];
-            self._getDataToFetchByModel(group, fieldName, toFetch);
-        });
-
-        var defs = [];
-        // one display_name read by model
-        Object.entries(toFetch).forEach(([model, datapoints]) => {
-            defs.push(self._fetchReferenceData(datapoints, model, fieldName));
-        });
-
-        return Promise.all(defs);
-    },
-    /**
-     * Batch requests for all reference field in list's children.
-     * Called by _readGroup to make only one display_name 'read' rpc by fieldName.
-     *
-     * @param {Object} list a valid resource object
-     * @returns {Promise}
-     */
-    _fetchReferencesSingleBatch: function (list) {
-        var defs = [];
-        var fieldNames = list.getFieldNames();
-        for (var fIndex in fieldNames) {
-            var field = list.fields[fieldNames[fIndex]];
-            if (field.type === 'reference') {
-                defs.push(this._fetchReferenceSingleBatch(list, fieldNames[fIndex]));
-            }
-        }
-        return Promise.all(defs);
-    },
-    /**
-     * Fetch model data from server, relationally to fieldName and resulted
-     * field relation. For example, if fieldName is "tag_ids" and referred to
-     * project.tags, it will fetch project.tags' related fields where its id is
-     * contained in toFetch.ids array.
-     *
-     * @param {Object} list a valid resource object
-     * @param {Object} toFetch a list of records and res_ids,
-     *   @see _getDataToFetch
-     * @param {string} fieldName
-     * @returns {Promise}
-     */
-    _fetchRelatedData: function (list, toFetch, fieldName) {
-        var self = this;
-        var ids = Object.keys(toFetch || {});
-        for (var i = 0; i < ids.length; i++) {
-            ids[i] = Number(ids[i]);
-        }
-        var fieldInfo = list.fieldsInfo[list.viewType][fieldName];
-
-        if (!ids.length || fieldInfo.__no_fetch) {
-            return Promise.resolve();
-        }
-
-        var def;
-        var fieldNames = Object.keys(fieldInfo.relatedFields || {});
-        if (fieldNames.length) {
-            var field = list.fields[fieldName];
-            def = this._rpc({
-                model: field.relation,
-                method: 'read',
-                args: [ids, fieldNames],
-                context: list.getContext({withoutRecordData: true}) || {},
-            });
-        } else {
-            def = Promise.resolve(
-                ids.map((id) => {
-                    return { id: id };
-                })
-            );
-        }
-        return def.then(function (result) {
-            var records = unique(Object.values(toFetch || {}).flat());
-            self._updateRecordsData(records, fieldName, result);
-        });
-    },
-    /**
-     * Check the AbstractField specializations that are (will be) used by the
-     * given record and fetch the special data they will need. Special data are
-     * data that the rendering of the record won't need if it was not using
-     * particular widgets (example of these can be found at the methods which
-     * start with _fetchSpecial).
-     *
-     * @param {Object} record - an element from the localData
-     * @param {Object} options
-     * @returns {Promise<Array>}
-     *          The promise is resolved with an array containing the names of
-     *          the field whose special data has been changed.
-     */
-    _fetchSpecialData: function (record, options) {
-        var self = this;
-        var specialFieldNames = [];
-        var fieldNames = (options && options.fieldNames) || record.getFieldNames();
-        return Promise.all(fieldNames.map((name) => {
-            var viewType = (options && options.viewType) || record.viewType;
-            var fieldInfo = record.fieldsInfo[viewType][name] || {};
-            let specialData;
-            if ("specialData" in fieldInfo) {
-                specialData = fieldInfo.specialData;
-            } else if (fieldInfo.Widget) {
-                specialData = fieldInfo.Widget.prototype.specialData;
-            }
-            if (specialData) {
-                return self[specialData](record, name, fieldInfo).then(function (data) {
-                    if (data === undefined) {
-                        return;
-                    }
-                    record.specialData[name] = data;
-                    specialFieldNames.push(name);
-                });
-            }
-        })).then(function () {
-            return specialFieldNames;
-        });
-    },
-    /**
-     * Fetches all the m2o records associated to the given fieldName. If the
-     * given fieldName is not a m2o field, nothing is done.
-     *
-     * @param {Object} record - an element from the localData
-     * @param {Object} fieldName - the name of the field
-     * @param {Object} fieldInfo
-     * @param {string[]} [fieldsToRead] - the m2os fields to read (id and
-     *                                  display_name are automatic).
-     * @returns {Promise<any>}
-     *          The promise is resolved with the fetched special data. If this
-     *          data is the same as the previously fetched one (for the given
-     *          parameters), no RPC is done and the promise is resolved with
-     *          the undefined value.
-     */
-    _fetchSpecialMany2ones: function (record, fieldName, fieldInfo, fieldsToRead) {
-        var field = record.fields[fieldName];
-        if (field.type !== "many2one") {
-            return Promise.resolve();
-        }
-
-        var context = record.getContext({fieldName: fieldName});
-        var domain = record.getDomain({fieldName: fieldName});
-        if (domain.length) {
-            var localID = (record._changes && fieldName in record._changes) ?
-                            record._changes[fieldName] :
-                            record.data[fieldName];
-            if (localID) {
-                var element = this.localData[localID];
-                domain = ["|", ["id", "=", element.data.id]].concat(domain);
-            }
-        }
-
-        // avoid rpc if not necessary
-        var hasChanged = this._saveSpecialDataCache(record, fieldName, {
-            context: context,
-            domain: domain,
-        });
-        if (!hasChanged) {
-            return Promise.resolve();
-        }
-
-        return this._rpc({
-                model: field.relation,
-                method: 'search_read',
-                fields: ["display_name"].concat(fieldsToRead || []),
-                context: context,
-                domain: domain,
-            });
-    },
-    /**
-     * Fetches all the relation records associated to the given fieldName. If
-     * the given fieldName is not a relational field, nothing is done.
-     *
-     * @param {Object} record - an element from the localData
-     * @param {Object} fieldName - the name of the field
-     * @returns {Promise<any>}
-     *          The promise is resolved with the fetched special data. If this
-     *          data is the same as the previously fetched one (for the given
-     *          parameters), no RPC is done and the promise is resolved with
-     *          the undefined value.
-     */
-    _fetchSpecialRelation: function (record, fieldName) {
-        var field = record.fields[fieldName];
-        if (!["many2one", "many2many", "one2many"].includes(field.type)) {
-            return Promise.resolve();
-        }
-
-        var context = record.getContext({fieldName: fieldName});
-        var domain = record.getDomain({fieldName: fieldName});
-
-        // avoid rpc if not necessary
-        var hasChanged = this._saveSpecialDataCache(record, fieldName, {
-            context: context,
-            domain: domain,
-        });
-        if (!hasChanged) {
-            return Promise.resolve();
-        }
-
-        return this._rpc({
-                model: field.relation,
-                method: 'name_search',
-                args: ["", domain],
-                context: context
-            });
-    },
-    /**
-     * Fetches the `display_name` associated to the reference widget if the field is
-     * a `char` (which is a supported case).
-     *
-     * @private
-     * @param {Object} record - an element from the localData
-     * @param {Object} fieldName - the name of the field
-     * @param {Object} fieldInfo - the info of the field
-     * @returns {Promise}
-     */
-    _fetchSpecialReference: function (record, fieldName, fieldInfo) {
-        var field = record.fields[fieldName];
-        if (field.type === 'char') {
-            // if the widget reference is set on a char field, the display_name
-            // needs to be fetched a posteriori
-            return Promise.resolve(this._fetchReference(record, fieldName));
-        } else if (fieldInfo.options.model_field) {
-            return this._fetchModelFieldReference(record, fieldName, fieldInfo);
-        }
-        return Promise.resolve();
-    },
-    /**
-     * Fetches all the m2o records associated to the given fieldName. If the
-     * given fieldName is not a m2o field, nothing is done. The difference with
-     * _fetchSpecialMany2ones is that the field given by options.fold_field is
-     * also fetched.
-     *
-     * @param {Object} record - an element from the localData
-     * @param {Object} fieldName - the name of the field
-     * @param {Object} fieldInfo
-     * @returns {Promise<any>}
-     *          The promise is resolved with the fetched special data. If this
-     *          data is the same as the previously fetched one (for the given
-     *          parameters), no RPC is done and the promise is resolved with
-     *          the undefined value.
-     */
-    _fetchSpecialStatus: function (record, fieldName, fieldInfo) {
-        var foldField = fieldInfo.options.fold_field;
-        var fieldsToRead = foldField ? [foldField] : [];
-        return this._fetchSpecialMany2ones(record, fieldName, fieldInfo, fieldsToRead).then(function (m2os) {
-            Object.values(m2os || {}).forEach((m2o) => {
-                m2o.fold = foldField ? m2o[foldField] : false;
-            });
-            return m2os;
-        });
-    },
-    /**
-     * Fetch all data in a ungrouped list
-     *
-     * @param {Object} list a valid resource object
-     * @param {Object} [options]
-     * @param {boolean} [options.enableRelationalFetch=true] if false, will not
-     *   fetch x2m and relational data (that will be done by _readGroup in this
-     *   case).
-     * @returns {Promise<Object>} resolves to the fecthed list
-     */
-    _fetchUngroupedList: function (list, options) {
-        options = Object.assign({ enableRelationalFetch: true }, options || {});
-        var self = this;
-        var def;
-        if (list.static) {
-            def = this._readUngroupedList(list).then(function () {
-                if (list.parentID && self.isNew(list.parentID)) {
-                    // list from a default_get, so fetch display_name for many2one fields
-                    var many2ones = self._getMany2OneFieldNames(list);
-                    var defs = many2ones.map((name) => self._fetchNameGets(list, name));
-                    return Promise.all(defs);
-                }
-            });
-        } else {
-            def = this._searchReadUngroupedList(list);
-        }
-        return def.then(function () {
-            if (options.enableRelationalFetch) {
-                return Promise.all([
-                    self._fetchX2ManysBatched(list),
-                    self._fetchReferencesBatched(list)
-                ]);
-            }
-        }).then(function () {
-            return list;
-        });
-    },
-    /**
-     * batch requests for 1 x2m in list
-     *
-     * @see _fetchX2ManysBatched
-     * @param {Object} list
-     * @param {string} fieldName
-     * @returns {Promise}
-     */
-    _fetchX2ManyBatched: function (list, fieldName) {
-        list = this._applyX2ManyOperations(list);
-        this._sortList(list);
-
-        var toFetch = this._getDataToFetch(list, fieldName);
-        return this._fetchRelatedData(list, toFetch, fieldName);
-    },
-    /**
-     * X2Manys have to be fetched by separate rpcs (their data are stored on
-     * different models). This method takes a record, look at its x2many fields,
-     * then, if necessary, create a local resource and fetch the corresponding
-     * data.
-     *
-     * It also tries to reuse data, if it can find an existing list, to prevent
-     * useless rpcs.
-     *
-     * @param {Object} record local resource
-     * @param {Object} [options]
-     * @param {string[]} [options.fieldNames] the list of fields to fetch.
-     *   If not given, fetch all the fields in record.fieldNames
-     * @param {string} [options.viewType] the type of view for which the main
-     *   record is fetched (useful to load the adequate fields), by defaults,
-     *   uses record.viewType
-     * @returns {Promise}
-     */
-    _fetchX2Manys: function (record, options) {
-        var self = this;
-        var defs = [];
-        options = options || {};
-        var fieldNames = options.fieldNames || record.getFieldNames(options);
-        var viewType = options.viewType || record.viewType;
-        fieldNames.forEach((fieldName) => {
-            var field = record.fields[fieldName];
-            if (field.type === 'one2many' || field.type === 'many2many') {
-                var fieldInfo = record.fieldsInfo[viewType][fieldName];
-                var rawContext = fieldInfo && fieldInfo.context;
-                var view = fieldInfo.views && fieldInfo.views[fieldInfo.mode];
-                var fieldsInfo = view ? view.fieldsInfo : (fieldInfo.fieldsInfo || {});
-                var ids = record.data[fieldName] || [];
-
-                // remove default_* & *_view_ref keys from record context
-                const recordContext = { ...record.context };
-                for (const key in recordContext) {
-                    if (key.startsWith("default_") || key.endsWith("_view_ref")) {
-                        delete recordContext[key];
-                    }
-                }
-
-                var list = self._makeDataPoint({
-                    count: ids.length,
-                    context: Object.assign({}, recordContext, field.context),
-                    fieldsInfo: fieldsInfo,
-                    fields: view ? view.fields : fieldInfo.relatedFields,
-                    limit: fieldInfo.limit,
-                    modelName: field.relation,
-                    res_ids: ids,
-                    static: true,
-                    type: 'list',
-                    orderedBy: fieldInfo.orderedBy,
-                    parentID: record.id,
-                    rawContext: rawContext,
-                    relationField: field.relation_field,
-                    viewType: view ? view.type : fieldInfo.viewType,
-                });
-                record.data[fieldName] = list.id;
-                if (!fieldInfo.__no_fetch) {
-                    var def = self._readUngroupedList(list, { withoutRecordData: true }).then(function () {
-                        return Promise.all([
-                            self._fetchX2ManysBatched(list),
-                            self._fetchReferencesBatched(list)
-                        ]);
-                    });
-                    defs.push(def);
-                }
-            }
-        });
-        return Promise.all(defs);
-    },
-    /**
-     * batch request for x2ms for datapoint of type list
-     *
-     * @param {Object} list
-     * @returns {Promise}
-     */
-    _fetchX2ManysBatched: function (list) {
-        var defs = [];
-        var fieldNames = list.getFieldNames();
-        for (var i = 0; i < fieldNames.length; i++) {
-            var field = list.fields[fieldNames[i]];
-            if (field.type === 'many2many' || field.type === 'one2many') {
-                defs.push(this._fetchX2ManyBatched(list, fieldNames[i]));
-            }
-        }
-        return Promise.all(defs);
-    },
-    /**
-     * For a non-static list, batches requests for all its sublists' records.
-     * Make only one rpc for all records on the concerned field.
-     *
-     * @see _fetchX2ManysSingleBatch
-     * @param {Object} list a valid resource object, its data must be another
-     *   list containing records
-     * @param {string} fieldName
-     * @returns {Promise}
-     */
-    _fetchX2ManySingleBatch: function (list, fieldName) {
-        var self = this;
-        var toFetch = {};
-        list.data.forEach((groupIndex) => {
-            var group = self.localData[groupIndex];
-            var nextDataToFetch = self._getDataToFetch(group, fieldName);
-            Object.keys(nextDataToFetch).forEach((id) => {
-                if (toFetch[id]) {
-                    toFetch[id] = toFetch[id].concat(nextDataToFetch[id]);
-                } else {
-                    toFetch[id] = nextDataToFetch[id];
-                }
-            });
-        });
-        return self._fetchRelatedData(list, toFetch, fieldName);
-    },
-    /**
-     * Batch requests for all x2m in list's children.
-     * Called by _readGroup to make only one 'read' rpc by fieldName.
-     *
-     * @param {Object} list a valid resource object
-     * @returns {Promise}
-     */
-    _fetchX2ManysSingleBatch: function (list) {
-        var defs = [];
-        var fieldNames = list.getFieldNames();
-        for (var i = 0; i < fieldNames.length; i++) {
-            var field = list.fields[fieldNames[i]];
-            if (field.type === 'many2many' || field.type === 'one2many'){
-                defs.push(this._fetchX2ManySingleBatch(list, fieldNames[i]));
-            }
-        }
-        return Promise.all(defs);
-    },
-    /**
-     * Generates an object mapping field names to their changed value in a given
-     * record (i.e. maps to the new value for basic fields, to the res_id for
-     * many2ones and to commands for x2manys).
-     *
-     * @private
-     * @param {Object} record
-     * @param {Object} [options]
-     * @param {boolean} [options.changesOnly=true] if true, only generates
-     *   commands for fields that have changed (concerns x2many fields only)
-     * @param {boolean} [options.withReadonly=false] if false, doesn't generate
-     *   changes for readonly fields
-     * @param {string} [options.viewType] current viewType. If not set, we will
-     *   assume main viewType from the record. Note that if an editionViewType is
-     *   specified for a field, it will take the priority over the viewType arg.
-     * @returns {Object} a map from changed fields to their new value
-     */
-    _generateChanges: function (record, options) {
-        options = options || {};
-        var viewType = options.viewType || record.viewType;
-        var changes;
-        const changesOnly = 'changesOnly' in options ? !!options.changesOnly : true;
-        if (!changesOnly) {
-            changes = Object.assign({}, record.data, record._changes);
-        } else {
-            changes = Object.assign({}, record._changes);
-        }
-        var withReadonly = options.withReadonly || false;
-        var commands = this._generateX2ManyCommands(record, {
-            changesOnly: changesOnly,
-            withReadonly: withReadonly,
-        });
-        for (var fieldName in record.fields) {
-            // remove readonly fields from the list of changes
-            if (!withReadonly && fieldName in changes || fieldName in commands) {
-                var editionViewType = record._editionViewType[fieldName] || viewType;
-                if (this._isFieldProtected(record, fieldName, editionViewType)) {
-                    delete changes[fieldName];
-                    continue;
-                }
-            }
-
-            // process relational fields and handle the null case
-            var type = record.fields[fieldName].type;
-            var value;
-            if (type === 'one2many' || type === 'many2many') {
-                if (!changesOnly || (commands[fieldName] && commands[fieldName].length)) { // replace localId by commands
-                    changes[fieldName] = commands[fieldName];
-                } else { // no command -> no change for that field
-                    delete changes[fieldName];
-                }
-            } else if (type === 'many2one' && fieldName in changes) {
-                value = changes[fieldName];
-                changes[fieldName] = value ? this.localData[value].res_id : false;
-            } else if (type === 'reference' && fieldName in changes) {
-                value = changes[fieldName];
-                changes[fieldName] = value ?
-                    this.localData[value].model + ',' + this.localData[value].res_id :
-                    false;
-            } else if (type === 'char' && changes[fieldName] === '') {
-                changes[fieldName] = false;
-            } else if (changes[fieldName] === null) {
-                changes[fieldName] = false;
-            }
-        }
-        return changes;
-    },
-    /**
-     * Generates an object mapping field names to their current value in a given
-     * record. If the record is inside a one2many, the returned object contains
-     * an additional key (the corresponding many2one field name) mapping to the
-     * current value of the parent record.
-     *
-     * @param {Object} record
-     * @param {Object} [options] This option object will be given to the private
-     *   method _generateX2ManyCommands.  In particular, it is useful to be able
-     *   to send changesOnly:true to get all data, not only the current changes.
-     * @returns {Object} the data
-     */
-    _generateOnChangeData: function (record, options) {
-        options = Object.assign({}, options || {}, {withReadonly: true});
-        var data = {};
-        if (!options.firstOnChange) {
-            var commands = this._generateX2ManyCommands(record, options);
-            data = Object.assign(this.get(record.id, {raw: true}).data, commands);
-            // 'display_name' is automatically added to the list of fields to fetch,
-            // when fetching a record, even if it doesn't appear in the view. However,
-            // only the fields in the view must be passed to the onchange RPC, so we
-            // remove it from the data sent by RPC if it isn't in the view.
-            var hasDisplayName = Object.values(record.fieldsInfo || {}).some((fieldsInfo) => {
-                return 'display_name' in fieldsInfo;
-            });
-            if (!hasDisplayName) {
-                delete data.display_name;
-            }
-        }
-
-        // one2many records have a parentID
-        if (record.parentID) {
-            var parent = this.localData[record.parentID];
-            // parent is the list element containing all the records in the
-            // one2many and parent.parentID is the ID of the main record
-            // if there is a relation field, this means that record is an elem
-            // in a one2many. The relation field is the corresponding many2one
-            if (parent.parentID && parent.relationField) {
-                var parentRecord = this.localData[parent.parentID];
-                data[parent.relationField] = this._generateOnChangeData(parentRecord);
-            }
-        }
-
-        return data;
-    },
-    /**
-     * Read all x2many fields and generate the commands for the server to create
-     * or write them...
-     *
-     * @param {Object} record
-     * @param {Object} [options]
-     * @param {string} [options.fieldNames] if given, generates the commands for
-     *   these fields only
-     * @param {boolean} [changesOnly=false] if true, only generates commands for
-     *   fields that have changed
-     * @param {boolean} [options.withReadonly=false] if false, doesn't generate
-     *   changes for readonly fields in commands
-     * @returns {Object} a map from some field names to commands
-     */
-    _generateX2ManyCommands: function (record, options) {
-        var self = this;
-        options = options || {};
-        const changesOnly = options.changesOnly;
-        var fields = record.fields;
-        if (options.fieldNames) {
-            fields = pick(fields, ...options.fieldNames);
-        }
-        var commands = {};
-        var data = Object.assign({}, record.data, record._changes);
-        var type;
-        for (var fieldName in fields) {
-            type = fields[fieldName].type;
-
-            if (type === 'many2many' || type === 'one2many') {
-                if (!data[fieldName]) {
-                    // skip if this field is empty
-                    continue;
-                }
-                commands[fieldName] = [];
-                var list = this.localData[data[fieldName]];
-                if (options.changesOnly && (!list._changes || !list._changes.length)) {
-                    // if only changes are requested, skip if there is no change
-                    continue;
-                }
-                var oldResIDs = list.res_ids.slice(0);
-                var relRecordAdded = [];
-                var relRecordUpdated = [];
-                Object.values(list._changes || {}).forEach((change) => {
-                    if (change.operation === 'ADD' && change.id) {
-                        relRecordAdded.push(self.localData[change.id]);
-                    } else if (change.operation === 'UPDATE' && !self.isNew(change.id)) {
-                        // ignore new records that would have been updated
-                        // afterwards, as all their changes would already
-                        // be aggregated in the CREATE command
-                        relRecordUpdated.push(self.localData[change.id]);
-                    }
-                });
-                list = this._applyX2ManyOperations(list);
-                this._sortList(list);
-                if (type === 'many2many' || list._forceM2MLink) {
-                    var relRecordCreated = relRecordAdded.filter(rec => typeof rec.res_id === 'string');
-                    const relRecordCreatedResId = relRecordCreated.map(r => r.res_id)
-                    var realIDs = list.res_ids.filter((x) => relRecordCreatedResId.indexOf(x) < 0)
-                    // deliberately generate a single 'replace' command instead
-                    // of a 'delete' and a 'link' commands with the exact diff
-                    // because 1) performance-wise it doesn't change anything
-                    // and 2) to guard against concurrent updates (policy: force
-                    // a complete override of the actual value of the m2m)
-                    commands[fieldName].push(x2ManyCommands.replace_with(realIDs));
-                    relRecordCreated.forEach((relRecord) => {
-                        var changes = self._generateChanges(relRecord, options);
-                        commands[fieldName].push(x2ManyCommands.create(relRecord.ref, changes));
-                    });
-                    // generate update commands for records that have been
-                    // updated (it may happen with editable lists)
-                    relRecordUpdated.forEach((relRecord) => {
-                        var changes = self._generateChanges(relRecord, options);
-                        if (Object.keys(changes || {}).length > 0) {
-                            var command = x2ManyCommands.update(relRecord.res_id, changes);
-                            commands[fieldName].push(command);
-                        }
-                    });
-                } else if (type === 'one2many') {
-                    var removedIds = oldResIDs.filter((x) => list.res_ids.indexOf(x) < 0);
-                    var addedIds = list.res_ids.filter((x) => oldResIDs.indexOf(x) < 0);
-                    var keptIds = intersection(oldResIDs, list.res_ids);
-
-                    // the didChange variable keeps track of the fact that at
-                    // least one id was updated
-                    var didChange = false;
-                    var changes, command, relRecord;
-                    for (var i = 0; i < list.res_ids.length; i++) {
-                        if (keptIds.includes(list.res_ids[i])) {
-                            // this is an id that already existed
-                            relRecord = relRecordUpdated.find((record) => record.res_id === list.res_ids[i]);
-                            changes = relRecord ? this._generateChanges(relRecord, options) : {};
-                            if (Object.keys(changes || {}).length > 0) {
-                                command = x2ManyCommands.update(relRecord.res_id, changes);
-                                didChange = true;
-                            } else {
-                                command = x2ManyCommands.link_to(list.res_ids[i]);
-                            }
-                            commands[fieldName].push(command);
-                        } else if (addedIds.includes(list.res_ids[i])) {
-                            // this is a new id (maybe existing in DB, but new in JS)
-                            relRecord = relRecordAdded.find((record) => record.res_id === list.res_ids[i]);
-                            if (!relRecord) {
-                                commands[fieldName].push(x2ManyCommands.link_to(list.res_ids[i]));
-                                continue;
-                            }
-                            changes = this._generateChanges(relRecord, options);
-                            if (!this.isNew(relRecord.id)) {
-                                // the subrecord already exists in db
-                                commands[fieldName].push(x2ManyCommands.link_to(relRecord.res_id));
-                                if (changesOnly ? Object.keys(changes).length : this.isDirty(relRecord.id)) {
-                                    delete changes.id;
-                                    commands[fieldName].push(x2ManyCommands.update(relRecord.res_id, changes));
-                                }
-                            } else {
-                                // the subrecord is new, so create it
-
-                                // we may have received values from an onchange for fields that are
-                                // not in the view, and that we don't even know, as we don't have the
-                                // fields_get of models of related fields. We save those values
-                                // anyway, but for many2ones, we have to extract the id from the pair
-                                // [id, display_name]
-                                const rawChangesEntries = Object.entries(relRecord._rawChanges);
-                                for (const [fieldName, value] of rawChangesEntries) {
-                                    const isMany2OneValue = Array.isArray(value) &&
-                                                            value.length === 2 &&
-                                                            Number.isInteger(value[0]) &&
-                                                            typeof value[1] === 'string';
-                                    changes[fieldName] = isMany2OneValue ? value[0] : value;
-                                }
-
-                                commands[fieldName].push(x2ManyCommands.create(relRecord.ref, changes));
-                            }
-                        }
-                    }
-                    if (options.changesOnly && !didChange && addedIds.length === 0 && removedIds.length === 0) {
-                        // in this situation, we have no changed ids, no added
-                        // ids and no removed ids, so we can safely ignore the
-                        // last changes
-                        commands[fieldName] = [];
-                    }
-                    // add delete commands
-                    for (i = 0; i < removedIds.length; i++) {
-                        if (list._forceM2MUnlink) {
-                            commands[fieldName].push(x2ManyCommands.forget(removedIds[i]));
-                        } else {
-                            commands[fieldName].push(x2ManyCommands.delete(removedIds[i]));
-                        }
-                    }
-                }
-            }
-        }
-        return commands;
-    },
-    /**
-     * Every RPC done by the model need to add some context, which is a
-     * combination of the context of the session, of the record/list, and/or of
-     * the concerned field. This method combines all these contexts and evaluate
-     * them with the proper evalcontext.
-     *
-     * @param {Object} element an element from the localData
-     * @param {Object} [options]
-     * @param {string|Object} [options.additionalContext]
-     *        another context to evaluate and merge to the returned context
-     * @param {string} [options.fieldName]
-     *        if given, this field's context is added to the context, instead of
-     *        the element's context (except if options.full is true)
-     * @param {boolean} [options.full=false]
-     *        if true or nor fieldName or additionalContext given in options,
-     *        the element's context is added to the context
-     * @param {boolean} [options.withoutRecordData=false]
-     *        if true the record data will be replaced by a sentinel in the eval
-     *        context (useful for read rpcs, where we don't want the context to
-     *        depend on data)
-     * @returns {Object} the evaluated context
-     */
-    _getContext: function (element, options) {
-        options = options || {};
-        var context = new Context(session.user_context);
-
-        if (options.full || !(options.fieldName || options.additionalContext)) {
-            const keys_to_omit = Object.keys(element.context || {}).filter((key) => String(key).startsWith('default_'));
-            var context_to_add = options.sanitize_default_values ?
-                omit(element.context, ...keys_to_omit)
-                : element.context;
-            context.add(context_to_add);
-        }
-        if (options.fieldName) {
-            var viewType = options.viewType || element.viewType;
-            var fieldInfo = element.fieldsInfo[viewType][options.fieldName];
-            if (fieldInfo && fieldInfo.context) {
-                if (fieldInfo.context !== "{}") {
-                    context.add(fieldInfo.context);
-                }
-            } else {
-                var fieldParams = element.fields[options.fieldName];
-                if (fieldParams.context) {
-                    context.add(fieldParams.context);
-                }
-            }
-        }
-        if (element.rawContext) {
-            var rawContext = new Context(element.rawContext);
-            var evalContext = this._getEvalContext(this.localData[element.parentID], false, options.withoutRecordData);
-            evalContext.id = evalContext.id || false;
-            rawContext.set_eval_context(evalContext);
-            context.add(rawContext);
-        }
-        if (options.additionalContext) {
-            context.add(options.additionalContext);
-        }
-
-        if (context.__contexts.length > 1) {
-            context.set_eval_context(this._getEvalContext(element, false, options.withoutRecordData));
-            const evaluatedContext = context.eval();
-            if (options.withoutRecordData) {
-                for (const key in evaluatedContext) {
-                    if (evaluatedContext[key] === SENTINEL) {
-                        delete evaluatedContext[key];
-                    }
-                }
-                if (evaluatedContext.parent) {
-                    for (const key in evaluatedContext.parent) {
-                        if (evaluatedContext.parent[key] === SENTINEL) {
-                            delete evaluatedContext.parent[key];
-                        }
-                    }
-                }
-            }
-            return evaluatedContext;
-        } else {
-            return Object.assign({}, session.user_context);
-        }
-    },
-    /**
-     * Collects from a record a list of ids to fetch, according to fieldName,
-     * and a list of records where to set the result of the fetch.
-     *
-     * @param {Object} list a list containing records we want to get the ids,
-     *   it assumes _applyX2ManyOperations and _sort have been already called on
-     *   this list
-     * @param {string} fieldName
-     * @return {Object} a list of records and res_ids
-     */
-    _getDataToFetch: function (list, fieldName) {
-        var self = this;
-        var field = list.fields[fieldName];
-        var fieldInfo = list.fieldsInfo[list.viewType][fieldName];
-        var view = fieldInfo.views && fieldInfo.views[fieldInfo.mode];
-        var fieldsInfo = view ? view.fieldsInfo : fieldInfo.fieldsInfo;
-        var fields = view ? view.fields : fieldInfo.relatedFields;
-        var viewType = view ? view.type : fieldInfo.viewType;
-
-        var toFetch = {};
-
-        // flattens the list.data ids in a grouped case
-        let dataPointIds = list.data;
-        for (let i = 0; i < list.groupedBy.length; i++) {
-            dataPointIds = dataPointIds.reduce((acc, groupId) =>
-                acc.concat(this.localData[groupId].data), []);
-        }
-
-        dataPointIds.forEach(function (dataPoint) {
-            var record = self.localData[dataPoint];
-            if (typeof record.data[fieldName] === 'string'){
-                // in this case, the value is a local ID, which means that the
-                // record has already been processed. It can happen for example
-                // when a user adds a record in a m2m relation, or loads more
-                // records in a kanban column
-                return;
-            }
-
-            Object.values(record.data[fieldName] || {}).forEach((id) => {
-                toFetch[id] = toFetch[id] || [];
-                toFetch[id].push(record);
-            });
-
-            var m2mList = self._makeDataPoint({
-                fieldsInfo: fieldsInfo,
-                fields: fields,
-                modelName: field.relation,
-                parentID: record.id,
-                res_ids: record.data[fieldName],
-                static: true,
-                type: 'list',
-                viewType: viewType,
-            });
-            record.data[fieldName] = m2mList.id;
-        });
-
-        return toFetch;
-    },
-    /**
-     * Determines and returns from a list a collection of ids classed by
-     * their model.
-     *
-     * @param {Object} list a valid resource object
-     * @param {string} fieldName
-     * @param {Object} [toFetchAcc] an object to store fetching data. Used when
-     *  batching reference across multiple groups.
-     *    [modelName: string]: {
-     *        [recordId: number]: datapointId[]
-     *    }
-     * @returns {Object} each key represent a model and contain a sub-object
-     * where each key represent an id (res_id) containing an array of
-     * webclient id (referred to a datapoint, so not a res_id).
-     */
-    _getDataToFetchByModel: function (list, fieldName, toFetchAcc) {
-        var self = this;
-        var toFetch = toFetchAcc || {};
-        list.data.forEach((dataPoint) => {
-            var record = self.localData[dataPoint];
-            var value = record.data[fieldName];
-            // if the reference field has already been fetched, the value is a
-            // datapoint ID, and in this case there's nothing to do
-            if (value && !self.localData[value]) {
-                var model = value.split(',')[0];
-                var resID = value.split(',')[1];
-                if (!(model in toFetch)) {
-                    toFetch[model] = {};
-                }
-                // there could be multiple datapoints with the same model/resID
-                if (toFetch[model][resID]) {
-                    toFetch[model][resID].push(dataPoint);
-                } else {
-                    toFetch[model][resID] = [dataPoint];
-                }
-            }
-        });
-        return toFetch;
-    },
-    /**
-     * Given a dataPoint of type list (that may be a group), returns an object
-     * with 'default_' keys to be used to create new records in that group.
-     *
-     * @private
-     * @param {Object} dataPoint
-     * @returns {Object}
-     */
-    _getDefaultContext: function (dataPoint) {
-        var defaultContext = {};
-        while (dataPoint.parentID) {
-            var parent = this.localData[dataPoint.parentID];
-            var groupByField = parent.groupedBy[0].split(':')[0];
-            var value = viewUtils.getGroupValue(dataPoint, parent.groupedBy[0]);
-            if (value) {
-                defaultContext['default_' + groupByField] = value;
-            }
-            dataPoint = parent;
-        }
-        return defaultContext;
-    },
-    /**
-     * Some records are associated to a/some domain(s). This method allows to
-     * retrieve them, evaluated.
-     *
-     * @param {Object} element an element from the localData
-     * @param {Object} [options]
-     * @param {string} [options.fieldName]
-     *        the name of the field whose domain needs to be returned
-     * @returns {Array} the evaluated domain
-     */
-    _getDomain: function (element, options) {
-        if (options && options.fieldName) {
-            if (element._domains[options.fieldName]) {
-                return Domain.prototype.stringToArray(
-                    element._domains[options.fieldName],
-                    this._getEvalContext(element, true)
-                );
-            }
-            var viewType = options.viewType || element.viewType;
-            var fieldInfo = element.fieldsInfo[viewType][options.fieldName];
-            if (fieldInfo && fieldInfo.domain) {
-                return Domain.prototype.stringToArray(
-                    fieldInfo.domain,
-                    this._getEvalContext(element, true)
-                );
-            }
-            var fieldParams = element.fields[options.fieldName];
-            if (fieldParams.domain) {
-                return Domain.prototype.stringToArray(
-                    fieldParams.domain,
-                    this._getEvalContext(element, true)
-                );
-            }
-            return [];
-        }
-
-        return Domain.prototype.stringToArray(
-            element.domain,
-            this._getEvalContext(element, true)
-        );
-    },
-    /**
-     * Returns the evaluation context that should be used when evaluating the
-     * context/domain associated to a given element from the localData.
-     *
-     * It is actually quite subtle.  We need to add some magic keys: active_id
-     * and active_ids.  Also, the session user context is added in the mix to be
-     * sure.  This allows some domains to use the uid key for example
-     *
-     * @param {Object} element - an element from the localData
-     * @param {boolean} [forDomain=false] if true, evaluates x2manys as a list of
-     *   ids instead of a list of commands
-     * @param {boolean} [withoutRecordData=false] if true, replaces the record
-     *   values by null (same inside the parent key)
-     * @returns {Object}
-     */
-    _getEvalContext: function (element, forDomain, withoutRecordData) {
-        var evalContext = element.type === 'record' ? this._getRecordEvalContext(element, forDomain) : {};
-        if (withoutRecordData) {
-            const entries = Object.keys(evalContext).map((key) => [key, SENTINEL]);
-            evalContext = Object.fromEntries(entries);
-        }
-        if (element.parentID) {
-            var parent = this.localData[element.parentID];
-            if (parent.type === 'list' && parent.parentID) {
-                parent = this.localData[parent.parentID];
-            }
-            if (parent.type === 'record') {
-                evalContext.parent = this._getRecordEvalContext(parent, forDomain);
-                if (withoutRecordData) {
-                    const entries = Object.keys(evalContext.parent).map((key) => [key, SENTINEL]);
-                    evalContext.parent = Object.fromEntries(entries);
-                }
-            }
-        }
-        // Uses "current_company_id" because "company_id" would conflict with all the company_id fields
-        // in general, the actual "company_id" field of the form should be used for m2o domains, not this fallback
-        let current_company_id;
-        if (session.user_context.allowed_company_ids) {
-            current_company_id = session.user_context.allowed_company_ids[0];
-        } else {
-            current_company_id = session.user_companies ?
-                session.user_companies.current_company :
-                false;
-        }
-        return Object.assign(
-            {
-                active_id: evalContext.id || false,
-                active_ids: evalContext.id ? [evalContext.id] : [],
-                active_model: element.model,
-                current_company_id,
-                id: evalContext.id || false,
-            },
-            session.user_context,
-            element.context,
-            evalContext,
-        );
-    },
-
-    _getLazyEvalContext: function (element, forDomain) {
-        var evalContext = element.type === 'record' ? this._getLazyRecordEvalContext(element, forDomain) : {};
-
-        if (element.parentID) {
-            var parent = this.localData[element.parentID];
-            if (parent.type === 'list' && parent.parentID) {
-                parent = this.localData[parent.parentID];
-            }
-            if (parent.type === 'record') {
-                evalContext.parent = this._getLazyRecordEvalContext(parent, forDomain);
-            }
-        }
-        // Uses "current_company_id" because "company_id" would conflict with all the company_id fields
-        // in general, the actual "company_id" field of the form should be used for m2o domains, not this fallback
-        let current_company_id;
-        if (session.user_context.allowed_company_ids) {
-            current_company_id = session.user_context.allowed_company_ids[0];
-        } else {
-            current_company_id = session.user_companies ?
-                session.user_companies.current_company :
-                false;
-        }
-        let fallbackContext = Object.assign(
-            {
-                active_id: evalContext.id || false,
-                active_ids: evalContext.id ? [evalContext.id] : [],
-                active_model: element.model,
-                current_company_id,
-                id: evalContext.id || false,
-            },
-            session.user_context,
-            element.context,
-        );
-
-        return new Proxy(
-            {}, {
-                has(target, key) {
-                    return key in target || key in evalContext || key in fallbackContext;
-                },
-                get (target, key) {
-                    switch (true) {
-                        case key in target:
-                            return target[key];
-                        case key in evalContext:
-                            return evalContext[key];
-                        default:
-                            return fallbackContext[key];;
-                    }
-                },
-                ownKeys(target) {
-                    return [...new Set([...Reflect.ownKeys(target), ...Object.keys(fallbackContext), ...Object.keys(evalContext)])];
-                },
-                getOwnPropertyDescriptor(target, prop) {
-                    return Reflect.getOwnPropertyDescriptor(target, prop) || { writable: true, configurable: true, enumerable: true };
-                },
-            }
-        );
-    },
-    /**
-     * Returns the list of field names of the given element according to its
-     * default view type.
-     *
-     * @param {Object} element an element from the localData
-     * @param {Object} [options]
-     * @param {Object} [options.viewType] current viewType. If not set, we will
-     *   assume main viewType from the record
-     * @returns {string[]} the list of field names
-     */
-    _getFieldNames: function (element, options) {
-        var fieldsInfo = element.fieldsInfo;
-        var viewType = options && options.viewType || element.viewType;
-        return Object.keys(fieldsInfo && fieldsInfo[viewType] || {});
-    },
-    /**
-     * Get a subset of a list resource keeping only the props to keep.
-     * This permits to a web_read_group to keep some of the properties
-     * of a previous list if it is still in its results.
-     *
-     * @private
-     * @param {Object} list
-     * @param {boolean} options.onlyGroup true when we only fetched the group's own data
-     * @param {boolean} options.hasSubgroups true when the fetched group has subgroups
-     * @returns {Object} subset of list
-     */
-    _getGroupedListPropsToKeep(list, options) {
-        const { isOpen, offset, id } = list;
-        let propsToKeep = { isOpen, offset, id };
-
-        if (options.onlyGroup || isOpen && options.hasSubgroups) {
-            // If the group is opened and contains subgroups,
-            // also keep its data to keep internal state of
-            // sub-groups
-            // Also keep data if we only reload groups' own data
-            propsToKeep.data = list.data;
-            if (options.onlyGroup) {
-                // keep count and res_ids as in this case the group
-                // won't be search_read again. This situation happens
-                // when using kanban quick_create where the record is manually
-                // added to the datapoint before getting here.
-                propsToKeep.res_ids = list.res_ids;
-                propsToKeep.count = list.count;
-            }
-        }
-
-        return propsToKeep;
-    },
-    /**
-     * Get many2one fields names in a datapoint. This is useful in order to
-     * fetch their names in the case of a default_get.
-     *
-     * @private
-     * @param {Object} datapoint a valid resource object
-     * @returns {string[]} list of field names that are many2one
-     */
-    _getMany2OneFieldNames: function (datapoint) {
-        var many2ones = [];
-        for (const [name, field] of Object.entries(datapoint.fields)) {
-            if (field.type === 'many2one') {
-                many2ones.push(name);
-            }
-        }
-        return many2ones;
-    },
-    /**
-     * Evaluate the record evaluation context.  This method is supposed to be
-     * called by _getEvalContext.  It basically only generates a dictionary of
-     * current values for the record, with commands for x2manys fields.
-     *
-     * @param {Object} record an element of type 'record'
-     * @returns Object
-     */
-    _getRecordEvalContext: function (record) {
-        var relDataPoint;
-        var context = Object.assign({}, record.data, record._changes);
-
-        for (var fieldName in context) {
-            var field = record.fields[fieldName];
-            if (context[fieldName] === null) {
-                context[fieldName] = false;
-            }
-            if (!field || field.name === 'id') {
-                continue;
-            }
-            if (field.type === 'date' || field.type === 'datetime') {
-                if (context[fieldName]) {
-                    context[fieldName] = JSON.parse(JSON.stringify(context[fieldName]));
-                }
-                continue;
-            }
-            if (field.type === 'many2one') {
-                relDataPoint = this.localData[context[fieldName]];
-                context[fieldName] = relDataPoint ? relDataPoint.res_id : false;
-                continue;
-            }
-            if (field.type === 'one2many' || field.type === 'many2many') {
-                var ids;
-                if (!context[fieldName] || Array.isArray(context[fieldName])) { // no dataPoint created yet
-                    ids = context[fieldName] ? context[fieldName].slice(0) : [];
-                } else {
-                    relDataPoint = this._applyX2ManyOperations(this.localData[context[fieldName]]);
-                    ids = relDataPoint.res_ids.slice(0);
-                }
-                if (field.type === 'one2many') { // Ids are evaluated as a list of ids
-                    /* Filtering out virtual ids from the ids list
-                     * The server will crash if there are virtual ids in there
-                     * The webClient doesn't do literal id list comparison like ids == list
-                     * Only relevant in o2m: m2m does create actual records in db
-                     */
-                    ids = ids.filter(id => typeof id !== 'string');
-                }
-                context[fieldName] = ids;
-            }
-
-        }
-        return context;
-    },
-
-    _getLazyRecordEvalContext: function (record) {
-        let self = this;
-        let relDataPoint;
-
-        return new Proxy({}, {
-            has(target, key) {
-                return key in target || key in record.fields;
-            },
-            ownKeys(target) {
-                return [...new Set([...Reflect.ownKeys(target), ...Object.keys(record.fields)])];
-            },
-            getOwnPropertyDescriptor(target, prop) {
-                return Reflect.getOwnPropertyDescriptor(target, prop) || { writable: true, configurable: true, enumerable: true };
-            },
-            get( target, fieldName ) {
-                if (fieldName in target){
-                    return target[fieldName];
-                }
-                const fieldValue = record._changes && fieldName in record._changes ? record._changes[fieldName] : record.data[fieldName];
-                const field = record.fields[fieldName];
-                if (fieldValue === null) {
-                    return false;
-                }
-                if (fieldName === "id" && !fieldValue) {
-                    return false;
-                }
-
-                if (field.type === 'date' || field.type === 'datetime') {
-                    if (fieldValue) {
-                        return JSON.parse(JSON.stringify(fieldValue));
-                    }
-                }
-                if (field.type === 'many2one') {
-                    relDataPoint = self.localData[fieldValue];
-                    return relDataPoint ? relDataPoint.res_id : false;
-                }
-                if (field.type === 'one2many' || field.type === 'many2many') {
-                    let ids;
-                    if (!fieldValue || Array.isArray(fieldValue)) { // no dataPoint created yet
-                        ids = fieldValue ? fieldValue.slice(0) : [];
-                    } else {
-                        relDataPoint = self._applyX2ManyOperations(self.localData[fieldValue]);
-                        ids = relDataPoint.res_ids.slice(0);
-                    }
-                    if (field.type === 'one2many') { // Ids are evaluated as a list of ids
-                        /* Filtering out virtual ids from the ids list
-                        * The server will crash if there are virtual ids in there
-                        * The webClient doesn't do literal id list comparison like ids == list
-                        * Only relevant in o2m: m2m does create actual records in db
-                        */
-                        ids = ids.filter(id => typeof id !== 'string');
-                    }
-                    return ids;
-                }
-                if (field.type === "properties" && Array.isArray(fieldValue)) {
-                    // remove deleted properties to be able
-                    // to filter based on empty properties field
-                    return fieldValue.filter(definition => !definition.definition_deleted);
-                }
-                return fieldValue;
-            }
-        });
-    },
-    /**
-     * Get the domain for a list resource.
-     *
-     * @private
-     * @param {Object} list
-     * @returns {Array[]} list domain
-     */
-    _getUngroupedListDomain(list) {
-        return list.domain || [];
-    },
-    /**
-     * Returns true if the field is protected against changes, looking for a
-     * readonly modifier unless there is a force_save modifier (checking first
-     * in the modifiers, and if there is no readonly modifier, checking the
-     * readonly attribute of the field).
-     *
-     * @private
-     * @param {Object} record an element from the localData
-     * @param {string} fieldName
-     * @param {string} [viewType] current viewType. If not set, we will assume
-     *   main viewType from the record
-     * @returns {boolean}
-     */
-    _isFieldProtected: function (record, fieldName, viewType) {
-        viewType = viewType || record.viewType;
-        var fieldInfo = viewType && record.fieldsInfo && record.fieldsInfo[viewType][fieldName];
-        if (fieldInfo) {
-            var rawModifiers = fieldInfo.modifiers || {};
-            var modifiers = this._evalModifiers(record, pick(rawModifiers, 'readonly'));
-            return modifiers.readonly && !fieldInfo.force_save;
-        } else {
-            return false;
-        }
-    },
-    /**
-     * Returns true iff value is considered to be set for the given field's type.
-     *
-     * @private
-     * @param {any} value a value for the field
-     * @param {string} fieldType a type of field
-     * @returns {boolean}
-     */
-    _isFieldSet: function (value, fieldType) {
-        switch (fieldType) {
-            case 'boolean':
-                return true;
-            case 'one2many':
-            case 'many2many':
-                return value.length > 0;
-            default:
-                return value !== false;
-        }
-    },
-    /**
-     * return true if a list element is 'valid'. Such an element is valid if it
-     * has no sub record with an unset required field.
-     *
-     * This method is meant to be used to check if a x2many change will trigger
-     * an onchange.
-     *
-     * @param {string} id id for a local resource of type 'list'. This is
-     *   assumed to be a list element for an x2many
-     * @returns {boolean}
-     */
-    _isX2ManyValid: function (id) {
-        var self = this;
-        var isValid = true;
-        var element = this.localData[id];
-        Object.values(element._changes || {}).forEach((command) => {
-            if (command.operation === 'DELETE' ||
-                    command.operation === 'FORGET' ||
-                    (command.operation === 'ADD' &&  !command.isNew)||
-                    command.operation === 'REMOVE_ALL') {
-                return;
-            }
-            var recordData = self.get(command.id, {raw: true}).data;
-            var record = self.localData[command.id];
-            element.getFieldNames().forEach((fieldName) => {
-                var field = element.fields[fieldName];
-                var fieldInfo = element.fieldsInfo[element.viewType][fieldName];
-                var rawModifiers = fieldInfo.modifiers || {};
-                var modifiers = self._evalModifiers(record, pick(rawModifiers, 'required'));
-                if (modifiers.required && !self._isFieldSet(recordData[fieldName], field.type)) {
-                    isValid = false;
-                }
-            });
-        });
-        return isValid;
-    },
-    /**
-     * Helper method for the load entry point.
-     *
-     * @see load
-     *
-     * @param {Object} dataPoint some local resource
-     * @param {Object} [options]
-     * @param {string[]} [options.fieldNames] the fields to fetch for a record
-     * @param {boolean} [options.onlyGroups=false]
-     * @param {boolean} [options.keepEmptyGroups=false] if set, the groups not
-     *   present in the read_group anymore (empty groups) will stay in the
-     *   datapoint (used to mimic the kanban renderer behaviour for example)
-     * @returns {Promise}
-     */
-    _load: function (dataPoint, options) {
-        if (options && options.onlyGroups &&
-          !(dataPoint.type === 'list' && dataPoint.groupedBy.length)) {
-            return Promise.resolve(dataPoint);
-        }
-
-        if (dataPoint.type === 'record') {
-            return this._fetchRecord(dataPoint, options);
-        }
-        if (dataPoint.type === 'list' && dataPoint.groupedBy.length) {
-            return this._readGroup(dataPoint, options);
-        }
-        if (dataPoint.type === 'list' && !dataPoint.groupedBy.length) {
-            return this._fetchUngroupedList(dataPoint, options);
-        }
-    },
-    /**
-     * Turns a bag of properties into a valid local resource.  Also, register
-     * the resource in the localData object.
-     *
-     * @param {Object} params
-     * @param {Object} [params.aggregateValues={}]
-     * @param {Object} [params.context={}] context of the action
-     * @param {integer} [params.count=0] number of record being manipulated
-     * @param {Object|Object[]} [params.data={}|[]] data of the record
-     * @param {*[]} [params.domain=[]]
-     * @param {Object} params.fields contains the description of each field
-     * @param {Object} [params.fieldsInfo={}] contains the fieldInfo of each field
-     * @param {Object[]} [params.fieldNames] the name of fields to load, the list
-     *   of all fields by default
-     * @param {string[]} [params.groupedBy=[]]
-     * @param {boolean} [params.isOpen]
-     * @param {integer} params.limit max number of records shown on screen (pager size)
-     * @param {string} params.modelName
-     * @param {integer} [params.offset]
-     * @param {boolean} [params.openGroupByDefault]
-     * @param {Object[]} [params.orderedBy=[]]
-     * @param {integer[]} [params.orderedResIDs]
-     * @param {string} [params.parentID] model name ID of the parent model
-     * @param {Object} [params.rawContext]
-     * @param {[type]} [params.ref]
-     * @param {string} [params.relationField]
-     * @param {integer|null} [params.res_id] actual id of record in the server
-     * @param {integer[]} [params.res_ids] context in which the data point is used, from a list of res_id
-     * @param {boolean} [params.static=false]
-     * @param {string} [params.type='record'|'list']
-     * @param {[type]} [params.value]
-     * @param {Object} [params.range] only for datapoints representing groups
-     *   coming from a groupBy on a date(time) field @see _readGroup format:
-     *   {[fieldName:granularity]: {from: string, to: string}}, where
-     *   'from' (inclusive) and 'to' (exclusive) are the group bounds under the
-     *   respective date format
-     * @param {string} [params.viewType] the type of the view, e.g. 'list' or 'form'
-     * @returns {Object} the resource created
-     */
-    _makeDataPoint: function (params) {
-        var type = params.type || ('domain' in params && 'list') || 'record';
-        var res_id, value;
-        var res_ids = params.res_ids || [];
-        var data = params.data || (type === 'record' ? {} : []);
-        var context = params.context;
-        var fields = Object.assign({
-            display_name: {type: 'char'},
-            id: {type: 'integer'},
-        }, params.fields);
-
-        const groupedBy = params.groupedBy || [];
-        let isM2MGrouped = false;
-        if (type === 'record') {
-            res_id = params.res_id || (params.data && params.data.id);
-            if (res_id) {
-                data.id = res_id;
-            } else {
-                res_id = uniqueId('virtual_');
-            }
-            // it doesn't make sense for a record datapoint to have those keys
-            // besides, it will mess up x2m and actions down the line
-            context = omit(context, 'orderedBy', 'group_by');
-        } else {
-            var isValueArray = params.value instanceof Array;
-            res_id = isValueArray ? params.value[0] : undefined;
-            value = isValueArray ? params.value[1] : params.value;
-            isM2MGrouped = groupedBy.some((group) => {
-                const [fieldName] = group.split(':');
-                return fields[fieldName].type === "many2many";
-            });
-        }
-
-        var dataPoint = {
-            _cache: type === 'list' ? {} : undefined,
-            _changes: null,
-            _domains: {},
-            _rawChanges: {},
-            aggregateValues: params.aggregateValues || {},
-            context: context,
-            count: params.count || res_ids.length,
-            data: data,
-            domain: params.domain || [],
-            fields: fields,
-            fieldsInfo: params.fieldsInfo,
-            groupedBy,
-            groupsCount: 0,
-            groupsLimit: type === 'list' && params.groupsLimit || null,
-            groupsOffset: 0,
-            id: `${params.modelName}_${++this.__id}`,
-            isM2MGrouped,
-            isOpen: params.isOpen,
-            limit: type === 'record' ? 1 : (params.limit || Number.MAX_SAFE_INTEGER),
-            loadMoreOffset: 0,
-            model: params.modelName,
-            offset: params.offset || (type === 'record' ? res_ids.indexOf(res_id) : 0),
-            openGroupByDefault: params.openGroupByDefault,
-            orderedBy: params.orderedBy || [],
-            orderedResIDs: params.orderedResIDs,
-            parentID: params.parentID,
-            rawContext: params.rawContext,
-            ref: params.ref || res_id,
-            relationField: params.relationField,
-            res_id: res_id,
-            res_ids: res_ids,
-            specialData: {},
-            _specialDataCache: {},
-            static: params.static || false,
-            type: type,  // 'record' | 'list'
-            value: value,
-            range: params.range,
-            viewType: params.viewType,
-        };
-
-        // _editionViewType is a dict whose keys are field names and which is populated when a field
-        // is edited with the viewType as value. This is useful for one2manys to determine whether
-        // or not a field is readonly (using the readonly modifiers of the view in which the field
-        // has been edited)
-        dataPoint._editionViewType = {};
-
-        dataPoint.evalModifiers = this._evalModifiers.bind(this, dataPoint);
-        dataPoint.getContext = this._getContext.bind(this, dataPoint);
-        dataPoint.getDomain = this._getDomain.bind(this, dataPoint);
-        dataPoint.getFieldNames = this._getFieldNames.bind(this, dataPoint);
-        dataPoint.isDirty = this.isDirty.bind(this, dataPoint.id);
-        dataPoint.isNew = this.isNew.bind(this, dataPoint.id);
-
-        this.localData[dataPoint.id] = dataPoint;
-
-        return dataPoint;
-    },
-    /**
-     * When one needs to create a record from scratch, a not so simple process
-     * needs to be done:
-     * - call the /default_get route to get default values
-     * - fetch all relational data
-     * - apply all onchanges if necessary
-     * - fetch all relational data
-     *
-     * This method tries to optimize the process as much as possible.  Also,
-     * it is quite horrible and should be refactored at some point.
-     *
-     * @private
-     * @param {any} params
-     * @param {string} modelName model name
-     * @param {boolean} [params.allowWarning=false] if true, the default record
-     *   operation can complete, even if a warning is raised
-     * @param {Object} params.context the context for the new record
-     * @param {Object} params.fieldsInfo contains the fieldInfo of each view,
-     *   for each field
-     * @param {Object} params.fields contains the description of each field
-     * @param {Object} params.context the context for the new record
-     * @param {string} params.viewType the key in fieldsInfo of the fields to load
-     * @returns {Promise<string>} resolves to the id for the created resource
-     */
-    async _makeDefaultRecord(modelName, params) {
-        var targetView = params.viewType;
-        var fields = params.fields;
-        var fieldsInfo = params.fieldsInfo;
-        var fieldNames = Object.keys(fieldsInfo[targetView]);
-
-        // Fields that are present in the originating view, that need to be initialized
-        // Hence preventing their value to crash when getting back to the originating view
-        var parentRecord = params.parentID && this.localData[params.parentID].type === 'list' ? this.localData[params.parentID] : null;
-
-        if (parentRecord && parentRecord.viewType in parentRecord.fieldsInfo) {
-            var originView = parentRecord.viewType;
-            fieldNames = fieldNames.concat(Object.keys(parentRecord.fieldsInfo[originView]));
-            fieldsInfo[targetView] = Object.assign({}, parentRecord.fieldsInfo[originView], fieldsInfo[targetView]);
-            fields = Object.assign({}, parentRecord.fields, fields);
-        }
-
-        var record = this._makeDataPoint({
-            modelName: modelName,
-            fields: fields,
-            fieldsInfo: fieldsInfo,
-            context: params.context,
-            parentID: params.parentID,
-            res_ids: params.res_ids,
-            viewType: targetView,
-        });
-
-        await this.generateDefaultValues(record.id, {}, { fieldNames });
-        try {
-            await this._performOnChange(record, [], { firstOnChange: true });
-        } finally {
-            if (record._warning && params.allowWarning) {
-                delete record._warning;
-            }
-        }
-        if (record._warning) {
-            return Promise.reject();
-        }
-
-        // We want to overwrite the default value of the handle field (if any),
-        // in order for new lines to be added at the correct position.
-        // -> This is a rare case where the defaul_get from the server
-        //    will be ignored by the view for a certain field (usually "sequence").
-        var overrideDefaultFields = this._computeOverrideDefaultFields(params.parentID, params.position);
-        if (overrideDefaultFields.field) {
-            record._changes[overrideDefaultFields.field] = overrideDefaultFields.value;
-        }
-
-        // fetch additional data (special data and many2one namegets for "always_reload" fields)
-        await this._postprocess(record);
-        // save initial changes, so they can be restored later, if we need to discard
-        this.save(record.id, { savePoint: true });
-        return record.id;
-    },
-    /**
-     * parse the server values to javascript framwork
-     *
-     * @param {[string]} fieldNames
-     * @param {Object} element the dataPoint used as parent for the created
-     *   dataPoints
-     * @param {Object} data the server data to parse
-     */
-    _parseServerData: function (fieldNames, element, data) {
-        var self = this;
-        fieldNames.forEach((fieldName) => {
-            var field = element.fields[fieldName];
-            var val = data[fieldName];
-            if (field.type === 'many2one') {
-                // process many2one: split [id, nameget] and create corresponding record
-                if (val !== false) {
-                    // the many2one value is of the form [id, display_name]
-                    var r = self._makeDataPoint({
-                        modelName: field.relation,
-                        fields: {
-                            display_name: {type: 'char'},
-                            id: {type: 'integer'},
-                        },
-                        data: {
-                            display_name: val[1],
-                            id: val[0],
-                        },
-                        parentID: element.id,
-                    });
-                    data[fieldName] = r.id;
-                } else {
-                    // no value for the many2one
-                    data[fieldName] = false;
-                }
-            } else {
-                data[fieldName] = self._parseServerValue(field, val);
-            }
-        });
-    },
-    /**
-     * This method is quite important: it is supposed to perform the /onchange
-     * rpc and apply the result.
-     *
-     * The changes that triggered the onchange are assumed to have already been
-     * applied to the record.
-     *
-     * @param {Object} record
-     * @param {string[]} fields changed fields (empty list in the case of first
-     *   onchange)
-     * @param {Object} [options={}]
-     * @param {string} [options.viewType] current viewType. If not set, we will assume
-     *   main viewType from the record
-     * @param {boolean} [options.firstOnChange=false] set to true if this is the
-     *   first onchange
-     * @returns {Promise}
-     */
-    async _performOnChange(record, fields, options = {}) {
-        const firstOnChange = options.firstOnChange;
-        let { hasOnchange, onchangeSpec } = this._buildOnchangeSpecs(record, options.viewType);
-        if (!firstOnChange && !hasOnchange) {
-            return;
-        }
-        var idList = record.data.id ? [record.data.id] : [];
-        const ctxOptions = {
-            full: true,
-        };
-        if (fields.length === 1) {
-            fields = fields[0];
-            // if only one field changed, add its context to the RPC context
-            ctxOptions.fieldName = fields;
-        }
-        var context = this._getContext(record, ctxOptions);
-        var currentData = this._generateOnChangeData(record, {
-            changesOnly: false,
-            firstOnChange,
-        });
-
-        const result = await this._rpc({
-            model: record.model,
-            method: 'onchange',
-            args: [idList, currentData, fields, onchangeSpec],
-            context: context,
-        });
-        if (!record._changes) {
-            // if the _changes key does not exist anymore, it means that
-            // it was removed by discarding the changes after the rpc
-            // to onchange. So, in that case, the proper response is to
-            // ignore the onchange.
-            return;
-        }
-        if (result.warning) {
-            this.trigger_up('warning', result.warning);
-            record._warning = true;
-        }
-        if (result.domain) {
-            record._domains = Object.assign(record._domains, result.domain);
-        }
-        await this._applyOnChange(result.value, record, { firstOnChange });
-        return result;
-    },
-    /**
-     * This function accumulates RPC requests done in the same call stack, and
-     * performs them in the next micro task tick so that similar requests can be
-     * batched in a single RPC.
-     *
-     * For now, only 'read' calls are supported.
-     *
-     * @private
-     * @param {Object} params
-     * @returns {Promise}
-     */
-    _performRPC: function (params) {
-        var self = this;
-
-        // save the RPC request
-        var request = Object.assign({}, params);
-        var prom = new Promise(function (resolve, reject) {
-            request.resolve = resolve;
-            request.reject = reject;
-        });
-        this.batchedRPCsRequests.push(request);
-
-        // empty the pool of RPC requests in the next micro tick
-        Promise.resolve().then(function () {
-            if (!self.batchedRPCsRequests.length) {
-                // pool has already been processed
-                return;
-            }
-
-            // reset pool of RPC requests
-            var batchedRPCsRequests = self.batchedRPCsRequests;
-            self.batchedRPCsRequests = [];
-
-            // batch similar requests
-            var batches = {};
-            var key;
-            for (var i = 0; i < batchedRPCsRequests.length; i++) {
-                var request = batchedRPCsRequests[i];
-                key = request.model + ',' + JSON.stringify(request.context);
-                if (!batches[key]) {
-                    batches[key] = Object.assign({}, request, {requests: [request]});
-                } else {
-                    batches[key].ids = unique(batches[key].ids.concat(request.ids));
-                    batches[key].fieldNames = unique(batches[key].fieldNames.concat(request.fieldNames));
-                    batches[key].requests.push(request);
-                }
-            }
-
-            // perform batched RPCs
-            function onSuccess(batch, results) {
-                for (var i = 0; i < batch.requests.length; i++) {
-                    var request = batch.requests[i];
-                    var fieldNames = request.fieldNames.concat(['id']);
-                    var filteredResults = results.filter(function (record) {
-                        return request.ids.indexOf(record.id) >= 0;
-                    }).map(function (record) {
-                        return pick(record, ...fieldNames);
-                    });
-                    request.resolve(filteredResults);
-                }
-            }
-            function onFailure(batch, error) {
-                for (var i = 0; i < batch.requests.length; i++) {
-                    var request = batch.requests[i];
-                    request.reject(error);
-                }
-            }
-            for (key in batches) {
-                var batch = batches[key];
-                self._rpc({
-                    model: batch.model,
-                    method: 'read',
-                    args: [batch.ids, batch.fieldNames],
-                    context: batch.context,
-                }).then(onSuccess.bind(null, batch)).guardedCatch(onFailure.bind(null, batch));
-            }
-        });
-
-        return prom;
-    },
-    /**
-     * Once a record is created and some data has been fetched, we need to do
-     * quite a lot of computations to determine what needs to be fetched. This
-     * method is doing that.
-     *
-     * @see _fetchRecord @see _makeDefaultRecord
-     *
-     * @param {Object} record
-     * @param {Object} [options]
-     * @param {Object} [options.viewType] current viewType. If not set, we will
-     *   assume main viewType from the record
-     * @returns {Promise<Object>} resolves to the finished resource
-     */
-    _postprocess: function (record, options) {
-        var self = this;
-        var viewType = options && options.viewType || record.viewType;
-        var defs = [];
-
-        record.getFieldNames(options).forEach((name) => {
-            var field = record.fields[name];
-            var fieldInfo = record.fieldsInfo[viewType][name] || {};
-            var options = fieldInfo.options || {};
-            if (options.always_reload) {
-                if (record.fields[name].type === 'many2one') {
-                    const _changes = record._changes || {};
-                    const relRecordId = _changes[name] || record.data[name];
-                    if (!relRecordId) {
-                        return; // field is unset, no need to do the display_name read
-                    }
-                    var relRecord = self.localData[relRecordId];
-                    defs.push(self._rpc({
-                            model: field.relation,
-                            method: 'read',
-                            args: [relRecord.data.id, ['display_name']],
-                            context: self._getContext(record, {fieldName: name, viewType: viewType, withoutRecordData: true}),
-                        })
-                        .then(function (result) {
-                            relRecord.data.display_name = result[0]['display_name'];
-                        }));
-                }
-            }
-        });
-
-        defs.push(this._fetchSpecialData(record, options));
-
-        return Promise.all(defs).then(function () {
-            record._specialDataSavepoint = Object.assign({}, record.specialData);
-            return record;
-        });
-    },
-    /**
-     * Process x2many commands in a default record by transforming the list of
-     * commands in operations (pushed in _changes) and fetch the related
-     * records fields.
-     *
-     * Note that this method can be called recursively.
-     *
-     * @todo in master: factorize this code with the postprocessing of x2many in
-     *  _applyOnChange
-     *
-     * @private
-     * @param {Object} record
-     * @param {string} fieldName
-     * @param {Array[Array]} commands
-     * @param {Object} [options]
-     * @param {string} [options.viewType] current viewType. If not set, we will
-     *   assume main viewType from the record
-     * @returns {Promise}
-     */
-    _processX2ManyCommands: function (record, fieldName, commands, options) {
-        var self = this;
-        options = options || {};
-        var defs = [];
-        var field = record.fields[fieldName];
-        var fieldInfo = record.fieldsInfo[options.viewType || record.viewType][fieldName] || {};
-        var view = fieldInfo.views && fieldInfo.views[fieldInfo.mode];
-        var fieldsInfo = view ? view.fieldsInfo : fieldInfo.fieldsInfo;
-        var fields = view ? view.fields : fieldInfo.relatedFields;
-        var viewType = view ? view.type : fieldInfo.viewType;
-
-        // remove default_* & *_view_ref keys from record context
-        const recordContext = { ...record.context };
-        for (const key in recordContext) {
-            if (key.startsWith("default_") || key.endsWith("_view_ref")) {
-                delete recordContext[key];
-            }
-        }
-
-        var x2manyList = self._makeDataPoint({
-            context: recordContext,
-            fieldsInfo: fieldsInfo,
-            fields: fields,
-            limit: fieldInfo.limit,
-            modelName: field.relation,
-            parentID: record.id,
-            rawContext: fieldInfo && fieldInfo.context,
-            relationField: field.relation_field,
-            res_ids: [],
-            static: true,
-            type: 'list',
-            viewType: viewType,
-        });
-        record._changes[fieldName] = x2manyList.id;
-        x2manyList._changes = [];
-        var many2ones = {};
-        var r;
-        commands = commands || []; // handle false value
-        var isCommandList = commands.length && Array.isArray(commands[0]);
-        if (!isCommandList) {
-            commands = [[6, false, commands]];
-        }
-        commands.forEach((value) => {
-            // value is a command
-            if (value[0] === 0) {
-                // CREATE
-                r = self._makeDataPoint({
-                    modelName: x2manyList.model,
-                    context: x2manyList.context,
-                    fieldsInfo: fieldsInfo,
-                    fields: fields,
-                    parentID: x2manyList.id,
-                    viewType: viewType,
-                });
-                r._noAbandon = true;
-                x2manyList._changes.push({operation: 'ADD', id: r.id});
-                x2manyList._cache[r.res_id] = r.id;
-
-                // this is necessary so the fields are initialized
-                r.getFieldNames().forEach((fieldName) => {
-                    r.data[fieldName] = null;
-                });
-
-                r._changes = Object.assign(r.data, value[2]);
-                for (var fieldName in r._changes) {
-                    if (!r._changes[fieldName]) {
-                        continue;
-                    }
-                    var isFieldInView = fieldName in r.fields;
-                    if (isFieldInView) {
-                        var field = r.fields[fieldName];
-                        var fieldType = field.type;
-                        var rec;
-                        if (fieldType === 'many2one') {
-                            rec = self._makeDataPoint({
-                                context: r.context,
-                                modelName: field.relation,
-                                data: {id: r._changes[fieldName]},
-                                parentID: r.id,
-                            });
-                            r._changes[fieldName] = rec.id;
-                            many2ones[fieldName] = true;
-                        } else if (fieldType === 'reference') {
-                            var reference = r._changes[fieldName].split(',');
-                            rec = self._makeDataPoint({
-                                context: r.context,
-                                modelName: reference[0],
-                                data: {id: parseInt(reference[1])},
-                                parentID: r.id,
-                            });
-                            r._changes[fieldName] = rec.id;
-                            many2ones[fieldName] = true;
-                        } else if (['one2many', 'many2many'].includes(fieldType)) {
-                            var x2mCommands = value[2][fieldName];
-                            defs.push(self._processX2ManyCommands(r, fieldName, x2mCommands));
-                        } else {
-                            r._changes[fieldName] = self._parseServerValue(field, r._changes[fieldName]);
-                        }
-                    }
-                }
-            }
-            if (value[0] === 6) {
-                // REPLACE_WITH
-                value[2].forEach((res_id) => {
-                    x2manyList._changes.push({operation: 'ADD', resID: res_id});
-                });
-                var def = self._readUngroupedList(x2manyList).then(function () {
-                    return Promise.all([
-                        self._fetchX2ManysBatched(x2manyList),
-                        self._fetchReferencesBatched(x2manyList)
-                    ]);
-                });
-                defs.push(def);
-            }
-        });
-
-        // fetch many2ones display_name
-        Object.keys(many2ones).forEach((name) => {
-            defs.push(self._fetchNameGets(x2manyList, name));
-        });
-
-        return Promise.all(defs);
-    },
-    /**
-     * Reads data from server for all missing fields.
-     *
-     * @private
-     * @param {Object} list a valid resource object
-     * @param {interger[]} resIDs
-     * @param {string[]} fieldNames to check and read if missing
-     * @returns {Promise<Object>}
-     */
-    _readMissingFields: function (list, resIDs, fieldNames, withoutRecordData) {
-        var self = this;
-
-        var missingIDs = [];
-        for (var i = 0, len = resIDs.length; i < len; i++) {
-            var resId = resIDs[i];
-            var dataPointID = list._cache[resId];
-            if (!dataPointID) {
-                missingIDs.push(resId);
-                continue;
-            }
-            var record = self.localData[dataPointID];
-            var data = Object.assign({}, record.data, record._changes);
-            if (fieldNames.filter((x) => Object.keys(data).indexOf(x) < 0).length) {
-                missingIDs.push(resId);
-            }
-        }
-
-        var def;
-        if (missingIDs.length && fieldNames.length) {
-            def = self._performRPC({
-                context: list.getContext({ withoutRecordData: !!withoutRecordData }),
-                fieldNames: fieldNames,
-                ids: missingIDs,
-                method: 'read',
-                model: list.model,
-            });
-        } else {
-            def = Promise.resolve(missingIDs.map((id) => {
-                return {id:id};
-            }));
-        }
-        return def.then(function (records) {
-            resIDs.forEach((id) => {
-                var dataPoint;
-                var data = records.find((record) => record.id === id);
-                if (id in list._cache) {
-                    dataPoint = self.localData[list._cache[id]];
-                    if (data) {
-                        self._parseServerData(fieldNames, dataPoint, data);
-                        Object.assign(dataPoint.data, data);
-                    }
-                } else {
-                    dataPoint = self._makeDataPoint({
-                        context: list.getContext(),
-                        data: data,
-                        fieldsInfo: list.fieldsInfo,
-                        fields: list.fields,
-                        modelName: list.model,
-                        parentID: list.id,
-                        viewType: list.viewType,
-                    });
-                    self._parseServerData(fieldNames, dataPoint, dataPoint.data);
-
-                    // add many2one records
-                    list._cache[id] = dataPoint.id;
-                }
-                // set the dataPoint id in potential 'ADD' operation adding the current record
-                Object.values(list._changes || {}).forEach((change) => {
-                    if (change.operation === 'ADD' && !change.id && change.resID === id) {
-                        change.id = dataPoint.id;
-                    }
-                });
-            });
-            return list;
-        });
-    },
-    /**
-     * For a grouped list resource, this method fetches all group data by
-     * performing a /read_group. It also tries to read open subgroups if they
-     * were open before.
-     *
-     * @param {Object} list valid resource object
-     * @param {Object} [options] @see _load
-     * @returns {Promise<Object>} resolves to the fetched group object
-     */
-    _readGroup: function (list, options) {
-        var self = this;
-        options = options || {};
-        var groupByField = list.groupedBy[0];
-        var rawGroupBy = groupByField.split(':')[0];
-        var fields = unique(list.getFieldNames().concat(rawGroupBy));
-        var orderedBy = list.orderedBy?.filter(order => {
-            return order.name === rawGroupBy || list.fields[order.name].group_operator !== undefined;
-        }) || [];
-        var openGroupsLimit = list.groupsLimit || self.OPEN_GROUP_LIMIT;
-        var expand = list.openGroupByDefault && options.fetchRecordsWithGroups;
-        return this._rpc({
-                model: list.model,
-                method: 'web_read_group',
-                fields: fields,
-                domain: list.domain,
-                context: list.context,
-                groupBy: list.groupedBy,
-                limit: list.groupsLimit,
-                offset: list.groupsOffset,
-                orderBy: orderedBy,
-                lazy: true,
-                expand: expand,
-                expand_limit: expand ? list.limit : null,
-                expand_orderby: expand ? list.orderedBy : null,
-            })
-            .then(function (result) {
-                var groups = result.groups;
-                list.groupsCount = result.length;
-                var previousGroups = list.data.map((groupID) => self.localData[groupID]);
-                list.data = [];
-                list.count = 0;
-                var defs = [];
-                var openGroupCount = 0;
-
-                groups.forEach((group) => {
-                    var aggregateValues = {};
-                    for (const [key, value] of Object.entries(group)) {
-                        if (fields.includes(key) && key !== groupByField &&
-                            AGGREGATABLE_TYPES.includes(list.fields[key].type)) {
-                                aggregateValues[key] = value;
-                        }
-                    }
-                    // When a view is grouped, we need to display the name of each group in
-                    // the 'title'.
-                    var value = group[groupByField];
-                    if (list.fields[rawGroupBy].type === "selection") {
-                        var choice = list.fields[rawGroupBy].selection.find(c => c[0] === value);
-                        value = choice ? choice[1] : false;
-                    }
-                    var newGroup = self._makeDataPoint({
-                        modelName: list.model,
-                        count: group[rawGroupBy + '_count'],
-                        domain: group.__domain,
-                        context: list.context,
-                        fields: list.fields,
-                        fieldsInfo: list.fieldsInfo,
-                        value: value,
-                        range: group.__range,
-                        aggregateValues: aggregateValues,
-                        groupedBy: list.groupedBy.slice(1),
-                        orderedBy: list.orderedBy,
-                        orderedResIDs: list.orderedResIDs,
-                        limit: list.limit,
-                        openGroupByDefault: list.openGroupByDefault,
-                        parentID: list.id,
-                        type: 'list',
-                        viewType: list.viewType,
-                    });
-                    var oldGroup = previousGroups.find(g => g.res_id === newGroup.res_id && g.value === newGroup.value);
-                    if (oldGroup) {
-                        delete self.localData[newGroup.id];
-                        // restore the internal state of the group
-                        const oldPropsToKeep = self._getGroupedListPropsToKeep(oldGroup, {
-                            onlyGroup: options.onlyGroups,
-                            hasSubgroups: newGroup.groupedBy.length
-                        });
-                        Object.assign(newGroup, oldPropsToKeep);
-                        // set the limit such that all previously loaded records
-                        // (e.g. if we are coming back to the kanban view from a
-                        // form view) are reloaded
-                        newGroup.limit = oldGroup.limit + oldGroup.loadMoreOffset;
-                        self.localData[newGroup.id] = newGroup;
-                    } else if (!newGroup.openGroupByDefault || openGroupCount >= openGroupsLimit) {
-                        newGroup.isOpen = false;
-                    } else if ('__fold' in group) {
-                        newGroup.isOpen = !group.__fold;
-                    } else {
-                        // open the group iff it is a first level group
-                        newGroup.isOpen = !self.localData[newGroup.parentID].parentID;
-                    }
-                    list.data.push(newGroup.id);
-                    list.count += newGroup.count;
-                    if (newGroup.isOpen && newGroup.count > 0) {
-                        openGroupCount++;
-                        if (group.__data) {
-                            // bypass the search_read when the group's records have been obtained
-                            // by the call to 'web_read_group' (see @_searchReadUngroupedList)
-                            newGroup.__data = group.__data;
-                        }
-                        options = Object.assign(options, {enableRelationalFetch: false});
-                        defs.push(self._load(newGroup, options));
-                    }
-                });
-                if (options.keepEmptyGroups) {
-                    // Find the groups that were available in a previous
-                    // readGroup but are not there anymore.
-                    // Note that these groups are put after existing groups so
-                    // the order is not conserved. A sort *might* be useful.
-                    var emptyGroupsIDs = previousGroups.map((group) => group.id).filter((x) => list.data.indexOf(x)<0);
-                    emptyGroupsIDs.forEach((groupID) => {
-                        list.data.push(groupID);
-                        var emptyGroup = self.localData[groupID];
-                        // this attribute hasn't been updated in the previous
-                        // loop for empty groups
-                        emptyGroup.aggregateValues = {};
-                    });
-                }
-
-                return Promise.all(defs).then(function (groups) {
-                    if (!options.onlyGroups) {
-                        // generate the res_ids of the main list, being the concatenation
-                        // of the fetched res_ids in each group
-                        list.res_ids = groups.map((group) => {
-                            return group ? group.res_ids : [];
-                        }).flat();
-                    }
-                    return list;
-                }).then(function () {
-                    return Promise.all([
-                        self._fetchX2ManysSingleBatch(list),
-                        self._fetchReferencesSingleBatch(list)
-                    ]).then(function () {
-                        return list;
-                    });
-                });
-            });
-    },
-    /**
-     * For 'static' list, such as one2manys in a form view, we can do a /read
-     * instead of a /search_read.
-     *
-     * @param {Object} list a valid resource object
-     * @returns {Promise<Object>} resolves to the fetched list object
-     */
-    _readUngroupedList: function (list, options) {
-        options = options || {};
-        var self = this;
-        var def = Promise.resolve();
-
-        // generate the current count and res_ids list by applying the changes
-        list = this._applyX2ManyOperations(list);
-
-        // for multi-pages list datapoints, we might need to read the
-        // order field first to apply the order on all pages
-        if (list.res_ids.length > list.limit && list.orderedBy.length) {
-            if (!list.orderedResIDs) {
-                var fieldNames = list.orderedBy.map((list) => list.name);
-                def = this._readMissingFields(list, list.res_ids.filter(id => Number.isFinite(id)), fieldNames, options.withoutRecordData);
-            }
-            def.then(function () {
-                self._sortList(list);
-            });
-        }
-        return def.then(function () {
-            var resIDs = [];
-            var currentResIDs = list.res_ids;
-            // if new records have been added to the list, their virtual ids have
-            // been pushed at the end of res_ids (or at the beginning, depending
-            // on the editable property), ignoring completely the current page
-            // where the records have actually been created ; for that reason,
-            // we use orderedResIDs which is a freezed order with the virtual ids
-            // at the correct position where they were actually inserted ; however,
-            // when we use orderedResIDs, we must filter out ids that are not in
-            // res_ids, which correspond to records that have been removed from
-            // the relation (this information being taken into account in res_ids
-            // but not in orderedResIDs)
-            if (list.orderedResIDs) {
-                currentResIDs = list.orderedResIDs.filter(function (resID) {
-                    return list.res_ids.indexOf(resID) >= 0;
-                });
-            }
-            var currentCount = currentResIDs.length;
-            var upperBound = list.limit ? Math.min(list.offset + list.limit, currentCount) : currentCount;
-            var fieldNames = list.getFieldNames();
-            for (var i = list.offset; i < upperBound; i++) {
-                var resId = currentResIDs[i];
-                if (Number.isFinite(resId)) {
-                    resIDs.push(resId);
-                }
-            }
-            return self._readMissingFields(list, resIDs, fieldNames, options.withoutRecordData).then(function () {
-                if (list.res_ids.length <= list.limit) {
-                    self._sortList(list);
-                } else {
-                    // sortList has already been applied after first the read
-                    self._setDataInRange(list);
-                }
-                return list;
-            });
-        });
-    },
-    /**
-     * Reload all data for a given resource
-     *
-     * @private
-     * @param {string} id local id for a resource
-     * @param {Object} [options]
-     * @param {boolean} [options.keepChanges=false] if true, doesn't discard the
-     *   changes on the record before reloading it
-     * @returns {Promise<string>} resolves to the id of the resource
-     */
-    _reload: function (id, options) {
-        options = options || {};
-        var element = this.localData[id];
-
-        if (element.type === 'record') {
-            if (!options.currentId && (('currentId' in options) || this.isNew(id))) {
-                var params = {
-                    context: element.context,
-                    fieldsInfo: element.fieldsInfo,
-                    fields: element.fields,
-                    viewType: element.viewType,
-                    allowWarning: true,
-                };
-                return this._makeDefaultRecord(element.model, params);
-            }
-            if (!options.keepChanges) {
-                this.discardChanges(id, {rollback: false});
-            }
-        } else if (element._changes) {
-            delete element.tempLimitIncrement;
-            element._changes.forEach((change) => {
-                delete change.isNew;
-            });
-        }
-
-        if (options.context !== undefined) {
-            element.context = options.context;
-        }
-        if (options.orderedBy !== undefined) {
-            element.orderedBy = (options.orderedBy.length && options.orderedBy) || element.orderedBy;
-        }
-        if (options.domain !== undefined) {
-            element.domain = options.domain;
-        }
-        if (options.groupBy !== undefined) {
-            element.groupedBy = options.groupBy;
-            element.isM2MGrouped = element.groupedBy.some((group) => {
-                const [fieldName] = group.split(':');
-                return element.fields[fieldName].type === "many2many";
-            });
-        }
-        if (options.limit !== undefined) {
-            element.limit = options.limit;
-        }
-        if (options.offset !== undefined) {
-            this._setOffset(element.id, options.offset);
-        }
-        if (options.groupsLimit !== undefined) {
-            element.groupsLimit = options.groupsLimit;
-        }
-        if (options.groupsOffset !== undefined) {
-            element.groupsOffset = options.groupsOffset;
-        }
-        if (options.loadMoreOffset !== undefined) {
-            element.loadMoreOffset = options.loadMoreOffset;
-        } else {
-            // reset if not specified
-            element.loadMoreOffset = 0;
-        }
-        if (options.currentId !== undefined) {
-            element.res_id = options.currentId;
-        }
-        if (options.ids !== undefined) {
-            element.res_ids = options.ids;
-            element.count = element.res_ids.length;
-        }
-        if (element.type === 'record') {
-            element.offset = element.res_ids.indexOf(element.res_id);
-        }
-        var loadOptions = pick(options, 'fieldNames', 'viewType');
-        return this._load(element, loadOptions).then(function (result) {
-            return result.id;
-        });
-    },
-    /**
-     * Override to handle the case where we want sample data, and we are in a
-     * grouped kanban or list view with real groups, but all groups are empty.
-     * In this case, we use the result of the web_read_group rpc to tweak the
-     * data in the SampleServer instance of the sampleModel (so that calls to
-     * that server will return the same groups).
-     *
-     * @override
-     */
-    async _rpc(params) {
-        const result = await this._super(...arguments);
-        if (this.sampleModel && params.method === 'web_read_group' && result.length) {
-            const sampleServer = this.sampleModel.sampleServer;
-            sampleServer.setExistingGroups(result.groups);
-        }
-        return result;
-    },
-    /**
-     * Allows to save a value in the specialData cache associated to a given
-     * record and fieldName. If the value in the cache was already the given
-     * one, nothing is done and the method indicates it by returning false
-     * instead of true.
-     *
-     * @private
-     * @param {Object} record - an element from the localData
-     * @param {string} fieldName - the name of the field
-     * @param {*} value - the cache value to save
-     * @returns {boolean} false if the value was already the given one
-     */
-    _saveSpecialDataCache: function (record, fieldName, value) {
-        if (JSON.stringify(record._specialDataCache[fieldName]) === JSON.stringify(value)) {
-            return false;
-        }
-        record._specialDataCache[fieldName] = value;
-        return true;
-    },
-    /**
-     * Do a /search_read to get data for a list resource.  This does a
-     * /search_read because the data may not be static (for ex, a list view).
-     *
-     * @param {Object} list
-     * @returns {Promise}
-     */
-    _searchReadUngroupedList: function (list) {
-        var self = this;
-        var fieldNames = list.getFieldNames();
-        var prom;
-        if (list.__data) {
-            // the data have already been fetched (alongside the groups by the
-            // call to 'web_read_group'), so we can bypass the search_read
-            // But the web_read_group returns the rawGroupBy field's value, which may not be present
-            // in the view. So we filter it out.
-            const fieldNameSet = new Set(fieldNames);
-            fieldNameSet.add("id"); // don't filter out the id
-            list.__data.records.forEach(record =>
-                Object.keys(record)
-                    .filter(fieldName => !fieldNameSet.has(fieldName))
-                    .forEach(fieldName => delete record[fieldName]));
-            prom = Promise.resolve(list.__data);
-        } else {
-            prom = this._rpc({
-                route: '/web/dataset/search_read',
-                model: list.model,
-                fields: fieldNames,
-                context: Object.assign({}, list.getContext(), {bin_size: true}),
-                domain: this._getUngroupedListDomain(list),
-                limit: list.limit,
-                offset: list.loadMoreOffset + list.offset,
-                orderBy: list.orderedBy,
-            });
-        }
-        return prom.then(function (result) {
-            delete list.__data;
-            list.count = result.length;
-            var ids = result.records.map((r) => r.id);
-            var data = result.records.map((record) => {
-                var dataPoint = self._makeDataPoint({
-                    context: list.context,
-                    data: record,
-                    fields: list.fields,
-                    fieldsInfo: list.fieldsInfo,
-                    modelName: list.model,
-                    parentID: list.id,
-                    viewType: list.viewType,
-                });
-
-                // add many2one records
-                self._parseServerData(fieldNames, dataPoint, dataPoint.data);
-                return dataPoint.id;
-            });
-            if (list.loadMoreOffset) {
-                list.data = list.data.concat(data);
-                list.res_ids = list.res_ids.concat(ids);
-            } else {
-                list.data = data;
-                list.res_ids = ids;
-            }
-            self._updateParentResIDs(list);
-            return list;
-        });
-    },
-    /**
-     * Set data in range, i.e. according to the list offset and limit.
-     *
-     * @param {Object} list
-     */
-    _setDataInRange: function (list) {
-        var idsInRange;
-        if (list.limit) {
-            idsInRange = list.res_ids.slice(list.offset, list.offset + list.limit);
-        } else {
-            idsInRange = list.res_ids;
-        }
-        list.data = [];
-        idsInRange.forEach((id) => {
-            if (list._cache[id]) {
-                list.data.push(list._cache[id]);
-            }
-        });
-
-        // display newly created record in addition to the displayed records
-        if (list.limit) {
-            for (var i = list.offset + list.limit; i < list.res_ids.length; i++) {
-                var id = list.res_ids[i];
-                var dataPointID = list._cache[id];
-                if (Object.values(list._changes || {}).find((change) => change.isNew === true && change.id === dataPointID)) {
-                    list.data.push(dataPointID);
-                } else {
-                    break;
-                }
-            }
-        }
-    },
-    /**
-     * Change the offset of a record. Note that this does not reload the data.
-     * The offset is used to load a different record in a list of record (for
-     * example, a form view with a pager.  Clicking on next/previous actually
-     * changes the offset through this method).
-     *
-     * @param {string} elementId local id for the resource
-     * @param {number} offset
-     */
-    _setOffset: function (elementId, offset) {
-        var element = this.localData[elementId];
-        element.offset = offset;
-        if (element.type === 'record' && element.res_ids.length) {
-            element.res_id = element.res_ids[offset];
-        }
-    },
-    /**
-     * Do a in-memory sort of a list resource data points. This method assumes
-     * that the list data has already been fetched, and that the changes that
-     * need to be sorted have already been applied. Its intended use is for
-     * static datasets, such as a one2many in a form view.
-     *
-     * @param {Object} list list dataPoint on which (some) changes might have
-     *   been applied; it is a copy of an internal dataPoint, not the result of
-     *   get
-     */
-    _sortList: function (list) {
-        if (!list.static) {
-            // only sort x2many lists
-            return;
-        }
-        var self = this;
-
-        if (list.orderedResIDs) {
-            var orderedResIDs = {};
-            for (var k = 0; k < list.orderedResIDs.length; k++) {
-                orderedResIDs[list.orderedResIDs[k]] = k;
-            }
-            utils.stableSort(list.res_ids, function compareResIdIndexes (resId1, resId2) {
-                if (!(resId1 in orderedResIDs) && !(resId2 in orderedResIDs)) {
-                    return 0;
-                }
-                if (!(resId1 in orderedResIDs)) {
-                    return Infinity;
-                }
-                if (!(resId2 in orderedResIDs)) {
-                    return -Infinity;
-                }
-                return orderedResIDs[resId1] - orderedResIDs[resId2];
-            });
-        } else if (list.orderedBy.length) {
-            // sort records according to ordered_by[0]
-            var compareRecords = function (resId1, resId2, level) {
-                if(!level) {
-                    level = 0;
-                }
-                if(list.orderedBy.length < level + 1) {
-                    return 0;
-                }
-                var order = list.orderedBy[level];
-                var record1ID = list._cache[resId1];
-                var record2ID = list._cache[resId2];
-                if (!record1ID && !record2ID) {
-                    return 0;
-                }
-                if (!record1ID) {
-                    return Infinity;
-                }
-                if (!record2ID) {
-                    return -Infinity;
-                }
-                var r1 = self.localData[record1ID];
-                var r2 = self.localData[record2ID];
-                var data1 = Object.assign({}, r1.data, r1._changes);
-                var data2 = Object.assign({}, r2.data, r2._changes);
-
-                // Default value to sort against: the value of the field
-                var orderData1 = data1[order.name];
-                var orderData2 = data2[order.name];
-
-                // If the field is a relation, sort on the display_name of those records
-                if (list.fields[order.name].type === 'many2one') {
-                    orderData1 = orderData1 ? self.localData[orderData1].data.display_name : "";
-                    orderData2 = orderData2 ? self.localData[orderData2].data.display_name : "";
-                }
-                if (orderData1 < orderData2) {
-                    return order.asc ? -1 : 1;
-                }
-                if (orderData1 > orderData2) {
-                    return order.asc ? 1 : -1;
-                }
-                return compareRecords(resId1, resId2, level + 1);
-            };
-            utils.stableSort(list.res_ids, compareRecords);
-        }
-        this._setDataInRange(list);
-    },
-    /**
-     * Updates the res_ids of the parent of a given element of type list.
-     *
-     * After some operations (e.g. loading more records, folding/unfolding a
-     * group), the res_ids list of an element may be updated. When this happens,
-     * the res_ids of its ancestors need to be updated as well. This is the
-     * purpose of this function.
-     *
-     * @param {Object} element
-     */
-    _updateParentResIDs: function (element) {
-        var self = this;
-        if (element.parentID) {
-            var parent = this.localData[element.parentID];
-            parent.res_ids =  parent.data.map((dataPointID) => self.localData[dataPointID].res_ids).flat();
-            this._updateParentResIDs(parent);
-        }
-    },
-    /**
-     * Helper method to create datapoints and assign them values, then link
-     * those datapoints into records' data.
-     *
-     * @param {Object[]} records a list of record where datapoints will be
-     *   assigned, it assumes _applyX2ManyOperations and _sort have been
-     *   already called on this list
-     * @param {string} fieldName concerned field in records
-     * @param {Object[]} values typically a list of values got from a rpc
-     */
-    _updateRecordsData: function (records, fieldName, values) {
-        if (!records.length || !values) {
-            return;
-        }
-        var self = this;
-        var field = records[0].fields[fieldName];
-        var fieldInfo = records[0].fieldsInfo[records[0].viewType][fieldName];
-        var view = fieldInfo.views && fieldInfo.views[fieldInfo.mode];
-        var fieldsInfo = view ? view.fieldsInfo : fieldInfo.fieldsInfo;
-        var fields = view ? view.fields : fieldInfo.relatedFields;
-        var viewType = view ? view.type : fieldInfo.viewType;
-        var id2Values = new Map(values.map((value) => [value.id, value]))
-
-        records.forEach((record) => {
-            var x2mList = self.localData[record.data[fieldName]];
-            x2mList.data = [];
-            x2mList.res_ids.forEach((res_id) => {
-                var dataPoint = self._makeDataPoint({
-                    modelName: field.relation,
-                    data: id2Values.get(res_id),
-                    fields: fields,
-                    fieldsInfo: fieldsInfo,
-                    parentID: x2mList.id,
-                    viewType: viewType,
-                });
-                x2mList.data.push(dataPoint.id);
-                x2mList._cache[res_id] = dataPoint.id;
-            });
-        });
-    },
-    /**
-     * Used to apply a updateFn to other records with same res_id, that are
-     * under the same topmost list groupedby many2many.
-     *
-     * When a list datapoint is grouped by many2many, same res_id record could
-     * be in multiple groups, so use this method to apply the same callback to
-     * each one of them.
-     *
-     * @protected
-     * @param {string} recordID local resource
-     * @param {(recordID: string)=>void} updateFn called for each record datapoint
-     *  representing the same res_id record
-     */
-    _updateDuplicateRecords(recordID, updateFn) {
-        const { res_id } = this.localData[recordID];
-        // Get the topmost groupedby m2m list
-        const getTopmostID = () => {
-            let element = this.localData[recordID];
-            while (element.parentID && this.localData[element.parentID].type === "list") {
-                element = this.localData[element.parentID];
-            }
-            return element.type === "list" && element.isM2MGrouped ? element.id : false;
-        };
-        const topmostID = getTopmostID();
-        if (!topmostID) {
-            return;
-        }
-        const topmostList = this.get(topmostID);
-        utils.traverse_records(topmostList, (r) => {
-            if (r.res_id === res_id && r.id !== recordID) {
-                updateFn(r.id);
-            }
-        });
-    },
-    /**
-     * Helper method.  Recursively traverses the data, starting from the element
-     * record (or list), then following all relations.  This is useful when one
-     * want to determine a property for the current record.
-     *
-     * For example, isDirty need to check all relations to find out if something
-     * has been modified, or not.
-     *
-     * Note that this method follows all the changes, so if a record has
-     * relational sub data, it will visit the new sub records and not the old
-     * ones.
-     *
-     * @param {Object} element a valid local resource
-     * @param {callback} fn a function to be called on each visited element
-     */
-    _visitChildren: function (element, fn) {
-        var self = this;
-        fn(element);
-        if (element.type === 'record') {
-            for (var fieldName in element.data) {
-                var field = element.fields[fieldName];
-                if (!field) {
-                    continue;
-                }
-                if (['one2many', 'many2one', 'many2many'].includes(field.type)) {
-                    var hasChange = element._changes && fieldName in element._changes;
-                    var value =  hasChange ? element._changes[fieldName] : element.data[fieldName];
-                    var relationalElement = this.localData[value];
-                    // relationalElement could be empty in the case of a many2one
-                    if (relationalElement) {
-                        self._visitChildren(relationalElement, fn);
-                    }
-                }
-            }
-        }
-        if (element.type === 'list') {
-            element = this._applyX2ManyOperations(element);
-            element.data.forEach((elemId) => {
-                var elem = self.localData[elemId];
-                self._visitChildren(elem, fn);
-            });
-        }
-    },
-});
-
-export default BasicModel;
diff --git a/addons/web/static/src/legacy/js/views/field_manager_mixin.js b/addons/web/static/src/legacy/js/views/field_manager_mixin.js
deleted file mode 100644
index f4113de6d38..00000000000
--- a/addons/web/static/src/legacy/js/views/field_manager_mixin.js
+++ /dev/null
@@ -1,165 +0,0 @@
-/** @odoo-module alias=web.FieldManagerMixin **/
-
-/**
- * The FieldManagerMixin is a mixin, designed to do the plumbing between field
- * widgets and a basicmodel.  Field widgets can be used outside of a view.  In
- * that case, someone needs to listen to events bubbling up from the widgets and
- * calling the correct methods on the model.  This is the field_manager's job.
- */
-
-import { pick } from '@web/core/utils/objects';
-import BasicModel from 'web.BasicModel';
-import concurrency from 'web.concurrency';
-
-var FieldManagerMixin = {
-    custom_events: {
-        field_changed: '_onFieldChanged',
-        load: '_onLoad',
-        mutexify: '_onMutexify',
-    },
-    /**
-     * A FieldManagerMixin can be initialized with an instance of a basicModel.
-     * If not, it will simply uses its own.
-     *
-     * @param {BasicModel} [model]
-     */
-    init: function (model) {
-        this.model = model || new BasicModel(this);
-        this.mutex = new concurrency.Mutex();
-    },
-
-    //--------------------------------------------------------------------------
-    // Private
-    //--------------------------------------------------------------------------
-
-    /**
-     * Apply changes by notifying the basic model, then saving the data if
-     * necessary, and finally, confirming the changes to the UI.
-     *
-     * @todo find a way to remove ugly 3rd argument...
-     *
-     * @param {string} dataPointID
-     * @param {Object} changes
-     * @param {OdooEvent} event
-     * @returns {Promise} resolves when the change has been done, and the UI
-     *   updated
-     */
-    _applyChanges: function (dataPointID, changes, event) {
-        var self = this;
-        var options = pick(event.data, 'context', 'doNotSetDirty', 'notifyChange', 'viewType', 'allowWarning');
-        return this.model.notifyChanges(dataPointID, changes, options)
-            .then(function (result) {
-                if (event.data.force_save) {
-                    return self.model.save(dataPointID).then(function () {
-                        return self._confirmSave(dataPointID);
-                    }).guardedCatch(function () {
-                        return self._rejectSave(dataPointID);
-                    });
-                } else if (options.notifyChange !== false) {
-                    return self._confirmChange(dataPointID, result, event);
-                }
-            });
-    },
-    /**
-     * This method will be called whenever a field value has changed (and has
-     * been confirmed by the model).
-     *
-     * @abstract
-     * @param {string} id basicModel Id for the changed record
-     * @param {string[]} fields the fields (names) that have been changed
-     * @param {OdooEvent} event the event that triggered the change
-     * @returns {Promise}
-     */
-    _confirmChange: function (id, fields, event) {
-        return Promise.resolve();
-    },
-    /**
-     * This method will be called whenever a save has been triggered by a change
-     * in some controlled field value.  For example, when a priority widget is
-     * being changed in a readonly form.
-     *
-     * @see _onFieldChanged
-     * @abstract
-     * @param {string} id The basicModel ID for the saved record
-     * @returns {Promise}
-     */
-    _confirmSave: function (id) {
-        return Promise.resolve();
-    },
-    /**
-     * This method will be called whenever a save has been triggered by a change
-     * and has failed. For example, when a statusbar button is clicked in a
-     * readonly form view.
-     *
-     * @abstract
-     * @private
-     * @param {string} id The basicModel ID for the saved record
-     * @returns {Deferred}
-     */
-    _rejectSave: function (id) {
-        return Promise.resolve();
-    },
-
-    //--------------------------------------------------------------------------
-    // Handlers
-    //--------------------------------------------------------------------------
-
-    /**
-     * This is the main job of the FMM: deciding what to do when a controlled
-     * field changes.  Most of the time, it notifies the model that a change
-     * just occurred, then confirm the change.
-     *
-     * @param {OdooEvent} event
-     */
-    _onFieldChanged: function (event) {
-        // in case of field changed in relational record (e.g. in the form view
-        // of a one2many subrecord), the field_changed event must be stopped as
-        // soon as is it handled by a field_manager (i.e. the one of the
-        // subrecord's form view), otherwise it bubbles up to the main form view
-        // but its model doesn't have any data related to the given dataPointID
-        event.stopPropagation();
-        return this._applyChanges(event.data.dataPointID, event.data.changes, event)
-            .then(event.data.onSuccess || function () {})
-            .guardedCatch(event.data.onFailure || function () {});
-    },
-    /**
-     * Some widgets need to trigger a reload of their data.  For example, a
-     * one2many with a pager needs to be able to fetch the next page.  To do
-     * that, it can trigger a load event. This will then ask the model to
-     * actually reload the data, then call the on_success callback.
-     *
-     * @param {OdooEvent} event
-     * @param {number} [event.data.limit]
-     * @param {number} [event.data.offset]
-     * @param {function} [event.data.on_success] callback
-     */
-    _onLoad: function (event) {
-        var self = this;
-        event.stopPropagation(); // prevent other field managers from handling this request
-        var data = event.data;
-        if (!data.on_success) { return; }
-        var params = {};
-        if ('limit' in data) {
-            params.limit = data.limit;
-        }
-        if ('offset' in data) {
-            params.offset = data.offset;
-        }
-        this.mutex.exec(function () {
-            return self.model.reload(data.id, params).then(function (db_id) {
-                data.on_success(self.model.get(db_id));
-            });
-        });
-    },
-    /**
-     * @private
-     * @param {OdooEvent} ev
-     * @param {function} ev.data.action the function to execute in the mutex
-     */
-    _onMutexify: function (ev) {
-        ev.stopPropagation(); // prevent other field managers from handling this request
-        this.mutex.exec(ev.data.action);
-    },
-};
-
-export default FieldManagerMixin;
diff --git a/addons/web/static/src/legacy/js/views/standalone_field_manager_mixin.js b/addons/web/static/src/legacy/js/views/standalone_field_manager_mixin.js
deleted file mode 100644
index cef759851c4..00000000000
--- a/addons/web/static/src/legacy/js/views/standalone_field_manager_mixin.js
+++ /dev/null
@@ -1,60 +0,0 @@
-/** @odoo-module alias=web.StandaloneFieldManagerMixin **/
-
-import FieldManagerMixin from 'web.FieldManagerMixin';
-
-/**
- * The StandaloneFieldManagerMixin is a mixin, designed to be used by a widget
- * that instanciates its own field widgets.
- *
- * @mixin
- * @name StandaloneFieldManagerMixin
- * @mixes FieldManagerMixin
- * @property {Function} _confirmChange
- * @property {Function} _registerWidget
- */
-var StandaloneFieldManagerMixin = Object.assign({}, FieldManagerMixin, {
-
-    /**
-     * @override
-     */
-    init: function () {
-        FieldManagerMixin.init.apply(this, arguments);
-
-        // registeredWidgets is a dict of all field widgets used by the widget
-        this.registeredWidgets = {};
-    },
-
-    //--------------------------------------------------------------------------
-    // Private
-    //--------------------------------------------------------------------------
-
-    /**
-     * This method will be called whenever a field value has changed (and has
-     * been confirmed by the model).
-     *
-     * @private
-     * @param {string} id basicModel Id for the changed record
-     * @param {string[]} fields the fields (names) that have been changed
-     * @param {OdooEvent} event the event that triggered the change
-     * @returns {Promise}
-     */
-    _confirmChange: function (id, fields, event) {
-        var result = FieldManagerMixin._confirmChange.apply(this, arguments);
-        var record = this.model.get(id);
-        for (const [fieldName, widget] of Object.entries(this.registeredWidgets[id])) {
-            if (fields.includes(fieldName)) {
-                widget.reset(record, event);
-            }
-        }
-        return result;
-    },
-
-    _registerWidget: function (datapointID, fieldName, widget) {
-        if (!this.registeredWidgets[datapointID]) {
-            this.registeredWidgets[datapointID] = {};
-        }
-        this.registeredWidgets[datapointID][fieldName] = widget;
-    },
-});
-
-export default StandaloneFieldManagerMixin;
diff --git a/addons/web/static/src/legacy/js/views/view_utils.js b/addons/web/static/src/legacy/js/views/view_utils.js
deleted file mode 100644
index dcc56412de2..00000000000
--- a/addons/web/static/src/legacy/js/views/view_utils.js
+++ /dev/null
@@ -1,112 +0,0 @@
-/** @odoo-module alias=web.viewUtils **/
-
-
-import { unique } from '@web/core/utils/arrays';
-import { omit } from '@web/core/utils/objects';
-import * as dom from 'web.dom';
-import * as utils from 'web.utils';
-
-var viewUtils = {
-    /**
-     * Since a date field can have a granularity in a groupby (date_field:granularity),
-     * when we require only the field name, we have to split out the
-     * eventual granularity
-     * 
-     * @param {string} groupedBy the groupby with the eventual granularity
-     * @returns {string}
-     */
-    getGroupByField: function(groupedBy) {
-        return groupedBy && groupedBy.split(':')[0];
-    },
-    /**
-     * Returns the value of a group dataPoint, i.e. the value of the groupBy
-     * field for the records in that group.
-     *
-     * @param {Object} group dataPoint of type list, corresponding to a group
-     * @param {string} groupedBy the value of the groupby, i.e.
-     *                           field_name:granularity for date/datetime
-     * @returns {string | integer | false}
-     */
-    getGroupValue: function (group, groupedBy) {
-        var groupedByField = group.fields[this.getGroupByField(groupedBy)];
-        switch (groupedByField.type) {
-            case 'many2one':
-                return group.res_id || false;
-            case 'selection':
-                var descriptor = groupedByField.selection.find(option => option[1] === group.value);
-                return descriptor && descriptor[0];
-            case 'char':
-            case 'boolean':
-                return group.value;
-            // for a date/datetime field, we take the last moment of the group as the group value
-            case 'date':
-            case 'datetime':
-                const [format, granularity] = groupedByField.type === 'date' ?
-                    ["YYYY-MM-DD", 'day'] : ["YYYY-MM-DD HH:mm:ss", 'second'];
-                return group.range[groupedBy] ?
-                    moment.utc(group.range[groupedBy].to).subtract(1, granularity).format(format) : false;
-            default:
-                return false; // other field types are not handled
-        }
-    },
-    /**
-     * States whether or not the quick create feature is available for the given
-     * datapoint, depending on its groupBy field.
-     *
-     * @param {Object} list dataPoint of type list
-     * @returns {Boolean} true iff the kanban quick create feature is available
-     */
-    isQuickCreateEnabled: function (list) {
-        var groupByField = list.groupedBy[0] && viewUtils.getGroupByField(list.groupedBy[0]);
-        if (!groupByField) {
-            return false;
-        }
-        var dateTypes = ['date', 'datetime'];
-        if (!list.fields[groupByField].readonly &&
-            dateTypes.includes(list.fields[groupByField].type)) {
-            return list.fieldsInfo && list.fieldsInfo[list.viewType][groupByField] &&
-                list.fieldsInfo[list.viewType][groupByField].allowGroupRangeValue;
-        }
-        var availableTypes = ['char', 'boolean', 'many2one', 'selection'];
-        return availableTypes.includes(list.fields[groupByField].type);
-    },
-    /**
-     * @param {string} arch view arch
-     * @returns {Object} parsed arch
-     */
-    parseArch: function (arch) {
-        var doc = $.parseXML(arch).documentElement;
-        var stripWhitespaces = doc.nodeName.toLowerCase() !== 'kanban';
-        return utils.xml_to_json(doc, stripWhitespaces);
-    },
-    /**
-     * Renders a button according to a given arch node element.
-     *
-     * @param {Object} node
-     * @param {Object} [options]
-     * @param {string} [options.extraClass]
-     * @param {boolean} [options.textAsTitle=false]
-     * @returns {jQuery}
-     */
-    renderButtonFromNode: function (node, options) {
-        var btnOptions = {
-            attrs: omit(node.attrs, 'icon', 'string', 'type', 'attrs', 'modifiers', 'options', 'effect'),
-            icon: node.attrs.icon,
-        };
-        if (options && options.extraClass) {
-            var classes = btnOptions.attrs.class ? btnOptions.attrs.class.split(' ') : [];
-            btnOptions.attrs.class = unique(classes.concat(options.extraClass.split(' '))).join(' ');
-        }
-        var str = (node.attrs.string || '').replace(/_/g, '');
-        if (str) {
-            if (options && options.textAsTitle) {
-                btnOptions.attrs.title = str;
-            } else {
-                btnOptions.text = str;
-            }
-        }
-        return dom.renderButton(btnOptions);
-    },
-};
-
-export default viewUtils;
diff --git a/addons/web/static/src/views/model.js b/addons/web/static/src/model/model.js
similarity index 69%
rename from addons/web/static/src/views/model.js
rename to addons/web/static/src/model/model.js
index 40d95d2c25d..c1945e98423 100644
--- a/addons/web/static/src/views/model.js
+++ b/addons/web/static/src/model/model.js
@@ -2,8 +2,8 @@
 
 import { useBus, useService } from "@web/core/utils/hooks";
 import { SEARCH_KEYS } from "@web/search/with_search/with_search";
-import { buildSampleORM } from "@web/views/sample_server";
 import { useSetupView } from "@web/views/view_hook";
+import { buildSampleORM } from "./sample_server";
 
 import { EventBus, onWillStart, onWillUpdateProps, useComponent } from "@odoo/owl";
 
@@ -20,7 +20,6 @@ export class Model {
         this.env = env;
         this.orm = services.orm;
         this.bus = new EventBus();
-        this.useSampleModel = false; // will be set to true by the "useModel" hook if necessary
         this.setup(params, services);
     }
 
@@ -81,12 +80,36 @@ function getSearchParams(props) {
  * @param {T} ModelClass
  * @param {Object} params
  * @param {Object} [options]
- * @param {Function} [options.onUpdate]
- * @param {Function} [options.onWillStart] callback executed before the first load of the model
- * @param {boolean} [options.ignoreUseSampleModel]
+ * @param {Function} [options.beforeFirstLoad]
  * @returns {InstanceType<T>}
  */
 export function useModel(ModelClass, params, options = {}) {
+    const component = useComponent();
+    const services = {};
+    for (const key of ModelClass.services) {
+        services[key] = useService(key);
+    }
+    services.orm = services.orm || useService("orm");
+    const model = new ModelClass(component.env, params, services);
+    onWillStart(async () => {
+        await options.beforeFirstLoad?.();
+        return model.load(component.props);
+    });
+    onWillUpdateProps((nextProps) => model.load(nextProps));
+    return model;
+}
+
+/**
+ * @template {typeof Model} T
+ * @param {T} ModelClass
+ * @param {Object} params
+ * @param {Object} [options]
+ * @param {Function} [options.onUpdate]
+ * @param {Function} [options.onWillStart]
+ * @param {Function} [options.onWillStartAfterLoad]
+ * @returns {InstanceType<T>}
+ */
+export function useModelWithSampleData(ModelClass, params, options = {}) {
     const component = useComponent();
     if (!(ModelClass.prototype instanceof Model)) {
         throw new Error(`the model class should extend Model`);
@@ -98,6 +121,7 @@ export function useModel(ModelClass, params, options = {}) {
     services.orm = services.orm || useService("orm");
 
     const model = new ModelClass(component.env, params, services);
+
     useBus(
         model.bus,
         "update",
@@ -108,33 +132,31 @@ export function useModel(ModelClass, params, options = {}) {
     );
 
     const globalState = component.props.globalState || {};
+    const localState = component.props.state || {};
     let useSampleModel = Boolean(
         "useSampleModel" in globalState
             ? globalState.useSampleModel
             : component.props.useSampleModel
     );
-    model.useSampleModel = !options.ignoreUseSampleModel ? useSampleModel : false;
+    model.useSampleModel = useSampleModel;
     const orm = model.orm;
-    let sampleORM = globalState.sampleORM;
+    let sampleORM = localState.sampleORM;
     const user = useService("user");
     let started = false;
+
     async function load(props) {
         const searchParams = getSearchParams(props);
         await model.load(searchParams);
-        if (!options.ignoreUseSampleModel) {
-            if (useSampleModel && !model.hasData()) {
-                sampleORM =
-                    sampleORM ||
-                    buildSampleORM(component.props.resModel, component.props.fields, user);
-                sampleORM.setGroups(model.getGroups());
-                // Load data with sampleORM then restore real ORM.
-                model.orm = sampleORM;
-                await model.load(searchParams);
-                model.orm = orm;
-            } else {
-                useSampleModel = false;
-                model.useSampleModel = useSampleModel;
-            }
+        if (useSampleModel && !model.hasData()) {
+            sampleORM =
+                sampleORM || buildSampleORM(component.props.resModel, component.props.fields, user);
+            // Load data with sampleORM then restore real ORM.
+            model.orm = sampleORM;
+            await model.load(searchParams);
+            model.orm = orm;
+        } else {
+            useSampleModel = false;
+            model.useSampleModel = useSampleModel;
         }
         if (started) {
             model.notify();
@@ -151,15 +173,16 @@ export function useModel(ModelClass, params, options = {}) {
         started = true;
     });
     onWillUpdateProps((nextProps) => {
-        if (!options.ignoreUseSampleModel) {
-            useSampleModel = false;
-        }
+        useSampleModel = false;
         load(nextProps);
     });
 
     useSetupView({
         getGlobalState() {
-            return { sampleORM, useSampleModel };
+            return { useSampleModel };
+        },
+        getLocalState: () => {
+            return { sampleORM };
         },
     });
 
diff --git a/addons/web/static/src/model/relational_model/datapoint.js b/addons/web/static/src/model/relational_model/datapoint.js
new file mode 100644
index 00000000000..9c845695f6f
--- /dev/null
+++ b/addons/web/static/src/model/relational_model/datapoint.js
@@ -0,0 +1,92 @@
+/* @odoo-module */
+
+import { evalDomain } from "@web/core/domain";
+import { Reactive } from "@web/core/utils/reactive";
+import { getId } from "./utils";
+
+/**
+ * @typedef Params
+ * @property {string} resModel
+ * @property {Object} context
+ * @property {{[key: string]: FieldInfo}} activeFields
+ * @property {{[key: string]: Field}} fields
+ */
+
+/**
+ * @typedef Field
+ * @property {string} name
+ * @property {string} type
+ * @property {[string,string][]} [selection]
+ */
+
+/**
+ * @typedef FieldInfo
+ * @property {string} context
+ * @property {boolean} invisible
+ * @property {boolean} readonly
+ * @property {boolean} required
+ * @property {boolean} onChange
+ */
+
+export class DataPoint extends Reactive {
+    /**
+     * @param {import("./relational_model").RelationalModel} model
+     * @param {import("./relational_model").Config"} config
+     * @param {any} data
+     * @param {Object} [options]
+     */
+    constructor(model, config, data, options) {
+        super(...arguments);
+        this.id = getId("datapoint");
+        this.model = model;
+        this._config = config;
+        this.setup(config, data, options);
+    }
+
+    /**
+     * @abstract
+     * @param {Object} params
+     * @param {Object} state
+     */
+    setup() {}
+
+    get activeFields() {
+        return this.config.activeFields;
+    }
+
+    get fields() {
+        return this.config.fields;
+    }
+
+    get fieldNames() {
+        return Object.keys(this.activeFields).filter(
+            (fieldName) => !this.fields[fieldName].relatedPropertyField
+        );
+    }
+
+    get resModel() {
+        return this.config.resModel;
+    }
+
+    get config() {
+        return this._config;
+    }
+
+    get context() {
+        return this.config.context;
+    }
+
+    // -------------------------------------------------------------------------
+    // Public
+    // -------------------------------------------------------------------------
+
+    /**
+     * @param {string} fieldName
+     * @returns {boolean}
+     */
+    isFieldReadonly(fieldName) {
+        const activeField = this.activeFields[fieldName];
+        const { readonly } = activeField || this.fields[fieldName];
+        return readonly && evalDomain(readonly, this.evalContext);
+    }
+}
diff --git a/addons/web/static/src/model/relational_model/dynamic_group_list.js b/addons/web/static/src/model/relational_model/dynamic_group_list.js
new file mode 100644
index 00000000000..7176ebbb461
--- /dev/null
+++ b/addons/web/static/src/model/relational_model/dynamic_group_list.js
@@ -0,0 +1,294 @@
+/* @odoo-module */
+//@ts-check
+
+import { Domain } from "@web/core/domain";
+import { DynamicList } from "./dynamic_list";
+
+export class DynamicGroupList extends DynamicList {
+    static type = "DynamicGroupList";
+
+    /**
+     * @param {import("./relational_model").Config} config
+     * @param {Object} data
+     */
+    setup(config, data) {
+        super.setup(...arguments);
+        this.isGrouped = true;
+        this._setData(data);
+    }
+
+    _setData(data) {
+        /** @type {import("./group").Group[]} */
+        this.groups = data.groups.map((g) => this._createGroupDatapoint(g));
+        this.count = data.length;
+    }
+
+    // -------------------------------------------------------------------------
+    // Getters
+    // -------------------------------------------------------------------------
+
+    get groupBy() {
+        return this.config.groupBy;
+    }
+
+    get groupByField() {
+        return this.fields[this.groupBy[0].split(":")[0]];
+    }
+
+    get hasData() {
+        if (this.count === 0) {
+            return false;
+        }
+        return this.groups.some((group) => group.hasData);
+    }
+
+    /**
+     * List of loaded records inside groups.
+     * @returns {import("./record").Record[]}
+     */
+    get records() {
+        return this.groups
+            .filter((group) => !group.isFolded)
+            .map((group) => group.records)
+            .flat();
+    }
+
+    /**
+     * @returns {number}
+     */
+    get recordCount() {
+        return this.groups.reduce((acc, group) => acc + group.count, 0);
+    }
+
+    // -------------------------------------------------------------------------
+    // Public
+    // -------------------------------------------------------------------------
+
+    async createGroup(groupName, groupData, isFolded) {
+        if (!this.groupByField || this.groupByField.type !== "many2one") {
+            throw new Error("Cannot create a group on a non many2one group field");
+        }
+
+        await this.model.mutex.exec(() => this._createGroup(groupName, groupData, isFolded));
+    }
+
+    async deleteGroups(groups) {
+        await this.model.mutex.exec(() => this._deleteGroups(groups));
+    }
+
+    /**
+     * @param {string} dataRecordId
+     * @param {string} dataGroupId
+     * @param {string} refId
+     * @param {string} targetGroupId
+     */
+    async moveRecord(dataRecordId, dataGroupId, refId, targetGroupId) {
+        const targetGroup = this.groups.find((g) => g.id === targetGroupId);
+        if (dataGroupId === targetGroupId) {
+            // move a record inside the same group
+            targetGroup.list.records = await targetGroup.list._resequence(
+                targetGroup.list.records,
+                this.resModel,
+                dataRecordId,
+                refId
+            );
+            return;
+        }
+
+        // move record from a group to another group
+        const sourceGroup = this.groups.find((g) => g.id === dataGroupId);
+        const recordIndex = sourceGroup.list.records.findIndex((r) => r.id === dataRecordId);
+        const record = sourceGroup.list.records[recordIndex];
+        // step 1: move record to correct position
+        const refIndex = targetGroup.list.records.findIndex((r) => r.id === refId);
+        const oldIndex = sourceGroup.list.records.findIndex((r) => r.id === dataRecordId);
+        sourceGroup._removeRecords([record.id]);
+        targetGroup._addRecord(record, refIndex + 1);
+        // step 2: update record value
+        const value =
+            targetGroup.groupByField.type === "many2one"
+                ? [targetGroup.value, targetGroup.displayName]
+                : targetGroup.value;
+        const revert = () => {
+            targetGroup._removeRecords([record.id]);
+            sourceGroup._addRecord(record, oldIndex);
+        };
+        try {
+            await record.update({ [targetGroup.groupByField.name]: value });
+            const res = await record.save({ noReload: true });
+            if (!res) {
+                revert();
+            }
+        } catch (e) {
+            // revert changes
+            revert();
+            throw e;
+        }
+        if (!targetGroup.isFolded) {
+            targetGroup.list.records = await targetGroup.list._resequence(
+                targetGroup.list.records,
+                this.resModel,
+                dataRecordId,
+                refId
+            );
+        }
+    }
+
+    async resequence(movedGroupId, targetGroupId) {
+        if (!this.groupByField || this.groupByField.type !== "many2one") {
+            throw new Error("Cannot resequence a group on a non many2one group field");
+        }
+
+        return this.model.mutex.exec(async () => {
+            this.groups = await this._resequence(
+                this.groups,
+                this.groupByField.relation,
+                movedGroupId,
+                targetGroupId
+            );
+        });
+    }
+
+    async sortBy(fieldName) {
+        if (!this.groups.length) {
+            return;
+        }
+        if (this.groups.every((group) => group.isFolded)) {
+            // all groups are folded
+            if (this.groupByField.name !== fieldName) {
+                // grouped by another field than fieldName
+                if (!(fieldName in this.groups[0].aggregates)) {
+                    // fieldName has no aggregate values
+                    return;
+                }
+            }
+        }
+        return super.sortBy(fieldName);
+    }
+
+    // -------------------------------------------------------------------------
+    // Protected
+    // -------------------------------------------------------------------------
+
+    async _createGroup(groupName, groupData = {}, isFolded = false) {
+        groupData = { ...groupData, name: groupName };
+        const [id] = await this.model.orm.create(this.groupByField.relation, [groupData], {
+            context: this.context,
+        });
+        const lastGroup = this.groups.at(-1);
+
+        // This is almost a copy/past of the code in relational_model.js
+        // Maybe we can create an addGroup method in relational_model.js
+        // and call it from here and from relational_model.js
+        const commonConfig = {
+            resModel: this.config.resModel,
+            fields: this.config.fields,
+            activeFields: this.config.activeFields,
+        };
+        const context = {
+            ...this.context,
+            [`default_${this.groupByField.name}`]: id,
+        };
+        const nextConfigGroups = { ...this.config.groups };
+        const domain = Domain.and([this.domain, [[this.groupByField.name, "=", id]]]).toList();
+        nextConfigGroups[id] = {
+            ...commonConfig,
+            context,
+            groupByFieldName: this.groupByField.name,
+            isFolded,
+            initialDomain: domain,
+            list: {
+                ...commonConfig,
+                context,
+                domain: domain,
+                groupBy: [],
+                orderBy: this.orderBy,
+            },
+        };
+        this.model._updateConfig(this.config, { groups: nextConfigGroups }, { noReload: true });
+
+        const data = {
+            count: 0,
+            length: 0,
+            records: [],
+            __domain: domain,
+            [this.groupByField.name]: [id, groupName],
+            value: id,
+            displayName: groupName,
+        };
+
+        const group = this._createGroupDatapoint(data);
+        if (lastGroup) {
+            const groups = [...this.groups, group];
+            this.groups = await this._resequence(
+                groups,
+                this.groupByField.relation,
+                group.id,
+                lastGroup.id
+            );
+        } else {
+            this.groups.push(group);
+        }
+    }
+
+    _createGroupDatapoint(data) {
+        return new this.model.constructor.Group(this.model, this.config.groups[data.value], data);
+    }
+
+    async _deleteGroups(groups) {
+        const shouldReload = groups.some((g) => g.count > 0);
+        await this._unlinkGroups(groups);
+        if (shouldReload) {
+            const configGroups = { ...this.config.groups };
+            for (const group of groups) {
+                delete configGroups[group.value];
+            }
+            await this.model._updateConfig(
+                this.config,
+                { groups: configGroups },
+                { commit: this._setData.bind(this) }
+            );
+        } else {
+            for (const group of groups) {
+                this._removeGroup(group);
+            }
+        }
+    }
+
+    _getDPresId(group) {
+        return group.value;
+    }
+
+    _getDPHandleField(group) {
+        return group[this.handleField];
+    }
+
+    async _load(offset, limit, orderBy, domain) {
+        await this.model._updateConfig(
+            this.config,
+            { offset, limit, orderBy, domain },
+            { commit: this._setData.bind(this) }
+        );
+    }
+
+    _removeGroup(group) {
+        const index = this.groups.findIndex((g) => g.id === group.id);
+        this.groups.splice(index, 1);
+        this.count--;
+    }
+
+    _removeRecords(recordIds) {
+        const proms = [];
+        for (const group of this.groups) {
+            proms.push(group._removeRecords(recordIds));
+        }
+        return Promise.all(proms);
+    }
+
+    _unlinkGroups(groups) {
+        const groupResIds = groups.map((g) => g.value);
+        return this.model.orm.unlink(this.groupByField.relation, groupResIds, {
+            context: this.context,
+        });
+    }
+}
diff --git a/addons/web/static/src/model/relational_model/dynamic_list.js b/addons/web/static/src/model/relational_model/dynamic_list.js
new file mode 100644
index 00000000000..e8e2815a8c9
--- /dev/null
+++ b/addons/web/static/src/model/relational_model/dynamic_list.js
@@ -0,0 +1,388 @@
+/* @odoo-module */
+
+import { AlertDialog } from "@web/core/confirmation_dialog/confirmation_dialog";
+import { _t } from "@web/core/l10n/translation";
+import { sprintf } from "@web/core/utils/strings";
+import { DataPoint } from "./datapoint";
+import { Record } from "./record";
+
+const DEFAULT_HANDLE_FIELD = "sequence";
+
+export class DynamicList extends DataPoint {
+    /**
+     * @param {import("./relational_model").Config} config
+     */
+    setup(config) {
+        super.setup(...arguments);
+        this.handleField = Object.keys(this.activeFields).find(
+            (fieldName) => this.activeFields[fieldName].isHandle
+        );
+        if (!this.handleField && DEFAULT_HANDLE_FIELD in this.fields) {
+            this.handleField = DEFAULT_HANDLE_FIELD;
+        }
+        this.isDomainSelected = false;
+        this.evalContext = this.context;
+    }
+
+    // -------------------------------------------------------------------------
+    // Getters
+    // -------------------------------------------------------------------------
+
+    get groupBy() {
+        return [];
+    }
+
+    get orderBy() {
+        return this.config.orderBy;
+    }
+
+    get domain() {
+        return this.config.domain;
+    }
+
+    get editedRecord() {
+        return this.records.find((record) => record.isInEdition);
+    }
+
+    get limit() {
+        return this.config.limit;
+    }
+
+    get offset() {
+        return this.config.offset;
+    }
+
+    get selection() {
+        return this.records.filter((record) => record.selected);
+    }
+
+    // -------------------------------------------------------------------------
+    // Public
+    // -------------------------------------------------------------------------
+
+    archive(isSelected) {
+        return this.model.mutex.exec(() => this._toggleArchive(isSelected, true));
+    }
+
+    canResequence() {
+        return !!this.handleField;
+    }
+
+    deleteRecords(records = []) {
+        return this.model.mutex.exec(() => this._deleteRecords(records));
+    }
+
+    async enterEditMode(record) {
+        if (this.editedRecord === record) {
+            return true;
+        }
+        const canProceed = await this.leaveEditMode();
+        if (canProceed) {
+            this.model._updateConfig(record.config, { mode: "edit" }, { noReload: true });
+        }
+        return canProceed;
+    }
+
+    /**
+     * @param {boolean} [isSelected]
+     * @returns {Promise<number[]>}
+     */
+    async getResIds(isSelected) {
+        let resIds;
+        if (isSelected) {
+            if (this.isDomainSelected) {
+                resIds = await this.model.orm.search(this.resModel, this.domain, {
+                    limit: this.model.activeIdsLimit,
+                    context: this.context,
+                });
+            } else {
+                resIds = this.selection.map((r) => r.resId);
+            }
+        } else {
+            resIds = this.records.map((r) => r.resId);
+        }
+        return resIds;
+    }
+
+    async leaveEditMode({ discard } = {}) {
+        if (this.editedRecord) {
+            let canProceed = true;
+            if (discard) {
+                await this.editedRecord.discard();
+                if (this.editedRecord && this.editedRecord.isNew) {
+                    this._removeRecords([this.editedRecord.id]);
+                }
+            } else {
+                if (!this.model._urgentSave) {
+                    await this.editedRecord.checkValidity();
+                    if (!this.editedRecord) {
+                        return true;
+                    }
+                }
+                if (this.editedRecord.isNew && !this.editedRecord.dirty) {
+                    this._removeRecords([this.editedRecord.id]);
+                } else {
+                    canProceed = await this.editedRecord.save();
+                }
+            }
+
+            if (canProceed && this.editedRecord) {
+                this.model._updateConfig(
+                    this.editedRecord.config,
+                    { mode: "readonly" },
+                    { noReload: true }
+                );
+            } else {
+                return canProceed;
+            }
+        }
+        return true;
+    }
+
+    load(params = {}) {
+        const limit = params.limit === undefined ? this.limit : params.limit;
+        const offset = params.offset === undefined ? this.offset : params.offset;
+        const orderBy = params.orderBy === undefined ? this.orderBy : params.orderBy;
+        const domain = params.domain === undefined ? this.domain : params.domain;
+        return this.model.mutex.exec(() => this._load(offset, limit, orderBy, domain));
+    }
+
+    async multiSave(record) {
+        return this.model.mutex.exec(() => this._multiSave(record));
+    }
+
+    selectDomain(value) {
+        return this.model.mutex.exec(() => {
+            this.isDomainSelected = value;
+        });
+    }
+
+    sortBy(fieldName) {
+        return this.model.mutex.exec(() => {
+            let orderBy = [...this.orderBy];
+            if (orderBy.length && orderBy[0].name === fieldName) {
+                orderBy[0] = { name: orderBy[0].name, asc: !orderBy[0].asc };
+            } else {
+                orderBy = orderBy.filter((o) => o.name !== fieldName);
+                orderBy.unshift({
+                    name: fieldName,
+                    asc: true,
+                });
+            }
+            return this._load(this.offset, this.limit, orderBy, this.domain);
+        });
+    }
+
+    unarchive(isSelected) {
+        return this.model.mutex.exec(() => this._toggleArchive(isSelected, false));
+    }
+
+    // -------------------------------------------------------------------------
+    // Protected
+    // -------------------------------------------------------------------------
+
+    async _deleteRecords(records) {
+        let resIds;
+        if (records.length) {
+            resIds = records.map((r) => r.resId);
+        } else {
+            resIds = await this.getResIds(true);
+            records = this.records.filter((r) => resIds.includes(r.resId));
+        }
+        const unlinked = await this.model.orm.unlink(this.resModel, resIds, {
+            context: this.context,
+        });
+        if (!unlinked) {
+            return false;
+        }
+        if (
+            this.isDomainSelected &&
+            resIds.length === this.model.activeIdsLimit &&
+            resIds.length < this.count
+        ) {
+            const msg = sprintf(
+                _t(`Only the first %s records have been deleted (out of %s selected)`),
+                resIds.length,
+                this.count
+            );
+            this.model.notification.add(msg, { title: _t("Warning") });
+        }
+        await this._removeRecords(records.map((r) => r.id));
+        return unlinked;
+    }
+
+    _leaveSampleMode() {
+        if (this.model.useSampleModel) {
+            this.model.useSampleModel = false;
+            return this._load(this.offset, this.limit, this.orderBy, this.domain);
+        }
+    }
+
+    async _multiSave(record) {
+        const changes = record._getChanges();
+        if (!Object.keys(changes).length) {
+            return;
+        }
+        const validSelection = this.selection.filter((record) => {
+            return Object.keys(changes).every((fieldName) => {
+                if (record._isReadonly(fieldName)) {
+                    return false;
+                } else if (record._isRequired(fieldName) && !changes[fieldName]) {
+                    return false;
+                }
+                return true;
+            });
+        });
+        const canProceed = await this.model.hooks.onWillSaveMulti(record, changes, validSelection);
+        if (canProceed === false) {
+            return false;
+        }
+        if (validSelection.length === 0) {
+            this.model.dialog.add(AlertDialog, {
+                body: _t("No valid record to save"),
+                confirm: () => this.leaveEditMode({ discard: true }),
+            });
+            return false;
+        } else {
+            const resIds = validSelection.map((r) => r.resId);
+            const context = this.context;
+            try {
+                await this.model.orm.write(this.resModel, resIds, changes, { context });
+            } catch (e) {
+                record._discard();
+                this.model._updateConfig(record.config, { mode: "readonly" }, { noReload: true });
+                throw e;
+            }
+            const records = await this.model._loadRecords({ ...this.config, resIds });
+            for (const record of validSelection) {
+                const serverValues = records.find((r) => r.id === record.resId);
+                record._applyValues(serverValues);
+                this.model._updateSimilarRecords(record, serverValues);
+            }
+            record._discard();
+            this.model._updateConfig(record.config, { mode: "readonly" }, { noReload: true });
+        }
+        this.model.hooks.onSavedMulti(validSelection);
+        return true;
+    }
+
+    async _resequence(originalList, resModel, movedId, targetId) {
+        if (this.resModel === resModel && !this.canResequence()) {
+            return originalList;
+        }
+        const handleField = this.handleField;
+        const dataPoints = [...originalList];
+        const order = this.orderBy.find((o) => o.name === handleField);
+        const asc = !order || order.asc;
+
+        // Find indices
+        const fromIndex = dataPoints.findIndex((d) => d.id === movedId);
+        let toIndex = 0;
+        if (targetId !== null) {
+            const targetIndex = dataPoints.findIndex((d) => d.id === targetId);
+            toIndex = fromIndex > targetIndex ? targetIndex + 1 : targetIndex;
+        }
+
+        const getSequence = (dp) => dp && this._getDPHandleField(dp, handleField);
+
+        // Determine which records/groups need to be modified
+        const firstIndex = Math.min(fromIndex, toIndex);
+        const lastIndex = Math.max(fromIndex, toIndex) + 1;
+        let reorderAll = dataPoints.some(
+            (dp) => this._getDPHandleField(dp, handleField) === undefined
+        );
+        if (!reorderAll) {
+            let lastSequence = (asc ? -1 : 1) * Infinity;
+            for (let index = 0; index < dataPoints.length; index++) {
+                const sequence = getSequence(dataPoints[index]);
+                if (
+                    ((index < firstIndex || index >= lastIndex) &&
+                        ((asc && lastSequence >= sequence) ||
+                            (!asc && lastSequence <= sequence))) ||
+                    (index >= firstIndex && index < lastIndex && lastSequence === sequence)
+                ) {
+                    reorderAll = true;
+                }
+                lastSequence = sequence;
+            }
+        }
+
+        // Perform the resequence in the list of records/groups
+        const [dp] = dataPoints.splice(fromIndex, 1);
+        dataPoints.splice(toIndex, 0, dp);
+
+        // Creates the list of records/groups to modify
+        let toReorder = dataPoints;
+        if (!reorderAll) {
+            toReorder = toReorder.slice(firstIndex, lastIndex).filter((r) => r.id !== movedId);
+            if (fromIndex < toIndex) {
+                toReorder.push(dp);
+            } else {
+                toReorder.unshift(dp);
+            }
+        }
+        if (!asc) {
+            toReorder.reverse();
+        }
+
+        const resIds = toReorder.map((d) => this._getDPresId(d)).filter((id) => id && !isNaN(id));
+        const sequences = toReorder.map(getSequence);
+        const offset = sequences.length && Math.min(...sequences);
+
+        // Try to write new sequences on the affected records/groups
+        const params = {
+            model: resModel,
+            ids: resIds,
+            context: this.context,
+            field: handleField,
+        };
+        if (offset) {
+            params.offset = offset;
+        }
+        const wasResequenced = await this.model.rpc("/web/dataset/resequence", params);
+        if (!wasResequenced) {
+            return originalList;
+        }
+
+        // Read the actual values set by the server and update the records/groups
+        const kwargs = { context: this.context };
+        const result = await this.model.orm.read(resModel, resIds, [handleField], kwargs);
+        for (const dpData of result) {
+            const dp = dataPoints.find((d) => this._getDPresId(d) === dpData.id);
+            if (dp instanceof Record) {
+                dp._applyValues(dpData);
+            } else {
+                dp[handleField] = dpData[handleField];
+            }
+        }
+
+        return dataPoints;
+    }
+
+    async _toggleArchive(isSelected, state) {
+        const method = state ? "action_archive" : "action_unarchive";
+        const context = this.context;
+        const resIds = await this.getResIds(isSelected);
+        const action = await this.model.orm.call(this.resModel, method, [resIds], { context });
+        if (
+            this.isDomainSelected &&
+            resIds.length === this.model.activeIdsLimit &&
+            resIds.length < this.count
+        ) {
+            const msg = sprintf(
+                _t("Of the %s records selected, only the first %s have been archived/unarchived."),
+                resIds.length,
+                this.count
+            );
+            this.model.notification.add(msg, { title: _t("Warning") });
+        }
+        const reload = () => this.model.load();
+        if (action && Object.keys(action).length) {
+            this.model.action.doAction(action, {
+                onClose: reload,
+            });
+        } else {
+            return reload();
+        }
+    }
+}
diff --git a/addons/web/static/src/model/relational_model/dynamic_record_list.js b/addons/web/static/src/model/relational_model/dynamic_record_list.js
new file mode 100644
index 00000000000..7543896e552
--- /dev/null
+++ b/addons/web/static/src/model/relational_model/dynamic_record_list.js
@@ -0,0 +1,185 @@
+/* @odoo-module */
+
+import { DynamicList } from "./dynamic_list";
+
+export class DynamicRecordList extends DynamicList {
+    static type = "DynamicRecordList";
+
+    /**
+     * @param {import("./relational_model").Config} config
+     * @param {Object} data
+     */
+    setup(config, data) {
+        super.setup(config);
+        this._setData(data);
+    }
+
+    _setData(data) {
+        /** @type {import("./record").Record[]} */
+        this.records = data.records.map((r) => this._createRecordDatapoint(r));
+        this._updateCount(data);
+    }
+
+    // -------------------------------------------------------------------------
+    // Getter
+    // -------------------------------------------------------------------------
+
+    get hasData() {
+        return this.count > 0;
+    }
+
+    // -------------------------------------------------------------------------
+    // Public
+    // -------------------------------------------------------------------------
+
+    /**
+     * @param {number} resId
+     * @param {boolean} [atFirstPosition]
+     * @returns {Promise<Record>} the newly created record
+     */
+    addExistingRecord(resId, atFirstPosition) {
+        return this.model.mutex.exec(async () => {
+            const record = this._createRecordDatapoint({});
+            await record._load({ resId });
+            this._addRecord(record, atFirstPosition ? 0 : this.records.length);
+            return record;
+        });
+    }
+
+    /**
+     * @param {boolean} [atFirstPosition=false]
+     * @returns {Promise<Record>}
+     */
+    addNewRecord(atFirstPosition = false) {
+        return this.model.mutex.exec(async () => {
+            await this._leaveSampleMode();
+            return this._addNewRecord(atFirstPosition);
+        });
+    }
+
+    /**
+     * Performs a search_count with the current domain to set the count. This is
+     * useful as web_search_read limits the count for performance reasons, so it
+     * might sometimes be less than the real number of records matching the domain.
+     **/
+    async fetchCount() {
+        this.count = await this.model._updateCount(this.config);
+        this.hasLimitedCount = false;
+        return this.count;
+    }
+
+    moveRecord(dataRecordId, _dataGroupId, refId, _targetGroupId) {
+        return this.resequence(dataRecordId, refId);
+    }
+
+    removeRecord(record) {
+        if (!record.isNew) {
+            throw new Error("removeRecord can't be called on an existing record");
+        }
+        const index = this.records.findIndex((r) => r === record);
+        if (index < 0) {
+            return;
+        }
+        this.records.splice(index, 1);
+        this.count--;
+        return record;
+    }
+
+    async resequence(movedRecordId, targetRecordId) {
+        return this.model.mutex.exec(
+            async () =>
+                (this.records = await this._resequence(
+                    this.records,
+                    this.resModel,
+                    movedRecordId,
+                    targetRecordId
+                ))
+        );
+    }
+
+    // -------------------------------------------------------------------------
+    // Protected
+    // -------------------------------------------------------------------------
+
+    async _addNewRecord(atFirstPosition) {
+        const values = await this.model._loadNewRecord({
+            resModel: this.resModel,
+            activeFields: this.activeFields,
+            fields: this.fields,
+            context: this.context,
+        });
+        const record = this._createRecordDatapoint(values, "edit");
+        this._addRecord(record, atFirstPosition ? 0 : this.records.length);
+        return record;
+    }
+
+    _addRecord(record, index) {
+        this.records.splice(Number.isInteger(index) ? index : this.records.length, 0, record);
+        this.count++;
+    }
+
+    _createRecordDatapoint(data, mode = "readonly") {
+        return new this.model.constructor.Record(
+            this.model,
+            {
+                context: this.context,
+                activeFields: this.activeFields,
+                resModel: this.resModel,
+                fields: this.fields,
+                resId: data.id || false,
+                resIds: data.id ? [data.id] : [],
+                isMonoRecord: true,
+                mode,
+            },
+            data,
+            { manuallyAdded: !data.id }
+        );
+    }
+
+    _getDPresId(record) {
+        return record.resId;
+    }
+
+    _getDPHandleField(record) {
+        return record.data[this.handleField];
+    }
+
+    async _load(offset, limit, orderBy, domain) {
+        await this.model._updateConfig(
+            this.config,
+            { offset, limit, orderBy, domain },
+            { commit: this._setData.bind(this) }
+        );
+    }
+
+    _removeRecords(recordIds) {
+        const _records = this.records.filter((r) => !recordIds.includes(r.id));
+        if (this.offset && !_records.length) {
+            // we weren't on the first page, and we removed all records of the current page
+            const offset = Math.max(this.offset - this.limit, 0);
+            return this._load(offset, this.limit, this.orderBy, this.domain);
+        }
+        const nbRemovedRecords = this.records.length - _records.length;
+        if (nbRemovedRecords > 0) {
+            if (this.count > this.offset + this.limit) {
+                // we removed some records, and there are other pages after the current one
+                return this._load(this.offset, this.limit, this.orderBy, this.domain);
+            } else {
+                // we are on the last page and there are still records remaining
+                this.count -= nbRemovedRecords;
+                this.records = _records;
+            }
+        }
+    }
+
+    _updateCount(data) {
+        const length = data.length;
+        if (length >= this.config.countLimit + 1) {
+            this.hasLimitedCount = true;
+            this.count = this.config.countLimit;
+        } else {
+            this.hasLimitedCount = false;
+            this.count = length;
+        }
+    }
+}
diff --git a/addons/web/static/src/model/relational_model/group.js b/addons/web/static/src/model/relational_model/group.js
new file mode 100644
index 00000000000..b1afe73d5f7
--- /dev/null
+++ b/addons/web/static/src/model/relational_model/group.js
@@ -0,0 +1,132 @@
+/* @odoo-module */
+
+import { Domain } from "@web/core/domain";
+import { DataPoint } from "./datapoint";
+
+/**
+ * @typedef Params
+ * @property {string[]} groupBy
+ */
+
+export class Group extends DataPoint {
+    static type = "Group";
+
+    /**
+     * @param {import("./relational_model").Config} config
+     */
+    setup(config, data) {
+        super.setup(...arguments);
+        this.groupByField = this.fields[config.groupByFieldName];
+        this.range = data.range;
+        this._rawValue = data[this.groupByField.name];
+        /** @type {number} */
+        this.count = data.count;
+        this.value = data.value;
+        this.displayName = data.displayName;
+        this.aggregates = data.aggregates;
+        let List;
+        if (config.list.groupBy.length) {
+            List = this.model.constructor.DynamicGroupList;
+        } else {
+            List = this.model.constructor.DynamicRecordList;
+        }
+        /** @type {import("./dynamic_group_list").DynamicGroupList | import("./dynamic_record_list").DynamicRecordList} */
+        this.list = new List(this.model, config.list, data);
+        if (config.record) {
+            this.record = new this.model.constructor.Record(this.model, config.record, data.values);
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Getters
+    // -------------------------------------------------------------------------
+
+    get hasData() {
+        return this.list.hasData;
+    }
+    get isFolded() {
+        return this.config.isFolded;
+    }
+    get records() {
+        return this.list.records;
+    }
+    get serverValue() {
+        const { type } = this.groupByField;
+        switch (type) {
+            case "many2one":
+                return this.value || false;
+            case "many2many": {
+                return this.value ? [this.value] : false;
+            }
+            default: {
+                return this._rawValue || false;
+            }
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Public
+    // -------------------------------------------------------------------------
+
+    async addExistingRecord(resId, atFirstPosition = false) {
+        const record = await this.list.addExistingRecord(resId, atFirstPosition);
+        this.count++;
+        return record;
+    }
+
+    async addNewRecord(_unused, atFirstPosition = false) {
+        const canProceed = await this.model.root.leaveEditMode({ discard: true });
+        if (canProceed) {
+            const record = await this.list.addNewRecord(atFirstPosition);
+            if (record) {
+                this.count++;
+            }
+        }
+    }
+
+    async applyFilter(filter) {
+        if (filter) {
+            await this.list.load({
+                domain: Domain.and([this.config.initialDomain, filter]).toList(),
+            });
+        } else {
+            await this.list.load({ domain: this.config.initialDomain });
+        }
+        this.model._updateConfig(this.config, { extraDomain: filter }, { noReload: true });
+    }
+
+    deleteRecords(records) {
+        return this.model.mutex.exec(() => this._deleteRecords(records));
+    }
+
+    async toggle() {
+        if (this.config.isFolded) {
+            await this.list.load();
+        }
+        this.model._updateConfig(
+            this.config,
+            { isFolded: !this.config.isFolded },
+            { noReload: true }
+        );
+    }
+
+    // -------------------------------------------------------------------------
+    // Protected
+    // -------------------------------------------------------------------------
+
+    _addRecord(record, index) {
+        this.list._addRecord(record, index);
+        this.count++;
+    }
+
+    async _deleteRecords(records) {
+        await this.list._deleteRecords(records);
+        this.count -= records.length;
+    }
+
+    async _removeRecords(recordIds) {
+        const idsToRemove = recordIds.filter((id) => this.list.records.some((r) => r.id === id));
+        await this.list._removeRecords(idsToRemove);
+        this.count -= idsToRemove.length;
+    }
+}
diff --git a/addons/web/static/src/model/relational_model/record.js b/addons/web/static/src/model/relational_model/record.js
new file mode 100644
index 00000000000..62a417861b0
--- /dev/null
+++ b/addons/web/static/src/model/relational_model/record.js
@@ -0,0 +1,932 @@
+/* @odoo-module */
+
+import { markRaw, markup, toRaw } from "@odoo/owl";
+import { AlertDialog } from "@web/core/confirmation_dialog/confirmation_dialog";
+import { Domain, evalDomain } from "@web/core/domain";
+import { serializeDate, serializeDateTime } from "@web/core/l10n/dates";
+import { _t } from "@web/core/l10n/translation";
+import { pick } from "@web/core/utils/objects";
+import { escape } from "@web/core/utils/strings";
+import { DataPoint } from "./datapoint";
+import { getFieldContext, parseServerValue } from "./utils";
+
+export class Record extends DataPoint {
+    static type = "Record";
+
+    /**
+     * @param {import("./relational_model").Config} config
+     * @param {Object} data
+     * @param {Object} [options={}]
+     * @param {boolean} [options.manuallyAdded]
+     * @param {Function} [options.onUpdate]
+     * @param {Record} [options.parentRecord]
+     * @param {string} [options.virtualId]
+     */
+    setup(config, data, options = {}) {
+        this._manuallyAdded = options.manuallyAdded === true;
+        this._onUpdate = options.onUpdate || (() => {});
+        this._parentRecord = options.parentRecord;
+        this._virtualId = options.virtualId || false;
+
+        // Be careful that pending changes might not have been notified yet, so the "dirty" flag may
+        // be false even though there are changes in a field. Consider calling "isDirty()" instead.
+        this.dirty = false;
+        this.selected = false;
+
+        this._invalidFields = new Set();
+        this._unsetRequiredFields = markRaw(new Set());
+        this._closeInvalidFieldsNotification = () => {};
+
+        const parentRecord = this._parentRecord;
+        if (parentRecord) {
+            this.evalContext = {
+                get parent() {
+                    return parentRecord.evalContext;
+                },
+            };
+        } else {
+            this.evalContext = {};
+        }
+        const missingFields = this.fieldNames.filter((fieldName) => !(fieldName in data));
+        data = { ...this._getDefaultValues(missingFields), ...data };
+        // In db, char, text and html fields can be not set (NULL) and set to the empty string. In
+        // the UI, there's no difference, but in the eval context, it's not the same. The next
+        // structure keeps track of the server values we received for those fields (which can thus
+        // be false or a string). This allows us to properly build the eval context, and to always
+        // expose string values (false fallbacks on the empty string) in this.data.
+        this._textValues = markRaw({});
+        this._setData(data);
+    }
+
+    _setData(data) {
+        if (this.resId) {
+            this._values = this._parseServerValues(data);
+            this._changes = markRaw({});
+            this._setTextValues(data);
+        } else {
+            this._values = markRaw({});
+            const allVals = { ...this._getDefaultValues(), ...data };
+            this._changes = this._parseServerValues(allVals);
+            this._setTextValues(allVals);
+        }
+        this.dirty = false;
+        this.data = { ...this._values, ...this._changes };
+        this._setEvalContext();
+        this._savePoint = markRaw({
+            dirty: false,
+            changes: { ...this._changes },
+            textValues: { ...this._textValues },
+        });
+        this._invalidFields.clear();
+    }
+
+    // -------------------------------------------------------------------------
+    // Getter
+    // -------------------------------------------------------------------------
+
+    get canBeAbandoned() {
+        return this.isNew && !this.dirty && this._manuallyAdded;
+    }
+
+    get hasData() {
+        return true;
+    }
+
+    get isActive() {
+        if ("active" in this.activeFields) {
+            return this.data.active;
+        } else if ("x_active" in this.activeFields) {
+            return this.data.x_active;
+        }
+        return true;
+    }
+
+    get isInEdition() {
+        if (this.config.mode === "readonly") {
+            return false;
+        } else {
+            return this.config.mode === "edit" || !this.resId;
+        }
+    }
+
+    get isNew() {
+        return !this.resId;
+    }
+
+    get isValid() {
+        return !this._invalidFields.size;
+    }
+
+    get resId() {
+        return this.config.resId;
+    }
+
+    get resIds() {
+        return this.config.resIds;
+    }
+
+    // -------------------------------------------------------------------------
+    // Public
+    // -------------------------------------------------------------------------
+
+    archive() {
+        return this.model.mutex.exec(() => this._toggleArchive(true));
+    }
+
+    async checkValidity() {
+        if (!this._urgentSave) {
+            await this.model._askChanges();
+        }
+        return this._checkValidity();
+    }
+
+    delete() {
+        return this.model.mutex.exec(async () => {
+            const unlinked = await this.model.orm.unlink(this.resModel, [this.resId], {
+                context: this.context,
+            });
+            if (!unlinked) {
+                return false;
+            }
+            const resIds = this.resIds.slice();
+            const index = resIds.indexOf(this.resId);
+            resIds.splice(index, 1);
+            const resId = resIds[Math.min(index, resIds.length - 1)] || false;
+            if (resId) {
+                await this.model.load({ resId, resIds });
+            } else {
+                this.model._updateConfig(this.config, { resId: false }, { noReload: true });
+                this.dirty = false;
+                this._changes = this._parseServerValues(this._getDefaultValues());
+                this._values = markRaw({});
+                this._textValues = markRaw({});
+                this.data = { ...this._changes };
+                this._setEvalContext();
+            }
+        });
+    }
+
+    discard() {
+        return this.model.mutex.exec(() => this._discard());
+    }
+
+    duplicate() {
+        return this.model.mutex.exec(async () => {
+            const kwargs = { context: this.context };
+            const index = this.resIds.indexOf(this.resId);
+            const resId = await this.model.orm.call(this.resModel, "copy", [this.resId], kwargs);
+            const resIds = this.resIds.slice();
+            resIds.splice(index + 1, 0, resId);
+            await this.model.load({ resId, resIds, mode: "edit" });
+        });
+    }
+
+    /**
+     * @param {string} fieldName
+     */
+    getFieldDomain(fieldName) {
+        const { domain } = this.fields[fieldName];
+        return domain ? new Domain(domain).toList(this.evalContext) : [];
+    }
+
+    async isDirty() {
+        await this.model._askChanges();
+        return this.dirty;
+    }
+
+    /**
+     * @param {string} fieldName
+     */
+    isFieldInvalid(fieldName) {
+        return this._invalidFields.has(fieldName);
+    }
+
+    load() {
+        if (arguments.length > 0) {
+            throw new Error("Record.load() does not accept arguments");
+        }
+        return this.model.mutex.exec(() => this._load());
+    }
+
+    openInvalidFieldsNotification() {
+        if (this._invalidFields.size) {
+            const items = [...this._invalidFields].map((fieldName) => {
+                return `<li>${escape(this.fields[fieldName].string || fieldName)}</li>`;
+            }, this);
+            this._closeInvalidFieldsNotification = this.model.notification.add(
+                markup(`<ul>${items.join("")}</ul>`),
+                {
+                    title: _t("Invalid fields: "),
+                    type: "danger",
+                }
+            );
+        }
+    }
+
+    async save(options) {
+        await this.model._askChanges();
+        return this.model.mutex.exec(() => this._save(options));
+    }
+
+    async setInvalidField(fieldName) {
+        this.dirty = true;
+        return this._setInvalidField(fieldName);
+    }
+
+    switchMode(mode) {
+        return this.model.mutex.exec(() => this._switchMode(mode));
+    }
+
+    toggleSelection(selected) {
+        return this.model.mutex.exec(() => {
+            if (typeof selected === "boolean") {
+                this.selected = selected;
+            } else {
+                this.selected = !this.selected;
+            }
+        });
+    }
+
+    unarchive() {
+        return this.model.mutex.exec(() => this._toggleArchive(false));
+    }
+
+    update(changes) {
+        if (this.model._urgentSave) {
+            return this._update(changes);
+        }
+        return this.model.mutex.exec(() => this._update(changes));
+    }
+
+    urgentSave() {
+        this.model._urgentSave = true;
+        this.model.bus.trigger("WILL_SAVE_URGENTLY");
+        this._save({ noReload: true });
+        return this.isValid;
+    }
+
+    // -------------------------------------------------------------------------
+    // Protected
+    // -------------------------------------------------------------------------
+
+    _addSavePoint() {
+        this._savePoint.dirty = this.dirty;
+        Object.assign(this._savePoint.textValues, this._textValues);
+        Object.assign(this._savePoint.changes, this._changes);
+        for (const fieldName in this._changes) {
+            if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
+                this._changes[fieldName]._addSavePoint();
+            }
+        }
+    }
+
+    _applyChanges(changes) {
+        for (const fieldName in changes) {
+            this._changes[fieldName] = changes[fieldName];
+            this.data[fieldName] = changes[fieldName];
+        }
+        this._setTextValues(changes);
+        this._setEvalContext();
+        this._removeInvalidFields(Object.keys(changes));
+    }
+
+    _applyDefaultValues() {
+        const fieldNames = this.fieldNames.filter((fieldName) => {
+            return !(fieldName in this.data);
+        });
+        const defaultValues = this._getDefaultValues(fieldNames);
+        if (this.isNew) {
+            this._applyChanges(this._parseServerValues(defaultValues));
+        } else {
+            this._applyValues(defaultValues);
+        }
+    }
+
+    _applyValues(values) {
+        const newValues = this._parseServerValues(values);
+        Object.assign(this._values, newValues);
+        for (const fieldName in newValues) {
+            if (fieldName in this._changes) {
+                if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
+                    this._changes[fieldName] = newValues[fieldName];
+                }
+            }
+        }
+        Object.assign(this.data, this._values, this._changes);
+        this._setTextValues(Object.assign({}, values, this._changes));
+        this._setEvalContext();
+    }
+
+    _checkValidity({ silent } = {}) {
+        const unsetRequiredFields = [];
+        for (const fieldName in this.activeFields) {
+            const fieldType = this.fields[fieldName].type;
+            if (this._isInvisible(fieldName)) {
+                continue;
+            }
+            switch (fieldType) {
+                case "boolean":
+                case "float":
+                case "integer":
+                case "monetary":
+                    continue;
+                case "one2many":
+                case "many2many": {
+                    const list = this.data[fieldName];
+                    if (
+                        (this._isRequired(fieldName) && !list.count) ||
+                        !list.records.every((r) => !r.dirty || r._checkValidity({ silent }))
+                    ) {
+                        unsetRequiredFields.push(fieldName);
+                    }
+                    break;
+                }
+                default:
+                    if (!this.data[fieldName] && this._isRequired(fieldName)) {
+                        unsetRequiredFields.push(fieldName);
+                    }
+            }
+        }
+
+        if (silent) {
+            return !unsetRequiredFields.length;
+        }
+
+        for (const fieldName of Array.from(this._unsetRequiredFields)) {
+            this._invalidFields.delete(fieldName);
+        }
+        this._unsetRequiredFields.clear();
+        for (const fieldName of unsetRequiredFields) {
+            this._unsetRequiredFields.add(fieldName);
+            this._setInvalidField(fieldName);
+        }
+        return !this._invalidFields.size;
+    }
+
+    _computeDataContext() {
+        const dataContext = {};
+        const data = toRaw(this.data);
+        for (const fieldName in data) {
+            const value = data[fieldName];
+            const field = this.fields[fieldName];
+            if (["char", "text", "html"].includes(field.type)) {
+                dataContext[fieldName] = this._textValues[fieldName];
+            } else if (["one2many", "many2many"].includes(field.type)) {
+                dataContext[fieldName] = value.currentIds.filter((id) => typeof id === "number");
+            } else if (value && field.type === "date") {
+                dataContext[fieldName] = serializeDate(value);
+            } else if (value && field.type === "datetime") {
+                dataContext[fieldName] = serializeDateTime(value);
+            } else if (value && field.type === "many2one") {
+                dataContext[fieldName] = value[0];
+            } else if (value && field.type === "reference") {
+                dataContext[fieldName] = `${value.resModel},${value.resId}`;
+            } else if (field.type === "properties") {
+                dataContext[fieldName] = value.filter(
+                    (property) => !property.definition_deleted !== false
+                );
+            } else {
+                dataContext[fieldName] = value;
+            }
+        }
+        dataContext.id = this.resId || false;
+        return dataContext;
+    }
+
+    _createStaticListDatapoint(data, fieldName) {
+        const { related, limit, defaultOrderBy } = this.activeFields[fieldName];
+        const config = {
+            resModel: this.fields[fieldName].relation,
+            activeFields: (related && related.activeFields) || {},
+            fields: (related && related.fields) || {},
+            relationField: this.fields[fieldName].relation_field || false,
+            offset: 0,
+            resIds: data.map((r) => r.id),
+            orderBy: defaultOrderBy || [],
+            limit: limit || Number.MAX_SAFE_INTEGER,
+            context: {}, // will be set afterwards, see "_updateContext" in "_setEvalContext"
+        };
+        let staticList;
+        const options = {
+            onUpdate: ({ withoutOnchange } = {}) =>
+                this._update({ [fieldName]: staticList }, { withoutOnchange }),
+            parent: this,
+        };
+        staticList = new this.model.constructor.StaticList(this.model, config, data, options);
+        return staticList;
+    }
+
+    _discard() {
+        for (const fieldName in this._changes) {
+            if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
+                this._changes[fieldName]._discard();
+            }
+        }
+        this.dirty = this._savePoint.dirty;
+        this._changes = markRaw({ ...this._savePoint.changes });
+        this.data = { ...this._values, ...this._changes };
+        this._textValues = markRaw({ ...this._savePoint.textValues });
+        this._setEvalContext();
+        this._invalidFields.clear();
+        this._closeInvalidFieldsNotification();
+        this._closeInvalidFieldsNotification = () => {};
+    }
+
+    _formatServerValue(fieldType, value) {
+        if (fieldType === "date") {
+            return value ? serializeDate(value) : false;
+        } else if (fieldType === "datetime") {
+            return value ? serializeDateTime(value) : false;
+        } else if (fieldType === "char" || fieldType === "text") {
+            return value !== "" ? value : false;
+        } else if (fieldType === "many2one") {
+            return value ? value[0] : false;
+        } else if (fieldType === "reference") {
+            return value && value.resModel && value.resId
+                ? `${value.resModel},${value.resId}`
+                : false;
+        } else if (fieldType === "properties") {
+            return value.map((property) => {
+                let value;
+                if (property.type === "many2one") {
+                    value = property.value;
+                } else if (
+                    (property.type === "date" || property.type === "datetime") &&
+                    typeof property.value === "string"
+                ) {
+                    // TO REMOVE: need refactoring PropertyField to use the same format as the server
+                    value = property.value;
+                } else {
+                    value = this._formatServerValue(property.type, property.value);
+                }
+                return {
+                    ...property,
+                    value,
+                };
+            });
+        }
+        return value;
+    }
+
+    _getChanges(changes = this._changes, { withReadonly } = {}) {
+        const result = {};
+        for (const [fieldName, value] of Object.entries(changes)) {
+            const field = this.fields[fieldName];
+            if (fieldName === "id") {
+                continue;
+            }
+            if (
+                !withReadonly &&
+                fieldName in this.activeFields &&
+                this._isReadonly(fieldName) &&
+                !this.activeFields[fieldName].forceSave
+            ) {
+                continue;
+            }
+            if (field.relatedPropertyField) {
+                continue;
+            }
+            if (field.type === "one2many" || field.type === "many2many") {
+                const commands = value._getCommands({ withReadonly });
+                result[fieldName] = commands;
+            } else {
+                result[fieldName] = this._formatServerValue(field.type, value);
+            }
+        }
+        return result;
+    }
+
+    _getDefaultValues(fieldNames = this.fieldNames) {
+        const defaultValues = {};
+        for (const fieldName of fieldNames) {
+            switch (this.fields[fieldName].type) {
+                case "integer":
+                case "float":
+                case "monetary":
+                    defaultValues[fieldName] = fieldName === "id" ? false : 0;
+                    break;
+                case "one2many":
+                case "many2many":
+                    defaultValues[fieldName] = [];
+                    break;
+                default:
+                    defaultValues[fieldName] = false;
+            }
+        }
+        return defaultValues;
+    }
+
+    _isInvisible(fieldName) {
+        const invisible = this.activeFields[fieldName].invisible;
+        return invisible ? evalDomain(invisible, this.evalContext) : false;
+    }
+
+    _isReadonly(fieldName) {
+        const readonly = this.activeFields[fieldName].readonly;
+        return readonly ? evalDomain(readonly, this.evalContext) : false;
+    }
+
+    _isRequired(fieldName) {
+        const required = this.activeFields[fieldName].required;
+        return required ? evalDomain(required, this.evalContext) : false;
+    }
+
+    async _load(nextConfig = {}) {
+        if ("resId" in nextConfig && this.resId) {
+            throw new Error("Cannot change resId of a record");
+        }
+        await this.model._updateConfig(this.config, nextConfig, {
+            commit: (values) => {
+                if (this.resId) {
+                    this.model._updateSimilarRecords(this, values);
+                }
+                this._setData(values);
+            },
+        });
+    }
+
+    _parseServerValues(serverValues, currentValues = {}) {
+        const parsedValues = {};
+        if (!serverValues) {
+            return parsedValues;
+        }
+        for (const fieldName in serverValues) {
+            const value = serverValues[fieldName];
+            if (!this.activeFields[fieldName]) {
+                continue;
+            }
+            const field = this.fields[fieldName];
+            if (field.type === "one2many" || field.type === "many2many") {
+                let staticList = currentValues[fieldName];
+                let valueIsCommandList = true;
+                // value can be a list of records or a list of commands (new record)
+                valueIsCommandList = value.length > 0 && Array.isArray(value[0]);
+                if (!staticList) {
+                    let data = valueIsCommandList ? [] : value;
+                    if (data.length > 0 && typeof data[0] === "number") {
+                        data = data.map((resId) => {
+                            return { id: resId };
+                        });
+                    }
+                    staticList = this._createStaticListDatapoint(data, fieldName);
+                }
+                if (valueIsCommandList) {
+                    staticList._applyCommands(value);
+                }
+                parsedValues[fieldName] = staticList;
+            } else {
+                parsedValues[fieldName] = parseServerValue(field, value);
+                if (field.type === "properties") {
+                    for (const property of parsedValues[fieldName]) {
+                        const fieldPropertyName = `${fieldName}.${property.name}`;
+                        if (property.type === "one2many" || property.type === "many2many") {
+                            const staticList = this._createStaticListDatapoint(
+                                property.value.map((record) => ({
+                                    id: record[0],
+                                    display_name: record[1],
+                                })),
+                                fieldPropertyName
+                            );
+                            parsedValues[fieldPropertyName] = staticList;
+                        } else if (property.type === "many2one") {
+                            parsedValues[fieldPropertyName] =
+                                property.value.length && property.value[1] === null
+                                    ? [property.value[0], this.model.env._t("No Access")]
+                                    : property.value;
+                        } else {
+                            parsedValues[fieldPropertyName] = property.value ?? false;
+                        }
+                    }
+                }
+            }
+        }
+        return parsedValues;
+    }
+
+    async _preprocessChanges(changes) {
+        await Promise.all([
+            this._preprocessMany2oneChanges(changes),
+            this._preprocessReferenceChanges(changes),
+        ]);
+    }
+
+    async _preprocessReferenceChanges(changes) {
+        const proms = [];
+        for (const [fieldName, value] of Object.entries(changes)) {
+            if (this.fields[fieldName].type !== "reference") {
+                continue;
+            }
+            if (!value) {
+                changes[fieldName] = false;
+                continue;
+            }
+            const id = value.resId;
+            const displayName = value.displayName;
+            if (!id && !displayName) {
+                changes[fieldName] = false;
+                continue;
+            }
+            const context = getFieldContext(this, fieldName);
+
+            if (!id && displayName !== undefined) {
+                proms.push(
+                    this.model.orm
+                        .call(value.resModel, "name_create", [displayName], {
+                            context,
+                        })
+                        .then((result) => {
+                            changes[fieldName] = result
+                                ? {
+                                      resModel: value.resModel,
+                                      resId: result[0],
+                                      displayName,
+                                  }
+                                : false;
+                        })
+                );
+            } else if (id && displayName === undefined) {
+                const kwargs = {
+                    context,
+                    specification: { display_name: {} },
+                };
+                proms.push(
+                    this.model.orm
+                        .call(value.resModel, "web_read", [[id]], kwargs)
+                        .then((records) => {
+                            changes[fieldName] = {
+                                resModel: value.resModel,
+                                resId: id,
+                                displayName: records[0].display_name,
+                            };
+                        })
+                );
+            } else {
+                changes[fieldName] = value;
+            }
+        }
+        return Promise.all(proms);
+    }
+
+    async _preprocessMany2oneChanges(changes) {
+        const proms = [];
+        for (const [fieldName, value] of Object.entries(changes)) {
+            if (this.fields[fieldName].type !== "many2one") {
+                continue;
+            }
+            if (!value) {
+                changes[fieldName] = false;
+                continue;
+            }
+            const [id, displayName] = value;
+            if (!id && !displayName) {
+                changes[fieldName] = [false, ""];
+                continue;
+            }
+
+            const activeField = this.activeFields[fieldName];
+
+            if (!activeField) {
+                changes[fieldName] = value;
+                continue;
+            }
+
+            const relation = this.fields[fieldName].relation;
+            const context = getFieldContext(this, fieldName);
+
+            if (!id && displayName !== undefined) {
+                proms.push(
+                    this.model.orm
+                        .call(relation, "name_create", [displayName], {
+                            context,
+                        })
+                        .then((result) => {
+                            changes[fieldName] = result ? result : [false, ""];
+                        })
+                );
+            } else if (id && displayName === undefined) {
+                const kwargs = {
+                    context,
+                    specification: { display_name: {} },
+                };
+                proms.push(
+                    this.model.orm.call(relation, "web_read", [[id]], kwargs).then((records) => {
+                        changes[fieldName] = [records[0].id, records[0].display_name || ""];
+                    })
+                );
+            } else {
+                changes[fieldName] = value;
+            }
+        }
+        return Promise.all(proms);
+    }
+
+    _removeInvalidFields(fieldNames) {
+        for (const fieldName of fieldNames) {
+            this._invalidFields.delete(fieldName);
+        }
+    }
+
+    async _save({ noReload, onError } = {}) {
+        // before saving, abandon new invalid, untouched records in x2manys
+        for (const fieldName in this.activeFields) {
+            if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
+                this.data[fieldName]._abandonRecords();
+            }
+        }
+        if (!this._checkValidity()) {
+            this.openInvalidFieldsNotification();
+            return false;
+        }
+        const changes = this._getChanges();
+        const creation = !this.resId;
+        delete changes.id; // id never changes, and should not be written
+        if (!creation && !Object.keys(changes).length) {
+            return true;
+        }
+        const canProceed = await this.model.hooks.onWillSaveRecord(this, changes);
+        if (canProceed === false) {
+            return false;
+        }
+        const kwargs = { context: this.context };
+        let resId = this.resId;
+        try {
+            if (creation) {
+                [resId] = await this.model.orm.create(this.resModel, [changes], kwargs);
+            } else {
+                await this.model.orm.write(this.resModel, [resId], changes, kwargs);
+            }
+        } catch (e) {
+            if (onError) {
+                return onError(e, { discard: () => this._discard() });
+            }
+            if (!this.isInEdition) {
+                const nextConfig = {};
+                if (creation) {
+                    nextConfig.resId = resId;
+                }
+                await this._load(nextConfig);
+            }
+            throw e;
+        }
+        if (!noReload) {
+            const nextConfig = {};
+            if (creation) {
+                nextConfig.resId = resId;
+                nextConfig.resIds = this.resIds.concat([resId]);
+            }
+            await this._load(nextConfig);
+        } else {
+            this.model._updateConfig(this.config, { resId }, { noReload: true });
+            this._values = { ...this._values, ...this._changes };
+            if ("id" in this.activeFields) {
+                this._values.id = resId;
+            }
+            this._changes = {};
+            this.data = { ...this._values };
+            this.dirty = false;
+        }
+        await this.model.hooks.onRecordSaved(this, changes);
+        return true;
+    }
+
+    /**
+     * For owl reactivity, it's better to only update the keys inside the evalContext
+     * instead of replacing the evalContext itself, because a lot of components are
+     * registered to the evalContext (but not necessarily keys inside it), and would
+     * be uselessly re-rendered if we replace it by a brand new object.
+     */
+    _setEvalContext() {
+        Object.assign(this.evalContext, {
+            ...this.context,
+            active_id: this.resId || false,
+            active_ids: this.resId ? [this.resId] : [],
+            active_model: this.resModel,
+            current_company_id: this.model.company.currentCompany.id,
+            ...this._computeDataContext(),
+        });
+
+        for (const [fieldName, value] of Object.entries(toRaw(this.data))) {
+            if (
+                this.fields[fieldName].type === "one2many" ||
+                this.fields[fieldName].type === "many2many"
+            ) {
+                value._updateContext(getFieldContext(this, fieldName));
+            }
+        }
+    }
+
+    async _setInvalidField(fieldName) {
+        const canProceed = this.model.hooks.onWillSetInvalidField(this, fieldName);
+        if (canProceed === false) {
+            return;
+        }
+        if (this.selected && this.model.multiEdit && !this._invalidFields.has(fieldName)) {
+            await this.model.dialog.add(AlertDialog, {
+                body: _t("No valid record to save"),
+                confirm: async () => {
+                    await this.discard();
+                    this.switchMode("readonly");
+                },
+            });
+        }
+        this._invalidFields.add(fieldName);
+    }
+
+    _setTextValues(values) {
+        for (const fieldName in values) {
+            if (!this.activeFields[fieldName]) {
+                continue;
+            }
+            if (["char", "text", "html"].includes(this.fields[fieldName].type)) {
+                this._textValues[fieldName] = values[fieldName];
+            }
+        }
+    }
+
+    _switchMode(mode) {
+        this.model._updateConfig(this.config, { mode }, { noReload: true });
+        if (mode === "readonly") {
+            this._invalidFields.clear();
+        }
+    }
+
+    /**
+     * @param {boolean} state archive the records if true, otherwise unarchive them
+     */
+    async _toggleArchive(state) {
+        const method = state ? "action_archive" : "action_unarchive";
+        const action = await this.model.orm.call(this.resModel, method, [[this.resId]], {
+            context: this.context,
+        });
+        if (action && Object.keys(action).length) {
+            this.model.action.doAction(action, { onClose: () => this._load() });
+        } else {
+            return this._load();
+        }
+    }
+
+    async _update(changes, { withoutOnchange, withoutParentUpdate } = {}) {
+        this.dirty = true;
+        const prom = this._preprocessChanges(changes);
+        if (prom && !this.model._urgentSave) {
+            await prom;
+        }
+        if (this.selected && this.model.multiEdit) {
+            this._applyChanges(changes);
+            return this.model.root._multiSave(this);
+        }
+        for (const [fieldName, value] of Object.entries(changes)) {
+            const field = this.fields[fieldName];
+            if (field && field.relatedPropertyField) {
+                const propertyFieldName = field.relatedPropertyField.fieldName;
+                changes[propertyFieldName] = this.data[propertyFieldName].map((property) =>
+                    property.name === field.propertyName ? { ...property, value } : property
+                );
+            }
+        }
+        const onChangeFields = Object.keys(changes).filter(
+            (fieldName) => this.activeFields[fieldName] && this.activeFields[fieldName].onChange
+        );
+        if (onChangeFields.length && !this.model._urgentSave && !withoutOnchange) {
+            const localChanges = this._getChanges(
+                { ...this._changes, ...changes },
+                { withReadonly: true }
+            );
+            if (this.config.relationField) {
+                localChanges[this.config.relationField] = this._parentRecord._getChanges();
+                if (!this._parentRecord.isNew) {
+                    localChanges[this.config.relationField].id = this._parentRecord.resId;
+                }
+            }
+            const otherChanges = await this.model._onchange(this.config, {
+                changes: localChanges,
+                fieldNames: onChangeFields,
+                evalContext: this.evalContext,
+            });
+            Object.assign(changes, this._parseServerValues(otherChanges, this.data));
+        }
+        // changes inside the record set as value for a many2one field must trigger the onchange,
+        // but can't be considered as changes on the parent record, so here we detect if many2one
+        // fields really changed, and if not, we delete them from changes
+        for (const fieldName in changes) {
+            if (this.fields[fieldName].type === "many2one") {
+                const curVal = toRaw(this.data[fieldName]);
+                const nextVal = changes[fieldName];
+                if (curVal && nextVal && curVal[0] === nextVal[0] && curVal[1] === nextVal[1]) {
+                    delete changes[fieldName];
+                }
+            }
+        }
+        if (Object.keys(changes).length > 0) {
+            const initialChanges = pick(this._changes, ...Object.keys(changes));
+            this._applyChanges(changes);
+            try {
+                await this._onUpdate(changes, { withoutParentUpdate });
+            } catch (e) {
+                this._applyChanges(initialChanges);
+                throw e;
+            }
+            await this.model.hooks.onRecordChanged(this, this._getChanges());
+        }
+    }
+}
diff --git a/addons/web/static/src/model/relational_model/relational_model.js b/addons/web/static/src/model/relational_model/relational_model.js
new file mode 100644
index 00000000000..0bd767e91ac
--- /dev/null
+++ b/addons/web/static/src/model/relational_model/relational_model.js
@@ -0,0 +1,679 @@
+/* @odoo-module */
+// @ts-check
+
+import { EventBus, markRaw } from "@odoo/owl";
+import { makeContext } from "@web/core/context";
+import { Domain } from "@web/core/domain";
+import { WarningDialog } from "@web/core/errors/error_dialogs";
+import { registry } from "@web/core/registry";
+import { shallowEqual, unique } from "@web/core/utils/arrays";
+import { KeepLast, Mutex } from "@web/core/utils/concurrency";
+import { orderByToString } from "@web/search/utils/order_by";
+import { Model } from "../model";
+import { DynamicGroupList } from "./dynamic_group_list";
+import { DynamicRecordList } from "./dynamic_record_list";
+import { Group } from "./group";
+import { Record } from "./record";
+import { StaticList } from "./static_list";
+import {
+    getFieldsSpec,
+    createPropertyActiveField,
+    getAggregatesFromGroupData,
+    getDisplayNameFromGroupData,
+    getValueFromGroupData,
+    isRelational,
+} from "./utils";
+
+/**
+ * @typedef Params
+ * @property {Config} config
+ * @property {State} [state]
+ * @property {Hooks} [hooks]
+ * @property {number} [limit]
+ * @property {number} [countLimit]
+ * @property {number} [groupsLimit]
+ * @property {string[]} [defaultOrderBy]
+ * @property {string[]} [defaultGroupBy]
+ * @property {number} [maxGroupByDepth]
+ * @property {boolean} [multiEdit]
+ * @property {Object} [groupByInfo]
+ */
+
+/**
+ * @typedef Config
+ * @property {string} resModel
+ * @property {Object} fields
+ * @property {Object} activeFields
+ * @property {object} context
+ * @property {boolean} isMonoRecord
+ * @property {boolean} isRoot
+ * @property {Array} [domain]
+ * @property {Array} [groupBy]
+ * @property {Array} [orderBy]
+ * @property {number} [resId]
+ * @property {number[]} [resIds]
+ * @property {string} [mode]
+ * @property {number} [limit]
+ * @property {number} [offset]
+ * @property {number} [countLimit]
+ * @property {number} [groupsLimit]
+ * @property {Object} [groups]
+ * @property {boolean} [openGroupsByDefault]
+ */
+
+/**
+ * @typedef Hooks
+ * @property {Function} [onWillLoadRoot]
+ * @property {Function} [onWillSaveRecord]
+ * @property {Function} [onRecordSaved]
+ * @property {Function} [onWillSaveMulti]
+ * @property {Function} [onSavedMulti]
+ * @property {Function} [onWillSetInvalidField]
+ * @property {Function} [onRecordChanged]
+ */
+
+/**
+ * @typedef State
+ * @property {Config} config
+ * @property {Object} specialDataCaches
+ */
+
+const DEFAULT_HOOKS = {
+    onWillLoadRoot: () => {},
+    onWillSaveRecord: () => {},
+    onRecordSaved: () => {},
+    onWillSaveMulti: () => {},
+    onSavedMulti: () => {},
+    onWillSetInvalidField: () => {},
+    onRecordChanged: () => {},
+};
+
+export class FetchRecordError extends Error {
+    constructor(resIds) {
+        super(`Can't fetch record(s) ${resIds}. They might have been deleted.`);
+    }
+}
+
+export function fetchRecordErrorHandler(env, error, originalError) {
+    if (originalError instanceof FetchRecordError) {
+        env.services.notification.add(originalError.message, { sticky: true, type: "danger" });
+        return true;
+    }
+}
+const errorHandlerRegistry = registry.category("error_handlers");
+errorHandlerRegistry.add("fetchRecordErrorHandler", fetchRecordErrorHandler);
+
+export class RelationalModel extends Model {
+    static services = ["action", "company", "dialog", "notification", "orm", "rpc", "user"];
+    static Record = Record;
+    static Group = Group;
+    static DynamicRecordList = DynamicRecordList;
+    static DynamicGroupList = DynamicGroupList;
+    static StaticList = StaticList;
+    static DEFAULT_LIMIT = 80;
+    static DEFAULT_COUNT_LIMIT = 10000;
+    static DEFAULT_GROUP_LIMIT = 80;
+    static DEFAULT_OPEN_GROUP_LIMIT = 10;
+    static MAX_NUMBER_OPENED_GROUPS = 10;
+
+    /**
+     * @param {Params} params
+     */
+    setup(params, { action, company, dialog, notification, rpc, user }) {
+        this.action = action;
+        this.company = company;
+        this.dialog = dialog;
+        this.notification = notification;
+        this.rpc = rpc;
+        this.user = user;
+
+        this.bus = new EventBus();
+
+        this.keepLast = markRaw(new KeepLast());
+        this.mutex = markRaw(new Mutex());
+
+        /** @type {Config} */
+        this.config = {
+            isMonoRecord: false,
+            ...params.config,
+            isRoot: true,
+        };
+
+        /** @type {Hooks} */
+        this.hooks = Object.assign({}, DEFAULT_HOOKS, params.hooks);
+
+        this.initialLimit = params.limit || this.constructor.DEFAULT_LIMIT;
+        this.initialGroupsLimit = params.groupsLimit;
+        this.initialCountLimit = params.countLimit || this.constructor.DEFAULT_COUNT_LIMIT;
+        this.defaultOrderBy = params.defaultOrderBy;
+        this.defaultGroupBy = params.defaultGroupBy;
+        this.maxGroupByDepth = params.maxGroupByDepth;
+        this.groupByInfo = params.groupByInfo || {};
+        this.multiEdit = params.multiEdit;
+        this.activeIdsLimit = params.activeIdsLimit || Number.MAX_SAFE_INTEGER;
+        this.specialDataCaches = markRaw(params.state?.specialDataCaches || {});
+
+        this._urgentSave = false;
+    }
+
+    // -------------------------------------------------------------------------
+    // Public
+    // -------------------------------------------------------------------------
+
+    exportState() {
+        return {
+            config: this.config,
+            specialDataCaches: this.specialDataCaches,
+        };
+    }
+
+    hasData() {
+        return this.root.hasData;
+    }
+
+    /**
+     * @param {Object} [params={}]
+     * @param {Comparison | null} [params.comparison]
+     * @param {Context} [params.context]
+     * @param {DomainListRepr} [params.domain]
+     * @param {string[]} [params.groupBy]
+     * @param {Object[]} [params.orderBy]
+     * @returns {Promise<void>}
+     */
+    async load(params = {}) {
+        const config = this._getNextConfig(this.config, params);
+        const data = await this.keepLast.add(this._loadData(config));
+        this.root = this._createRoot(config, data);
+        this.config = config;
+    }
+
+    // -------------------------------------------------------------------------
+    // Protected
+    // -------------------------------------------------------------------------
+
+    _applyProperties(records, config) {
+        for (const record of records) {
+            for (const fieldName in record) {
+                const field = config.fields[fieldName];
+                if (fieldName !== "id" && field.type === "properties" && record[fieldName]) {
+                    const parent = record[field.definition_record];
+                    const relatedPropertyField = {
+                        fieldName,
+                    };
+                    if (parent) {
+                        relatedPropertyField.id = parent.id;
+                        relatedPropertyField.displayName = parent.display_name;
+                    }
+                    for (const property of record[fieldName]) {
+                        const propertyFieldName = `${fieldName}.${property.name}`;
+                        if (!config.fields[propertyFieldName]) {
+                            config.fields[propertyFieldName] = {
+                                ...property,
+                                name: propertyFieldName,
+                                relatedPropertyField,
+                                propertyName: property.name,
+                                relation: property.comodel,
+                            };
+                            config.activeFields[propertyFieldName] =
+                                createPropertyActiveField(property);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    _askChanges() {
+        const proms = [];
+        this.bus.trigger("NEED_LOCAL_CHANGES", { proms });
+        return Promise.all([...proms, this.mutex.getUnlockedDef()]);
+    }
+
+    /**
+     *
+     * @param {Config} config
+     * @param {*} data
+     * @returns {DataPoint}
+     */
+    _createRoot(config, data) {
+        if (config.isMonoRecord) {
+            return new this.constructor.Record(this, config, data);
+        }
+        if (config.groupBy.length) {
+            return new this.constructor.DynamicGroupList(this, config, data);
+        }
+        return new this.constructor.DynamicRecordList(this, config, data);
+    }
+
+    /**
+     * @param {*} params
+     * @returns {Config}
+     */
+    _getNextConfig(currentConfig, params) {
+        const currentGroupBy = currentConfig.groupBy;
+        const config = Object.assign({}, currentConfig);
+
+        config.context = "context" in params ? params.context : config.context;
+        if (currentConfig.isMonoRecord) {
+            config.resId = "resId" in params ? params.resId : config.resId;
+            config.resIds = "resIds" in params ? params.resIds : config.resIds;
+            if (!config.resId && config.mode !== "edit") {
+                config.mode = "edit";
+            }
+        } else {
+            config.domain = "domain" in params ? params.domain : config.domain;
+            config.comparison = "comparison" in params ? params.comparison : config.comparison;
+
+            // groupBy
+            config.groupBy = "groupBy" in params ? params.groupBy : config.groupBy;
+            // apply default groupBy if any
+            if (this.defaultGroupBy && !config.groupBy.length) {
+                config.groupBy = [this.defaultGroupBy];
+            }
+            // restrict the number of groupbys if requested
+            if (this.maxGroupByDepth) {
+                config.groupBy = config.groupBy.slice(0, this.maxGroupByDepth);
+            }
+
+            // orderBy
+            config.orderBy = "orderBy" in params ? params.orderBy : config.orderBy;
+            // re-apply previous orderBy if not given (or no order)
+            if (!config.orderBy.length) {
+                config.orderBy = currentConfig.orderBy || [];
+            }
+            // apply default order if no order
+            if (this.defaultOrderBy && !config.orderBy.length) {
+                config.orderBy = this.defaultOrderBy;
+            }
+
+            // keep current root config if any, if the groupBy parameter is the same
+            if (!shallowEqual(config.groupBy || [], currentGroupBy || [])) {
+                delete config.groups;
+            }
+        }
+        if (!config.isMonoRecord && this.root) {
+            // always reset the offset to 0 when reloading from above
+            config.offset = 0;
+        }
+
+        return config;
+    }
+
+    /**
+     *
+     * @param {Config} config
+     */
+    async _loadData(config) {
+        if (config.isRoot) {
+            this.hooks.onWillLoadRoot();
+        }
+        if (config.isMonoRecord) {
+            const evalContext = {
+                ...config.context,
+                active_id: config.resId,
+                active_ids: [config.resId],
+                active_model: config.resModel,
+                current_company_id: this.company.currentCompany.id,
+            };
+            if (!config.resId) {
+                return this._loadNewRecord(config, { evalContext });
+            }
+
+            const records = await this._loadRecords(
+                {
+                    ...config,
+                    resIds: [config.resId],
+                },
+                evalContext
+            );
+            return records[0];
+        }
+        if (config.resIds) {
+            // static list
+            const resIds = config.resIds.slice(config.offset, config.offset + config.limit);
+            return this._loadRecords({ ...config, resIds });
+        }
+        if (config.groupBy.length) {
+            return this._loadGroupedList(config);
+        }
+        Object.assign(config, {
+            limit: config.limit || this.initialLimit,
+            countLimit: "countLimit" in config ? config.countLimit : this.initialCountLimit,
+            offset: config.offset || 0,
+        });
+        if (config.countLimit !== Number.MAX_SAFE_INTEGER) {
+            config.countLimit = Math.max(config.countLimit, config.offset + config.limit);
+        }
+        return this._loadUngroupedList({
+            ...config,
+            context: {
+                ...config.context,
+                current_company_id: this.company.currentCompany.id,
+            },
+        });
+    }
+
+    /**
+     * @param {Config} config
+     */
+    async _loadGroupedList(config) {
+        config.offset = config.offset || 0;
+        config.limit = config.limit || this.initialGroupsLimit;
+        if (!config.limit) {
+            config.limit = config.openGroupsByDefault
+                ? this.constructor.DEFAULT_OPEN_GROUP_LIMIT
+                : this.constructor.DEFAULT_GROUP_LIMIT;
+        }
+        config.groups = config.groups || {};
+        const firstGroupByName = config.groupBy[0].split(":")[0];
+        const orderBy = config.orderBy.filter(
+            (o) =>
+                o.name === firstGroupByName ||
+                (o.name in config.activeFields &&
+                    config.fields[o.name].group_operator !== undefined)
+        );
+        const response = await this._webReadGroup(config, firstGroupByName, orderBy);
+        const { groups, length } = response;
+        const groupBy = config.groupBy.slice(1);
+        const groupByField = config.fields[config.groupBy[0].split(":")[0]];
+        const commonConfig = {
+            resModel: config.resModel,
+            fields: config.fields,
+            activeFields: config.activeFields,
+        };
+        let groupRecordConfig;
+        const groupRecordResIds = [];
+        if (this.groupByInfo[firstGroupByName]) {
+            groupRecordConfig = {
+                ...this.groupByInfo[firstGroupByName],
+                resModel: config.fields[firstGroupByName].relation,
+                context: {},
+            };
+        }
+        const proms = [];
+        let nbOpenGroups = 0;
+        for (const group of groups) {
+            // When group_by_no_leaf key is present FIELD_ID_count doesn't exist
+            // we have to get the count from `__count` instead
+            // see _read_group_raw in models.py
+            group.count = group.__count || group[`${firstGroupByName}_count`];
+            group.length = group.count;
+            group.range = group.__range ? group.__range[config.groupBy[0]] : null;
+            delete group.__count;
+            delete group[`${firstGroupByName}_count`];
+            delete group.__range;
+            group.value = getValueFromGroupData(group, groupByField, group[config.groupBy[0]]);
+            group.displayName = getDisplayNameFromGroupData(groupByField, group[config.groupBy[0]]);
+            group.aggregates = getAggregatesFromGroupData(group, config.fields);
+            // delete group[config.groupBy[0]];
+            if (!config.groups[group.value]) {
+                config.groups[group.value] = {
+                    ...commonConfig,
+                    groupByFieldName: groupByField.name,
+                    isFolded: "__fold" in group ? group.__fold : !config.openGroupsByDefault,
+                    extraDomain: false,
+                    value: group.value,
+                    list: {
+                        ...commonConfig,
+                        groupBy,
+                    },
+                };
+                if (groupRecordConfig) {
+                    config.groups[group.value].record = {
+                        ...groupRecordConfig,
+                        resId: group.value ?? false,
+                    };
+                }
+            }
+            if (groupRecordConfig) {
+                const resId = config.groups[group.value].record.resId;
+                if (resId) {
+                    groupRecordResIds.push(resId);
+                }
+            }
+            const groupConfig = config.groups[group.value];
+            groupConfig.list.orderBy = config.orderBy;
+            groupConfig.initialDomain = group.__domain;
+            if (groupConfig.extraDomain) {
+                groupConfig.list.domain = Domain.and([
+                    group.__domain,
+                    groupConfig.extraDomain,
+                ]).toList();
+            } else {
+                groupConfig.list.domain = group.__domain;
+            }
+            const context = {
+                ...config.context,
+                [`default_${firstGroupByName}`]: group.value,
+            };
+            groupConfig.list.context = context;
+            groupConfig.context = context;
+            if (groupBy.length) {
+                group.groups = [];
+            } else {
+                group.records = [];
+            }
+            if (isRelational(config.fields[firstGroupByName]) && !group.value) {
+                groupConfig.isFolded = true;
+            }
+            if (!groupConfig.isFolded) {
+                nbOpenGroups++;
+                if (nbOpenGroups > this.constructor.MAX_NUMBER_OPENED_GROUPS) {
+                    groupConfig.isFolded = true;
+                }
+            }
+            if (!groupConfig.isFolded && group.count > 0) {
+                const prom = this._loadData(groupConfig.list).then((response) => {
+                    if (groupBy.length) {
+                        group.groups = response ? response.groups : [];
+                    } else {
+                        group.records = response ? response.records : [];
+                    }
+                });
+                proms.push(prom);
+            }
+        }
+        if (groupRecordConfig && Object.keys(groupRecordConfig.activeFields).length) {
+            const prom = this._loadRecords({
+                ...groupRecordConfig,
+                resIds: groupRecordResIds,
+            }).then((records) => {
+                for (const group of groups) {
+                    group.values = records.find((r) => group.value && r.id === group.value);
+                }
+            });
+            proms.push(prom);
+        }
+        await Promise.all(proms);
+
+        // if a group becomes empty at some point (e.g. we dragged its last record out of it), and the view is reloaded
+        // with the same domain and groupbys, we want to keep the empty group in the UI
+        if (
+            config.currentGroups &&
+            config.currentGroups.params ===
+                JSON.stringify([config.domain, config.groupBy, config.offset, config.limit])
+        ) {
+            const currentGroups = config.currentGroups.groups;
+            for (const group of currentGroups) {
+                if (
+                    config.groups[group.value] &&
+                    !groups.some((g) => JSON.stringify(g.value) === JSON.stringify(group.value))
+                ) {
+                    groups.push(Object.assign({}, group, { count: 0, length: 0, records: [] }));
+                }
+            }
+        }
+        config.currentGroups = {
+            params: JSON.stringify([config.domain, config.groupBy, config.offset, config.limit]),
+            groups,
+        };
+
+        return { groups, length };
+    }
+
+    /**
+     * @param {Config} config
+     * @param {Object} [params={}]
+     * @returns Promise<Object>
+     */
+    _loadNewRecord(config, params = {}) {
+        return this._onchange(config, params);
+    }
+
+    /**
+     *
+     * @param {Config} config
+     * @param {object} evalContext
+     * @returns
+     */
+    async _loadRecords(config, evalContext = config.context) {
+        const { resModel, resIds, activeFields, fields, context } = config;
+        if (!resIds.length) {
+            return [];
+        }
+        const fieldSpec = getFieldsSpec(activeFields, fields, evalContext);
+        if (Object.keys(fieldSpec).length > 0) {
+            const kwargs = {
+                context: { bin_size: true, ...context },
+                specification: fieldSpec,
+            };
+            const records = await this.orm.call(resModel, "web_read", [resIds], kwargs);
+            if (!records.length) {
+                throw new FetchRecordError(resIds);
+            }
+
+            this._applyProperties(records, config);
+            return records;
+        } else {
+            return resIds.map((resId) => {
+                return { id: resId };
+            });
+        }
+    }
+
+    /**
+     * Load records from the server for an ungrouped list. Return the result
+     * of unity read RPC.
+     *
+     * @param {Config} config
+     * @returns
+     */
+    async _loadUngroupedList(config) {
+        const kwargs = {
+            specification: getFieldsSpec(config.activeFields, config.fields, config.context),
+            domain: config.domain,
+            offset: config.offset,
+            order: orderByToString(config.orderBy),
+            limit: config.limit,
+            context: { bin_size: true, ...config.context },
+            count_limit:
+                config.countLimit !== Number.MAX_SAFE_INTEGER ? config.countLimit + 1 : undefined,
+        };
+        const response = await this.orm.call(config.resModel, "unity_web_search_read", [], kwargs);
+
+        this._applyProperties(response.records, config);
+        return response;
+    }
+
+    /**
+     * @param {Config} config
+     * @param {Object} param
+     * @param {Object} [param.changes={}]
+     * @param {string[]} [param.fieldNames=[]]
+     * @param {Object} [param.evalContext=config.context]
+     * @returns Promise<Object>
+     */
+    async _onchange(config, { changes = {}, fieldNames = [], evalContext = config.context }) {
+        const { fields, activeFields, resModel, resId } = config;
+        let context = config.context;
+        if (fieldNames.length === 1) {
+            const fieldContext = config.activeFields[fieldNames[0]].context;
+            context = makeContext([context, fieldContext], evalContext);
+        }
+        const spec = getFieldsSpec(activeFields, fields, evalContext, { withInvisible: true });
+        const args = [resId ? [resId] : [], changes, fieldNames, spec];
+        const response = await this.orm.call(resModel, "onchange2", args, { context });
+        if (response.warning) {
+            const { type, title, message, className, sticky } = response.warning;
+            if (type === "dialog") {
+                this.dialog.add(WarningDialog, { title, message });
+            } else {
+                this.notification.add(message, {
+                    className,
+                    sticky,
+                    title,
+                    type: "warning",
+                });
+            }
+        }
+        return response.value;
+    }
+
+    /**
+     *
+     * @param {Config} config
+     * @param {Partial<Config>} patch
+     * @param {Object} [options]
+     * @param {boolean} [options.noReload=false]
+     * @param {Function} [options.commit] Function to call once the data has been loaded
+     */
+    async _updateConfig(config, patch, options = {}) {
+        const tmpConfig = { ...config, ...patch };
+        let data;
+        if (!options.noReload) {
+            data = await this._loadData(tmpConfig);
+        }
+        Object.assign(config, tmpConfig);
+        if (data && options.commit) {
+            options.commit(data);
+        }
+    }
+
+    /**
+     *
+     * @param {Config} config
+     * @returns {Promise<number>}
+     */
+    async _updateCount(config) {
+        const count = await this.keepLast.add(this.orm.searchCount(config.resModel, config.domain));
+        config.countLimit = Number.MAX_SAFE_INTEGER;
+        return count;
+    }
+
+    /**
+     * When grouped by a many2many field, the same record may be displayed in
+     * several groups. When one of these records is edited, we want all other
+     * occurrences to be updated. The purpose of this function is to find and
+     * update all occurrences of a record that has been reloaded, in a grouped
+     * list view.
+     */
+    _updateSimilarRecords(reloadedRecord, serverValues) {
+        if (this.config.isMonoRecord || !this.config.groupBy.length) {
+            return;
+        }
+        for (const record of this.root.records) {
+            if (record === reloadedRecord) {
+                continue;
+            }
+            if (record.resId === reloadedRecord.resId) {
+                record._applyValues(serverValues);
+            }
+        }
+    }
+
+    async _webReadGroup(config, firstGroupByName, orderBy) {
+        return this.orm.webReadGroup(
+            config.resModel,
+            config.domain,
+            unique([...Object.keys(config.activeFields), firstGroupByName]),
+            [config.groupBy[0]],
+            {
+                orderby: orderByToString(orderBy),
+                lazy: true, // maybe useless
+                offset: config.offset,
+                limit: config.limit,
+                context: config.context,
+            }
+        );
+    }
+}
diff --git a/addons/web/static/src/model/relational_model/static_list.js b/addons/web/static/src/model/relational_model/static_list.js
new file mode 100644
index 00000000000..0cf8be6ef40
--- /dev/null
+++ b/addons/web/static/src/model/relational_model/static_list.js
@@ -0,0 +1,935 @@
+/* @odoo-module */
+
+import { x2ManyCommands } from "@web/core/orm_service";
+import { intersection } from "@web/core/utils/arrays";
+import { pick } from "@web/core/utils/objects";
+import { DataPoint } from "./datapoint";
+import { fromUnityToServerValues, getId, patchActiveFields } from "./utils";
+
+import { markRaw } from "@odoo/owl";
+
+function compareFieldValues(v1, v2, fieldType) {
+    if (fieldType === "many2one") {
+        v1 = v1 ? v1[1] : "";
+        v2 = v2 ? v2[1] : "";
+    }
+    return v1 < v2;
+}
+
+function compareRecords(r1, r2, orderBy, fields) {
+    const { name, asc } = orderBy[0];
+    const v1 = asc ? r1.data[name] : r2.data[name];
+    const v2 = asc ? r2.data[name] : r1.data[name];
+    if (compareFieldValues(v1, v2, fields[name].type)) {
+        return -1;
+    }
+    if (compareFieldValues(v2, v1, fields[name].type)) {
+        return 1;
+    }
+    if (orderBy.length > 1) {
+        return compareRecords(r1, r2, orderBy.slice(1), fields);
+    }
+    return 0;
+}
+
+export class StaticList extends DataPoint {
+    static type = "StaticList";
+
+    /**
+     * @param {import("./relational_model").Config} config
+     * @param {Object} data
+     * @param {Object} [options={}]
+     * @param {Function} [options.onUpdate]
+     * @param {Record} [options.parent]
+     */
+    setup(config, data, options = {}) {
+        this._parent = options.parent;
+        this._onUpdate = options.onUpdate;
+
+        this._cache = markRaw({});
+        this._commands = [];
+        this._savePoint = markRaw({});
+        this._unknownRecordCommands = {}; // tracks update commands on records we haven't fetched yet
+        this._currentIds = [...this.resIds];
+        this._needsReordering = false;
+        this._tmpIncreaseLimit = 0;
+        // In kanban and non editable list views, x2many records can be opened in a form view in
+        // dialog, which may contain other fields than the kanban or list view. The next set keeps
+        // tracks of records we already opened in dialog and thus for which we already modified the
+        // config to add the form view's fields in activeFields.
+        this._extendedRecords = new Set();
+
+        this.records = data
+            .slice(this.offset, this.limit)
+            .map((r) => this._createRecordDatapoint(r));
+        this.count = this.resIds.length;
+        this.handleField = Object.keys(this.activeFields).find(
+            (fieldName) => this.activeFields[fieldName].isHandle
+        );
+    }
+
+    // -------------------------------------------------------------------------
+    // Getters
+    // -------------------------------------------------------------------------
+
+    get currentIds() {
+        return this._currentIds;
+    }
+
+    get editedRecord() {
+        return this.records.find((record) => record.isInEdition);
+    }
+
+    get evalContext() {
+        return {
+            ...this.config.context,
+            parent: this._parent.evalContext,
+        };
+    }
+
+    get limit() {
+        return this.config.limit;
+    }
+
+    get offset() {
+        return this.config.offset;
+    }
+
+    get orderBy() {
+        return this.config.orderBy;
+    }
+
+    get resIds() {
+        return this.config.resIds;
+    }
+
+    // -------------------------------------------------------------------------
+    // Public
+    // -------------------------------------------------------------------------
+
+    /**
+     * Adds a new record to an x2many relation. If params.record is given, adds
+     * given record (use case: after saving the form dialog in a, e.g., non
+     * editable x2many list). Otherwise, do an onchange to get the initial
+     * values and create a new Record (e.g. after clicking on Add a line in an
+     * editable x2many list).
+     *
+     * @param {Object} params
+     * @param {"top"|"bottom"} [params.position]
+     * @param {Object} [params.activeFields=this.activeFields]
+     * @param {boolean} [params.withoutParent=false]
+     */
+    addNewRecord(params) {
+        return this.model.mutex.exec(async () => {
+            const { activeFields, context, mode, position, withoutParent } = params;
+            const record = await this._createNewRecordDatapoint({
+                activeFields,
+                context,
+                position,
+                withoutParent,
+                manuallyAdded: true,
+                mode,
+            });
+            await this._addRecord(record, { position });
+            await this._onUpdate({ withoutOnchange: !record._checkValidity({ silent: true }) });
+            return record;
+        });
+    }
+
+    canResequence() {
+        return this.handleField && this.orderBy.length && this.orderBy[0].name === this.handleField;
+    }
+
+    /**
+     * TODO: We should probably delete this function.
+     * It is only used for the product configurator.
+     * It will take a list of contexts containing default
+     * values used to create the new records in the static list.
+     * It will then delete the old records from the static list
+     * and replace them with the new ones we have just created.
+     */
+    createAndReplace(contextRecords) {
+        return this.model.mutex.exec(async () => {
+            const proms = [];
+            for (const context of contextRecords) {
+                proms.push(
+                    this._createNewRecordDatapoint({
+                        context,
+                        manuallyAdded: true,
+                    })
+                );
+            }
+            this.records = await Promise.all(proms);
+            this._commands = this.records.map((record) => [
+                x2ManyCommands.CREATE,
+                record._virtualId,
+            ]);
+            this._currentIds = this.records.map((record) => record._virtualId);
+        });
+    }
+
+    delete(record) {
+        return this.model.mutex.exec(async () => {
+            await this._applyCommands([[x2ManyCommands.DELETE, record.resId || record._virtualId]]);
+            await this._onUpdate();
+        });
+    }
+
+    async enterEditMode(record) {
+        const canProceed = await this.leaveEditMode();
+        if (canProceed) {
+            await record.switchMode("edit");
+        }
+        return canProceed;
+    }
+
+    /**
+     * This method is meant to be used in a very specific usecase: when an x2many record is viewed
+     * or edited through a form view dialog (e.g. x2many kanban or non editable list). In this case,
+     * the form typically contains different fields than the kanban or list, so we need to "extend"
+     * the fields and activeFields. If the record opened in a form view dialog already exists, we
+     * modify it's config to add the new fields. If it is a new record, we create it with the
+     * extended config.
+     *
+     * @param {Object} params
+     * @param {Object} params.activeFields
+     * @param {Object} params.fields
+     * @param {Object} [params.context]
+     * @param {boolean} [params.withoutParent]
+     * @param {Record} [record]
+     * @returns {Record}
+     */
+    extendRecord(params, record) {
+        return this.model.mutex.exec(async () => {
+            // extend fields and activeFields of the list with those given in params
+            Object.assign(this.fields, params.fields);
+            const activeFields = { ...params.activeFields };
+            for (const fieldName in this.activeFields) {
+                if (fieldName in activeFields) {
+                    patchActiveFields(activeFields[fieldName], this.activeFields[fieldName]);
+                } else {
+                    activeFields[fieldName] = this.activeFields[fieldName];
+                }
+            }
+
+            if (record) {
+                // case 1: the record already exists
+                if (this._extendedRecords.has(record.id)) {
+                    // case 1.1: the record has already been extended
+                    // -> simply switch it to edit and store a savepoint
+                    record._switchMode("edit");
+                    record._addSavePoint();
+                    return record;
+                }
+                // case 1.2: the record is extended for the first time, and it now potentially has
+                // more fields than before (or x2many fields displayed differently)
+                // -> if it isn't a new record, load it to retrieve the values of new fields
+                // -> generate default values for new fields
+                // -> recursively update the config of the record and it's sub datapoints
+                // -> apply the loaded values in the case of a not new record
+                // -> store a savepoint
+                // These operations must be done in that specific order to ensure that the model is
+                // mutated only once (in a tick), and that datapoints have the correct config to
+                // handle field values they receive.
+                const config = {
+                    ...record.config,
+                    ...params,
+                    activeFields,
+                };
+                let data = {};
+                if (!record.isNew) {
+                    const evalContext = Object.assign({}, record.evalContext, config.context);
+                    const resIds = [record.resId];
+                    [data] = await this.model._loadRecords({ ...config, resIds }, evalContext);
+                }
+                this.model._updateConfig(record.config, config, { noReload: true });
+                record._applyDefaultValues();
+                for (const fieldName in record.activeFields) {
+                    if (["one2many", "many2many"].includes(record.fields[fieldName].type)) {
+                        if (activeFields[fieldName].related) {
+                            const list = record.data[fieldName];
+                            const patch = {
+                                activeFields: activeFields[fieldName].related.activeFields,
+                                fields: activeFields[fieldName].related.fields,
+                            };
+                            for (const subRecord of Object.values(list._cache)) {
+                                this.model._updateConfig(subRecord.config, patch, {
+                                    noReload: true,
+                                });
+                            }
+                            this.model._updateConfig(list.config, patch, { noReload: true });
+                        }
+                    }
+                }
+                record._applyValues(data);
+                const commands = this._unknownRecordCommands[record.resId];
+                delete this._unknownRecordCommands[record.resId];
+                if (commands) {
+                    this._applyCommands(commands);
+                }
+                record._addSavePoint();
+            } else {
+                // case 2: the record is a new record
+                // -> simply create one with the extended config
+                record = await this._createNewRecordDatapoint({
+                    activeFields,
+                    context: params.context,
+                    withoutParent: params.withoutParent,
+                    manuallyAdded: true,
+                });
+            }
+
+            // mark the record as being extended, to go through case 1.1 next time
+            this._extendedRecords.add(record.id);
+
+            return record;
+        });
+    }
+
+    forget(record) {
+        return this.model.mutex.exec(async () => {
+            await this._applyCommands([[x2ManyCommands.FORGET, record.resId]]);
+            await this._onUpdate();
+        });
+    }
+
+    async leaveEditMode({ discard, canAbandon, validate } = {}) {
+        if (this.editedRecord) {
+            await this.model._askChanges(false);
+        }
+        return this.model.mutex.exec(async () => {
+            if (this.editedRecord) {
+                const isValid = this.editedRecord._checkValidity();
+                if (!isValid && validate) {
+                    return false;
+                }
+                if (canAbandon !== false && !validate) {
+                    this._abandonRecords([this.editedRecord], { force: true });
+                }
+                // if we still have an editedRecord, it means it hasn't been abandonned
+                if (this.editedRecord) {
+                    if (isValid && !this.editedRecord.dirty && discard) {
+                        return false;
+                    }
+                    if (
+                        isValid ||
+                        (!this.editedRecord.dirty && !this.editedRecord._manuallyAdded)
+                    ) {
+                        this.editedRecord._switchMode("readonly");
+                    }
+                }
+            }
+            return !this.editedRecord;
+        });
+    }
+
+    linkTo(resId, serverData) {
+        return this.model.mutex.exec(async () => {
+            await this._applyCommands([[x2ManyCommands.LINK_TO, resId, serverData]]);
+            await this._onUpdate();
+        });
+    }
+
+    load({ limit, offset, orderBy } = {}) {
+        return this.model.mutex.exec(async () => {
+            if (this.editedRecord && !(await this.editedRecord.checkValidity())) {
+                return;
+            }
+            limit = limit !== undefined ? limit : this.limit;
+            offset = offset !== undefined ? offset : this.offset;
+            orderBy = orderBy !== undefined ? orderBy : this.orderBy;
+            return this._load({ limit, offset, orderBy });
+        });
+    }
+
+    moveRecord(dataRecordId, _dataGroupId, refId, _targetGroupId) {
+        return this.resequence(dataRecordId, refId);
+    }
+
+    sortBy(fieldName) {
+        return this.model.mutex.exec(() => this._sortBy(fieldName));
+    }
+
+    async replaceWith(ids, { reload = false, silent = false } = {}) {
+        return this.model.mutex.exec(async () => {
+            const resIds = reload ? ids : ids.filter((id) => !this._cache[id]);
+            if (resIds.length) {
+                const records = await this.model._loadRecords({
+                    ...this.config,
+                    resIds,
+                    context: this.context,
+                });
+                for (const record of records) {
+                    this._createRecordDatapoint(record);
+                }
+            }
+            this.records = ids.map((id) => this._cache[id]);
+            const updateCommandsToKeep = this._commands.filter(
+                (c) => c[0] === x2ManyCommands.UPDATE && ids.includes(c[1])
+            );
+            this._commands = [x2ManyCommands.replaceWith(ids)].concat(updateCommandsToKeep);
+            this._currentIds = [...ids];
+            this.count = this._currentIds.length;
+            if (!silent) {
+                await this._onUpdate();
+            }
+        });
+    }
+
+    async resequence(movedId, targetId) {
+        return this.model.mutex.exec(() => this._resequence(movedId, targetId));
+    }
+
+    /**
+     * This method is meant to be called when a record, which has previously been extended to be
+     * displayed in a form view dialog (see @extendRecord) is saved. In this case, we may need to
+     * add this record to the list (if it is a new one), and to notify the parent record of the
+     * update. We may also want to sort the list.
+     *
+     * @param {Record} record
+     */
+    validateExtendedRecord(record) {
+        return this.model.mutex.exec(async () => {
+            if (!this._currentIds.includes(record.isNew ? record._virtualId : record.resId)) {
+                // new record created, not yet in the list
+                await this._addRecord(record);
+            } else if (!record.dirty) {
+                return;
+            }
+            await this._onUpdate();
+            if (this.orderBy.length) {
+                await this._sort();
+            }
+        });
+    }
+
+    // -------------------------------------------------------------------------
+    // Protected
+    // -------------------------------------------------------------------------
+
+    _abandonRecords(records = this.records, { force } = {}) {
+        for (const record of records) {
+            if (record.canBeAbandoned && (force || !record._checkValidity())) {
+                const virtualId = record._virtualId;
+                const index = this._currentIds.findIndex((id) => id === virtualId);
+                this._currentIds.splice(index, 1);
+                this.records.splice(
+                    this.records.findIndex((r) => r === record),
+                    1
+                );
+                this._commands = this._commands.filter((c) => c[1] !== virtualId);
+                this.count--;
+                if (this._tmpIncreaseLimit > 0) {
+                    this.model._updateConfig(
+                        this.config,
+                        { limit: this.limit - 1 },
+                        { noReload: true }
+                    );
+                    this._tmpIncreaseLimit--;
+                }
+            }
+        }
+    }
+
+    async _addRecord(record, { position } = {}) {
+        const command = [x2ManyCommands.CREATE, record._virtualId];
+        if (position === "top") {
+            this.records.unshift(record);
+            if (this.records.length > this.limit) {
+                this.records.pop();
+            }
+            this._currentIds.splice(this.offset, 0, record._virtualId);
+            this._commands.unshift(command);
+        } else if (position === "bottom") {
+            this.records.push(record);
+            this._currentIds.splice(this.offset + this.limit, 0, record._virtualId);
+            if (this.records.length > this.limit) {
+                this._tmpIncreaseLimit++;
+                const nextLimit = this.limit + 1;
+                this.model._updateConfig(this.config, { limit: nextLimit }, { noReload: true });
+            }
+            this._commands.push(command);
+        } else {
+            const currentIds = [...this._currentIds, record._virtualId];
+            if (this.orderBy.length) {
+                await this._sort(currentIds);
+            } else {
+                if (this.records.length < this.limit) {
+                    this.records.push(record);
+                }
+            }
+            this._currentIds = currentIds;
+            this._commands.push(command);
+        }
+        this.count++;
+        this._needsReordering = true;
+    }
+
+    _addSavePoint() {
+        for (const id in this._cache) {
+            this._cache[id]._addSavePoint();
+        }
+        this._savePoint._commands = [...this._commands];
+        this._savePoint._currentIds = [...this._currentIds];
+        this._savePoint.count = this.count;
+    }
+
+    _applyCommands(commands) {
+        const isOnLastPage = this.limit + this.offset >= this.count;
+        const { CREATE, UPDATE, DELETE, FORGET, LINK_TO, REPLACE_WITH } = x2ManyCommands;
+        for (const command of commands) {
+            switch (command[0]) {
+                case CREATE: {
+                    const virtualId = getId("virtual");
+                    const record = this._createRecordDatapoint(command[2], { virtualId });
+                    this.records.push(record);
+                    this._commands.push([CREATE, virtualId]);
+                    this._currentIds.splice(this.offset + this.limit, 0, virtualId);
+                    this.count++;
+                    break;
+                }
+                case UPDATE: {
+                    const existingCommand = this._commands.find((c) => {
+                        return (c[0] === CREATE || c[0] === UPDATE) && c[1] === command[1];
+                    });
+                    if (!existingCommand) {
+                        this._commands.push([UPDATE, command[1]]);
+                    }
+                    const record = this._cache[command[1]];
+                    if (!record) {
+                        // the record isn't in the cache, it means it is on a page we haven't loaded
+                        // so we say the record is "unknown", and store all update commands we
+                        // receive about it in a separated structure, s.t. we can easily apply them
+                        // later on after loading the record, if we ever load it.
+                        if (!(command[1] in this._unknownRecordCommands)) {
+                            this._unknownRecordCommands[command[1]] = [];
+                        }
+                        this._unknownRecordCommands[command[1]].push(command);
+                    } else if (command[1] in this._unknownRecordCommands) {
+                        // this case is more tricky: the record is in the cache, but it isn't loaded
+                        // yet, as we are currently loading it (see below, where we load missing
+                        // records for the current page)
+                        this._unknownRecordCommands[command[1]].push(command);
+                    } else {
+                        const changes = {};
+                        for (const fieldName in command[2]) {
+                            if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
+                                if (record.activeFields[fieldName].invisible) {
+                                    if (!(command[1] in this._unknownRecordCommands)) {
+                                        this._unknownRecordCommands[command[1]] = [];
+                                    }
+                                    this._unknownRecordCommands[command[1]].push(command);
+                                    continue;
+                                }
+                            }
+                            changes[fieldName] = command[2][fieldName];
+                        }
+                        record._applyChanges(record._parseServerValues(changes, record.data));
+                    }
+                    break;
+                }
+                case DELETE:
+                case FORGET: {
+                    if (command[0] === DELETE) {
+                        if (!this._commands.find((c) => c[0] === CREATE && c[1] === command[1])) {
+                            this._commands.push([DELETE, command[1]]);
+                        }
+                        this._commands = this._commands.filter((c) => {
+                            return !(c[0] === CREATE || c[0] === UPDATE) || c[1] !== command[1];
+                        });
+                    } else {
+                        // FORGET
+                        const replaceWithIndex = this._commands.findIndex(
+                            (c) => c[0] === REPLACE_WITH && c[2].includes(command[1])
+                        );
+                        if (replaceWithIndex >= 0) {
+                            const ids = this._commands[replaceWithIndex][2];
+                            this._commands[replaceWithIndex][2] = ids.filter(
+                                (id) => id !== command[1]
+                            );
+                        } else {
+                            const linkToIndex = this._commands.findIndex(
+                                (c) => c[0] === LINK_TO && c[1] === command[1]
+                            );
+                            if (linkToIndex >= 0) {
+                                this._commands.splice(linkToIndex, 1);
+                            } else {
+                                this._commands.push([FORGET, command[1]]);
+                            }
+                        }
+                    }
+                    const record = this._cache[command[1]];
+                    if (record) {
+                        const index = this.records.findIndex((r) => r.id === record.id);
+                        if (index >= 0) {
+                            this.records.splice(index, 1);
+                        }
+                    }
+                    const index = this._currentIds.findIndex((id) => id === command[1]);
+                    this._currentIds.splice(index, 1);
+                    this.count--;
+                    break;
+                }
+                case LINK_TO: {
+                    const record = this._createRecordDatapoint({ ...command[2], id: command[1] });
+                    if (!this.limit || this.records.length < this.limit) {
+                        this.records.push(record);
+                    }
+                    this._currentIds.push(record.resId);
+                    this._commands.push([command[0], command[1]]);
+                    this.count++;
+                    break;
+                }
+            }
+        }
+        // if we aren't on the last page, and *n* records of the current page have been removed
+        // removed, the first *n* records of the next page become the last *n* ones of the current
+        // page, so we need to add (and maybe load) them.
+        const nbMissingRecords = this.limit - this.records.length;
+        if (!isOnLastPage && nbMissingRecords > 0) {
+            const lastRecordIndex = this.limit + this.offset;
+            const firstRecordIndex = lastRecordIndex - nbMissingRecords;
+            const nextRecordIds = this._currentIds.slice(firstRecordIndex, lastRecordIndex);
+            const recordsToLoad = [];
+            for (const id of nextRecordIds) {
+                if (this._cache[id]) {
+                    this.records.push(this._cache[id]);
+                } else {
+                    // id isn't in the cache, so we know it's not a virtual id
+                    const record = this._createRecordDatapoint({ id }, { dontApplyCommands: true });
+                    this.records.push(record);
+                    recordsToLoad.push(record);
+                }
+            }
+            const resIds = recordsToLoad.map((r) => r.resId);
+            this.model._loadRecords({ ...this.config, resIds }).then((recordValues) => {
+                for (let i = 0; i < recordsToLoad.length; i++) {
+                    const record = recordsToLoad[i];
+                    record._applyValues(recordValues[i]);
+                    const commands = this._unknownRecordCommands[record.resId];
+                    if (commands) {
+                        delete this._unknownRecordCommands[record.resId];
+                        this._applyCommands(commands);
+                    }
+                }
+            });
+        }
+    }
+
+    async _createNewRecordDatapoint(params = {}) {
+        const changes = {};
+        if (!params.withoutParent && this.config.relationField) {
+            changes[this.config.relationField] = this._parent._getChanges();
+            if (!this._parent.isNew) {
+                changes[this.config.relationField].id = this._parent.resId;
+            }
+        }
+        const values = await this.model._loadNewRecord(
+            {
+                resModel: this.resModel,
+                activeFields: params.activeFields || this.activeFields,
+                fields: this.fields,
+                context: Object.assign({}, this.context, params.context),
+            },
+            { changes, evalContext: this.evalContext }
+        );
+
+        if (this.canResequence() && this.records.length) {
+            const position = params.position || "bottom";
+            const order = this.orderBy[0];
+            const asc = !order || order.asc;
+            let value;
+            if (position === "top") {
+                const isOnFirstPage = this.offset === 0;
+                value = this.records[0].data[this.handleField];
+                if (isOnFirstPage) {
+                    if (asc) {
+                        value = value > 0 ? value - 1 : 0;
+                    } else {
+                        value = value + 1;
+                    }
+                }
+            } else if (position === "bottom") {
+                value = this.records[this.records.length - 1].data[this.handleField];
+                const isOnLastPage = this.limit + this.offset >= this.count;
+                if (isOnLastPage) {
+                    if (asc) {
+                        value = value + 1;
+                    } else {
+                        value = value > 0 ? value - 1 : 0;
+                    }
+                }
+            }
+            values[this.handleField] = value;
+        }
+        return this._createRecordDatapoint(values, {
+            mode: params.mode || "edit",
+            virtualId: getId("virtual"),
+            activeFields: params.activeFields,
+            manuallyAdded: params.manuallyAdded,
+        });
+    }
+
+    _createRecordDatapoint(data, params = {}) {
+        const resId = data.id || false;
+        if (!resId && !params.virtualId) {
+            throw new Error("You must provide a virtualId if the record has no id");
+        }
+        const id = resId || params.virtualId;
+        const config = {
+            context: this.context,
+            activeFields: params.activeFields || this.activeFields,
+            resModel: this.resModel,
+            fields: params.fields || this.fields,
+            relationField: this.config.relationField,
+            resId,
+            resIds: resId ? [resId] : [],
+            mode: params.mode || "readonly",
+            isMonoRecord: true,
+        };
+        const { CREATE, UPDATE } = x2ManyCommands;
+        const options = {
+            parentRecord: this._parent,
+            onUpdate: async (changes, { withoutParentUpdate }) => {
+                if (!this.currentIds.includes(record.isNew ? record._virtualId : record.resId)) {
+                    // the record hasn't been added to the list yet (we're currently creating it
+                    // from a dialog)
+                    return;
+                }
+                const hasCommand = this._commands.some(
+                    (c) => (c[0] === CREATE || c[0] === UPDATE) && c[1] === id
+                );
+                if (!hasCommand) {
+                    this._commands.push([UPDATE, id]);
+                }
+                if (this._extendedRecords.has(record.id)) {
+                    // the record is edited from a dialog, so we don't want to notify the parent
+                    // record to be notified at each change inside the dialog (it will be notified
+                    // at the end when the dialog is saved)
+                    return;
+                }
+                if (!withoutParentUpdate) {
+                    await this._onUpdate({
+                        withoutOnchange: !record._checkValidity({ silent: true }),
+                    });
+                }
+            },
+            virtualId: params.virtualId,
+            manuallyAdded: params.manuallyAdded,
+        };
+        const record = new this.model.constructor.Record(this.model, config, data, options);
+        this._cache[id] = record;
+        if (!params.dontApplyCommands) {
+            const commands = this._unknownRecordCommands[id];
+            if (commands) {
+                delete this._unknownRecordCommands[id];
+                this._applyCommands(commands);
+            }
+        }
+        return record;
+    }
+
+    _discard() {
+        for (const id in this._cache) {
+            this._cache[id]._discard();
+        }
+        if (this._savePoint._commands) {
+            this._commands = this._savePoint._commands;
+            this._currentIds = this._savePoint._currentIds;
+            this.count = this._savePoint.count;
+            delete this._savePoint._commands;
+            delete this._savePoint._currentIds;
+            delete this._savePoint.count;
+        } else {
+            this._commands = [];
+            this._currentIds = [...this.resIds];
+            this.count = this.resIds.length;
+        }
+        this._unknownRecordCommands = [];
+        const limit = this.limit - this._tmpIncreaseLimit;
+        this._tmpIncreaseLimit = 0;
+        this.model._updateConfig(this.config, { limit }, { noReload: true });
+        this.records = this._currentIds
+            .slice(this.offset, this.limit)
+            .map((resId) => this._cache[resId]);
+    }
+
+    _getCommands({ withReadonly } = {}) {
+        const { CREATE, UPDATE } = x2ManyCommands;
+        const commands = [];
+        for (const command of this._commands) {
+            if (command[0] === UPDATE && command[1] in this._unknownRecordCommands) {
+                // the record has never been loaded, but we received update commands from the
+                // server for it, so we need to sanitize them (as they contained unity values)
+                const uCommands = this._unknownRecordCommands[command[1]];
+                for (const uCommand of uCommands) {
+                    const values = fromUnityToServerValues(
+                        uCommand[2],
+                        this.fields,
+                        this.activeFields
+                    );
+                    commands.push([uCommand[0], uCommand[1], values]);
+                }
+            } else if (command[0] === CREATE || command[0] === UPDATE) {
+                const record = this._cache[command[1]];
+                const values = record._getChanges(record._changes, { withReadonly });
+                if (command[0] === CREATE || Object.keys(values).length) {
+                    commands.push([command[0], command[1], values]);
+                }
+            } else {
+                commands.push(command);
+            }
+        }
+        return commands;
+    }
+
+    _getResIdsToLoad(resIds, fieldNames = this.fieldNames) {
+        return resIds.filter((resId) => {
+            if (typeof resId === "string") {
+                // this is a virtual id, we don't want to read it
+                return false;
+            }
+            const record = this._cache[resId];
+            if (!record) {
+                // record hasn't been loaded yet
+                return true;
+            }
+            // record has already been loaded -> check if we already read all orderBy fields
+            return intersection(fieldNames, record.fieldNames).length !== fieldNames.length;
+        });
+    }
+
+    async _load({
+        limit = this.limit,
+        offset = this.offset,
+        orderBy = this.orderBy,
+        nextCurrentIds = this._currentIds,
+    } = {}) {
+        const currentIds = nextCurrentIds.slice(offset, offset + limit);
+        const resIds = this._getResIdsToLoad(currentIds);
+        if (resIds.length) {
+            const records = await this.model._loadRecords(
+                { ...this.config, resIds },
+                this.evalContext
+            );
+            for (const record of records) {
+                this._createRecordDatapoint(record);
+            }
+        }
+        this.records = currentIds.map((id) => this._cache[id]);
+        this._currentIds = nextCurrentIds;
+        await this.model._updateConfig(this.config, { limit, offset, orderBy }, { noReload: true });
+    }
+
+    async _resequence(movedId, targetId) {
+        const records = [...this.records];
+        const order = this.orderBy.find((o) => o.name === this.handleField);
+        const asc = !order || order.asc;
+
+        // Find indices
+        const fromIndex = records.findIndex((r) => r.id === movedId);
+        let toIndex = 0;
+        if (targetId !== null) {
+            const targetIndex = records.findIndex((r) => r.id === targetId);
+            toIndex = fromIndex > targetIndex ? targetIndex + 1 : targetIndex;
+        }
+
+        const getSequence = (rec) => rec && rec.data[this.handleField];
+
+        // Determine what records need to be modified
+        const firstIndex = Math.min(fromIndex, toIndex);
+        const lastIndex = Math.max(fromIndex, toIndex) + 1;
+        let reorderAll = false;
+        let lastSequence = (asc ? -1 : 1) * Infinity;
+        for (let index = 0; index < records.length; index++) {
+            const sequence = getSequence(records[index]);
+            if (
+                ((index < firstIndex || index >= lastIndex) &&
+                    ((asc && lastSequence >= sequence) || (!asc && lastSequence <= sequence))) ||
+                (index >= firstIndex && index < lastIndex && lastSequence === sequence)
+            ) {
+                reorderAll = true;
+            }
+            lastSequence = sequence;
+        }
+
+        // Perform the resequence in the list of records
+        const [record] = records.splice(fromIndex, 1);
+        records.splice(toIndex, 0, record);
+
+        // Creates the list of to modify
+        let toReorder = records;
+        if (!reorderAll) {
+            toReorder = toReorder.slice(firstIndex, lastIndex).filter((r) => r.id !== movedId);
+            if (fromIndex < toIndex) {
+                toReorder.push(record);
+            } else {
+                toReorder.unshift(record);
+            }
+        }
+        if (!asc) {
+            toReorder.reverse();
+        }
+
+        const sequences = toReorder.map(getSequence);
+        const offset = sequences.length && Math.min(...sequences);
+
+        const proms = [];
+        for (const [i, record] of Object.entries(toReorder)) {
+            proms.push(
+                record._update(
+                    { [this.handleField]: offset + Number(i) },
+                    { withoutParentUpdate: true }
+                )
+            );
+        }
+        await Promise.all(proms);
+
+        await this._sort();
+        await this._onUpdate();
+    }
+
+    async _sort(currentIds = this.currentIds, orderBy = this.orderBy) {
+        const fieldNames = orderBy.map((o) => o.name);
+        const resIds = this._getResIdsToLoad(currentIds, fieldNames);
+        if (resIds.length) {
+            const activeFields = pick(this.activeFields, ...fieldNames);
+            const config = { ...this.config, resIds, activeFields };
+            const records = await this.model._loadRecords(config);
+            for (const record of records) {
+                this._createRecordDatapoint(record, { activeFields });
+            }
+        }
+        const allRecords = currentIds.map((id) => this._cache[id]);
+        const sortedRecords = allRecords.sort((r1, r2) => {
+            return compareRecords(r1, r2, orderBy, this.fields);
+        });
+        await this._load({
+            orderBy,
+            nextCurrentIds: sortedRecords.map((r) => r.resId || r._virtualId),
+        });
+        this._needsReordering = false;
+    }
+
+    async _sortBy(fieldName) {
+        let orderBy = [...this.orderBy];
+        if (fieldName) {
+            if (orderBy.length && orderBy[0].name === fieldName) {
+                if (!this._needsReordering) {
+                    orderBy[0] = { name: orderBy[0].name, asc: !orderBy[0].asc };
+                }
+            } else {
+                orderBy = orderBy.filter((o) => o.name !== fieldName);
+                orderBy.unshift({
+                    name: fieldName,
+                    asc: true,
+                });
+            }
+        }
+        return this._sort(this._currentIds, orderBy);
+    }
+
+    _updateContext(context) {
+        Object.assign(this.context, context);
+    }
+}
diff --git a/addons/web/static/src/model/relational_model/utils.js b/addons/web/static/src/model/relational_model/utils.js
new file mode 100644
index 00000000000..2e3f625d325
--- /dev/null
+++ b/addons/web/static/src/model/relational_model/utils.js
@@ -0,0 +1,523 @@
+/* @odoo-module */
+
+import { markup, onWillDestroy, onWillStart, onWillUpdateProps, useComponent } from "@odoo/owl";
+import { makeContext } from "@web/core/context";
+import { deserializeDate, deserializeDateTime } from "@web/core/l10n/dates";
+import { x2ManyCommands } from "@web/core/orm_service";
+import { Deferred } from "@web/core/utils/concurrency";
+import { omit } from "@web/core/utils/objects";
+import { effect } from "@web/core/utils/reactive";
+import { batched } from "@web/core/utils/timing";
+import { orderByToString } from "@web/search/utils/order_by";
+
+export function makeActiveField({
+    context,
+    invisible,
+    readonly,
+    required,
+    onChange,
+    forceSave,
+    isHandle,
+} = {}) {
+    return {
+        context: context || "{}",
+        invisible: invisible || false,
+        readonly: readonly || false,
+        required: required || false,
+        onChange: onChange || false,
+        forceSave: forceSave || false,
+        isHandle: isHandle || false,
+    };
+}
+
+const AGGREGATABLE_FIELD_TYPES = ["float", "integer", "monetary"]; // types that can be aggregated in grouped views
+
+export function addFieldDependencies(activeFields, fields, fieldDependencies = []) {
+    for (const field of fieldDependencies) {
+        if (field.name in activeFields) {
+            patchActiveFields(activeFields[field.name], field);
+        } else {
+            activeFields[field.name] = makeActiveField(field);
+        }
+        if (!fields[field.name]) {
+            fields[field.name] = omit(field, [
+                "context",
+                "invisible",
+                "required",
+                "readonly",
+                "onChange",
+            ]);
+        }
+    }
+}
+
+export function createPropertyActiveField(property) {
+    const { type } = property;
+
+    const activeField = makeActiveField();
+    if (type === "many2many") {
+        activeField.related = {
+            fields: {
+                id: { name: "id", type: "integer" },
+                display_name: { name: "display_name", type: "char" },
+            },
+            activeFields: {
+                id: makeActiveField({ readonly: true }),
+                display_name: makeActiveField(),
+            },
+        };
+    }
+    return activeField;
+}
+
+export function patchActiveFields(activeField, patch) {
+    activeField.invisible = activeField.invisible && patch.invisible;
+    activeField.readonly = activeField.readonly && patch.readonly;
+    activeField.required = activeField.required || patch.required;
+    activeField.onChange = activeField.onChange || patch.onChange;
+    activeField.forceSave = activeField.forceSave || patch.forceSave;
+    activeField.isHandle = activeField.isHandle || patch.isHandle;
+    // x2manys
+    if (patch.related) {
+        const related = activeField.related;
+        if (related) {
+            for (const fieldName in patch.related.activeFields) {
+                if (fieldName in related.activeFields) {
+                    patchActiveFields(
+                        related.activeFields[fieldName],
+                        patch.related.activeFields[fieldName]
+                    );
+                } else {
+                    related.activeFields[fieldName] = { ...patch.related.activeFields[fieldName] };
+                }
+            }
+            Object.assign(related.fields, patch.related.fields);
+        } else {
+            activeField.related = patch.related;
+        }
+    }
+    if ("limit" in patch) {
+        activeField.limit = patch.limit;
+    }
+    if ("defaultOrderBy" in patch) {
+        activeField.defaultOrderBy = patch.defaultOrderBy;
+    }
+}
+
+export function extractFieldsFromArchInfo({ fieldNodes, widgetNodes }, fields) {
+    const activeFields = {};
+    for (const fieldNode of Object.values(fieldNodes)) {
+        const fieldName = fieldNode.name;
+        const modifiers = fieldNode.modifiers || {};
+        const activeField = makeActiveField({
+            context: fieldNode.context,
+            invisible: modifiers.invisible || modifiers.column_invisible,
+            readonly: modifiers.readonly,
+            required: modifiers.required,
+            onChange: fieldNode.onChange,
+            forceSave: fieldNode.forceSave,
+            isHandle: fieldNode.isHandle,
+        });
+        if (["one2many", "many2many"].includes(fields[fieldName].type)) {
+            if (fieldNode.views) {
+                const viewDescr = fieldNode.views[fieldNode.viewMode];
+                if (viewDescr) {
+                    activeField.related = extractFieldsFromArchInfo(viewDescr, viewDescr.fields);
+                    activeField.limit = viewDescr.limit;
+                    activeField.defaultOrderBy = viewDescr.defaultOrder;
+                    if (fieldNode.views.form) {
+                        // we already know the form view (it is inline), so add its fields (in invisible)
+                        // s.t. they will be sent in the spec for onchange, and create commands returned
+                        // by the onchange could return values for those fields (that would be displayed
+                        // later if the user opens the form view)
+                        const formArchInfo = extractFieldsFromArchInfo(
+                            fieldNode.views.form,
+                            fieldNode.views.form.fields
+                        );
+                        for (const fieldName in formArchInfo.activeFields) {
+                            const formActiveField = {
+                                ...formArchInfo.activeFields[fieldName],
+                                invisible: true,
+                            };
+                            if (fieldName in activeField.related.activeFields) {
+                                patchActiveFields(
+                                    formActiveField,
+                                    activeField.related.activeFields[fieldName]
+                                );
+                            }
+                            activeField.related.activeFields[fieldName] = formActiveField;
+                        }
+                        Object.assign(activeField.related.fields, formArchInfo.fields);
+                    }
+                }
+            }
+            if (fieldNode.field?.useSubView) {
+                activeField.required = false;
+            }
+        }
+
+        if (fieldName in activeFields) {
+            patchActiveFields(activeFields[fieldName], activeField);
+        } else {
+            activeFields[fieldName] = activeField;
+        }
+
+        if (fieldNode.field) {
+            let fieldDependencies = fieldNode.field.fieldDependencies;
+            if (typeof fieldDependencies === "function") {
+                fieldDependencies = fieldDependencies(fieldNode);
+            }
+            addFieldDependencies(activeFields, fields, fieldDependencies);
+        }
+    }
+
+    for (const widgetInfo of Object.values(widgetNodes || {})) {
+        let fieldDependencies = widgetInfo.widget.fieldDependencies;
+        if (typeof fieldDependencies === "function") {
+            fieldDependencies = fieldDependencies(widgetInfo);
+        }
+        addFieldDependencies(activeFields, fields, fieldDependencies);
+    }
+    return { activeFields, fields };
+}
+
+export function getFieldContext(
+    record,
+    fieldName,
+    rawContext = record.activeFields[fieldName].context
+) {
+    const context = {};
+    for (const key in record.context) {
+        if (
+            !key.startsWith("default_") &&
+            !key.startsWith("search_default_") &&
+            !key.endsWith("_view_ref")
+        ) {
+            context[key] = record.context[key];
+        }
+    }
+
+    return {
+        ...context,
+        ...record.fields[fieldName].context,
+        ...makeContext([rawContext], record.evalContext),
+    };
+}
+
+const SENTINEL = Symbol("sentinel");
+function _getFieldContextSpec(
+    fieldName,
+    activeFields,
+    fields,
+    evalContext,
+    parentActiveFields = null
+) {
+    const rawContext = activeFields[fieldName].context;
+    if (!rawContext || rawContext === "{}") {
+        return fields[fieldName].context;
+    }
+
+    evalContext = {
+        ids: SENTINEL,
+        active_id: SENTINEL,
+        active_ids: SENTINEL,
+        active_model: SENTINEL,
+        ...evalContext,
+        id: SENTINEL,
+    };
+    for (const fieldName in activeFields) {
+        evalContext[fieldName] = SENTINEL;
+    }
+    if (parentActiveFields) {
+        evalContext.parent = {};
+        for (const fieldName in parentActiveFields) {
+            evalContext.parent[fieldName] = SENTINEL;
+        }
+    }
+    const evaluatedContext = makeContext([fields[fieldName].context, rawContext], evalContext);
+    for (const key in evaluatedContext) {
+        if (evaluatedContext[key] === SENTINEL || key.startsWith("default_")) {
+            // FIXME: this isn't perfect, a value might be evaluted to something else
+            // than the symbol because of the symbol
+            delete evaluatedContext[key];
+        }
+    }
+    if (Object.keys(evaluatedContext).length > 0) {
+        return evaluatedContext;
+    }
+}
+
+export function getFieldsSpec(
+    activeFields,
+    fields,
+    evalContext,
+    { parentActiveFields, withInvisible } = {}
+) {
+    const fieldsSpec = {};
+    const properties = [];
+    for (const fieldName in activeFields) {
+        if (fields[fieldName].relatedPropertyField) {
+            continue;
+        }
+        const { related, limit, defaultOrderBy, invisible } = activeFields[fieldName];
+        fieldsSpec[fieldName] = {};
+        // X2M
+        if (related && (invisible !== true || withInvisible)) {
+            fieldsSpec[fieldName].fields = getFieldsSpec(
+                related.activeFields,
+                related.fields,
+                evalContext,
+                { parentActiveFields: activeFields, withInvisible }
+            );
+            fieldsSpec[fieldName].limit = limit;
+            if (defaultOrderBy) {
+                fieldsSpec[fieldName].order = orderByToString(defaultOrderBy);
+            }
+        }
+        // Properties
+        if (fields[fieldName].type === "properties") {
+            properties.push(fieldName);
+        }
+        // M2O
+        if (fields[fieldName].type === "many2one" && invisible !== true) {
+            fieldsSpec[fieldName].fields = { display_name: {} };
+        }
+        if (["many2one", "one2many", "many2many"].includes(fields[fieldName].type)) {
+            const context = _getFieldContextSpec(
+                fieldName,
+                activeFields,
+                fields,
+                evalContext,
+                parentActiveFields
+            );
+            if (context) {
+                fieldsSpec[fieldName].context = context;
+            }
+        }
+        // Reference
+        if (fields[fieldName].type === "reference") {
+            fieldsSpec[fieldName].fields = { display_name: {} };
+        }
+    }
+
+    for (const fieldName of properties) {
+        const fieldSpec = fieldsSpec[fields[fieldName].definition_record];
+        if (fieldSpec) {
+            if (!fieldSpec.fields) {
+                fieldSpec.fields = {};
+            }
+            fieldSpec.fields.display_name = {};
+        }
+    }
+    return fieldsSpec;
+}
+
+let nextId = 0;
+/**
+ * @param {string} [prefix]
+ * @returns {string}
+ */
+export function getId(prefix = "") {
+    return `${prefix}_${++nextId}`;
+}
+
+/**
+ * @protected
+ * @param {Field | false} field
+ * @param {any} value
+ * @returns {any}
+ */
+export function parseServerValue(field, value) {
+    switch (field.type) {
+        case "char":
+        case "text": {
+            return value || "";
+        }
+        case "html": {
+            return markup(value || "");
+        }
+        case "date": {
+            return value ? deserializeDate(value) : false;
+        }
+        case "datetime": {
+            return value ? deserializeDateTime(value) : false;
+        }
+        case "selection": {
+            if (value === false) {
+                // process selection: convert false to 0, if 0 is a valid key
+                const hasKey0 = field.selection.find((option) => option[0] === 0);
+                return hasKey0 ? 0 : value;
+            }
+            return value;
+        }
+        case "reference": {
+            if (value === false) {
+                return false;
+            }
+            return {
+                resId: value.id.id,
+                resModel: value.id.model,
+                displayName: value.display_name,
+            };
+        }
+        case "many2one": {
+            if (Array.isArray(value)) {
+                return value;
+            }
+            if (Number.isInteger(value)) {
+                // for always invisible many2ones, unity directly returns the id, not a pair
+                return [value, ""];
+            }
+            return value ? [value.id, value.display_name] : false;
+        }
+        case "properties": {
+            return value
+                ? value.map((property) => ({
+                      ...property,
+                      value: parseServerValue(property, property.value ?? false),
+                  }))
+                : [];
+        }
+    }
+    return value;
+}
+
+/**
+ * @param {Object} groupData
+ * @returns {Object}
+ */
+export function getAggregatesFromGroupData(groupData, fields) {
+    const aggregates = {};
+    for (const [key, value] of Object.entries(groupData)) {
+        if (key in fields && AGGREGATABLE_FIELD_TYPES.includes(fields[key].type)) {
+            aggregates[key] = value;
+        }
+    }
+    return aggregates;
+}
+
+/**
+ * @param {import("./datapoint").Field} field
+ * @param {any} rawValue
+ * @returns {string | false}
+ */
+export function getDisplayNameFromGroupData(field, rawValue) {
+    if (field.type === "selection") {
+        return Object.fromEntries(field.selection)[rawValue];
+    }
+    if (["many2one", "many2many"].includes(field.type)) {
+        return rawValue ? rawValue[1] : false;
+    }
+    return rawValue;
+}
+
+/**
+ * @param {Object} groupData
+ * @param {import("./datapoint").Field} field
+ * @param {any} rawValue
+ * @returns {any}
+ */
+export function getValueFromGroupData(groupData, field, rawValue) {
+    if (["date", "datetime"].includes(field.type)) {
+        const range = groupData.range;
+        if (!range) {
+            return false;
+        }
+        const dateValue = parseServerValue(field, range.to);
+        return dateValue.minus({
+            [field.type === "date" ? "day" : "second"]: 1,
+        });
+    }
+    const value = parseServerValue(field, rawValue);
+    if (["many2one", "many2many"].includes(field.type)) {
+        return value ? value[0] : false;
+    }
+    return value;
+}
+
+/**
+ * Onchanges sometimes return update commands for records we don't know (e.g. if
+ * they are on a page we haven't loaded yet). We may actually never load them.
+ * When this happens, we must still be able to send back those commands to the
+ * server when saving. However, we can't send the commands exactly as we received
+ * them, since the values they contain have been "unity read". The purpose of this
+ * function is to transform field values from the unity format to the format
+ * expected by the server for a write.
+ * For instance, for a many2one: { id: 3, display_name: "Marc" } => 3.
+ */
+export function fromUnityToServerValues(values, fields, activeFields) {
+    const { CREATE, UPDATE } = x2ManyCommands;
+    const serverValues = {};
+    for (const fieldName in values) {
+        let value = values[fieldName];
+        switch (fields[fieldName].type) {
+            case "one2many":
+            case "many2many":
+                value = value.map((c) => {
+                    if (c[0] === CREATE || c[0] === UPDATE) {
+                        const _fields = activeFields[fieldName].related.fields;
+                        const _activeFields = activeFields[fieldName].related.activeFields;
+                        return [c[0], c[1], fromUnityToServerValues(c[2], _fields, _activeFields)];
+                    }
+                    return [c[0], c[1]];
+                });
+                break;
+            case "many2one":
+                value = value ? value.id : false;
+                break;
+            // case "reference":
+            //     // TODO
+            //     break;
+        }
+        serverValues[fieldName] = value;
+    }
+    return serverValues;
+}
+
+/**
+ * @param {any} field
+ * @returns {boolean}
+ */
+export function isRelational(field) {
+    return field && ["one2many", "many2many", "many2one"].includes(field.type);
+}
+
+/**
+ * This hook should only be used in a component field because it
+ * depends on the record props.
+ * The callback will be executed once during setup and each time
+ * a record value read in the callback changes.
+ * @param {(record) => void} callback
+ */
+export function useRecordObserver(callback) {
+    const component = useComponent();
+    let alive = true;
+    const fct = (props) => {
+        const def = new Deferred();
+        effect(
+            batched(
+                async (record) => {
+                    if (!alive) {
+                        // effect doesn't clean up when the component is unmounted.
+                        // We must do it manually.
+                        return;
+                    }
+                    await callback(record);
+                    def.resolve();
+                },
+                () => new Promise((resolve) => window.requestAnimationFrame(resolve))
+            ),
+            [props.record]
+        );
+        return def;
+    };
+    onWillDestroy(() => {
+        alive = false;
+    });
+    onWillStart(() => fct(component.props));
+    onWillUpdateProps((props) => {
+        if (props.record.id !== component.props.record.id) {
+            return fct(props);
+        }
+    });
+}
diff --git a/addons/web/static/src/views/sample_server.js b/addons/web/static/src/model/sample_server.js
similarity index 90%
rename from addons/web/static/src/views/sample_server.js
rename to addons/web/static/src/model/sample_server.js
index 847bc37bc64..4f1b0110385 100644
--- a/addons/web/static/src/views/sample_server.js
+++ b/addons/web/static/src/model/sample_server.js
@@ -10,9 +10,12 @@ import {
 import { ORM } from "@web/core/orm_service";
 import { registry } from "@web/core/registry";
 import { cartesian, sortBy as arraySortBy } from "@web/core/utils/arrays";
+import { parseServerValue } from "./relational_model/utils";
 
 class UnimplementedRouteError extends Error {}
 
+let searchReadNumber = 0;
+
 /**
  * Helper function returning the value from a list of sample strings
  * corresponding to the given ID.
@@ -24,15 +27,15 @@ function getSampleFromId(id, sampleTexts) {
     return sampleTexts[(id - 1) % sampleTexts.length];
 }
 
-function serializeGroupValue(value, type) {
-    switch (type) {
-        case "date":
-            return serializeDate(value);
-        case "datetime":
-            return serializeDateTime(value);
-        default:
-            return value;
+function serializeGroupDateValue(range, field) {
+    if (!range) {
+        return false;
     }
+    let dateValue = parseServerValue(field, range.to);
+    dateValue = dateValue.minus({
+        [field.type === "date" ? "day" : "second"]: 1,
+    });
+    return field.type === "date" ? serializeDate(dateValue) : serializeDateTime(dateValue);
 }
 
 /**
@@ -126,6 +129,8 @@ export class SampleServer {
                 return this._mockSearchReadController(params);
             case "web_search_read":
                 return this._mockWebSearchRead(params);
+            case "unity_web_search_read":
+                return this._mockWebSearchReadUnity(params);
             case "web_read_group":
                 return this._mockWebReadGroup(params);
             case "read_group":
@@ -632,6 +637,43 @@ export class SampleServer {
         return { records, length: records.length };
     }
 
+    _mockWebSearchReadUnity(params) {
+        const fields = Object.keys(params.specification);
+        let result;
+        if (this.existingGroups) {
+            const groups = this.existingGroups;
+            const group = groups[searchReadNumber++ % groups.length];
+            result = {
+                records: group.__data.records,
+                length: group.__data.records.length,
+            };
+        } else {
+            result = this._mockWebSearchRead({ ...params, fields });
+        }
+        // populate x2many values
+        for (const fieldName in params.specification) {
+            const field = this.data[params.model].fields[fieldName];
+            if (field.type === "one2many" || field.type === "many2many") {
+                const relFields = Object.keys(params.specification[fieldName].fields || {});
+                if (relFields.length) {
+                    const relIds = result.records.map((r) => r[fieldName]).flat();
+                    const relRecords = {};
+                    const _relRecords = this._mockRead({
+                        model: field.relation,
+                        args: [relIds, relFields],
+                    });
+                    for (const relRecord of _relRecords) {
+                        relRecords[relRecord.id] = relRecord;
+                    }
+                    for (const record of result.records) {
+                        record[fieldName] = record[fieldName].map((resId) => relRecords[resId]);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
     /**
      * Mocks calls to the web_read_group method to return groups populated
      * with sample records. Only handles the case where the real call to
@@ -668,22 +710,26 @@ export class SampleServer {
      * @param {string[]} params.groupBy
      */
     _populateExistingGroups(params) {
-        if (!this.existingGroupsPopulated) {
-            const groups = this.existingGroups;
-            const groupBy = params.groupBy[0].split(":")[0];
-            const groupByField = this.data[params.model].fields[groupBy];
-            const groupedByM2O = groupByField.type === "many2one";
-            if (groupedByM2O) {
-                // re-populate co model with relevant records
-                this.data[groupByField.relation].records = groups.map((g) => {
-                    return { id: g.value, display_name: g.displayName };
-                });
+        const groups = this.existingGroups;
+        const groupBy = params.groupBy[0].split(":")[0];
+        const groupByField = this.data[params.model].fields[groupBy];
+        const groupedByM2O = groupByField.type === "many2one";
+        if (groupedByM2O) {
+            // re-populate co model with relevant records
+            this.data[groupByField.relation].records = groups.map((g) => {
+                return { id: g.value, display_name: g.displayName };
+            });
+        }
+        for (const r of this.data[params.model].records) {
+            const group = getSampleFromId(r.id, groups);
+            if (["date", "datetime"].includes(groupByField.type)) {
+                r[groupBy] = serializeGroupDateValue(
+                    group.__range[params.groupBy[0]],
+                    groupByField
+                );
+            } else {
+                r[groupBy] = group[params.groupBy[0]];
             }
-            for (const r of this.data[params.model].records) {
-                const group = getSampleFromId(r.id, groups);
-                r[groupBy] = serializeGroupValue(group.value, groupByField.type);
-            }
-            this.existingGroupsPopulated = true;
         }
     }
 
@@ -748,16 +794,20 @@ export class SampleServer {
         const records = this.data[params.model].records;
         for (const g of groups) {
             const recordsInGroup = records.filter((r) => {
-                return r[groupBy] === serializeGroupValue(g.value, groupByField.type);
+                if (["date", "datetime"].includes(groupByField.type)) {
+                    return (
+                        r[groupBy] === serializeGroupDateValue(g.__range[fullGroupBy], groupByField)
+                    );
+                }
+                return r[groupBy] === g[fullGroupBy];
             });
-            g[`${groupBy}_count`] = recordsInGroup.length;
-            g[fullGroupBy] = g.__rawValue;
             for (const field of params.fields) {
                 const fieldType = this.data[params.model].fields[field].type;
                 if (["integer, float", "monetary"].includes(fieldType)) {
                     g[field] = recordsInGroup.reduce((acc, r) => acc + r[field], 0);
                 }
             }
+            g[`${groupBy}_count`] = recordsInGroup.length;
             g.__data = {
                 records: this._mockRead({
                     model: params.model,
@@ -765,7 +815,6 @@ export class SampleServer {
                 }),
                 length: recordsInGroup.length,
             };
-            g.__range = { ...g.range };
         }
     }
 }
diff --git a/addons/web/static/src/search/search_model.js b/addons/web/static/src/search/search_model.js
index 3d631511688..70312c53549 100644
--- a/addons/web/static/src/search/search_model.js
+++ b/addons/web/static/src/search/search_model.js
@@ -26,7 +26,7 @@ import { useGetDomainTreeDescription } from "@web/core/domain_selector/utils";
 const { DateTime } = luxon;
 
 /** @typedef {import("@web/core/domain").DomainRepr} DomainRepr */
-/** @typedef {import("../views/relational_model").OrderTerm} OrderTerm */
+/** @typedef {import("../views/utils").OrderTerm} OrderTerm */
 
 /**
  * @typedef {Object} ComparisonDomain
diff --git a/addons/web/static/src/search/utils/order_by.js b/addons/web/static/src/search/utils/order_by.js
new file mode 100644
index 00000000000..d908dadf2fc
--- /dev/null
+++ b/addons/web/static/src/search/utils/order_by.js
@@ -0,0 +1,39 @@
+/** @odoo-module */
+
+/**
+ * @typedef {Object} OrderTerm
+ * @property {string} name
+ * @property {boolean} asc
+ */
+
+/**
+ * @param {OrderTerm[]} orderBy
+ * @returns {string}
+ */
+export function orderByToString(orderBy) {
+    return orderBy.map((o) => `${o.name} ${o.asc ? "ASC" : "DESC"}`).join(", ");
+}
+
+/**
+ * @param {any} string
+ * @return {OrderTerm[]}
+ */
+export function stringToOrderBy(string) {
+    if (!string) {
+        return [];
+    }
+    return string.split(",").map((order) => {
+        const splitOrder = order.trim().split(" ");
+        if (splitOrder.length === 2) {
+            return {
+                name: splitOrder[0],
+                asc: splitOrder[1].toLowerCase() === "asc",
+            };
+        } else {
+            return {
+                name: splitOrder[0],
+                asc: true,
+            };
+        }
+    });
+}
diff --git a/addons/web/static/src/views/basic_relational_model.js b/addons/web/static/src/views/basic_relational_model.js
deleted file mode 100644
index f577c35111c..00000000000
--- a/addons/web/static/src/views/basic_relational_model.js
+++ /dev/null
@@ -1,1445 +0,0 @@
-/* @odoo-module */
-
-import { makeContext } from "@web/core/context";
-import { Domain } from "@web/core/domain";
-import { WarningDialog } from "@web/core/errors/error_dialogs";
-import { deserializeDate, deserializeDateTime } from "@web/core/l10n/dates";
-import { KeepLast } from "@web/core/utils/concurrency";
-import { escape } from "@web/core/utils/strings";
-import { mapDoActionOptionAPI } from "@web/legacy/backend_utils";
-import {
-    mapActiveFieldsToFieldsInfo,
-    mapViews,
-    mapWowlValueToLegacy,
-} from "@web/views/legacy_utils";
-import { Model } from "@web/views/model";
-import { evalDomain } from "@web/views/utils";
-import BasicModel from "web.BasicModel";
-import Context from "web.Context";
-
-import { markup, toRaw } from "@odoo/owl";
-
-const DEFAULT_HANDLE_FIELD = "sequence";
-
-let nextId = 0;
-class DataPoint {
-    /**
-     * @param {RelationalModel} model
-     * @param {Object} [params={}]
-     * @param {Object} [state={}]
-     */
-    constructor(model, params, state = {}) {
-        this.id = `datapoint_${nextId++}`;
-        this.model = model;
-
-        let info;
-        if (params.__bm_load_params__) {
-            this.__bm_load_params__ = params.__bm_load_params__;
-            info = this.__bm_load_params__;
-            this.context = info.context;
-        } else if (params.handle) {
-            this.__bm_handle__ = params.handle;
-            info = this.model.__bm__.get(this.__bm_handle__);
-            this.context = this.model.__bm__.localData[this.__bm_handle__].getContext();
-        } else {
-            throw new Error("Datapoint needs load params or handle");
-        }
-        this.resModel = info.model || info.modelName;
-        this.fields = info.fields;
-        this.activeFields = {};
-
-        this.__syncParent = params.__syncParent || (() => {});
-        this.__viewType = params.viewType || info.viewType;
-        const fieldsInfo = (info.fieldsInfo && info.fieldsInfo[this.__viewType]) || {};
-        for (const [name, descr] of Object.entries(fieldsInfo)) {
-            this.activeFields[name] = descr.__WOWL_FIELD_DESCR__ || {};
-        }
-
-        this.setup(params, state);
-    }
-
-    /**
-     * @abstract
-     * @param {Object} params
-     * @param {Object} state
-     */
-    setup() {}
-
-    get evalContext() {
-        const datapoint = this.model.__bm__.localData[this.__bm_handle__];
-        return this.model.__bm__._getLazyEvalContext(datapoint);
-    }
-
-    getEvalContext(forDomain) {
-        const datapoint = this.model.__bm__.localData[this.__bm_handle__];
-        return this.model.__bm__._getEvalContext(datapoint, forDomain, false, true);
-    }
-
-    get fieldNames() {
-        return Object.keys(this.activeFields);
-    }
-
-    exportState() {
-        return {};
-    }
-
-    async load() {
-        throw new Error("load must be implemented");
-    }
-}
-
-export class Record extends DataPoint {
-    setup(params, state) {
-        this.data = {};
-        this._invalidFields = new Set();
-        this.preloadedData = {};
-        this.selected = false;
-        this.isInQuickCreation = params.isInQuickCreation || false;
-        this._onChangePromise = Promise.resolve({});
-        this._savePromise = Promise.resolve();
-        this._domains = {};
-        this._closeInvalidFieldsNotification = () => {};
-
-        this.onWillSaveRecord = params.onWillSaveRecord || (() => {});
-        this.onRecordSaved = params.onRecordSaved || (() => {});
-
-        this._requiredFields = {};
-        for (const [fieldName, activeField] of Object.entries(this.activeFields)) {
-            const { modifiers } = activeField;
-            if (modifiers && modifiers.required) {
-                this._requiredFields[fieldName] = modifiers.required;
-            }
-        }
-
-        if (!this.resId && this.__viewType === "form") {
-            this.mode = "edit"; // always edit a new record in form view.
-        } else {
-            this.mode = params.mode || state.mode || "readonly";
-        }
-
-        this._onWillSwitchMode = params.onRecordWillSwitchMode || (() => {});
-
-        if (this.__bm_handle__) {
-            this.__syncData();
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Getters
-    // -------------------------------------------------------------------------
-
-    get canBeAbandoned() {
-        return this.model.__bm__.canBeAbandoned(this.__bm_handle__);
-    }
-
-    /**
-     * Since the ORM can support both `active` and `x_active` fields for
-     * the archiving mechanism, check if any such field exists and prioritize
-     * them. The `active` field should always take priority over its custom
-     * version.
-     *
-     * @returns {boolean} true iff the field is active or there is no `active`
-     *   or `x_active` field on the model
-     */
-    get isActive() {
-        if ("active" in this.activeFields) {
-            return this.data.active;
-        } else if ("x_active" in this.activeFields) {
-            return this.data.x_active;
-        }
-        return true;
-    }
-
-    get isDirty() {
-        return this.model.__bm__.isDirty(this.__bm_handle__);
-    }
-
-    get isInEdition() {
-        return this.mode === "edit";
-    }
-
-    get isNew() {
-        return !this.resId;
-    }
-
-    get isValid() {
-        return !this._invalidFields.size;
-    }
-
-    get resId() {
-        if (this.__bm_handle__) {
-            const resId = this.model.__bm__.localData[this.__bm_handle__].res_id;
-            if (typeof resId === "string") {
-                return false;
-            }
-            return resId;
-        } else {
-            // record not loaded yet
-            return this.__bm_load_params__.res_id;
-        }
-    }
-
-    get resIds() {
-        return this.model.__bm__.localData[this.__bm_handle__].res_ids;
-    }
-
-    async askChanges() {
-        const proms = [];
-        this.model.bus.trigger("NEED_LOCAL_CHANGES", { proms });
-        return Promise.all([...proms, this._updatePromise]);
-    }
-
-    // -------------------------------------------------------------------------
-    // Getters
-    // -------------------------------------------------------------------------
-
-    async checkValidity(urgent) {
-        if (!urgent) {
-            await this.askChanges();
-        }
-        for (const fieldName in this.activeFields) {
-            const fieldType = this.fields[fieldName].type;
-            const activeField = this.activeFields[fieldName];
-            if (fieldName in this._requiredFields) {
-                if (
-                    !evalDomain(this._requiredFields[fieldName], this.evalContext) ||
-                    (activeField && activeField.alwaysInvisible)
-                ) {
-                    this._removeInvalidFields([fieldName]);
-                    continue;
-                }
-            }
-
-            const isSet = activeField && activeField.field && activeField.field.isSet;
-
-            if (this._isRequired(fieldName) && isSet && !isSet(this.data[fieldName])) {
-                this.setInvalidField(fieldName);
-                continue;
-            }
-
-            switch (fieldType) {
-                case "boolean":
-                case "float":
-                case "integer":
-                case "monetary":
-                    continue;
-                case "properties":
-                    if (!this.checkPropertiesValidity(fieldName)) {
-                        this._setInvalidField(fieldName);
-                    }
-                    break;
-                case "one2many":
-                case "many2many":
-                    if (!(await this.checkX2ManyValidity(fieldName, urgent))) {
-                        this._setInvalidField(fieldName);
-                    }
-                    break;
-                default:
-                    if (!isSet && this._isRequired(fieldName) && !this.data[fieldName]) {
-                        this._setInvalidField(fieldName);
-                    }
-            }
-        }
-        return !this._invalidFields.size;
-    }
-
-    openInvalidFieldsNotification() {
-        if (this._invalidFields.size) {
-            const invalidFields = [...this._invalidFields].map((fieldName) => {
-                return `<li>${escape(this.fields[fieldName].string || fieldName)}</li>`;
-            }, this);
-            this._closeInvalidFieldsNotification = this.model.notificationService.add(
-                markup(`<ul>${invalidFields.join("")}</ul>`),
-                {
-                    title: this.model.env._t("Invalid fields: "),
-                    type: "danger",
-                }
-            );
-        }
-    }
-
-    async switchMode(mode, options) {
-        if (this.mode === mode) {
-            return true;
-        }
-        const canSwitch = await this._onWillSwitchMode(this, mode, options);
-        if (canSwitch === false) {
-            return false;
-        }
-
-        if (mode === "edit") {
-            // wait for potential pending changes to be saved (done with widgets
-            // allowing to edit in readonly)
-            await this.model.__bm__.mutex.getUnlockedDef();
-        }
-
-        if (mode === "readonly") {
-            for (const fieldName in this.activeFields) {
-                if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
-                    const editedRecord = this.data[fieldName] && this.data[fieldName].editedRecord;
-                    if (editedRecord) {
-                        editedRecord.switchMode("readonly");
-                    }
-                }
-            }
-        }
-        this.mode = mode;
-        this.model.notify();
-        return true;
-    }
-
-    isFieldDirty(fieldName) {
-        const changes = this.model.__bm__.localData[this.__bm_handle__]._changes;
-        return changes && changes[fieldName];
-    }
-
-    /**
-     * FIXME: memoize this at some point?
-     * @param {string} fieldName
-     * @returns {boolean}
-     */
-    _isReadonly(fieldName) {
-        const { readonly } = this.activeFields[fieldName].modifiers || {};
-        return evalDomain(readonly, this.evalContext);
-    }
-
-    /**
-     * FIXME: memoize this at some point?
-     * @param {string} fieldName
-     * @returns {boolean}
-     */
-    _isRequired(fieldName) {
-        const { required } = this.activeFields[fieldName].modifiers || {};
-        return evalDomain(required, this.evalContext);
-    }
-
-    async checkX2ManyValidity(fieldName, urgent = false) {
-        const list = this.data[fieldName];
-        const record = list.editedRecord;
-        if (record && !(await record.checkValidity(urgent))) {
-            if (record.canBeAbandoned && !record.isDirty) {
-                list.abandonRecord(record.id);
-            } else {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * The label and the id of the properties are always required.
-     *
-     * @param {string} fieldName
-     * @returns {boolean}
-     */
-    checkPropertiesValidity(fieldName) {
-        const value = this.data[fieldName];
-        if (!value) {
-            return true;
-        }
-        return value.every(
-            (propertyDefinition) =>
-                !propertyDefinition.id ||
-                (propertyDefinition.string && propertyDefinition.string.length)
-        );
-    }
-
-    _setInvalidField(fieldName) {
-        this._invalidFields.add(fieldName);
-        this.model.notify();
-    }
-
-    setInvalidField(fieldName) {
-        const bm = this.model.__bm__;
-        bm.setDirty(this.__bm_handle__);
-        this._setInvalidField(fieldName);
-    }
-
-    isInvalid(fieldName) {
-        return this._invalidFields.has(fieldName);
-    }
-
-    async load(params = {}, options = {}) {
-        if (!this.__bm_handle__) {
-            this.__bm_handle__ = await this.model.__bm__.load({
-                ...this.__bm_load_params__,
-                viewType: this.__viewType,
-            });
-        } else {
-            this.__bm_handle__ = await this.model.__bm__.reload(this.__bm_handle__, {
-                viewType: this.__viewType,
-                keepChanges: !!options.keepChanges,
-            });
-        }
-        this.__syncData();
-        this._invalidFields = new Set();
-    }
-
-    exportState() {
-        return {
-            mode: this.mode,
-            resId: this.resId,
-            resIds: this.resIds,
-        };
-    }
-
-    __syncData(force) {
-        const bm = this.model.__bm__;
-        const legDP = bm.get(this.__bm_handle__);
-        const data = Object.assign({}, legDP.data);
-        for (const fieldName of this.fieldNames) {
-            const fieldType = legDP.fields[fieldName].type;
-            switch (fieldType) {
-                case "date":
-                case "datetime": {
-                    // from moment to luxon
-                    if (data[fieldName]) {
-                        const deserialize =
-                            fieldType === "date" ? deserializeDate : deserializeDateTime;
-                        data[fieldName] = deserialize(data[fieldName].toJSON());
-                    }
-                    break;
-                }
-                case "one2many":
-                case "many2many": {
-                    const currentVal = this.data[fieldName];
-                    if (
-                        !data[fieldName] ||
-                        (currentVal && currentVal.__bm_handle__ === data[fieldName].id && !force)
-                    ) {
-                        data[fieldName] = this.data[fieldName];
-                        data[fieldName].__syncData();
-                    } else {
-                        const { viewMode, views } = this.activeFields[fieldName];
-                        const handleField =
-                            (views && views[viewMode] && views[viewMode].handleField) || null;
-                        data[fieldName] = new StaticList(this.model, {
-                            handle: data[fieldName].id,
-                            handleField,
-                            viewType: viewMode,
-                            __syncParent: async (value) => {
-                                await this.model.__bm__.save(this.__bm_handle__, {
-                                    savePoint: true,
-                                });
-                                await this.update({ [fieldName]: value });
-                            },
-                        });
-                        data[fieldName].__fieldName__ = fieldName;
-                    }
-                    break;
-                }
-                case "many2one": {
-                    if (data[fieldName]) {
-                        data[fieldName] = [
-                            data[fieldName].data.id,
-                            data[fieldName].data.display_name || "",
-                        ];
-                    } else {
-                        data[fieldName] = false;
-                    }
-                    break;
-                }
-                case "reference": {
-                    data[fieldName] = data[fieldName]
-                        ? {
-                              resModel: data[fieldName].model,
-                              resId: data[fieldName].data.id,
-                              displayName: data[fieldName].data.display_name,
-                          }
-                        : false;
-                    break;
-                }
-                case "text":
-                case "char": {
-                    data[fieldName] = data[fieldName] || "";
-                    break;
-                }
-                case "html": {
-                    data[fieldName] = markup(data[fieldName] || "");
-                    break;
-                }
-            }
-            if (legDP.specialData[fieldName]) {
-                this.preloadedData[fieldName] = legDP.specialData[fieldName];
-            }
-        }
-        this.data = data;
-    }
-
-    getFieldDomain(fieldName) {
-        const { domain } = this.fields[fieldName];
-        return domain ? new Domain(domain).toList(this.getEvalContext(true)) : [];
-    }
-
-    _getFieldContext(fieldName) {
-        return this.model.__bm__.localData[this.__bm_handle__].getContext({
-            fieldName,
-            viewType: this.__viewType,
-        });
-    }
-
-    async update(changes) {
-        if (this.batchingUpdateProm) {
-            // Assign changes in the current batch
-            Object.assign(this.batchChanges, changes);
-            return this._updatePromise;
-        }
-
-        this.batchingUpdateProm = Promise.resolve();
-        this.batchChanges = Object.assign({}, changes);
-
-        let resolveUpdatePromise;
-        this._updatePromise = new Promise((r) => {
-            resolveUpdatePromise = r;
-        });
-
-        await this.batchingUpdateProm;
-        changes = this.batchChanges;
-        this.batchingUpdateProm = null;
-        this.batchChanges = null;
-
-        const data = {};
-        for (const [fieldName, value] of Object.entries(changes)) {
-            const fieldType = this.fields[fieldName].type;
-            data[fieldName] = mapWowlValueToLegacy(value, fieldType);
-            // special case for many2ones: they can be updated with a new name (e.g. if edited from
-            // the dialog), but in the basic_model it worked differently, we had a datapoint for the
-            // many2one value and we reloaded it directly. In the new model, we directly update the
-            // value [id, display_name], so we reload beforehand, in the many2one field itself. In
-            // the next few lines, we thus manually apply the renaming on the legacy datapoint.
-            if (this.fields[fieldName].type === "many2one" && Array.isArray(changes[fieldName])) {
-                const newName = changes[fieldName][1];
-                if (newName || newName === "") {
-                    const bm = this.model.__bm__;
-                    const m2oDatapointId = bm.get(this.__bm_handle__).data[fieldName].id;
-                    const m2oDatapoint = bm.localData[m2oDatapointId];
-                    if (m2oDatapoint && m2oDatapoint.data.id === changes[fieldName][0]) {
-                        m2oDatapoint.data.display_name = newName;
-                    }
-                }
-            }
-            // same for reference fields
-            if (this.fields[fieldName].type === "reference" && changes[fieldName].displayName) {
-                const bm = this.model.__bm__;
-                const m2oDatapointId = bm.get(this.__bm_handle__).data[fieldName].id;
-                const m2oDatapoint = bm.localData[m2oDatapointId];
-                if (m2oDatapoint) {
-                    m2oDatapoint.data.display_name = changes[fieldName].displayName;
-                }
-            }
-        }
-        if (this._urgentSave) {
-            const fieldNames = await this.model.__bm__.notifyChanges(this.__bm_handle__, data, {
-                viewType: this.__viewType,
-                notifyChange: false,
-            });
-            resolveUpdatePromise();
-            this._removeInvalidFields(fieldNames);
-            this.__syncData();
-            return;
-        }
-
-        const parentID = this.model.__bm__.localData[this.__bm_handle__].parentID;
-        if (parentID && this.__viewType === "list") {
-            // inside an x2many (parentID is the id of the static list datapoint)
-            const mainRecordId = this.model.__bm__.localData[parentID].parentID;
-            const mainRecordDP = this.model.__bm__.localData[mainRecordId];
-            const mainRecordValues = { ...mainRecordDP.data, ...mainRecordDP._changes };
-            const x2manyFieldName = Object.keys(mainRecordValues).find(
-                (name) => mainRecordValues[name] === parentID
-            );
-            if (!x2manyFieldName) {
-                throw new Error("couldn't find x2many field name");
-            }
-            const operation = { operation: "UPDATE", id: this.__bm_handle__, data };
-            const prom = this.__syncParent(operation);
-            prom.catch(resolveUpdatePromise);
-            await prom;
-        } else {
-            const prom = this.model.__bm__.notifyChanges(this.__bm_handle__, data, {
-                viewType: this.__viewType,
-            });
-            prom.catch(resolveUpdatePromise); // onchange rpc may return an error
-            const fieldNames = await prom;
-            this._removeInvalidFields(fieldNames);
-            for (const fieldName of fieldNames) {
-                if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
-                    const { editedRecord } = this.data[fieldName];
-                    if (editedRecord) {
-                        editedRecord._removeAllInvalidFields();
-                    }
-                }
-            }
-            this.__syncData();
-        }
-        this._removeInvalidFields(Object.keys(changes));
-        this.model.notify();
-        resolveUpdatePromise();
-    }
-
-    /**
-     *
-     * @param {Object} options
-     * @param {boolean} [options.stayInEdition=false]
-     * @param {boolean} [options.noReload=false] prevents the record from
-     *  reloading after changes are applied, typically used to defer the load.
-     * @param {boolean} [options.useSaveErrorDialog=false] displays a custom
-     *  dialog and await the response from this dialog when an error is
-     *  returned by the server.
-     * @param {boolean} [options.throwOnError=false] throws the saving error if
-     *  applicable, allowing to catch it.
-     * @returns {Promise<boolean>}
-     */
-    async save(options = {}) {
-        options = Object.assign(
-            {
-                stayInEdition: true,
-                noReload: false,
-                savePoint: false,
-                useSaveErrorDialog: false,
-                throwOnError: false,
-            },
-            options
-        );
-        const shouldSwitchToReadonly = !options.stayInEdition && this.isInEdition;
-        let resolveSavePromise;
-        this._savePromise = new Promise((r) => {
-            resolveSavePromise = r;
-        });
-        this._closeInvalidFieldsNotification();
-        if (!(await this.checkValidity())) {
-            this.openInvalidFieldsNotification();
-            resolveSavePromise();
-            return false;
-        }
-        if ((await this.onWillSaveRecord(this)) === false) {
-            return false;
-        }
-        const saveOptions = {
-            reload: !options.noReload,
-            savePoint: options.savePoint,
-        };
-        try {
-            await this.model.__bm__.save(this.__bm_handle__, saveOptions);
-        } catch (_e) {
-            resolveSavePromise();
-            let canProceed = false;
-            if (options.useSaveErrorDialog) {
-                _e.__raisedOnFormSave = true;
-                canProceed = await new Promise((resolve) => {
-                    _e.onDiscard = async () => {
-                        await this.discard();
-                        resolve(true);
-                    };
-                    _e.onStayHere = () => resolve(false);
-                });
-            }
-
-            if (!this.isInEdition) {
-                await this.load();
-                this.model.notify();
-            }
-            if (options.throwOnError) {
-                throw _e;
-            }
-            return canProceed;
-        }
-        this.__syncData(true);
-        if (shouldSwitchToReadonly) {
-            this.switchMode("readonly");
-        }
-        this.model.notify();
-        resolveSavePromise();
-
-        await this.onRecordSaved(this);
-        return true;
-    }
-
-    /**
-     * To be called **only** when Odoo is about to be closed, and we want to
-     * save potential changes on a given record.
-     *
-     * We can't follow the normal flow (onchange(s) + save, mutexified),
-     * because the 'beforeunload' handler must be *almost* sync (< 10 ms
-     * setTimeout seems fine, but an rpc roundtrip is definitely too long),
-     * so here we bypass the standard mechanism of notifying changes and
-     * saving them:
-     *  - we ask the model to bypass its mutex for upcoming 'notifyChanges' and
-     *   'save' requests
-     *  - we ask all fields to commit their changes (in case there would
-     *    be a focused field with a fresh value)
-     *  - we take all changes that have been reported to the
-     *    controller, but not yet sent to the model because of the mutex,
-     *    and directly notify the model about them, see update.
-     *  - we reset the widgets with all those changes, s.t. a further call
-     *    to 'canBeRemoved' uses the correct data (it asks the widgets if
-     *    they are set/valid, based on their internal state)
-     *  - if the record is dirty, we save directly
-     *
-     * @param {string} recordID
-     * @private
-     */
-    async urgentSave() {
-        this.model.__bm__.bypassMutex = true;
-        this._urgentSave = true;
-        this.model.bus.trigger("WILL_SAVE_URGENTLY");
-        await Promise.resolve();
-        this.__syncData();
-        let isValid = true;
-        if (this.isDirty) {
-            isValid = await this.checkValidity(true);
-            if (isValid) {
-                this.model.__bm__.save(this.__bm_handle__, { reload: false });
-            }
-        }
-        this.model.__bm__.bypassMutex = false;
-        return isValid;
-    }
-
-    async archive() {
-        await this.model.__bm__.actionArchive([this.resId], this.__bm_handle__);
-        this.__syncData();
-        this.model.notify();
-    }
-
-    async unarchive() {
-        await this.model.__bm__.actionUnarchive([this.resId], this.__bm_handle__);
-        this.__syncData();
-        this.model.notify();
-    }
-
-    // FIXME AAB: to discuss: not sure we want to keep resIds in the model (this concerns
-    // "duplicate" and "delete"). Alternative: handle this in form_view (but then what's the
-    // point of calling a Record method to do the operation?)
-    async duplicate() {
-        this.__bm_handle__ = await this.model.__bm__.duplicateRecord(this.__bm_handle__);
-        this.__syncData();
-        this.switchMode("edit");
-        this.model.notify();
-    }
-
-    async delete() {
-        await this.model.__bm__.deleteRecords([this.__bm_handle__], this.resModel);
-        if (this.resIds.length) {
-            await this.load();
-        }
-        this.model.notify();
-    }
-
-    toggleSelection(selected) {
-        if (typeof selected === "boolean") {
-            this.selected = selected;
-        } else {
-            this.selected = !this.selected;
-        }
-        this.model.notify();
-    }
-
-    async discard() {
-        await this._savePromise;
-        this._closeInvalidFieldsNotification();
-        this.model.__bm__.discardChanges(this.__bm_handle__);
-        this._invalidFields = new Set();
-        this.__syncData();
-        this.model.notify();
-    }
-
-    _removeInvalidFields(fieldNames) {
-        for (const fieldName of fieldNames) {
-            this._invalidFields.delete(fieldName);
-        }
-    }
-
-    _removeAllInvalidFields() {
-        this._removeInvalidFields(Object.keys(this.activeFields));
-    }
-}
-
-export class StaticList extends DataPoint {
-    setup(params) {
-        /** @type {Record[]} */
-        this.records = [];
-
-        this.handleField = params.handleField;
-
-        this.editedRecord = null;
-        this.onRecordWillSwitchMode = async (record, mode, options = {}) => {
-            if (mode === "edit") {
-                await this.model.__bm__.save(this.__bm_handle__, { savePoint: true });
-                this.model.__bm__.freezeOrder(this.__bm_handle__);
-            }
-
-            const editedRecord = this.editedRecord;
-            this.editedRecord = null;
-            if (editedRecord) {
-                // Validity is checked if one of the following is true:
-                // - "switchMode" has been called with explicit "checkValidity"
-                // - the record is dirty
-                // - the record is new and can be abandonned
-                const shouldCheckValidity =
-                    options.checkValidity || editedRecord.isDirty || editedRecord.canBeAbandoned;
-                const isValid = !shouldCheckValidity || (await editedRecord.checkValidity());
-                if (isValid) {
-                    await editedRecord.switchMode("readonly");
-                } else if (editedRecord.id !== record.id && editedRecord.canBeAbandoned) {
-                    this.abandonRecord(editedRecord.id);
-                } else {
-                    this.editedRecord = editedRecord;
-                    return false;
-                }
-            }
-            if (mode === "edit") {
-                this.editedRecord = record;
-            }
-        };
-
-        this.__syncData();
-    }
-
-    __syncData() {
-        const legacyListDP = this.model.__bm__.get(this.__bm_handle__);
-        this.records = legacyListDP.data.map((dp) => {
-            let record = this.records.find((r) => r.__bm_handle__ === dp.id);
-            if (record) {
-                record.__syncData();
-            } else {
-                record = new this.model.constructor.Record(this.model, {
-                    handle: dp.id,
-                    onRecordWillSwitchMode: this.onRecordWillSwitchMode,
-                    mode: "readonly",
-                    viewType: this.__viewType,
-                    __syncParent: async (value) => {
-                        await this.__syncParent(value);
-                    },
-                });
-                if (record.mode === "edit" && this.editedRecord) {
-                    this.editedRecord.mode = "readonly";
-                }
-            }
-            return record;
-        });
-        this.editedRecord = this.records.find((r) => r.mode === "edit") || null;
-    }
-
-    // FIXME: remove?
-    get resIds() {
-        return this.model.__bm__.get(this.__bm_handle__).res_ids;
-    }
-    get currentIds() {
-        return this.model.__bm__.get(this.__bm_handle__).res_ids;
-    }
-
-    get orderBy() {
-        return this.model.__bm__.localData[this.__bm_handle__].orderedBy;
-    }
-    get limit() {
-        return this.model.__bm__.localData[this.__bm_handle__].limit;
-    }
-    get offset() {
-        return this.model.__bm__.localData[this.__bm_handle__].offset;
-    }
-    get count() {
-        return this.currentIds.length;
-    }
-
-    abandonRecord(recordId) {
-        const record = this.records.find((r) => r.id === recordId);
-        this.model.__bm__.removeLine(record.__bm_handle__);
-        this.__syncData();
-        this.model.notify();
-    }
-
-    canResequence() {
-        return this.handleField || DEFAULT_HANDLE_FIELD in this.fields;
-    }
-
-    removeRecord(record) {
-        // if (true) { see _onRemoveRecord in rel fields
-        this.delete(record.id);
-        // }
-    }
-
-    async delete(recordId, operation = "DELETE") {
-        const record = this.records.find((r) => r.id === recordId);
-        await this.__syncParent({ operation, ids: [record.__bm_handle__] });
-    }
-
-    async add(object, params = { isM2M: false }) {
-        let operation;
-        const bm = this.model.__bm__;
-        if (object instanceof Record) {
-            const recHandle = object.__bm_handle__;
-            await bm.save(recHandle, { savePoint: !params.isM2M, viewType: object.__viewType });
-            if (params.isM2M) {
-                const id = bm.localData[recHandle].res_id;
-                operation = { operation: "ADD_M2M", ids: [{ id }] };
-            } else {
-                operation = { operation: "ADD", id: recHandle };
-            }
-        } else if (Array.isArray(object) && params.isM2M) {
-            const oldIds = this.resIds;
-            const newIds = object.filter((id) => !oldIds.includes(id)).map((id) => ({ id }));
-            operation = { operation: "ADD_M2M", ids: newIds };
-        }
-        await this.__syncParent(operation);
-    }
-
-    /** Creates a Draft record from nothing and edits it. Relevant in editable x2m's */
-    async addNew(params) {
-        const position = params.position;
-        const operation = { context: [params.context], operation: "CREATE", position };
-        await this.model.__bm__.save(this.__bm_handle__, { savePoint: true });
-        this.model.__bm__.freezeOrder(this.__bm_handle__);
-        await this.__syncParent(operation);
-        const newRecord = this.records[position === "bottom" ? this.records.length - 1 : 0];
-        if (params.mode === "edit") {
-            await newRecord.switchMode("edit");
-        }
-        return newRecord;
-    }
-
-    // x2many dialog edition
-    // addRecord(record) {
-    //     this.onChanges();
-    //     this._cache[record.virtualId] = record;
-    //     this._cache[record.virtualId] = record;
-    //     this.records.push(record);
-    //     this.resIds.push(record.virtualId);
-    //     this.limit = this.limit + 1; // might be not good
-    //     this.validated[record.virtualId] = false;
-    //     this.model.notify();
-    // }
-
-    exportState() {
-        return {
-            limit: this.limit,
-        };
-    }
-
-    async load(params) {
-        await this.model.__bm__._reload(this.__bm_handle__, params);
-        this.__syncData();
-    }
-
-    async sortBy(fieldName) {
-        await this.model.__bm__.setSort(this.__bm_handle__, fieldName);
-        this.__syncData();
-        this.model.notify();
-    }
-
-    async replaceWith(resIds) {
-        const addedIds = resIds.filter((id) => !this.currentIds.includes(id));
-        const deletedIds = this.currentIds.filter((id) => !resIds.includes(id));
-        let operation;
-        if (addedIds.length && deletedIds.length) {
-            operation = {
-                ids: resIds,
-                operation: "REPLACE_WITH",
-            };
-        } else if (addedIds.length) {
-            operation = {
-                ids: addedIds.map((id) => ({ id })),
-                operation: "ADD_M2M",
-            };
-        } else if (deletedIds.length) {
-            operation = {
-                ids: deletedIds,
-                operation: "FORGET",
-            };
-        } else {
-            // no change?
-            return;
-        }
-        await this.__syncParent(operation);
-    }
-
-    /**
-     * @param {Array[]} commands  array of commands
-     */
-    async applyCommands(fieldName, commands) {
-        const commandsWithId = commands.map((command) => {
-            return {
-                operation: command.operation,
-                id: command.record.__bm_handle__,
-                data: command.data,
-            };
-        });
-
-        const parentID = this.model.__bm__.localData[this.__bm_handle__].parentID;
-        await this.model.__bm__.notifyChanges(parentID, {
-            [fieldName]: {
-                operation: "MULTI",
-                commands: commandsWithId,
-            },
-        });
-
-        this.model.root.__syncData();
-        this.model.notify();
-    }
-
-    /**
-     * @param {string} dataRecordId
-     * @param {string} dataGroupId
-     * @param {string} refId
-     * @param {string} targetGroupId
-     * @returns {Promise<Record>}
-     */
-    async moveRecord(dataRecordId, dataGroupId, refId, targetGroupId) {
-        await this.resequence(dataRecordId, refId);
-    }
-
-    /**
-     * @param {RecordId} movedId  // id of the moved record
-     * @param {RecordId | null} targetId // id of the record (if any) that must be before moved record after operation is done
-     */
-    async resequence(movedId, targetId) {
-        if (!this.canResequence()) {
-            // There is no handle field on the current model
-            return;
-        }
-
-        if (this.__viewType === "list") {
-            await this.model.__bm__.save(this.__bm_handle__, { savePoint: true });
-            this.model.__bm__.freezeOrder(this.__bm_handle__);
-        }
-
-        const handleField = this.handleField || DEFAULT_HANDLE_FIELD;
-        const records = [...this.records];
-        const order = this.orderBy.find((o) => o.name === handleField);
-        const asc = !order || order.asc;
-
-        // Find indices
-        const fromIndex = records.findIndex((r) => r.id === movedId);
-        let toIndex = 0;
-        if (targetId !== null) {
-            const targetIndex = records.findIndex((r) => r.id === targetId);
-            toIndex = fromIndex > targetIndex ? targetIndex + 1 : targetIndex;
-        }
-
-        const getSequence = (rec) => rec && rec.data[handleField];
-
-        // Determine what records need to be modified
-        const firstIndex = Math.min(fromIndex, toIndex);
-        const lastIndex = Math.max(fromIndex, toIndex) + 1;
-        let reorderAll = false;
-        let lastSequence = (asc ? -1 : 1) * Infinity;
-        for (let index = 0; index < records.length; index++) {
-            const sequence = getSequence(records[index]);
-            if (
-                ((index < firstIndex || index >= lastIndex) &&
-                    ((asc && lastSequence >= sequence) || (!asc && lastSequence <= sequence))) ||
-                (index >= firstIndex && index < lastIndex && lastSequence === sequence)
-            ) {
-                reorderAll = true;
-            }
-            lastSequence = sequence;
-        }
-
-        // Perform the resequence in the list of records
-        const [record] = records.splice(fromIndex, 1);
-        records.splice(toIndex, 0, record);
-
-        // Creates the list of to modify
-        let toReorder = records;
-        if (!reorderAll) {
-            toReorder = toReorder.slice(firstIndex, lastIndex).filter((r) => r.id !== movedId);
-            if (fromIndex < toIndex) {
-                toReorder.push(record);
-            } else {
-                toReorder.unshift(record);
-            }
-        }
-        if (!asc) {
-            toReorder.reverse();
-        }
-
-        const sequences = toReorder.map(getSequence);
-        const offset = sequences.length && Math.min(...sequences);
-
-        const operations = toReorder.map((record, i) => ({
-            operation: "UPDATE",
-            id: record.__bm_handle__,
-            data: { [handleField]: offset + i },
-        }));
-        const lastOperation = operations.pop();
-
-        const parentID = this.model.__bm__.localData[this.__bm_handle__].parentID;
-
-        await Promise.all(
-            operations.map((op) => {
-                this.model.__bm__.notifyChanges(
-                    parentID,
-                    { [this.__fieldName__]: op },
-                    { notifyChange: false, viewType: "form" }
-                );
-            })
-        );
-
-        try {
-            await this.model.__bm__.notifyChanges(
-                parentID,
-                {
-                    [this.__fieldName__]: lastOperation,
-                },
-                { viewType: "form" }
-            );
-        } finally {
-            if (this.__viewType === "list") {
-                await this.model.__bm__.setSort(this.__bm_handle__, handleField);
-            }
-        }
-
-        this.records = records;
-
-        this.__syncData();
-        this.model.notify();
-    }
-
-    async unselectRecord(canDiscard = false) {
-        // something seems wrong with switchMode --> review system?
-        const editedRecord = this.editedRecord;
-        if (!editedRecord) {
-            return true;
-        }
-
-        const isValid = await editedRecord.checkValidity();
-        const handle = editedRecord.__bm_handle__;
-        if (!editedRecord.isDirty && ((canDiscard && editedRecord.isNew) || !isValid)) {
-            this.model.__bm__.discardChanges(handle);
-            if (editedRecord.canBeAbandoned) {
-                this.model.__bm__.removeLine(handle);
-            }
-            this.__syncData();
-            this.editedRecord = null;
-            return await editedRecord.switchMode("readonly");
-        } else if (isValid) {
-            return await editedRecord.switchMode("readonly");
-        }
-        return false;
-    }
-}
-
-export class RelationalModel extends Model {
-    setup(params, { action, dialog, notification }) {
-        this.actionService = action;
-        this.dialogService = dialog;
-        this.notificationService = notification;
-        this.keepLast = new KeepLast();
-
-        if (params.rootType !== "record") {
-            throw "only record root type is supported";
-        }
-
-        this.__component = params.component;
-
-        this.root = null;
-
-        this.__bm__ = new this.constructor.LegacyModel(this, {
-            fields: params.fields || {},
-            modelName: params.resModel,
-            useSampleModel: false, // FIXME AAB
-        });
-        this.__activeFields = params.activeFields;
-        this.__fields = params.fields;
-
-        const res_id = params.resId || undefined;
-        const res_ids = (params.resIds ? toRaw(params.resIds) : null) || (res_id ? [res_id] : []);
-
-        this.__bm_load_params__ = {
-            type: "record",
-            modelName: params.resModel,
-            res_id,
-            res_ids,
-            fields: params.fields || {},
-            viewType: "form",
-        };
-
-        this.initialMode = params.mode;
-
-        this.onWillSaveRecord = params.onWillSaveRecord || (() => {});
-        this.onRecordSaved = params.onRecordSaved || (() => {});
-    }
-
-    async duplicateDatapoint(record, params) {
-        const bm = this.__bm__;
-        const fieldsInfo = mapViews(params.views, this.env);
-        const handle = record.__bm_handle__;
-
-        // Sync with the mutex to wait for potential onchanges
-        await bm.mutex.getUnlockedDef();
-
-        await bm.addFieldsInfo(handle, {
-            fields: params.fields,
-            viewType: params.viewMode,
-            fieldInfo: fieldsInfo[params.viewMode].fieldsInfo[params.viewMode],
-        });
-
-        // determine fieldNames to load (comes from basic_view.js)
-        const legRec = this.__bm__.get(record.__bm_handle__);
-        const viewType = params.viewMode;
-        const viewFields = Object.keys(legRec.fieldsInfo[viewType]);
-        const fieldNames = viewFields.filter((x) => Object.keys(legRec.data).indexOf(x) < 0);
-        const legFieldsInfo = legRec.fieldsInfo[viewType];
-
-        // Suppose that in a form view, there is an x2many list view with
-        // a field F, and that F is also displayed in the x2many form view.
-        // In this case, F is represented in legRec.data (as it is known by
-        // the x2many list view), but the loaded information may not suffice
-        // in the form view (e.g. if field is a many2many list in the form
-        // view, or if it is displayed by a widget requiring specialData).
-        // So when this happens, F is added to the list of fieldNames to fetch.
-        for (const name of viewFields) {
-            if (!fieldNames.includes(name)) {
-                const fieldType = legRec.fields[name].type;
-                const fieldInfo = legFieldsInfo[name];
-                // SpecialData case: field requires specialData that haven't
-                // been fetched yet.
-                if (fieldInfo.specialData && !(name in legRec.specialData)) {
-                    fieldNames.push(name);
-                    continue;
-                }
-
-                // X2Many case: field is an x2many displayed as a list or
-                // kanban view, but the related fields haven't been loaded yet.
-                if (fieldType === "one2many" || fieldType === "many2many") {
-                    if (!("fieldsInfo" in legRec.data[name])) {
-                        fieldNames.push(name);
-                    } else {
-                        const x2mFieldInfo = legRec.fieldsInfo[params.viewMode][name];
-                        const viewType = x2mFieldInfo.viewType || x2mFieldInfo.mode;
-                        const knownFields = Object.keys(
-                            legRec.data[name].fieldsInfo[legRec.data[name].viewType] || {}
-                        );
-                        const newFields = Object.keys(legRec.data[name].fieldsInfo[viewType] || {});
-                        if (newFields.filter((f) => !knownFields.includes(f)).length) {
-                            fieldNames.push(name);
-                        }
-
-                        if (legRec.data[name].viewType === "default") {
-                            // Use case: x2many (tags) in x2many list views
-                            // When opening the x2many legRec form view, the
-                            // x2many will be reloaded but it may not have
-                            // the same fields (ex: tags in list and list in
-                            // form) so we need to merge the fieldsInfo to
-                            // avoid losing the initial fields (display_name)
-                            const fieldViews = fieldInfo.views || fieldInfo.fieldsInfo || {};
-                            const defaultFieldInfo = legRec.data[name].fieldsInfo.default;
-                            Object.values(fieldViews).forEach((fieldView) => {
-                                Object.assign(defaultFieldInfo, fieldView.fields);
-                                Object.values(fieldView.fieldsInfo).forEach((x2mFieldInfo) => {
-                                    Object.assign(defaultFieldInfo, x2mFieldInfo);
-                                });
-                            });
-                        }
-                    }
-                }
-                // Many2one: context is not the same between the different views
-                // this means the result of a name_get could differ
-                if (fieldType === "many2one") {
-                    if (
-                        JSON.stringify(legRec.data[name].context) !==
-                        JSON.stringify(fieldInfo.context)
-                    ) {
-                        fieldNames.push(name);
-                    }
-                }
-            }
-        }
-
-        if (fieldNames.length) {
-            if (this.__bm__.isNew(record.__bm_handle__)) {
-                await this.__bm__.generateDefaultValues(record.__bm_handle__, {
-                    fieldNames: fieldNames,
-                    viewType: viewType,
-                });
-            } else {
-                await this.__bm__.reload(record.__bm_handle__, {
-                    fieldNames: fieldNames,
-                    keepChanges: true,
-                    viewType: viewType,
-                });
-            }
-        }
-
-        const Record = this.constructor.Record;
-        const newRecord = new Record(this, {
-            handle,
-            viewType: params.viewMode,
-            mode: params.mode,
-        });
-
-        const recordSave = Record.prototype.save;
-        record.save = recordSave;
-        record.save = async (...args) => {
-            record.__syncData();
-            const res = await recordSave.call(record, ...args);
-            record.save = recordSave;
-            return res;
-        };
-
-        return newRecord;
-    }
-    async addNewRecord(list, params, withParentId = true) {
-        const parentId = this.__bm__.localData[list.__bm_handle__].parentID;
-        const fieldName = list.__fieldName__;
-        const context = this.__bm__._getContext(this.__bm__.localData[parentId], { fieldName });
-        params.context = makeContext([context, params.context]);
-        params.__syncParent = () => list.__syncData();
-        const newRecord = this.createDataPoint("record", params);
-        if (withParentId) {
-            newRecord.__bm_load_params__.parentID = list.__bm_handle__;
-        }
-        await newRecord.load();
-        return newRecord;
-    }
-    async updateRecord(list, record, params = { isM2M: false }) {
-        let operation;
-        const isM2M = params.isM2M;
-        if (!isM2M) {
-            operation = { operation: "UPDATE", id: record.__bm_handle__ };
-        } else {
-            await record.save({ noReload: true });
-            operation = { operation: "TRIGGER_ONCHANGE" };
-        }
-        await list.__syncParent(operation);
-        if (isM2M) {
-            await record.load();
-        }
-    }
-
-    /**
-     * @param {Object} [params={}]
-     * @param {Comparison | null} [params.comparison]
-     * @param {Context} [params.context]
-     * @param {DomainListRepr} [params.domain]
-     * @param {string[]} [params.groupBy]
-     * @param {Object[]} [params.orderBy]
-     * @param {number} [params.resId] should not be there
-     * @returns {Promise<void>}
-     */
-    async load(params = {}) {
-        if (!this.__bm_load_params__.fieldsInfo) {
-            // only the first time (must wait for the subviews to be loaded)
-            this.__bm_load_params__.fieldsInfo = mapActiveFieldsToFieldsInfo(
-                this.__activeFields || {},
-                this.__fields || {},
-                "form",
-                this.env
-            );
-        }
-        const loadParams = { ...this.__bm_load_params__ };
-        if ("resId" in params) {
-            loadParams.res_id = params.resId || undefined;
-        }
-        if ("context" in params) {
-            loadParams.context = params.context;
-        }
-        const state = this.root ? this.root.exportState() : {};
-        const nextRoot = new this.constructor.Record(
-            this,
-            {
-                __bm_load_params__: loadParams,
-                mode: this.initialMode,
-                onWillSaveRecord: this.onWillSaveRecord,
-                onRecordSaved: this.onRecordSaved,
-            },
-            state
-        );
-        await this.keepLast.add(nextRoot.load());
-        this.root = nextRoot;
-        this.__bm_load_params__ = loadParams;
-        this.notify();
-    }
-    _trigger_up(ev) {
-        const evType = ev.name;
-        const payload = ev.data;
-        if (evType === "call_service") {
-            let args = payload.args || [];
-            if (payload.service === "ajax" && payload.method === "rpc") {
-                // ajax service uses an extra 'target' argument for rpc
-                args = args.concat(ev.target);
-                if (owl.status(this.__component) === "destroyed") {
-                    console.warn("Component is destroyed");
-                    return payload.callback(new Promise(() => {}));
-                }
-                const prom = new Promise((resolve, reject) => {
-                    owl.Component.env.session
-                        .rpc(...args)
-                        .then((value) => {
-                            if (owl.status(this.__component) !== "destroyed") {
-                                resolve(value);
-                            }
-                        })
-                        .guardedCatch((reason) => {
-                            if (owl.status(this.__component) !== "destroyed") {
-                                reject(reason);
-                            }
-                        });
-                });
-                return payload.callback(prom);
-            } else if (payload.service === "notification") {
-                return this.notificationService.add(payload.message, {
-                    className: payload.className,
-                    sticky: payload.sticky,
-                    title: payload.title,
-                    type: payload.type,
-                });
-            }
-            throw new Error(`call service ${payload.service} not handled in relational model`);
-        } else if (evType === "warning") {
-            if (payload.type === "dialog") {
-                return this.dialogService.add(WarningDialog, {
-                    title: payload.title,
-                    message: payload.message,
-                });
-            } else {
-                return this.notificationService.add(payload.message, {
-                    className: payload.className,
-                    sticky: payload.sticky,
-                    title: payload.title,
-                    type: "warning",
-                });
-            }
-        } else if (evType === "do_action") {
-            // SAME CODE AS legacy_service_provider
-            if (payload.action.context) {
-                payload.action.context = new Context(payload.action.context).eval();
-            }
-            const legacyOptions = mapDoActionOptionAPI(payload.options);
-            return this.actionService.doAction(payload.action, legacyOptions);
-        } else if (evType === "reload") {
-            return this.load().then(() => {
-                if (ev.data.onSuccess) {
-                    ev.data.onSuccess();
-                }
-            });
-        }
-        throw new Error(`trigger_up(${evType}) not handled in relational model`);
-    }
-    createDataPoint(type, params, state = {}) {
-        if (type !== "record") {
-            throw new Error("LPE CRASH");
-        }
-        const fieldsInfo = mapActiveFieldsToFieldsInfo(
-            params.activeFields,
-            params.fields,
-            params.viewType,
-            this.env
-        );
-        params = Object.assign({}, params, {
-            __bm_load_params__: {
-                type: "record",
-                modelName: params.resModel,
-                fields: params.fields || {},
-                viewType: "form",
-                fieldsInfo,
-                parentID: params.parentID,
-                context: params.context,
-            },
-        });
-        return new this.constructor.Record(this, params, state);
-    }
-}
-RelationalModel.services = ["action", "dialog", "notification"];
-RelationalModel.LegacyModel = BasicModel;
-RelationalModel.Record = Record;
diff --git a/addons/web/static/src/views/calendar/calendar_arch_parser.js b/addons/web/static/src/views/calendar/calendar_arch_parser.js
index 161751994aa..01d87ce3fa7 100644
--- a/addons/web/static/src/views/calendar/calendar_arch_parser.js
+++ b/addons/web/static/src/views/calendar/calendar_arch_parser.js
@@ -35,7 +35,7 @@ export class CalendarArchParser extends XMLParser {
         let isDateHidden = false;
         let isTimeHidden = false;
         let formViewId = false;
-        const popoverFields = {};
+        const popoverFieldNodes = {};
         const filtersInfo = {};
 
         this.visitXML(arch, (node) => {
@@ -122,7 +122,7 @@ export class CalendarArchParser extends XMLParser {
                         "calendar",
                         jsClass
                     );
-                    popoverFields[fieldName] = fieldInfo;
+                    popoverFieldNodes[fieldName] = fieldInfo;
 
                     const field = fields[fieldName];
                     if (!node.hasAttribute("invisible") || node.hasAttribute("filters")) {
@@ -193,7 +193,7 @@ export class CalendarArchParser extends XMLParser {
             quickCreate,
             isDateHidden,
             isTimeHidden,
-            popoverFields,
+            popoverFieldNodes,
             scale,
             scales,
             showUnusualDays,
diff --git a/addons/web/static/src/views/calendar/calendar_common/calendar_common_popover.js b/addons/web/static/src/views/calendar/calendar_common/calendar_common_popover.js
index e50adc111e0..1bb8e840374 100644
--- a/addons/web/static/src/views/calendar/calendar_common/calendar_common_popover.js
+++ b/addons/web/static/src/views/calendar/calendar_common/calendar_common_popover.js
@@ -1,11 +1,11 @@
 /** @odoo-module **/
 
 import { Dialog } from "@web/core/dialog/dialog";
+import { evalDomain } from "@web/core/domain";
 import { is24HourFormat } from "@web/core/l10n/dates";
 import { Field } from "@web/views/fields/field";
 import { Record } from "@web/views/record";
-import { evalDomain } from "@web/views/utils";
-import { getFormattedDateSpan } from '@web/views/calendar/utils';
+import { getFormattedDateSpan } from "@web/views/calendar/utils";
 
 import { Component } from "@odoo/owl";
 
@@ -19,6 +19,9 @@ export class CalendarCommonPopover extends Component {
         this.computeDateTimeAndDuration();
     }
 
+    get activeFields() {
+        return this.props.model.popoverFields;
+    }
     get isEventEditable() {
         return true;
     }
@@ -29,9 +32,8 @@ export class CalendarCommonPopover extends Component {
         return this.isEventEditable || this.isEventDeletable;
     }
 
-    isInvisible(fieldName, record) {
-        const { invisible } = this.props.model.popoverFields[fieldName].modifiers;
-        return evalDomain(invisible, record.evalContext);
+    isInvisible(fieldNode, record) {
+        return evalDomain(fieldNode.modifiers.invisible, record.evalContext);
     }
 
     computeDateTimeAndDuration() {
diff --git a/addons/web/static/src/views/calendar/calendar_common/calendar_common_popover.xml b/addons/web/static/src/views/calendar/calendar_common/calendar_common_popover.xml
index 48a558a4cfd..ddfdf0d888c 100644
--- a/addons/web/static/src/views/calendar/calendar_common/calendar_common_popover.xml
+++ b/addons/web/static/src/views/calendar/calendar_common/calendar_common_popover.xml
@@ -44,10 +44,10 @@
             </li>
         </ul>
         <ul class="list-group list-group-flush o_cw_popover_fields_secondary">
-            <Record resModel="props.model.resModel" resId="props.record.id" fields="props.model.fields" activeFields="props.model.popoverFields" mode="'readonly'" values="props.record.rawRecord" t-slot-scope="slot">
-                <t t-foreach="slot.record.fieldNames" t-as="fieldName" t-key="fieldName">
-                    <t t-if="!isInvisible(fieldName, slot.record)">
-                        <t t-set="fieldInfo" t-value="props.model.popoverFields[fieldName]" />
+            <Record resModel="props.model.resModel" resId="props.record.id" fields="props.model.fields" activeFields="activeFields" mode="'readonly'" values="props.record.rawRecord" t-slot-scope="slot">
+                <t t-foreach="Object.keys(props.model.popoverFieldNodes)" t-as="fieldId" t-key="fieldId">
+                    <t t-set="fieldInfo" t-value="props.model.popoverFieldNodes[fieldId]"/>
+                    <t t-if="!isInvisible(fieldInfo, slot.record)">
                         <li class="list-group-item flex-shrink-0 d-flex align-items-start" t-att-class="fieldInfo.attrs.class">
                             <strong class="me-2">
                                 <t t-if="fieldInfo.options.icon">
@@ -60,7 +60,7 @@
                                 </t>
                             </strong>
                             <div class="flex-grow-1">
-                                <Field name="fieldName" record="slot.record" fieldInfo="fieldInfo" type="fieldInfo.widget" />
+                                <Field name="fieldInfo.name" record="slot.record" fieldInfo="fieldInfo" type="fieldInfo.widget" />
                             </div>
                         </li>
                     </t>
diff --git a/addons/web/static/src/views/calendar/calendar_controller.js b/addons/web/static/src/views/calendar/calendar_controller.js
index d71a9fcebdb..ada6eeab49f 100644
--- a/addons/web/static/src/views/calendar/calendar_controller.js
+++ b/addons/web/static/src/views/calendar/calendar_controller.js
@@ -5,7 +5,7 @@ import { _t, _lt } from "@web/core/l10n/translation";
 import { useOwnedDialogs, useService } from "@web/core/utils/hooks";
 import { sprintf } from "@web/core/utils/strings";
 import { Layout } from "@web/search/layout";
-import { useModel } from "@web/views/model";
+import { useModelWithSampleData } from "@web/model/model";
 import { FormViewDialog } from "@web/views/view_dialogs/form_view_dialog";
 import { useSetupView } from "@web/views/view_hook";
 import { CalendarDatePicker } from "./date_picker/calendar_date_picker";
@@ -43,7 +43,7 @@ export class CalendarController extends Component {
         this.orm = useService("orm");
         this.displayDialog = useUniqueDialog();
 
-        this.model = useModel(this.props.Model, {
+        this.model = useModelWithSampleData(this.props.Model, {
             ...this.props.archInfo,
             resModel: this.props.resModel,
             domain: this.props.domain,
diff --git a/addons/web/static/src/views/calendar/calendar_model.js b/addons/web/static/src/views/calendar/calendar_model.js
index 4db550bf8ac..016e6f68fa9 100644
--- a/addons/web/static/src/views/calendar/calendar_model.js
+++ b/addons/web/static/src/views/calendar/calendar_model.js
@@ -10,7 +10,8 @@ import { localization } from "@web/core/l10n/localization";
 import { _t } from "@web/core/l10n/translation";
 import { registry } from "@web/core/registry";
 import { KeepLast } from "@web/core/utils/concurrency";
-import { Model } from "@web/views/model";
+import { Model } from "@web/model/model";
+import { extractFieldsFromArchInfo } from "@web/model/relational_model/utils";
 
 export class CalendarModel extends Model {
     setup(params, services) {
@@ -22,8 +23,12 @@ export class CalendarModel extends Model {
 
         const formViewFromConfig = (this.env.config.views || []).find((view) => view[1] === "form");
         const formViewIdFromConfig = formViewFromConfig ? formViewFromConfig[0] : false;
+        const fieldNodes = params.popoverFieldNodes;
+        const { activeFields, fields } = extractFieldsFromArchInfo({ fieldNodes }, params.fields);
         this.meta = {
             ...params,
+            popoverFields: activeFields,
+            fields,
             firstDayOfWeek: localization.weekStart,
             formViewId: params.formViewId || formViewIdFromConfig,
         };
@@ -110,6 +115,9 @@ export class CalendarModel extends Model {
     get isTimeHidden() {
         return this.meta.isTimeHidden;
     }
+    get popoverFieldNodes() {
+        return this.meta.popoverFieldNodes;
+    }
     get popoverFields() {
         return this.meta.popoverFields;
     }
diff --git a/addons/web/static/src/views/debug_items.js b/addons/web/static/src/views/debug_items.js
index 39a40dc0ccd..0557b9c9593 100644
--- a/addons/web/static/src/views/debug_items.js
+++ b/addons/web/static/src/views/debug_items.js
@@ -2,12 +2,12 @@
 
 import { _lt } from "@web/core/l10n/translation";
 import { Dialog } from "@web/core/dialog/dialog";
+import { evalDomain } from "@web/core/domain";
 import { editModelDebug } from "@web/core/debug/debug_utils";
 import { formatDateTime, deserializeDateTime } from "@web/core/l10n/dates";
 import { registry } from "@web/core/registry";
 import { useService } from "@web/core/utils/hooks";
 import { formatMany2one } from "@web/views/fields/formatters";
-import { evalDomain } from "@web/views/utils";
 import { FormViewDialog } from "@web/views/view_dialogs/form_view_dialog";
 
 import { Component, onWillStart, useState, xml } from "@odoo/owl";
@@ -199,16 +199,12 @@ class SetDefaultDialog extends Component {
             condition: "",
             scope: "self",
         };
-        const root = this.props.component.model.root;
-        this.fields = root.fields;
-        this.fieldsInfo = root.activeFields;
-        this.fieldNamesInView = root.fieldNames;
+        this.fields = this.props.record.fields;
+        this.activeFields = this.props.record.activeFields;
+        this.fieldNamesInView = this.props.record.fieldNames;
         this.fieldNamesBlackList = ["message_attachment_count"];
-        this.fieldsValues = root.data;
+        this.fieldsValues = this.props.record.data;
         this.modifierDatas = {};
-        this.fieldNamesInView.forEach((fieldName) => {
-            this.modifierDatas[fieldName] = this.fieldsInfo[fieldName].modifiers;
-        });
         this.defaultFields = this.getDefaultFields();
         this.conditions = this.getConditions();
     }
@@ -217,26 +213,22 @@ class SetDefaultDialog extends Component {
         return this.fieldNamesInView
             .filter((fieldName) => !this.fieldNamesBlackList.includes(fieldName))
             .map((fieldName) => {
-                const modifierData = this.modifierDatas[fieldName];
-                let invisibleOrReadOnly;
-                if (modifierData) {
-                    const evalContext = this.props.component.model.root.evalContext;
-                    invisibleOrReadOnly =
-                        evalDomain(modifierData.invisible, evalContext) ||
-                        evalDomain(modifierData.readonly, evalContext);
-                }
                 const fieldInfo = this.fields[fieldName];
                 const valueDisplayed = this.display(fieldInfo, this.fieldsValues[fieldName]);
                 const value = valueDisplayed[0];
                 const displayed = valueDisplayed[1];
+                const evalContext = this.props.record.evalContext;
                 // ignore fields which are empty, invisible, readonly, o2m or m2m
                 if (
                     !value ||
-                    invisibleOrReadOnly ||
+                    evalDomain(this.activeFields[fieldName].invisible, evalContext) ||
+                    evalDomain(this.activeFields[fieldName].readonly, evalContext) ||
                     fieldInfo.type === "one2many" ||
                     fieldInfo.type === "many2many" ||
                     fieldInfo.type === "binary" ||
-                    this.fieldsInfo[fieldName].options.isPassword
+                    Object.entries(this.props.fieldNodes)
+                        .filter(([key, value]) => value.name === fieldName)
+                        .some(([key, value]) => value.options.isPassword)
                 ) {
                     return false;
                 }
@@ -292,7 +284,7 @@ class SetDefaultDialog extends Component {
             return field.name === this.state.fieldToSet;
         }).value;
         await this.orm.call("ir.default", "set", [
-            this.props.resModel,
+            this.props.record.resModel,
             this.state.fieldToSet,
             fieldToSet,
             this.state.scope === "self",
@@ -305,8 +297,8 @@ class SetDefaultDialog extends Component {
 SetDefaultDialog.template = "web.DebugMenu.SetDefaultDialog";
 SetDefaultDialog.components = { Dialog };
 SetDefaultDialog.props = {
-    resModel: { type: String },
-    component: { type: Component },
+    record: { type: Object },
+    fieldNodes: { type: Object },
     close: { type: Function },
 };
 
@@ -316,8 +308,8 @@ export function setDefaults({ component, env }) {
         description: env._t("Set Defaults"),
         callback: () => {
             env.services.dialog.add(SetDefaultDialog, {
-                resModel: component.props.resModel,
-                component,
+                record: component.model.root,
+                fieldNodes: component.props.archInfo.fieldNodes,
             });
         },
         sequence: 310,
diff --git a/addons/web/static/src/views/fields/ace/ace_field.js b/addons/web/static/src/views/fields/ace/ace_field.js
index c4f4a3e9bc3..ab532b61823 100644
--- a/addons/web/static/src/views/fields/ace/ace_field.js
+++ b/addons/web/static/src/views/fields/ace/ace_field.js
@@ -3,11 +3,11 @@
 import { _lt } from "@web/core/l10n/translation";
 import { registry } from "@web/core/registry";
 import { useBus, useService } from "@web/core/utils/hooks";
-import { formatText } from "../formatters";
 import { standardFieldProps } from "../standard_field_props";
 
 import { CodeEditor } from "@web/core/code_editor/code_editor";
-import { Component, onWillUpdateProps, useState } from "@odoo/owl";
+import { Component, useState } from "@odoo/owl";
+import { useRecordObserver } from "@web/model/relational_model/utils";
 import { useDebounced } from "@web/core/utils/timing";
 
 export class AceField extends Component {
@@ -23,17 +23,13 @@ export class AceField extends Component {
 
     setup() {
         this.cookies = useService("cookie");
-        this.debouncedCommit = useDebounced(this.commitChanges, 10);
+        this.debouncedCommit = useDebounced(this.commitChanges, 5000);
 
-        this.state = useState({
-            onChange: (value) => this.handleChange(value),
-            class: "ace-view-editor",
-            theme: this.theme,
+        this.state = useState({});
+        useRecordObserver((record) => {
+            this.state.value = record.data[this.props.name];
         });
 
-        this.updateCodeEditor(this.props);
-        onWillUpdateProps(this.updateCodeEditor);
-
         const { model } = this.props.record;
         useBus(model.bus, "WILL_SAVE_URGENTLY", () => this.commitChanges());
         useBus(model.bus, "NEED_LOCAL_CHANGES", ({ detail }) =>
@@ -41,26 +37,24 @@ export class AceField extends Component {
         );
     }
 
+    get mode() {
+        return this.props.mode === "xml" ? "qweb" : this.props.mode;
+    }
     get theme() {
         return this.cookies.current.color_scheme === "dark" ? "monokai" : "";
     }
 
     handleChange(newValue) {
+        this.props.record.model.bus.trigger("FIELD_IS_DIRTY", true);
         this.state.value = newValue;
         this.debouncedCommit();
     }
 
-    updateCodeEditor({ record, mode, readonly }) {
-        this.state.value = formatText(record.data[this.props.name]);
-        this.state.mode = mode === "xml" ? "qweb" : mode;
-        this.state.readonly = readonly;
-    }
-
-    commitChanges() {
+    async commitChanges() {
         if (!this.props.readonly) {
             const value = this.state.value;
             if (this.props.record.data[this.props.name] !== value) {
-                return this.props.record.update({ [this.props.name]: value });
+                await this.props.record.update({ [this.props.name]: value });
             }
         }
     }
diff --git a/addons/web/static/src/views/fields/ace/ace_field.xml b/addons/web/static/src/views/fields/ace/ace_field.xml
index f86d50c153b..ab8920630b8 100644
--- a/addons/web/static/src/views/fields/ace/ace_field.xml
+++ b/addons/web/static/src/views/fields/ace/ace_field.xml
@@ -6,8 +6,8 @@
         <div class="o_field_widget oe_form_field o_ace_view_editor oe_ace_open">
             <CodeEditor
                 value="state.value"
-                mode="state.mode"
-                readonly="state.readonly"
+                mode="mode"
+                readonly="props.readonly"
                 onChange.bind="handleChange"
                 class="'ace-view-editor'"
                 theme="theme"
diff --git a/addons/web/static/src/views/fields/badge_selection/badge_selection_field.js b/addons/web/static/src/views/fields/badge_selection/badge_selection_field.js
index fab3376e2c9..5a13d772810 100644
--- a/addons/web/static/src/views/fields/badge_selection/badge_selection_field.js
+++ b/addons/web/static/src/views/fields/badge_selection/badge_selection_field.js
@@ -1,24 +1,32 @@
 /** @odoo-module **/
 
-import { registry } from "@web/core/registry";
-import { _lt } from "@web/core/l10n/translation";
-import { standardFieldProps } from "../standard_field_props";
-
 import { Component } from "@odoo/owl";
+import { _lt } from "@web/core/l10n/translation";
+import { registry } from "@web/core/registry";
+import { useSpecialData } from "@web/views/fields/relational_utils";
+import { standardFieldProps } from "../standard_field_props";
 
 export class BadgeSelectionField extends Component {
     static template = "web.BadgeSelectionField";
     static props = {
         ...standardFieldProps,
+        domain: { type: Array, optional: true },
     };
 
+    setup() {
+        this.type = this.props.record.fields[this.props.name].type;
+        if (this.type === "many2one") {
+            this.specialData = useSpecialData((orm, props) => {
+                const { relation } = props.record.fields[props.name];
+                return orm.call(relation, "name_search", ["", props.domain]);
+            });
+        }
+    }
+
     get options() {
-        switch (this.props.record.fields[this.props.name].type) {
+        switch (this.type) {
             case "many2one":
-                // WOWL: conversion needed while we keep using the legacy model
-                return Object.values(this.props.record.preloadedData[this.props.name]).map((v) => {
-                    return [v.id, v.display_name];
-                });
+                return this.specialData.data;
             case "selection":
                 return this.props.record.fields[this.props.name].selection;
             default:
@@ -27,7 +35,7 @@ export class BadgeSelectionField extends Component {
     }
 
     get string() {
-        switch (this.props.record.fields[this.props.name].type) {
+        switch (this.type) {
             case "many2one":
                 return this.props.record.data[this.props.name]
                     ? this.props.record.data[this.props.name][1]
@@ -42,9 +50,7 @@ export class BadgeSelectionField extends Component {
     }
     get value() {
         const rawValue = this.props.record.data[this.props.name];
-        return this.props.record.fields[this.props.name].type === "many2one" && rawValue
-            ? rawValue[0]
-            : rawValue;
+        return this.type === "many2one" && rawValue ? rawValue[0] : rawValue;
     }
 
     stringify(value) {
@@ -55,7 +61,7 @@ export class BadgeSelectionField extends Component {
      * @param {string | number | false} value
      */
     onChange(value) {
-        switch (this.props.record.fields[this.props.name].type) {
+        switch (this.type) {
             case "many2one":
                 if (value === false) {
                     this.props.record.update({ [this.props.name]: false });
@@ -77,17 +83,9 @@ export const badgeSelectionField = {
     displayName: _lt("Badges"),
     supportedTypes: ["many2one", "selection"],
     isEmpty: (record, fieldName) => record.data[fieldName] === false,
-    legacySpecialData: "_fetchSpecialMany2ones",
+    extractProps: (fieldInfo, dynamicInfo) => ({
+        domain: dynamicInfo.domain(),
+    }),
 };
 
 registry.category("fields").add("selection_badge", badgeSelectionField);
-
-export function preloadSelection(orm, record, fieldName, { domain }) {
-    const field = record.fields[fieldName];
-    return orm.call(field.relation, "name_search", ["", domain]);
-}
-
-registry.category("preloadedData").add("selection_badge", {
-    loadOnTypes: ["many2one"],
-    preload: preloadSelection,
-});
diff --git a/addons/web/static/src/views/fields/binary/binary_field.js b/addons/web/static/src/views/fields/binary/binary_field.js
index 44adb9064c9..6de9d6c31f9 100644
--- a/addons/web/static/src/views/fields/binary/binary_field.js
+++ b/addons/web/static/src/views/fields/binary/binary_field.js
@@ -8,7 +8,7 @@ import { standardFieldProps } from "../standard_field_props";
 import { FileUploader } from "../file_handler";
 import { _lt } from "@web/core/l10n/translation";
 
-import { Component, onWillUpdateProps, useState } from "@odoo/owl";
+import { Component } from "@odoo/owl";
 export class BinaryField extends Component {
     static template = "web.BinaryField";
     static components = {
@@ -25,20 +25,17 @@ export class BinaryField extends Component {
 
     setup() {
         this.notification = useService("notification");
-        this.state = useState({
-            fileName: this.props.record.data[this.props.fileNameField] || "",
-        });
-        onWillUpdateProps((nextProps) => {
-            this.state.fileName = nextProps.record.data[nextProps.fileNameField] || "";
-        });
     }
 
     get fileName() {
-        return this.state.fileName || this.props.record.data[this.props.name] || "";
+        return (
+            this.props.record.data[this.props.fileNameField] ||
+            this.props.record.data[this.props.name] ||
+            ""
+        );
     }
 
     update({ data, name }) {
-        this.state.fileName = name || "";
         const { fileNameField, record } = this.props;
         const changes = { [this.props.name]: data || false };
         if (fileNameField in record.fields && record.data[fileNameField] !== name) {
diff --git a/addons/web/static/src/views/fields/binary/binary_field.xml b/addons/web/static/src/views/fields/binary/binary_field.xml
index 92b9adeaee3..2e90c452f61 100644
--- a/addons/web/static/src/views/fields/binary/binary_field.xml
+++ b/addons/web/static/src/views/fields/binary/binary_field.xml
@@ -56,7 +56,7 @@
         <t t-elif="props.record.resId and props.record.data[props.name]">
             <a class="o_form_uri" href="#" t-on-click.prevent="onFileDownload">
                 <span class="fa fa-download me-2" />
-                <t t-if="state.fileName" t-esc="state.fileName" />
+                <t t-if="fileName" t-esc="fileName" />
             </a>
         </t>
     </t>
diff --git a/addons/web/static/src/views/fields/color/color_field.js b/addons/web/static/src/views/fields/color/color_field.js
index b258402870d..631e98b7e01 100644
--- a/addons/web/static/src/views/fields/color/color_field.js
+++ b/addons/web/static/src/views/fields/color/color_field.js
@@ -1,6 +1,6 @@
 /** @odoo-module **/
 
-import { Component, onWillUpdateProps, useState } from "@odoo/owl";
+import { Component } from "@odoo/owl";
 import { registry } from "@web/core/registry";
 import { standardFieldProps } from "../standard_field_props";
 
@@ -10,14 +10,8 @@ export class ColorField extends Component {
         ...standardFieldProps,
     };
 
-    setup() {
-        this.state = useState({
-            color: this.props.record.data[this.props.name] || "",
-        });
-
-        onWillUpdateProps((nextProps) => {
-            this.state.color = nextProps.record.data[nextProps.name] || "";
-        });
+    get color() {
+        return this.props.record.data[this.props.name] || "";
     }
 }
 
diff --git a/addons/web/static/src/views/fields/color/color_field.xml b/addons/web/static/src/views/fields/color/color_field.xml
index dddf2f5af6c..098102da6d9 100644
--- a/addons/web/static/src/views/fields/color/color_field.xml
+++ b/addons/web/static/src/views/fields/color/color_field.xml
@@ -2,8 +2,8 @@
 <templates xml:space="preserve">
 
     <t t-name="web.ColorField" owl="1">
-        <div class="o_field_color d-flex" t-att-class="{ 'o_field_cursor_disabled': props.readonly }" t-attf-style="background: #{state.color or 'url(/web/static/img/transparent.png)'}">
-            <input t-on-click.stop="" class="w-100 h-100 opacity-0" type="color" t-att-value="state.color" t-att-disabled="props.readonly" t-on-input="(ev) => this.state.color = ev.target.value" t-on-change="(ev) => this.props.record.update({ [this.props.name]: ev.target.value })" />
+        <div class="o_field_color d-flex" t-att-class="{ 'o_field_cursor_disabled': props.readonly }" t-attf-style="background: #{color or 'url(/web/static/img/transparent.png)'}">
+            <input t-on-click.stop="" class="w-100 h-100 opacity-0" type="color" t-att-value="color" t-att-disabled="props.readonly" t-on-input="(ev) => this.color = ev.target.value" t-on-change="(ev) => this.props.record.update({ [this.props.name]: ev.target.value })" />
         </div>
     </t>
 
diff --git a/addons/web/static/src/views/fields/copy_clipboard/copy_clipboard_field.js b/addons/web/static/src/views/fields/copy_clipboard/copy_clipboard_field.js
index a8f1aa5583c..1f3096f52ba 100644
--- a/addons/web/static/src/views/fields/copy_clipboard/copy_clipboard_field.js
+++ b/addons/web/static/src/views/fields/copy_clipboard/copy_clipboard_field.js
@@ -1,8 +1,8 @@
 /** @odoo-module **/
 
+import { evalDomain } from "@web/core/domain";
 import { _lt } from "@web/core/l10n/translation";
 import { evaluateExpr } from "@web/core/py_js/py";
-import { evalDomain } from "@web/views/utils";
 import { registry } from "@web/core/registry";
 import { omit } from "@web/core/utils/objects";
 
diff --git a/addons/web/static/src/views/fields/field.js b/addons/web/static/src/views/fields/field.js
index 9e3ce5d3932..b48aac5020d 100644
--- a/addons/web/static/src/views/fields/field.js
+++ b/addons/web/static/src/views/fields/field.js
@@ -1,19 +1,17 @@
 /** @odoo-module **/
 
-import { makeContext } from "@web/core/context";
-import { Domain } from "@web/core/domain";
+import { Domain, evalDomain } from "@web/core/domain";
 import { evaluateExpr } from "@web/core/py_js/py";
 import { registry } from "@web/core/registry";
-import {
-    archParseBoolean,
-    evalDomain,
-    getClassNameFromDecoration,
-    X2M_TYPES,
-} from "@web/views/utils";
+import { utils } from "@web/core/ui/ui_service";
+import { getFieldContext } from "@web/model/relational_model/utils";
+import { archParseBoolean, getClassNameFromDecoration, X2M_TYPES } from "@web/views/utils";
 import { getTooltipInfo } from "./field_tooltip";
 
 import { Component, xml } from "@odoo/owl";
 
+const isSmall = utils.isSmall;
+
 const viewRegistry = registry.category("views");
 const fieldRegistry = registry.category("fields");
 
@@ -55,11 +53,63 @@ export function fieldVisualFeedback(field, record, fieldName, fieldInfo) {
     return {
         readonly,
         required: evalDomain(modifiers.required, record.evalContext),
-        invalid: record.isInvalid(fieldName),
+        invalid: record.isFieldInvalid(fieldName),
         empty,
     };
 }
 
+export function getPropertyFieldInfo(propertyField) {
+    const { name, relatedPropertyField, string, type } = propertyField;
+
+    const fieldInfo = {
+        name,
+        string,
+        type,
+        widget: type,
+        options: {},
+        modifiers: {},
+        attrs: {},
+        relatedPropertyField,
+
+        // ??? We don t use it ? But it s in the fieldInfo of the field
+        context: "{}",
+        help: undefined,
+        onChange: false,
+        forceSave: false,
+        alwaysInvisible: false,
+        decorations: {},
+        // ???
+    };
+
+    if (type === "many2one" || type === "many2many") {
+        const { domain, relation } = propertyField;
+        fieldInfo.relation = relation;
+        fieldInfo.domain = domain;
+
+        if (relation === "res.users" || relation === "res.partner") {
+            fieldInfo.widget =
+                propertyField.type === "many2one" ? "many2one_avatar" : "many2many_tags_avatar";
+        } else {
+            fieldInfo.widget = propertyField.type === "many2one" ? type : "many2many_tags";
+        }
+    } else if (type === "tags") {
+        fieldInfo.tags = propertyField.tags;
+        fieldInfo.widget = `property_tags`;
+    } else if (type === "selection") {
+        fieldInfo.selection = propertyField.selection;
+    }
+
+    fieldInfo.field = getFieldFromRegistry(propertyField.type, fieldInfo.widget);
+    let { relatedFields } = fieldInfo.field;
+    if (relatedFields) {
+        if (relatedFields instanceof Function) {
+            relatedFields = relatedFields({ options: {}, attrs: {} });
+        }
+        fieldInfo.relatedFields = Object.fromEntries(relatedFields.map((f) => [f.name, f]));
+    }
+
+    return fieldInfo;
+}
 export class Field extends Component {
     setup() {
         if (this.props.fieldInfo) {
@@ -134,21 +184,7 @@ export class Field extends Component {
                 }
                 const dynamicInfo = {
                     get context() {
-                        const evalContext = record.getEvalContext
-                            ? record.getEvalContext(false)
-                            : record.evalContext;
-
-                        const context = {};
-                        for (const key in record.context) {
-                            if (!key.startsWith("default_") && !key.endsWith("_view_ref")) {
-                                context[key] = record.context[key];
-                            }
-                        }
-
-                        return {
-                            ...context,
-                            ...makeContext([fieldInfo.context], evalContext),
-                        };
+                        return getFieldContext(record, fieldInfo.name, fieldInfo.context);
                     },
                     domain() {
                         const evalContext = record.getEvalContext
@@ -256,43 +292,59 @@ Field.parseFieldNode = function (node, models, modelName, viewType, jsClass) {
             fieldInfo.attrs[name] = value;
         }
     }
+    if (name === "id") {
+        fieldInfo.modifiers.readonly = true;
+    }
+
+    if (widget === "handle") {
+        fieldInfo.isHandle = true;
+    }
 
     if (X2M_TYPES.includes(fields[name].type)) {
         const views = {};
-        for (const child of node.children) {
-            const viewType = child.tagName === "tree" ? "list" : child.tagName;
-            const { ArchParser } = viewRegistry.get(viewType);
-            const xmlSerializer = new XMLSerializer();
-            const subArch = xmlSerializer.serializeToString(child);
-            const archInfo = new ArchParser().parse(subArch, models, fields[name].relation);
-            views[viewType] = {
-                ...archInfo,
-                fields: models[fields[name].relation],
-            };
-            fieldInfo.relatedFields = models[fields[name].relation];
-        }
-
-        let viewMode = node.getAttribute("mode");
-        if (!viewMode) {
-            if (views.list && !views.kanban) {
-                viewMode = "list";
-            } else if (!views.list && views.kanban) {
-                viewMode = "kanban";
-            } else if (views.list && views.kanban) {
-                viewMode = "list,kanban";
-            }
-        } else {
-            viewMode = viewMode.replace("tree", "list");
-        }
-        fieldInfo.viewMode = viewMode;
-        fieldInfo.views = views;
-
-        let relatedFields = field.relatedFields;
+        let relatedFields = fieldInfo.field.relatedFields;
         if (relatedFields) {
             if (relatedFields instanceof Function) {
                 relatedFields = relatedFields(fieldInfo);
             }
-            fieldInfo.relatedFields = Object.fromEntries(relatedFields.map((f) => [f.name, f]));
+            relatedFields = Object.fromEntries(relatedFields.map((f) => [f.name, f]));
+            views.default = { fieldNodes: relatedFields, fields: relatedFields };
+            fieldInfo.viewMode = "default";
+        } else {
+            for (const child of node.children) {
+                const viewType = child.tagName === "tree" ? "list" : child.tagName;
+                const { ArchParser } = viewRegistry.get(viewType);
+                const xmlSerializer = new XMLSerializer();
+                const subArch = xmlSerializer.serializeToString(child);
+                const archInfo = new ArchParser().parse(subArch, models, fields[name].relation);
+                views[viewType] = {
+                    ...archInfo,
+                    limit: archInfo.limit || 40,
+                    fields: models[fields[name].relation],
+                };
+            }
+
+            let viewMode = node.getAttribute("mode");
+            if (!viewMode) {
+                if (views.list && !views.kanban) {
+                    viewMode = "list";
+                } else if (!views.list && views.kanban) {
+                    viewMode = "kanban";
+                } else if (views.list && views.kanban) {
+                    viewMode = isSmall() ? "kanban" : "list";
+                }
+            } else {
+                if (viewMode.split(",").length !== 1) {
+                    viewMode = isSmall() ? "kanban" : "list";
+                } else {
+                    viewMode = viewMode === "tree" ? "list" : viewMode;
+                }
+            }
+            fieldInfo.viewMode = viewMode;
+        }
+        if (Object.keys(views).length) {
+            fieldInfo.relatedFields = models[fields[name].relation];
+            fieldInfo.views = views;
         }
     }
 
diff --git a/addons/web/static/src/views/fields/font_selection/font_selection_field.js b/addons/web/static/src/views/fields/font_selection/font_selection_field.js
index 0ac405a6997..f9a01d6b21d 100644
--- a/addons/web/static/src/views/fields/font_selection/font_selection_field.js
+++ b/addons/web/static/src/views/fields/font_selection/font_selection_field.js
@@ -49,7 +49,6 @@ export const fontSelectionField = {
             required: dynamicInfo.required,
         };
     },
-    legacySpecialData: "_fetchSpecialRelation",
 };
 
 registry.category("fields").add("font", fontSelectionField);
diff --git a/addons/web/static/src/views/fields/formatters.js b/addons/web/static/src/views/fields/formatters.js
index 197fe8fb485..05d391a9a82 100644
--- a/addons/web/static/src/views/fields/formatters.js
+++ b/addons/web/static/src/views/fields/formatters.js
@@ -133,10 +133,7 @@ export function formatBoolean(value) {
 }
 
 /**
- * Returns a string representing a char.  If the value is false, then we return
- * an empty string.
- *
- * @param {string|false} value
+ * @param {string} value
  * @param {Object} [options] additional options
  * @param {boolean} [options.escape=false] if true, escapes the formatted value
  * @param {boolean} [options.isPassword=false] if true, returns '********'
@@ -144,7 +141,6 @@ export function formatBoolean(value) {
  * @returns {string}
  */
 export function formatChar(value, options) {
-    value = typeof value === "string" ? value : "";
     if (options && options.isPassword) {
         return "*".repeat(value ? value.length : 0);
     }
@@ -487,16 +483,6 @@ export function formatSelection(value, options = {}) {
     return option ? option[1] : "";
 }
 
-/**
- * Returns the value or an empty string if it's falsy.
- *
- * @param {string | false} value
- * @returns {string}
- */
-export function formatText(value) {
-    return value || "";
-}
-
 export function formatJson(value) {
     return (value && JSON.stringify(value)) || "";
 }
@@ -524,4 +510,4 @@ registry
     .add("properties_definition", formatProperties)
     .add("reference", formatReference)
     .add("selection", formatSelection)
-    .add("text", formatText);
+    .add("text", (value) => value);
diff --git a/addons/web/static/src/views/fields/image/image_field.js b/addons/web/static/src/views/fields/image/image_field.js
index 16a42a37e55..13067aeaa7b 100644
--- a/addons/web/static/src/views/fields/image/image_field.js
+++ b/addons/web/static/src/views/fields/image/image_field.js
@@ -9,7 +9,7 @@ import { isBinarySize } from "@web/core/utils/binary";
 import { FileUploader } from "../file_handler";
 import { standardFieldProps } from "../standard_field_props";
 
-import { Component, useState, onWillUpdateProps } from "@odoo/owl";
+import { Component, useState } from "@odoo/owl";
 const { DateTime } = luxon;
 
 export const fileTypeMagicWordMap = {
@@ -49,6 +49,7 @@ export class ImageField extends Component {
         acceptedFileExtensions: { type: String, optional: true },
         width: { type: Number, optional: true },
         height: { type: Number, optional: true },
+        noReload: { type: Boolean, optional: true },
     };
     static defaultProps = {
         acceptedFileExtensions: "image/*",
@@ -61,15 +62,11 @@ export class ImageField extends Component {
         this.state = useState({
             isValid: true,
         });
+        this.lastURL = undefined;
+    }
 
-        this.rawCacheKey = this.props.record.data.write_date;
-        onWillUpdateProps((nextProps) => {
-            const { record } = this.props;
-            const { record: nextRecord } = nextProps;
-            if (record.resId !== nextRecord.resId || nextRecord.mode === "readonly") {
-                this.rawCacheKey = nextRecord.data.write_date;
-            }
-        });
+    get rawCacheKey() {
+        return this.props.record.data.write_date;
     }
 
     get sizeStyle() {
@@ -101,12 +98,12 @@ export class ImageField extends Component {
     }
 
     getUrl(previewFieldName) {
+        if (this.props.noReload && this.lastURL) {
+            return this.lastURL;
+        }
         if (this.state.isValid && this.props.record.data[this.props.name]) {
             if (isBinarySize(this.props.record.data[this.props.name])) {
-                if (!this.rawCacheKey) {
-                    this.rawCacheKey = this.props.record.data.write_date;
-                }
-                return url("/web/image", {
+                this.lastURL = url("/web/image", {
                     model: this.props.record.resModel,
                     id: this.props.record.resId,
                     field: previewFieldName,
@@ -116,8 +113,11 @@ export class ImageField extends Component {
                 // Use magic-word technique for detecting image type
                 const magic =
                     fileTypeMagicWordMap[this.props.record.data[this.props.name][0]] || "png";
-                return `data:image/${magic};base64,${this.props.record.data[this.props.name]}`;
+                this.lastURL = `data:image/${magic};base64,${
+                    this.props.record.data[this.props.name]
+                }`;
             }
+            return this.lastURL;
         }
         return placeholder;
     }
@@ -127,8 +127,6 @@ export class ImageField extends Component {
     }
     async onFileUploaded(info) {
         this.state.isValid = true;
-        // Invalidate the `rawCacheKey`.
-        this.rawCacheKey = null;
         if (info.type === 'image/webp') {
             // Generate alternate sizes and format for reports.
             const image = document.createElement('img');
@@ -230,6 +228,7 @@ export const imageField = {
         acceptedFileExtensions: options.accepted_file_extensions,
         width: options.size && Boolean(options.size[0]) ? options.size[0] : attrs.width,
         height: options.size && Boolean(options.size[1]) ? options.size[1] : attrs.height,
+        noReload: Boolean(options.no_reload),
     }),
 };
 
diff --git a/addons/web/static/src/views/fields/input_field_hook.js b/addons/web/static/src/views/fields/input_field_hook.js
index 0660f24a3d8..b44054d60e7 100644
--- a/addons/web/static/src/views/fields/input_field_hook.js
+++ b/addons/web/static/src/views/fields/input_field_hook.js
@@ -113,7 +113,11 @@ export function useInputField(params) {
      * If it is not such a case, we update the field with the new value.
      */
     useEffect(() => {
-        if (inputRef.el && !isDirty && !component.props.record.isInvalid(component.props.name)) {
+        if (
+            inputRef.el &&
+            !isDirty &&
+            !component.props.record.isFieldInvalid(component.props.name)
+        ) {
             inputRef.el.value = params.getValue();
             lastSetValue = inputRef.el.value;
         }
@@ -154,10 +158,9 @@ export function useInputField(params) {
             }
 
             if ((val || false) !== (component.props.record.data[component.props.name] || false)) {
-                const nextValue = inputRef.el.value;
+                lastSetValue = inputRef.el.value;
                 await component.props.record.update({ [component.props.name]: val });
                 component.props.record.model.bus.trigger("FIELD_IS_DIRTY", false);
-                lastSetValue = nextValue;
             }
         }
     }
diff --git a/addons/web/static/src/views/fields/many2many_binary/many2many_binary_field.js b/addons/web/static/src/views/fields/many2many_binary/many2many_binary_field.js
index 9c834abe4e8..51732d65a84 100644
--- a/addons/web/static/src/views/fields/many2many_binary/many2many_binary_field.js
+++ b/addons/web/static/src/views/fields/many2many_binary/many2many_binary_field.js
@@ -30,7 +30,12 @@ export class Many2ManyBinaryField extends Component {
         return this.props.record.fields[this.props.name].string;
     }
     get files() {
-        return this.props.record.data[this.props.name].records.map((record) => record.data);
+        return this.props.record.data[this.props.name].records.map((record) => {
+            return {
+                ...record.data,
+                id: record.resId,
+            };
+        });
     }
 
     getUrl(id) {
@@ -55,7 +60,7 @@ export class Many2ManyBinaryField extends Component {
 
     async onFileRemove(deleteId) {
         const record = this.props.record.data[this.props.name].records.find(
-            (record) => record.data.id === deleteId
+            (record) => record.resId === deleteId
         );
         this.operations.removeRecord(record);
     }
diff --git a/addons/web/static/src/views/fields/many2many_checkboxes/many2many_checkboxes_field.js b/addons/web/static/src/views/fields/many2many_checkboxes/many2many_checkboxes_field.js
index e65bedfed48..cf7170e4bd7 100644
--- a/addons/web/static/src/views/fields/many2many_checkboxes/many2many_checkboxes_field.js
+++ b/addons/web/static/src/views/fields/many2many_checkboxes/many2many_checkboxes_field.js
@@ -1,41 +1,76 @@
 /** @odoo-module **/
 
+import { Component, onWillUnmount } from "@odoo/owl";
 import { CheckBox } from "@web/core/checkbox/checkbox";
 import { _lt } from "@web/core/l10n/translation";
 import { registry } from "@web/core/registry";
+import { useBus } from "@web/core/utils/hooks";
+import { debounce } from "@web/core/utils/timing";
+import { useSpecialData } from "@web/views/fields/relational_utils";
 import { standardFieldProps } from "../standard_field_props";
 
-import { Component } from "@odoo/owl";
-
 export class Many2ManyCheckboxesField extends Component {
     static template = "web.Many2ManyCheckboxesField";
     static components = { CheckBox };
     static props = {
         ...standardFieldProps,
+        domain: { type: Array, optional: true },
     };
 
+    setup() {
+        this.specialData = useSpecialData((orm, props) => {
+            const { relation } = props.record.fields[props.name];
+            return orm.call(relation, "name_search", ["", props.domain]);
+        });
+        // these two sets track pending changes in the relation, and allow us to
+        // batch consecutive changes into a single replaceWith, thus saving
+        // unnecessary potential intermediate onchanges
+        this.idsToAdd = new Set();
+        this.idsToRemove = new Set();
+        this.debouncedCommitChanges = debounce(this.commitChanges.bind(this), 500);
+        useBus(this.props.record.model.bus, "NEED_LOCAL_CHANGES", this.commitChanges.bind(this));
+        onWillUnmount(this.commitChanges.bind(this));
+    }
+
     get items() {
-        return this.props.record.preloadedData[this.props.name];
+        return this.specialData.data;
     }
 
     isSelected(item) {
         return this.props.record.data[this.props.name].currentIds.includes(item[0]);
     }
 
+    commitChanges() {
+        if (this.idsToAdd.size === 0 && this.idsToRemove.size === 0) {
+            return;
+        }
+        const ids = new Set(this.props.record.data[this.props.name].currentIds);
+        for (const el of this.idsToAdd) {
+            ids.add(el);
+        }
+        for (const el of this.idsToRemove) {
+            ids.delete(el);
+        }
+        this.idsToAdd.clear();
+        this.idsToRemove.clear();
+        return this.props.record.data[this.props.name].replaceWith([...ids]);
+    }
+
     onChange(resId, checked) {
         if (checked) {
-            this.props.record.data[this.props.name].replaceWith([
-                ...this.props.record.data[this.props.name].currentIds,
-                resId,
-            ]);
-        } else {
-            const currentIds = [...this.props.record.data[this.props.name].currentIds];
-            const index = currentIds.indexOf(resId);
-            if (index > -1) {
-                currentIds.splice(index, 1);
+            if (this.idsToRemove.has(resId)) {
+                this.idsToRemove.delete(resId);
+            } else {
+                this.idsToAdd.add(resId);
+            }
+        } else {
+            if (this.idsToAdd.has(resId)) {
+                this.idsToAdd.delete(resId);
+            } else {
+                this.idsToRemove.add(resId);
             }
-            this.props.record.data[this.props.name].replaceWith(currentIds);
         }
+        this.debouncedCommitChanges();
     }
 }
 
@@ -44,7 +79,11 @@ export const many2ManyCheckboxesField = {
     displayName: _lt("Checkboxes"),
     supportedTypes: ["many2many"],
     isEmpty: () => false,
-    legacySpecialData: "_fetchSpecialRelation",
+    extractProps(fieldInfo, dynamicInfo) {
+        return {
+            domain: dynamicInfo.domain(),
+        };
+    },
 };
 
 registry.category("fields").add("many2many_checkboxes", many2ManyCheckboxesField);
@@ -53,8 +92,3 @@ export function preloadMany2ManyCheckboxes(orm, record, fieldName, { domain }) {
     const field = record.fields[fieldName];
     return orm.call(field.relation, "name_search", ["", domain]);
 }
-
-registry.category("preloadedData").add("many2many_checkboxes", {
-    loadOnTypes: ["many2many"],
-    preload: preloadMany2ManyCheckboxes,
-});
diff --git a/addons/web/static/src/views/fields/many2many_tags/many2many_tags_field.js b/addons/web/static/src/views/fields/many2many_tags/many2many_tags_field.js
index 349fb4cb0e9..045fa4ebffd 100644
--- a/addons/web/static/src/views/fields/many2many_tags/many2many_tags_field.js
+++ b/addons/web/static/src/views/fields/many2many_tags/many2many_tags_field.js
@@ -271,7 +271,6 @@ export const many2ManyTagsField = {
         },
     ],
     supportedTypes: ["many2many"],
-    isSet: (value) => value.count > 0,
     relatedFields: ({ options }) => {
         const relatedFields = [{ name: "display_name", type: "char" }];
         if (options.color_field) {
diff --git a/addons/web/static/src/views/fields/many2one/many2one_field.js b/addons/web/static/src/views/fields/many2one/many2one_field.js
index d737d8a9464..c720ac13c04 100644
--- a/addons/web/static/src/views/fields/many2one/many2one_field.js
+++ b/addons/web/static/src/views/fields/many2one/many2one_field.js
@@ -106,11 +106,9 @@ export class Many2OneField extends Component {
                 const resId = this.value[0];
                 const fields = ["display_name"];
                 const { context } = this.props;
+                // use unity read + relatedFields from Field Component
                 const records = await this.orm.read(this.relation, [resId], fields, { context });
                 await this.updateRecord(m2oTupleFromData(records[0]));
-                if (this.props.record.model.root.id !== this.props.record.id) {
-                    this.props.record.switchMode("readonly");
-                }
             },
             onClose: () => this.focusInput(),
             fieldString: this.string,
diff --git a/addons/web/static/src/views/fields/progress_bar/progress_bar_field.js b/addons/web/static/src/views/fields/progress_bar/progress_bar_field.js
index ca7c78aba27..711896b19d2 100644
--- a/addons/web/static/src/views/fields/progress_bar/progress_bar_field.js
+++ b/addons/web/static/src/views/fields/progress_bar/progress_bar_field.js
@@ -6,9 +6,8 @@ import { useNumpadDecimal } from "../numpad_decimal_hook";
 import { parseFloat } from "../parsers";
 import { standardFieldProps } from "../standard_field_props";
 
-import { Component, onWillUpdateProps, useRef, useState } from "@odoo/owl";
+import { Component, useRef, useState } from "@odoo/owl";
 const formatters = registry.category("formatters");
-const parsers = registry.category("parsers");
 
 export class ProgressBarField extends Component {
     static template = "web.ProgressBarField";
@@ -28,76 +27,66 @@ export class ProgressBarField extends Component {
         this.root = useRef("numpadDecimal");
         this.maxValueRef = useRef("maxValue");
         this.currentValueRef = useRef("currentValue");
+
+        const { currentValueField, maxValueField, name } = this.props;
+        this.currentValueField = currentValueField ? currentValueField : name;
+        if (maxValueField) {
+            this.maxValueField = maxValueField;
+        }
+
         this.state = useState({
-            currentValue: this.getCurrentValue(this.props),
-            maxValue: this.getMaxValue(this.props),
             isEditing: false,
         });
-        onWillUpdateProps((nextProps) => {
-            Object.assign(this.state, {
-                currentValue: this.getCurrentValue(nextProps),
-                maxValue: this.getMaxValue(nextProps),
-            });
-        });
     }
 
-    get isCurrentValueInteger() {
-        return this.state.currentValue % 1 === 0;
-    }
     get isEditable() {
         return this.props.isEditable && !this.props.readonly;
     }
-    get isMaxValueInteger() {
-        return this.state.maxValue % 1 === 0;
-    }
     get isPercentage() {
         return !this.props.maxValueField || !isNaN(this.props.maxValueField);
     }
 
-    getCurrentValueField(p) {
-        return typeof p.currentValueField === "string" ? p.currentValueField : p.name;
-    }
-    getMaxValueField(p) {
-        return typeof p.maxValueField === "string" ? p.maxValueField : p.name;
+    get currentValue() {
+        return this.props.record.data[this.currentValueField] || 0;
     }
 
-    getCurrentValue(p) {
-        return p.record.data[this.getCurrentValueField(p)] || 0;
-    }
-    getMaxValue(p) {
-        if (p.maxValueField) {
-            return p.record.data[p.maxValueField] || 100;
-        }
-        return 100;
+    get maxValue() {
+        return this.props.record.data[this.maxValueField] || 100;
     }
 
     formatCurrentValue(humanReadable = !this.state.isEditing) {
-        const formatter = formatters.get(this.isCurrentValueInteger ? "integer" : "float");
-        return formatter(this.state.currentValue, { humanReadable });
+        const formatter = formatters.get(Number.isInteger(this.currentValue) ? "integer" : "float");
+        return formatter(this.currentValue, { humanReadable });
     }
     formatMaxValue(humanReadable = !this.state.isEditing) {
-        const formatter = formatters.get(this.isMaxValueInteger ? "integer" : "float");
-        return formatter(this.state.maxValue, { humanReadable });
+        const formatter = formatters.get(Number.isInteger(this.maxValue) ? "integer" : "float");
+        return formatter(this.maxValue, { humanReadable });
     }
 
-    onCurrentValueChange(ev) {
+    onValueChange(value, fieldName) {
         let parsedValue;
         try {
-            parsedValue = parseFloat(ev.target.value);
+            parsedValue = parseFloat(value);
         } catch {
             this.props.record.setInvalidField(this.props.name);
             return;
         }
 
-        if (this.isCurrentValueInteger) {
+        if (this.props.record.fields[fieldName].type === "integer") {
             parsedValue = Math.floor(parsedValue);
         }
-        this.state.currentValue = parsedValue;
-        this.props.record.update({ [this.getCurrentValueField(this.props)]: parsedValue });
+        this.props.record.update({ [fieldName]: parsedValue });
         if (this.props.readonly) {
             this.props.record.save();
         }
     }
+    onCurrentValueChange(ev) {
+        this.onValueChange(ev.target.value, this.currentValueField);
+    }
+    onMaxValueChange(ev) {
+        this.onValueChange(ev.target.value, this.maxValueField);
+    }
+
     onInputBlur() {
         if (
             document.activeElement !== this.maxValueRef.el &&
@@ -109,40 +98,6 @@ export class ProgressBarField extends Component {
     onInputFocus() {
         this.state.isEditing = true;
     }
-    onMaxValueChange(ev) {
-        let parsedValue;
-        try {
-            parsedValue = parseFloat(ev.target.value);
-        } catch {
-            this.props.record.setInvalidField(this.props.name);
-            return;
-        }
-
-        if (this.isMaxValueInteger) {
-            parsedValue = Math.floor(parsedValue);
-        }
-        this.state.maxValue = parsedValue;
-        this.props.record.update({ [this.getMaxValueField(this.props)]: parsedValue });
-        if (this.props.readonly) {
-            this.props.record.save();
-        }
-    }
-    onCurrentValueInput(ev) {
-        const parser = parsers.get(this.isCurrentValueInteger ? "integer" : "float");
-        try {
-            this.state.currentValue = parser(ev.target.value);
-        } catch {
-            // pass
-        }
-    }
-    onMaxValueInput(ev) {
-        const parser = parsers.get(this.isMaxValueInteger ? "integer" : "float");
-        try {
-            this.state.maxValue = parser(ev.target.value);
-        } catch {
-            // pass
-        }
-    }
 }
 
 export const progressBarField = {
diff --git a/addons/web/static/src/views/fields/progress_bar/progress_bar_field.xml b/addons/web/static/src/views/fields/progress_bar/progress_bar_field.xml
index a3ae7201445..31f11ac64b6 100644
--- a/addons/web/static/src/views/fields/progress_bar/progress_bar_field.xml
+++ b/addons/web/static/src/views/fields/progress_bar/progress_bar_field.xml
@@ -4,8 +4,8 @@
     <t t-name="web.ProgressBarField" owl="1">
         <div class="o_progressbar w-100 d-flex align-items-center" t-ref="numpadDecimal">
             <div t-if="props.title" class="o_progressbar_title text-nowrap pe-1"><t t-esc="props.title"/></div>
-            <div class="o_progress align-middle overflow-hidden" aria-valuemin="0" t-att-aria-valuemax="state.maxValue" t-att-aria-valuenow="state.currentValue">
-                <div t-attf-class="{{ state.currentValue > state.maxValue ? props.overflowClass : 'bg-primary' }} h-100" t-att-style="'width: min(' + 100 * state.currentValue / state.maxValue + '%, 100%)'"></div>
+            <div class="o_progress align-middle overflow-hidden" aria-valuemin="0" t-att-aria-valuemax="this.maxValue" t-att-aria-valuenow="this.currentValue">
+                <div t-attf-class="{{ this.currentValue > this.maxValue ? props.overflowClass : 'bg-primary' }} h-100" t-att-style="'width: min(' + 100 * this.currentValue / this.maxValue + '%, 100%)'"></div>
             </div>
             <div class="o_progressbar_value d-flex">
                 <t t-if="isPercentage">
@@ -18,7 +18,6 @@
                         t-att-value="formatCurrentValue() or ''"
                         t-att-required="props.required"
                         t-on-change="onCurrentValueChange"
-                        t-on-input="onCurrentValueInput"
                         t-on-focus="onInputFocus"
                         t-on-blur="onInputBlur"
                     />
@@ -34,7 +33,6 @@
                         inputmode="decimal"
                         t-att-value="formatCurrentValue()"
                         t-on-change="onCurrentValueChange"
-                        t-on-input="onCurrentValueInput"
                         t-on-focus="onInputFocus"
                         t-on-blur="onInputBlur"
                     />
@@ -48,7 +46,6 @@
                         inputmode="decimal"
                         t-att-value="formatMaxValue()"
                         t-on-change="onMaxValueChange"
-                        t-on-input="onMaxValueInput"
                         t-on-focus="onInputFocus"
                         t-on-blur="onInputBlur"
                     />
diff --git a/addons/web/static/src/views/fields/properties/properties_field.js b/addons/web/static/src/views/fields/properties/properties_field.js
index bc695f6aa11..86dc201596c 100644
--- a/addons/web/static/src/views/fields/properties/properties_field.js
+++ b/addons/web/static/src/views/fields/properties/properties_field.js
@@ -91,13 +91,7 @@ export class PropertiesField extends Component {
      * @returns {array}
      */
     get propertiesList() {
-        const propertiesValues = (this.props.record.data[this.props.name] || []).map(property => {
-            if (["date", "datetime"].includes(property.type)) {
-                // Date and Datetime are immutable luxon objects.
-                return property;
-            }
-            return JSON.parse(JSON.stringify(property));
-        });
+        const propertiesValues = this.props.record.data[this.props.name] || [];
         return propertiesValues.filter((definition) => !definition.definition_deleted);
     }
 
diff --git a/addons/web/static/src/views/fields/radio/radio_field.js b/addons/web/static/src/views/fields/radio/radio_field.js
index aa4acb2b2df..e1cb207e787 100644
--- a/addons/web/static/src/views/fields/radio/radio_field.js
+++ b/addons/web/static/src/views/fields/radio/radio_field.js
@@ -1,10 +1,10 @@
 /** @odoo-module **/
 
-import { registry } from "@web/core/registry";
-import { _lt } from "@web/core/l10n/translation";
-import { standardFieldProps } from "../standard_field_props";
-
 import { Component } from "@odoo/owl";
+import { _lt } from "@web/core/l10n/translation";
+import { registry } from "@web/core/registry";
+import { useSpecialData } from "@web/views/fields/relational_utils";
+import { standardFieldProps } from "../standard_field_props";
 
 export class RadioField extends Component {
     static template = "web.RadioField";
@@ -12,6 +12,7 @@ export class RadioField extends Component {
         ...standardFieldProps,
         orientation: { type: String, optional: true },
         label: { type: String, optional: true },
+        domain: { type: Array, optional: true },
     };
     static defaultProps = {
         orientation: "vertical",
@@ -19,28 +20,34 @@ export class RadioField extends Component {
 
     static nextId = 0;
 
-    static getItems(fieldName, record) {
-        switch (record.fields[fieldName].type) {
+    setup() {
+        this.type = this.props.record.fields[this.props.name].type;
+        if (this.type === "many2one") {
+            this.specialData = useSpecialData(async (orm, props) => {
+                const { relation } = props.record.fields[props.name];
+                const kwargs = {
+                    specification: { display_name: 1 },
+                    domain: props.domain,
+                };
+                const { records } = await orm.call(relation, "unity_web_search_read", [], kwargs);
+                return records.map((record) => [record.id, record.display_name]);
+            });
+        }
+    }
+
+    get items() {
+        switch (this.type) {
             case "selection":
-                return record.fields[fieldName].selection;
+                return this.props.record.fields[this.props.name].selection;
             case "many2one": {
-                const value = record.preloadedData[fieldName] || [];
-                return value.map((item) => [item.id, item.display_name]);
+                return this.specialData.data;
             }
             default:
                 return [];
         }
     }
-
-    setup() {
-        this.id = `radio_field_${++RadioField.nextId}`;
-    }
-
-    get items() {
-        return RadioField.getItems(this.props.name, this.props.record);
-    }
     get value() {
-        switch (this.props.record.fields[this.props.name].type) {
+        switch (this.type) {
             case "selection":
                 return this.props.record.data[this.props.name];
             case "many2one":
@@ -56,7 +63,7 @@ export class RadioField extends Component {
      * @param {any} value
      */
     onChange(value) {
-        switch (this.props.record.fields[this.props.name].type) {
+        switch (this.type) {
             case "selection":
                 this.props.record.update({ [this.props.name]: value[0] });
                 break;
@@ -79,22 +86,11 @@ export const radioField = {
     ],
     supportedTypes: ["many2one", "selection"],
     isEmpty: (record, fieldName) => record.data[fieldName] === false,
-    extractProps: ({ options, string }) => ({
+    extractProps: ({ options, string }, dynamicInfo) => ({
         orientation: options.horizontal ? "horizontal" : "vertical",
         label: string,
+        domain: dynamicInfo.domain(),
     }),
-    legacySpecialData: "_fetchSpecialMany2ones",
 };
 
 registry.category("fields").add("radio", radioField);
-
-export async function preloadRadio(orm, record, fieldName, { domain }) {
-    const field = record.fields[fieldName];
-    const records = await orm.searchRead(field.relation, domain, ["id"]);
-    return await orm.nameGet(field.relation, [records.map((record) => record.id)]);
-}
-
-registry.category("preloadedData").add("radio", {
-    loadOnTypes: ["many2one"],
-    preload: preloadRadio,
-});
diff --git a/addons/web/static/src/views/fields/reference/reference_field.js b/addons/web/static/src/views/fields/reference/reference_field.js
index dbd09ed21c9..890b7e00ea6 100644
--- a/addons/web/static/src/views/fields/reference/reference_field.js
+++ b/addons/web/static/src/views/fields/reference/reference_field.js
@@ -2,14 +2,39 @@
 
 import { _lt } from "@web/core/l10n/translation";
 import { registry } from "@web/core/registry";
+import { useRecordObserver } from "@web/model/relational_model/utils";
 import { many2OneField, Many2OneField } from "../many2one/many2one_field";
 
-import { Component, onWillUpdateProps, useState } from "@odoo/owl";
+import { Component, useState } from "@odoo/owl";
 
-function valuesEqual(a, b) {
-    return a.resId === b.resId && a.resModel === b.resModel;
-}
+/**
+ * @typedef ReferenceValue
+ * @property {string} resModel
+ * @property {number} resId
+ * @property {string} displayName
+ */
 
+/**
+ * 1. Reference field is a char field
+ * 2. Reference widget has model_field prop
+ * 3. Standard case
+ */
+
+/**
+ * This class represents a reference field widget. It can be used to display
+ * a reference field OR a char field.
+ * The res_model of the relation is defined either by the reference field itself
+ * or by the model_field prop.
+ *
+ * 1) Reference field is a char field
+ * We have to fetch the display name (name_get) of the referenced record.
+ *
+ * 2) Reference widget has model_field prop
+ * We have to fetch the technical name of the co model.
+ *
+ * 3) Standard case
+ * The value is already in record.data[fieldName]
+ */
 export class ReferenceField extends Component {
     static template = "web.ReferenceField";
     static components = {
@@ -17,120 +42,198 @@ export class ReferenceField extends Component {
     };
     static props = {
         ...Many2OneField.props,
-        hideModelSelector: { type: Boolean, optional: true },
+        hideModel: { type: Boolean, optional: true },
+        modelField: { type: String, optional: true },
     };
     static defaultProps = {
         ...Many2OneField.defaultProps,
     };
 
     setup() {
+        /** @type {{formattedCharValue?: ReferenceValue, modelName?: string}} */
         this.state = useState({
-            resModel: this.relation,
+            formattedCharValue: undefined, // Value extracted from reference char field
+            modelName: undefined, // Name get of the value of the model field
         });
-
-        this.currentValue = this.getValue(this.props);
-
-        onWillUpdateProps((nextProps) => {
-            if (
-                valuesEqual(this.currentValue || {}, this.getValue(nextProps) || {}) &&
-                this.state.resModel &&
-                this.getRelation(nextProps) !== this.state.resModel
-            ) {
-                nextProps.record.update({ [this.props.name]: false });
-            }
-            this.currentValue = this.getValue(this.props);
-        });
-    }
-
-    getPreloadedData(p) {
-        return p.record.preloadedData[p.name];
-    }
-    getValue(p) {
-        if (p.record.fields[p.name].type === "char") {
-            const pdata = this.getPreloadedData(p);
-            if (!pdata) {
-                return null;
-            }
-            return {
-                resModel: pdata.model,
-                resId: pdata.data.id,
-                displayName: pdata.data.display_name,
-            };
+        this.currentValue = undefined;
+        this.currentRelation = this.getRelation();
+        if (this._isCharField(this.props)) {
+            /** Fetch the display name of the record referenced by the field */
+            useRecordObserver(async (record) => {
+                if (this.currentValue !== record.data[this.props.name]) {
+                    this.state.formattedCharValue = await this._fetchReferenceCharData(this.props);
+                    this.currentValue = record.data[this.props.name];
+                }
+            });
+        } else if (this.props.modelField) {
+            /** Fetch the technical name of the co model */
+            useRecordObserver(async (record) => {
+                if (this.currentModelId !== record.data[this.props.modelField]?.[0]) {
+                    this.state.modelName = await this._fetchModelTechnicalName(this.props);
+                    if (this.currentModelId !== undefined) {
+                        record.update({ [this.props.name]: false });
+                    }
+                    this.currentModelId = record.data[this.props.modelField]?.[0];
+                }
+            });
         } else {
-            return p.record.data[p.name];
+            this.currentValue = this.props.record.data[this.props.name];
         }
     }
+
     get m2oProps() {
-        const value = this.getValue(this.props);
+        const value = this.getValue();
         const p = {
             ...this.props,
-            relation: this.relation,
+            relation: this.getRelation(),
             value: value && [value.resId, value.displayName],
             update: this.updateM2O.bind(this),
         };
-        delete p.hideModelSelector;
+        delete p.hideModel;
+        delete p.modelField;
         return p;
     }
     get selection() {
-        if (
-            this.props.record.fields[this.props.name].type !== "char" &&
-            !this.props.hideModelSelector
-        ) {
+        if (!this._isCharField(this.props) && !this.hideModelSelector) {
             return this.props.record.fields[this.props.name].selection;
         }
         return [];
     }
 
     get relation() {
-        return this.getRelation(this.props);
+        return this.getRelation();
     }
 
-    getRelation(props) {
-        const modelName = this.getModelName(props);
+    get hideModelSelector() {
+        return this.props.hideModel || this.props.modelField;
+    }
+
+    getRelation() {
+        const modelName = this.getModelName();
         if (modelName) {
             return modelName;
         }
 
-        const value = this.getValue(props);
+        const value = this.getValue();
         if (value && value.resModel) {
             return value.resModel;
         } else {
-            return this.state && this.state.resModel;
+            return this.currentRelation;
         }
     }
 
-    getModelName(p) {
-        if (p.hideModelSelector && p.record.preloadedData[p.name]) {
-            return p.record.preloadedData[p.name].modelName;
+    /**
+     * @returns {ReferenceValue|false}
+     */
+    getValue() {
+        if (this._isCharField(this.props)) {
+            return this.state.formattedCharValue;
+        } else {
+            return this.props.record.data[this.props.name];
         }
-        return null;
+    }
+
+    /**
+     * @returns {string|undefined}
+     */
+    getModelName() {
+        return this.hideModelSelector && this.state.modelName;
     }
 
     updateModel(value) {
-        this.state.resModel = value;
+        this.currentRelation = value;
         this.props.record.update({ [this.props.name]: false });
     }
 
     updateM2O(data) {
         const value = data[this.props.name];
-        if (!this.state.resModel) {
-            this.state.resModel = this.relation;
+        if (!this.currentRelation) {
+            this.currentRelation = this.getRelation();
         }
         this.props.record.update({
             [this.props.name]: value && {
-                resModel: this.state.resModel,
+                resModel: this.currentRelation,
                 resId: value[0],
                 displayName: value[1],
             },
         });
     }
+
+    /**
+     * Return true if the reference field is a char field.
+     */
+    _isCharField(props) {
+        return props.record.fields[props.name].type === "char";
+    }
+
+    /**
+     * Fetch special data if the reference field is a char field.
+     * It fetches the display name of the record.
+     *
+     * @returns {Promise<{ resId: number, resModel: string, displayName: string }|false>}
+     */
+    async _fetchReferenceCharData(props) {
+        const recordData = props.record.data[props.name];
+        if (!recordData) {
+            return false;
+        }
+        const [resModel, _resId] = recordData.split(",");
+        const resId = parseInt(_resId, 10);
+        if (resModel && resId) {
+            const { specialDataCaches, orm } = props.record.model;
+            const key = `__reference__name_get-${recordData}`;
+            if (!specialDataCaches[key]) {
+                specialDataCaches[key] = orm.nameGet(resModel, [resId]);
+            }
+            const result = await specialDataCaches[key];
+            return {
+                resId,
+                resModel,
+                displayName: result[0][1],
+            };
+        }
+        return false;
+    }
+
+    /**
+     * Ensure that the modelField is a many2one to ir.model
+     */
+    _assertMany2OneToIrModel(props) {
+        const field = props.modelField && props.record.fields[props.modelField];
+        if (field && (field.type !== "many2one" || field.relation !== "ir.model")) {
+            throw new Error(
+                `The model_field (${props.modelField}) of the reference field ${props.name} must be a many2one('ir.model').`
+            );
+        }
+    }
+
+    /**
+     * Fetch the technical name of the model which is selected in the modelField
+     * props
+     *
+     * @returns {Promise<string|false>}
+     */
+    async _fetchModelTechnicalName(props) {
+        this._assertMany2OneToIrModel(props);
+        const record = props.record;
+        const modelId = record.data[props.modelField]?.[0];
+        if (!modelId) {
+            return false;
+        }
+        const { specialDataCaches, orm } = props.record.model;
+        const key = `__reference__ir_model-${modelId}`;
+        if (!specialDataCaches[key]) {
+            specialDataCaches[key] = orm.read("ir.model", [modelId], ["model"]);
+        }
+        const result = await specialDataCaches[key];
+        return result[0].model;
+    }
 }
 
 export const referenceField = {
     component: ReferenceField,
     displayName: _lt("Reference"),
     supportedTypes: ["reference", "char"],
-    legacySpecialData: "_fetchSpecialReference",
     extractProps({ options }) {
         /*
         1 - <field name="ref" options="{'model_field': 'model_id'}" />
@@ -141,7 +244,8 @@ export const referenceField = {
         We want to display the model selector only in the 4th case.
         */
         const props = many2OneField.extractProps(...arguments);
-        props.hideModelSelector = !!options.hide_model || !!options.model_field;
+        props.hideModel = !!options.hide_model;
+        props.modelField = options.model_field;
         return props;
     },
 };
diff --git a/addons/web/static/src/views/fields/reference/reference_field.xml b/addons/web/static/src/views/fields/reference/reference_field.xml
index 82604929b20..5e444140504 100644
--- a/addons/web/static/src/views/fields/reference/reference_field.xml
+++ b/addons/web/static/src/views/fields/reference/reference_field.xml
@@ -3,7 +3,7 @@
 
     <t t-name="web.ReferenceField" owl="1">
         <div class="o_row">
-            <t t-if="!props.readonly and !props.hideModelSelector">
+            <t t-if="!props.readonly and !hideModelSelector">
                 <select class="o_input"
                     t-att-tabindex="relation ? '-1': 0"
                     t-on-change="(ev) => this.updateModel(ev.target.value || false)"
diff --git a/addons/web/static/src/views/fields/relational_utils.js b/addons/web/static/src/views/fields/relational_utils.js
index f9051822355..eb83aab9167 100644
--- a/addons/web/static/src/views/fields/relational_utils.js
+++ b/addons/web/static/src/views/fields/relational_utils.js
@@ -3,6 +3,9 @@
 import { AutoComplete } from "@web/core/autocomplete/autocomplete";
 import { makeContext } from "@web/core/context";
 import { Dialog } from "@web/core/dialog/dialog";
+import { evalDomain } from "@web/core/domain";
+import { RPCError } from "@web/core/network/rpc_service";
+import { Cache } from "@web/core/utils/cache";
 import {
     useBus,
     useChildRef,
@@ -15,7 +18,8 @@ import { createElement } from "@web/core/utils/xml";
 import { FormArchParser } from "@web/views/form/form_arch_parser";
 import { loadSubViews } from "@web/views/form/form_controller";
 import { FormRenderer } from "@web/views/form/form_renderer";
-import { computeViewClassName, evalDomain, isNull } from "@web/views/utils";
+import { extractFieldsFromArchInfo } from "@web/model/relational_model/utils";
+import { computeViewClassName, isNull } from "@web/views/utils";
 import { ViewButton } from "@web/views/view_button/view_button";
 import { useViewButtons } from "@web/views/view_button/view_button_hook";
 import { FormViewDialog } from "@web/views/view_dialogs/form_view_dialog";
@@ -35,11 +39,12 @@ import { SelectCreateDialog } from "@web/views/view_dialogs/select_create_dialog
 
 import {
     Component,
+    onWillStart,
+    onWillUpdateProps,
     useComponent,
     useEffect,
     useEnv,
     useSubEnv,
-    onWillUpdateProps,
 } from "@odoo/owl";
 
 //
@@ -137,6 +142,31 @@ export function useActiveActions({
     return activeActions;
 }
 
+export function useSpecialData(loadFn) {
+    const component = useComponent();
+    const record = component.props.record;
+    const key = `${record.resModel}-${component.props.name}`;
+    const { specialDataCaches } = record.model;
+    const orm = component.env.services.orm;
+    const ormWithCache = Object.create(orm);
+    if (!specialDataCaches[key]) {
+        specialDataCaches[key] = new Cache(
+            (...args) => orm.call(...args),
+            (...path) => JSON.stringify(path)
+        );
+    }
+    ormWithCache.call = (...args) => specialDataCaches[key].read(...args);
+
+    const result = {};
+    onWillStart(async () => {
+        result.data = await loadFn(ormWithCache, component.props);
+    });
+    onWillUpdateProps(async (props) => {
+        result.data = await loadFn(ormWithCache, props);
+    });
+    return result;
+}
+
 //
 // Many2X
 //
@@ -153,7 +183,7 @@ export class Many2XAutocomplete extends Component {
             activeActions,
             isToMany,
             onRecordSaved: (record) => {
-                return update([record.data]);
+                return update([{ ...record.data, id: record.resId }]);
             },
             onRecordDiscarded: () => {
                 if (!isToMany) {
@@ -221,7 +251,7 @@ export class Many2XAutocomplete extends Component {
         }
         const record = {
             id: option.value,
-            name: option.label,
+            display_name: option.displayName,
         };
         this.props.update([record], params);
     }
@@ -239,6 +269,7 @@ export class Many2XAutocomplete extends Component {
         return {
             value: result[0],
             label: result[1].split("\n")[0],
+            displayName: result[1],
         };
     }
     async loadOptionsSource(request) {
@@ -259,26 +290,13 @@ export class Many2XAutocomplete extends Component {
                         await this.props.quickCreate(request, params);
                     } catch (e) {
                         if (
-                            e &&
-                            e.name === "RPC_ERROR" &&
+                            e instanceof RPCError &&
                             e.exceptionName === "odoo.exceptions.ValidationError"
                         ) {
                             const context = this.getCreationContext(request);
                             return this.openMany2X({ context });
                         }
-                        // Compatibility with legacy code
-                        if (
-                            e &&
-                            e.message &&
-                            e.message.name === "RPC_ERROR" &&
-                            e.message.exceptionName === "odoo.exceptions.ValidationError"
-                        ) {
-                            // The event.preventDefault() is necessary because we still use the legacy
-                            e.event.preventDefault();
-                            const context = this.getCreationContext(request);
-                            return this.openMany2X({ context });
-                        }
-                        throw e.message ? e.message : e;
+                        throw e;
                     }
                 },
             });
@@ -573,7 +591,15 @@ export class X2ManyFieldDialog extends Component {
     async save({ saveAndNew }) {
         const disabledButtons = this.disableButtons();
         if (await this.record.checkValidity()) {
-            this.record = (await this.props.save(this.record, { saveAndNew })) || this.record;
+            try {
+                await this.props.save(this.record);
+            } catch (error) {
+                this.enableButtons(disabledButtons);
+                throw error;
+            }
+            if (saveAndNew) {
+                this.record = await this.props.addNew();
+            }
         } else {
             this.record.openInvalidFieldsNotification();
             this.enableButtons(disabledButtons);
@@ -606,6 +632,7 @@ X2ManyFieldDialog.props = {
     archInfo: Object,
     close: Function,
     record: Object,
+    addNew: Function,
     save: Function,
     title: String,
     delete: { optional: true },
@@ -615,24 +642,29 @@ X2ManyFieldDialog.props = {
 X2ManyFieldDialog.template = "web.X2ManyFieldDialog";
 
 async function getFormViewInfo({ list, activeField, viewService, userService, env }) {
-    let formViewInfo = activeField.views.form;
+    let formArchInfo = activeField.views.form;
+    let fields = activeField.fields;
     const comodel = list.resModel;
-    if (!formViewInfo) {
-        const { fields, relatedModels, views } = await viewService.loadViews({
+    if (!formArchInfo) {
+        const {
+            fields: formFields,
+            relatedModels,
+            views,
+        } = await viewService.loadViews({
             context: list.context,
             resModel: comodel,
             views: [[false, "form"]],
         });
-        const archInfo = new FormArchParser().parse(views.form.arch, relatedModels, comodel);
+        formArchInfo = new FormArchParser().parse(views.form.arch, relatedModels, comodel);
         // Fields that need to be defined are the ones in the form view, this is natural,
-        // plus the ones that the list record has, that is, present in either the list arch or the kanban arch
-        // of the one2many field
-        formViewInfo = { ...archInfo, fields: { ...list.fields, ...fields } }; // should be good to memorize this on activeField
+        // plus the ones that the list record has, that is, present in either the list arch
+        // or the kanban arch of the one2many field
+        fields = { ...list.fields, ...formFields }; // FIXME: update in place?
     }
 
     await loadSubViews(
-        formViewInfo.activeFields,
-        formViewInfo.fields,
+        formArchInfo.fieldNodes,
+        fields,
         {}, // context
         comodel,
         viewService,
@@ -640,7 +672,7 @@ async function getFormViewInfo({ list, activeField, viewService, userService, en
         env.isSmall
     );
 
-    return formViewInfo;
+    return { archInfo: formArchInfo, fields };
 }
 
 export function useAddInlineRecord({ addNew }) {
@@ -661,12 +693,12 @@ export function useAddInlineRecord({ addNew }) {
 
 export function useOpenX2ManyRecord({
     resModel,
-    activeField,
+    activeField, // TODO: this should be renamed (object with keys "viewMode", "views" and "string")
     activeActions,
     getList,
     updateRecord,
     saveRecord,
-    withParentId,
+    isMany2Many,
 }) {
     const viewService = useService("view");
     const userService = useService("user");
@@ -681,78 +713,65 @@ export function useOpenX2ManyRecord({
             title = sprintf(title, activeField.string);
         }
         const list = getList();
-        const model = list.model;
-        const form = await getFormViewInfo({ list, activeField, viewService, userService, env });
+        const { archInfo, fields: _fields } = await getFormViewInfo({
+            list,
+            activeField,
+            viewService,
+            userService,
+            env,
+        });
+
+        const { activeFields, fields } = extractFieldsFromArchInfo(archInfo, _fields);
 
         let deleteRecord;
         let deleteButtonLabel = undefined;
         const isDuplicate = !!record;
 
+        const params = { activeFields, fields, mode };
         if (record) {
-            const _record = record;
-            record = await model.duplicateDatapoint(record, {
-                mode,
-                viewMode: "form",
-                fields: { ...form.fields },
-                views: { form },
-            });
             const { delete: canDelete, onDelete } = activeActions;
-            deleteRecord = viewMode === "kanban" && canDelete ? () => onDelete(_record) : null;
+            deleteRecord = viewMode === "kanban" && canDelete ? () => onDelete(record) : null;
             deleteButtonLabel =
                 activeActions.type === "one2many" ? env._t("Delete") : env._t("Remove");
         } else {
-            const recordParams = {
-                context: makeContext([list.context, context]),
-                resModel: resModel,
-                activeFields: form.activeFields,
-                fields: { ...form.fields },
-                views: { form },
-                mode: "edit",
-                viewType: "form",
-            };
-            record = await model.addNewRecord(list, recordParams, withParentId);
+            params.context = makeContext([list.context, context]);
+            params.withoutParent = isMany2Many;
         }
+        record = await list.extendRecord(params, record);
+
+        const _onClose = () => {
+            list.editedRecord?.switchMode("readonly");
+            onClose?.();
+        };
 
         addDialog(
             X2ManyFieldDialog,
             {
                 config: env.config,
-                archInfo: form,
+                archInfo,
                 record,
-                save: async (rec, { saveAndNew }) => {
+                addNew: () => {
+                    return getList().extendRecord(params);
+                },
+                save: (rec) => {
                     if (isDuplicate && rec.id === record.id) {
-                        await updateRecord(rec);
+                        return updateRecord(rec);
                     } else {
-                        await saveRecord(rec);
-                    }
-                    if (saveAndNew) {
-                        return model.addNewRecord(
-                            list,
-                            {
-                                context: makeContext([list.context, context]),
-                                resModel: resModel,
-                                activeFields: form.activeFields,
-                                fields: { ...form.fields },
-                                views: { form },
-                                mode: "edit",
-                                viewType: "form",
-                            },
-                            withParentId
-                        );
+                        return saveRecord(rec);
                     }
                 },
                 title,
                 delete: deleteRecord,
                 deleteButtonLabel: deleteButtonLabel,
             },
-            { onClose }
+            { onClose: _onClose }
         );
     }
     return openRecord;
 }
 
 export function useX2ManyCrud(getList, isMany2Many) {
-    let saveRecord;
+    let saveRecord; // FIXME: isn't this "createRecord" instead?
     if (isMany2Many) {
         saveRecord = async (object) => {
             const list = getList();
@@ -760,31 +779,34 @@ export function useX2ManyCrud(getList, isMany2Many) {
             let resIds;
             if (Array.isArray(object)) {
                 resIds = [...currentIds, ...object];
-            } else if (object.resId) {
-                if (object.isDirty) {
-                   await object.save();
+            } else {
+                // object instanceof Record
+                if (!object.resId || object.isDirty) {
+                    await object.save();
                 }
                 resIds = [...currentIds, object.resId];
-            } else {
-                return list.add(object, { isM2M: isMany2Many });
             }
             return list.replaceWith(resIds);
         };
     } else {
-        saveRecord = (record) => {
-            return getList().add(record);
+        saveRecord = async (record) => {
+            return getList().validateExtendedRecord(record);
         };
     }
 
-    const updateRecord = (record) => {
-        const list = getList();
-        return list.model.updateRecord(list, record, { isM2M: isMany2Many });
+    const updateRecord = async (record) => {
+        if (isMany2Many) {
+            await record.save();
+        }
+        return getList().validateExtendedRecord(record);
     };
 
-    const operation = isMany2Many ? "FORGET" : "DELETE";
     const removeRecord = (record) => {
         const list = getList();
-        return list.delete(record.id, operation);
+        if (isMany2Many) {
+            return list.forget(record);
+        }
+        return list.delete(record);
     };
 
     return {
diff --git a/addons/web/static/src/views/fields/selection/selection_field.js b/addons/web/static/src/views/fields/selection/selection_field.js
index c93bd226c19..ba1d020f630 100644
--- a/addons/web/static/src/views/fields/selection/selection_field.js
+++ b/addons/web/static/src/views/fields/selection/selection_field.js
@@ -1,10 +1,10 @@
 /** @odoo-module **/
 
-import { registry } from "@web/core/registry";
-import { _lt } from "@web/core/l10n/translation";
-import { standardFieldProps } from "../standard_field_props";
-
 import { Component } from "@odoo/owl";
+import { _lt } from "@web/core/l10n/translation";
+import { registry } from "@web/core/registry";
+import { useSpecialData } from "@web/views/fields/relational_utils";
+import { standardFieldProps } from "../standard_field_props";
 
 export class SelectionField extends Component {
     static template = "web.SelectionField";
@@ -12,12 +12,23 @@ export class SelectionField extends Component {
         ...standardFieldProps,
         placeholder: { type: String, optional: true },
         required: { type: Boolean, optional: true },
+        domain: { type: Array, optional: true },
     };
 
+    setup() {
+        this.type = this.props.record.fields[this.props.name].type;
+        if (this.type === "many2one") {
+            this.specialData = useSpecialData((orm, props) => {
+                const { relation } = props.record.fields[props.name];
+                return orm.call(relation, "name_search", ["", props.domain]);
+            });
+        }
+    }
+
     get options() {
-        switch (this.props.record.fields[this.props.name].type) {
+        switch (this.type) {
             case "many2one":
-                return [...this.props.record.preloadedData[this.props.name]];
+                return [...this.specialData.data];
             case "selection":
                 return this.props.record.fields[this.props.name].selection.filter(
                     (option) => option[0] !== false && option[1] !== ""
@@ -27,7 +38,7 @@ export class SelectionField extends Component {
         }
     }
     get string() {
-        switch (this.props.record.fields[this.props.name].type) {
+        switch (this.type) {
             case "many2one":
                 return this.props.record.data[this.props.name]
                     ? this.props.record.data[this.props.name][1]
@@ -42,9 +53,7 @@ export class SelectionField extends Component {
     }
     get value() {
         const rawValue = this.props.record.data[this.props.name];
-        return this.props.record.fields[this.props.name].type === "many2one" && rawValue
-            ? rawValue[0]
-            : rawValue;
+        return this.type === "many2one" && rawValue ? rawValue[0] : rawValue;
     }
 
     stringify(value) {
@@ -56,7 +65,7 @@ export class SelectionField extends Component {
      */
     onChange(ev) {
         const value = JSON.parse(ev.target.value);
-        switch (this.props.record.fields[this.props.name].type) {
+        switch (this.type) {
             case "many2one":
                 if (value === false) {
                     this.props.record.update({ [this.props.name]: false });
@@ -77,24 +86,14 @@ export const selectionField = {
     component: SelectionField,
     displayName: _lt("Selection"),
     supportedTypes: ["many2one", "selection"],
-    legacySpecialData: "_fetchSpecialRelation",
     isEmpty: (record, fieldName) => record.data[fieldName] === false,
     extractProps({ attrs }, dynamicInfo) {
         return {
             placeholder: attrs.placeholder,
             required: dynamicInfo.required,
+            domain: dynamicInfo.domain(),
         };
     },
 };
 
 registry.category("fields").add("selection", selectionField);
-
-export function preloadSelection(orm, record, fieldName, { domain }) {
-    const field = record.fields[fieldName];
-    return orm.call(field.relation, "name_search", ["", domain]);
-}
-
-registry.category("preloadedData").add("selection", {
-    loadOnTypes: ["many2one"],
-    preload: preloadSelection,
-});
diff --git a/addons/web/static/src/views/fields/standard_field_props.js b/addons/web/static/src/views/fields/standard_field_props.js
index de3df8a4b55..1014638f19d 100644
--- a/addons/web/static/src/views/fields/standard_field_props.js
+++ b/addons/web/static/src/views/fields/standard_field_props.js
@@ -5,7 +5,7 @@
  * @property {string} [id]
  * @property {string} name
  * @property {boolean} [readonly]
- * @property {import("@web/views/relational_model").Record} record
+ * @property {import("@web/model/relational_model/record").Record} record
  */
 
 export const standardFieldProps = {
diff --git a/addons/web/static/src/views/fields/statusbar/statusbar_field.js b/addons/web/static/src/views/fields/statusbar/statusbar_field.js
index bc4ab17acbe..2918c782f1f 100644
--- a/addons/web/static/src/views/fields/statusbar/statusbar_field.js
+++ b/addons/web/static/src/views/fields/statusbar/statusbar_field.js
@@ -1,15 +1,16 @@
 /** @odoo-module **/
 
-import { registry } from "@web/core/registry";
+import { Component } from "@odoo/owl";
 import { useCommand } from "@web/core/commands/command_hook";
+import { Domain } from "@web/core/domain";
 import { Dropdown } from "@web/core/dropdown/dropdown";
 import { DropdownItem } from "@web/core/dropdown/dropdown_item";
+import { _lt } from "@web/core/l10n/translation";
+import { registry } from "@web/core/registry";
 import { groupBy } from "@web/core/utils/arrays";
 import { escape, sprintf } from "@web/core/utils/strings";
-import { Domain } from "@web/core/domain";
-import { _lt } from "@web/core/l10n/translation";
+import { useSpecialData } from "@web/views/fields/relational_utils";
 import { standardFieldProps } from "../standard_field_props";
-import { Component } from "@odoo/owl";
 
 export class StatusBarField extends Component {
     static template = "web.StatusBarField";
@@ -25,6 +26,8 @@ export class StatusBarField extends Component {
         isDisabled: { type: Boolean, optional: true },
         visibleSelection: { type: Array, optional: true },
         withCommand: { type: Boolean, optional: true },
+        foldField: { type: String, optional: true },
+        domain: { type: typeof Domain, optional: true },
     };
     static defaultProps = {
         visibleSelection: [],
@@ -90,6 +93,25 @@ export class StatusBarField extends Component {
                 }
             );
         }
+
+        if (this.type === "many2one") {
+            this.specialData = useSpecialData((orm, props) => {
+                const { foldField, name: fieldName, record } = props;
+                const { relation } = record.fields[fieldName];
+                const fieldNames = ["display_name"];
+                if (foldField) {
+                    fieldNames.push(foldField);
+                }
+                const value = props.record.data[fieldName];
+                let domain = props.domain;
+                if (domain.length && value) {
+                    domain = Domain.or([[["id", "=", value[0]]], domain]).toList(
+                        props.record.evalContext
+                    );
+                }
+                return orm.searchRead(relation, domain, fieldNames);
+            });
+        }
     }
 
     get currentName() {
@@ -114,7 +136,7 @@ export class StatusBarField extends Component {
     get options() {
         switch (this.type) {
             case "many2one":
-                return this.props.record.preloadedData[this.props.name];
+                return this.specialData.data;
             case "selection":
                 return this.props.record.fields[this.props.name].selection;
             default:
@@ -147,7 +169,7 @@ export class StatusBarField extends Component {
             return {
                 id: i.id,
                 name: i.display_name,
-                isFolded: i.fold,
+                isFolded: i[this.props.foldField],
             };
         });
         return items.map((item) => ({
@@ -234,40 +256,16 @@ export const statusBarField = {
     ],
     supportedTypes: ["many2one", "selection"],
     isEmpty: (record, fieldName) => record.model.env.isSmall && !record.data[fieldName],
-    legacySpecialData: "_fetchSpecialStatus",
-    extractProps: ({ attrs, options, viewType }) => ({
+    extractProps: ({ attrs, options, viewType }, dynamicInfo) => ({
         canCreate: Boolean(attrs.can_create),
         canWrite: Boolean(attrs.can_write),
         isDisabled: !options.clickable,
         visibleSelection:
             attrs.statusbar_visible && attrs.statusbar_visible.trim().split(/\s*,\s*/g),
         withCommand: viewType === "form",
+        foldField: options.fold_field,
+        domain: dynamicInfo.domain(),
     }),
 };
 
 registry.category("fields").add("statusbar", statusBarField);
-
-export async function preloadStatusBar(orm, record, fieldName, { domain }) {
-    const fieldNames = ["id", "display_name"];
-    const foldField = record.activeFields[fieldName].options.fold_field;
-    if (foldField) {
-        fieldNames.push(foldField);
-    }
-
-    if (domain.length && record.data[fieldName]) {
-        domain = Domain.or([[["id", "=", record.data[fieldName][0]]], domain]).toList(
-            record.evalContext
-        );
-    }
-
-    const relation = record.fields[fieldName].relation;
-    return await orm.searchRead(relation, domain, fieldNames);
-}
-
-registry.category("preloadedData").add("statusbar", {
-    loadOnTypes: ["many2one"],
-    extraMemoizationKey: (record, fieldName) => {
-        return record.data[fieldName];
-    },
-    preload: preloadStatusBar,
-});
diff --git a/addons/web/static/src/views/fields/translation_button.js b/addons/web/static/src/views/fields/translation_button.js
index 2214c909782..06db5ba3614 100644
--- a/addons/web/static/src/views/fields/translation_button.js
+++ b/addons/web/static/src/views/fields/translation_button.js
@@ -18,7 +18,7 @@ export function useTranslationDialog() {
     const addDialog = useOwnedDialogs();
 
     async function openTranslationDialog({ record, fieldName }) {
-        const saved = await record.save({ stayInEdition: true });
+        const saved = await record.save({ force: true });
         if (!saved) {
             return;
         }
diff --git a/addons/web/static/src/views/fields/x2many/x2many_field.js b/addons/web/static/src/views/fields/x2many/x2many_field.js
index 6d34eed63ee..b6974ab8156 100644
--- a/addons/web/static/src/views/fields/x2many/x2many_field.js
+++ b/addons/web/static/src/views/fields/x2many/x2many_field.js
@@ -1,6 +1,7 @@
 /** @odoo-module **/
 
 import { makeContext } from "@web/core/context";
+import { evalDomain } from "@web/core/domain";
 import { _lt } from "@web/core/l10n/translation";
 import { Pager } from "@web/core/pager/pager";
 import { registry } from "@web/core/registry";
@@ -15,7 +16,7 @@ import {
 import { standardFieldProps } from "@web/views/fields/standard_field_props";
 import { KanbanRenderer } from "@web/views/kanban/kanban_renderer";
 import { ListRenderer } from "@web/views/list/list_renderer";
-import { computeViewClassName, evalDomain } from "@web/views/utils";
+import { computeViewClassName } from "@web/views/utils";
 import { ViewButton } from "@web/views/view_button/view_button";
 
 import { Component } from "@odoo/owl";
@@ -31,6 +32,7 @@ export class X2ManyField extends Component {
         widget: { type: String, optional: true },
         crudOptions: { type: Object, optional: true },
         string: { type: String, optional: true },
+        relatedFields: { type: Object, optional: true },
         views: { type: Object, optional: true },
         domain: { type: [Array, Function], optional: true },
         context: { type: Object },
@@ -77,7 +79,7 @@ export class X2ManyField extends Component {
         });
 
         this.addInLine = useAddInlineRecord({
-            addNew: (...args) => this.list.addNew(...args),
+            addNew: (...args) => this.list.addNewRecord(...args),
         });
 
         const openRecord = useOpenX2ManyRecord({
@@ -87,7 +89,7 @@ export class X2ManyField extends Component {
             getList: () => this.list,
             saveRecord,
             updateRecord,
-            withParentId: this.props.widget !== "many2many",
+            isMany2Many: this.isMany2Many,
         });
         this._openRecord = (params) => {
             const activeElement = document.activeElement;
@@ -126,6 +128,7 @@ export class X2ManyField extends Component {
 
     get activeField() {
         return {
+            fields: this.props.relatedFields,
             views: this.props.views,
             viewMode: this.props.viewMode,
             string: this.props.string,
@@ -152,7 +155,7 @@ export class X2ManyField extends Component {
         return {
             field: this.props.name,
             model: this.props.record.resModel,
-            viewMode: this.props.record.viewMode || this.props.record.__viewType,
+            viewMode: "form",
         };
     }
 
@@ -164,8 +167,8 @@ export class X2ManyField extends Component {
             total: list.count,
             onUpdate: async ({ offset, limit }) => {
                 const initialLimit = this.list.limit;
-                const unselected = await list.unselectRecord(true);
-                if (unselected) {
+                const leaved = await list.leaveEditMode();
+                if (leaved) {
                     if (initialLimit === limit && initialLimit === this.list.limit + 1) {
                         // Unselecting the edited record might have abandonned it. If the page
                         // size was reached before that record was created, the limit was temporarily
@@ -195,6 +198,13 @@ export class X2ManyField extends Component {
             const recordsDraggable = !this.props.readonly && archInfo.recordsDraggable;
             props.archInfo = { ...archInfo, recordsDraggable };
             props.readonly = this.props.readonly;
+            // TODO: apply same logic in the list case
+            props.deleteRecord = (record) => {
+                if (this.isMany2Many) {
+                    return this.list.forget(record);
+                }
+                return this.list.delete(record);
+            };
             return props;
         }
 
@@ -256,9 +266,7 @@ export class X2ManyField extends Component {
                 const proms = [];
                 this.list.model.bus.trigger("NEED_LOCAL_CHANGES", { proms });
                 await Promise.all([...proms, this.list.editedRecord._updatePromise]);
-                if (this.list.editedRecord) {
-                    await this.list.editedRecord.switchMode("readonly", { checkValidity: true });
-                }
+                await this.list.leaveEditMode({ canAbandon: false });
             }
             if (!this.list.editedRecord) {
                 return this.addInLine({ context, editable });
@@ -280,7 +288,10 @@ export const x2ManyField = {
     displayName: _lt("Relational table"),
     supportedTypes: ["one2many", "many2many"],
     useSubView: true,
-    extractProps: ({ attrs, viewMode, views, widget, options, string }, dynamicInfo) => {
+    extractProps: (
+        { attrs, relatedFields, viewMode, views, widget, options, string },
+        dynamicInfo
+    ) => {
         const props = {
             addLabel: attrs["add-label"],
             context: dynamicInfo.context,
@@ -291,6 +302,7 @@ export const x2ManyField = {
         if (viewMode) {
             props.views = views;
             props.viewMode = viewMode;
+            props.relatedFields = relatedFields;
         }
         if (widget) {
             props.widget = widget;
diff --git a/addons/web/static/src/views/form/form_arch_parser.js b/addons/web/static/src/views/form/form_arch_parser.js
index ca89ac0d793..532922f4fd0 100644
--- a/addons/web/static/src/views/form/form_arch_parser.js
+++ b/addons/web/static/src/views/form/form_arch_parser.js
@@ -3,7 +3,7 @@
 import { XMLParser } from "@web/core/utils/xml";
 import { Field } from "@web/views/fields/field";
 import { Widget } from "@web/views/widgets/widget";
-import { addFieldDependencies, archParseBoolean, getActiveActions } from "@web/views/utils";
+import { archParseBoolean, getActiveActions } from "@web/views/utils";
 
 export class FormArchParser extends XMLParser {
     parse(arch, models, modelName) {
@@ -16,7 +16,6 @@ export class FormArchParser extends XMLParser {
         let widgetNextId = 0;
         const fieldNextIds = {};
         let autofocusFieldId = null;
-        const activeFields = {};
         this.visitXML(xmlDoc, (node) => {
             if (node.tagName === "field") {
                 const fieldInfo = Field.parseFieldNode(node, models, modelName, "form", jsClass);
@@ -29,7 +28,6 @@ export class FormArchParser extends XMLParser {
                 if (archParseBoolean(node.getAttribute("default_focus") || "")) {
                     autofocusFieldId = fieldId;
                 }
-                addFieldDependencies(fieldInfo, activeFields, models[modelName]);
                 return false;
             } else if (node.tagName === "div" && node.classList.contains("oe_chatter")) {
                 // remove this when chatter fields are declared as attributes on the root node
@@ -39,38 +37,11 @@ export class FormArchParser extends XMLParser {
                 const widgetId = `widget_${++widgetNextId}`;
                 widgetNodes[widgetId] = widgetInfo;
                 node.setAttribute("widget_id", widgetId);
-                addFieldDependencies(widgetInfo, activeFields, models[modelName]);
             }
         });
-        // TODO: generate activeFields for the model based on fieldNodes (merge duplicated fields)
-        for (const fieldNode of Object.values(fieldNodes)) {
-            const fieldName = fieldNode.name;
-            if (activeFields[fieldName]) {
-                const { alwaysInvisible } = fieldNode;
-                activeFields[fieldName] = {
-                    ...fieldNode,
-                    // a field can only be considered to be always invisible
-                    // if all its nodes are always invisible
-                    alwaysInvisible: activeFields[fieldName].alwaysInvisible && alwaysInvisible,
-                };
-            } else {
-                activeFields[fieldName] = fieldNode;
-            }
-            // const { onChange, modifiers } = fieldNode;
-            // let readonly = modifiers.readonly || [];
-            // let required = modifiers.required || [];
-            // if (activeFields[fieldNode.name]) {
-            //     activeFields[fieldNode.name].readonly = Domain.combine([activeFields[fieldNode.name].readonly, readonly], "|");
-            //     activeFields[fieldNode.name].required = Domain.combine([activeFields[fieldNode.name].required, required], "|");
-            //     activeFields[fieldNode.name].onChange = activeFields[fieldNode.name].onChange || onChange;
-            // } else {
-            //     activeFields[fieldNode.name] = { readonly, required, onChange };
-            // }
-        }
         return {
             arch,
             activeActions,
-            activeFields,
             autofocusFieldId,
             disableAutofocus,
             fieldNodes,
diff --git a/addons/web/static/src/views/form/form_compiler.js b/addons/web/static/src/views/form/form_compiler.js
index 44edadae7ad..9304ae58209 100644
--- a/addons/web/static/src/views/form/form_compiler.js
+++ b/addons/web/static/src/views/form/form_compiler.js
@@ -166,7 +166,7 @@ export class FormCompiler extends ViewCompiler {
             append(buttonBox, mainSlot);
         }
 
-        return hasContent ? buttonBox : '';
+        return hasContent ? buttonBox : "";
     }
 
     compileButton(el, params) {
@@ -214,7 +214,7 @@ export class FormCompiler extends ViewCompiler {
             ? `d-flex {{ __comp__.uiService.size < ${SIZES.XXL} ? "flex-column" : "flex-nowrap h-100" }}`
             : "d-block";
         const stateClasses =
-            "{{ __comp__.props.record.isDirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}";
+            "{{ __comp__.props.record.dirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}";
         const form = createElement("div", {
             class: "o_form_renderer",
             "t-att-class": "__comp__.props.class",
diff --git a/addons/web/static/src/views/form/form_controller.js b/addons/web/static/src/views/form/form_controller.js
index 7026cfb04f8..ce8a35d8744 100644
--- a/addons/web/static/src/views/form/form_controller.js
+++ b/addons/web/static/src/views/form/form_controller.js
@@ -3,6 +3,7 @@
 import { hasTouch } from "@web/core/browser/feature_detection";
 import { ConfirmationDialog } from "@web/core/confirmation_dialog/confirmation_dialog";
 import { makeContext } from "@web/core/context";
+import { evalDomain } from "@web/core/domain";
 import { useDebugCategory } from "@web/core/debug/debug_context";
 import { registry } from "@web/core/registry";
 import { SIZES } from "@web/core/ui/ui_service";
@@ -11,27 +12,29 @@ import { omit } from "@web/core/utils/objects";
 import { createElement } from "@web/core/utils/xml";
 import { Layout } from "@web/search/layout";
 import { usePager } from "@web/search/pager_hook";
-import { useModel } from "@web/views/model";
 import { standardViewProps } from "@web/views/standard_view_props";
 import { isX2Many } from "@web/views/utils";
 import { useViewButtons } from "@web/views/view_button/view_button_hook";
 import { useSetupView } from "@web/views/view_hook";
-import { FormStatusIndicator } from "./form_status_indicator/form_status_indicator";
-import { ButtonBox } from "./button_box/button_box";
 import { ViewButton } from "@web/views/view_button/view_button";
 import { Field } from "@web/views/fields/field";
+import { useModel } from "@web/model/model";
+import { addFieldDependencies, extractFieldsFromArchInfo } from "@web/model/relational_model/utils";
+import { useViewCompiler } from "@web/views/view_compiler";
 import { CogMenu } from "@web/search/cog_menu/cog_menu";
 import { STATIC_ACTIONS_GROUP_NUMBER } from "@web/search/action_menus/action_menus";
 
-import { Component, onRendered, useEffect, useRef } from "@odoo/owl";
-import { useViewCompiler } from "../view_compiler";
+import { ButtonBox } from "./button_box/button_box";
 import { FormCompiler } from "./form_compiler";
-import { evalDomain } from "../utils";
+import { FormErrorDialog } from "./form_error_dialog/form_error_dialog";
+import { FormStatusIndicator } from "./form_status_indicator/form_status_indicator";
+
+import { Component, onRendered, useEffect, useRef, useState } from "@odoo/owl";
 
 const viewRegistry = registry.category("views");
 
 export async function loadSubViews(
-    activeFields,
+    fieldNodes,
     fields,
     context,
     resModel,
@@ -39,20 +42,20 @@ export async function loadSubViews(
     userService,
     isSmall
 ) {
-    for (const fieldName in activeFields) {
+    for (const fieldInfo of Object.values(fieldNodes)) {
+        const fieldName = fieldInfo.name;
         const field = fields[fieldName];
         if (!isX2Many(field)) {
             continue; // what follows only concerns x2many fields
         }
-        const fieldInfo = activeFields[fieldName];
-        if (fieldInfo.modifiers.invisible === true) {
+        if (fieldInfo.alwaysInvisible) {
             continue; // no need to fetch the sub view if the field is always invisible
         }
-
         if (!fieldInfo.field.useSubView) {
             continue; // the FieldComponent used to render the field doesn't need a sub view
         }
 
+        fieldInfo.views = fieldInfo.views || {};
         let viewType = fieldInfo.viewMode || "list,kanban";
         viewType = viewType.replace("tree", "list");
         if (viewType.includes(",")) {
@@ -94,7 +97,11 @@ export async function loadSubViews(
         });
         const { ArchParser } = viewRegistry.get(viewType);
         const archInfo = new ArchParser().parse(views[viewType].arch, relatedModels, comodel);
-        fieldInfo.views[viewType] = { ...archInfo, fields: comodelFields };
+        fieldInfo.views[viewType] = {
+            ...archInfo,
+            limit: archInfo.limit || 40,
+            fields: comodelFields,
+        };
         fieldInfo.relatedFields = comodelFields;
     }
 }
@@ -111,68 +118,47 @@ export class FormController extends Component {
         useBus(this.ui.bus, "resize", this.render);
 
         this.archInfo = this.props.archInfo;
-        const activeFields = this.archInfo.activeFields;
-
         const { create, edit } = this.archInfo.activeActions;
         this.canCreate = create && !this.props.preventCreate;
         this.canEdit = edit && !this.props.preventEdit;
 
-        let mode = this.props.mode || "edit";
-        if (!this.canEdit) {
-            mode = "readonly";
-        }
-
-        this.model = useModel(
-            this.props.Model,
-            {
-                resModel: this.props.resModel,
-                resId: this.props.resId || false,
-                resIds: this.props.resIds,
-                fields: this.props.fields,
-                activeFields,
-                viewMode: "form",
-                rootType: "record",
-                mode,
-                component: this,
-                onRecordSaved: this.onRecordSaved.bind(this),
-                onWillSaveRecord: this.onWillSaveRecord.bind(this),
-            },
-            {
-                ignoreUseSampleModel: true,
-                onWillStart: () =>
-                    loadSubViews(
-                        this.archInfo.activeFields,
-                        this.props.fields,
-                        this.props.context,
-                        this.props.resModel,
-                        this.viewService,
-                        this.user,
-                        this.env.isSmall
-                    ),
-            }
-        );
-
-        this.cpButtonsRef = useRef("cpButtons");
-
         this.display = { ...this.props.display };
         if (this.env.inDialog) {
             this.display.controlPanel = false;
         }
 
+        const beforeFirstLoad = async () => {
+            await loadSubViews(
+                this.archInfo.fieldNodes,
+                this.props.fields,
+                this.props.context,
+                this.props.resModel,
+                this.viewService,
+                this.user,
+                this.env.isSmall
+            );
+            const { activeFields, fields } = extractFieldsFromArchInfo(
+                this.archInfo,
+                this.props.fields
+            );
+            if (this.display.controlPanel) {
+                addFieldDependencies(activeFields, fields, [
+                    { name: "display_name", type: "char", readonly: true },
+                ]);
+            }
+            this.model.config.activeFields = activeFields;
+            this.model.config.fields = fields;
+        };
+        this.model = useState(useModel(this.props.Model, this.modelParams, { beforeFirstLoad }));
+
+        this.cpButtonsRef = useRef("cpButtons");
+
         useEffect(() => {
             if (!this.env.inDialog) {
                 this.updateURL();
             }
         });
 
-        // enable the archive feature in Actions menu only if the active field is in the view
-        this.archiveEnabled =
-            "active" in activeFields
-                ? !this.props.fields.active.readonly
-                : "x_active" in activeFields
-                ? !this.props.fields.x_active.readonly
-                : false;
-
         // select footers that are not in subviews and move them to another arch
         // that will be moved to the dialog's footer (if we are in a dialog)
         const footers = [...this.archInfo.xmlDoc.querySelectorAll("footer:not(field footer)")];
@@ -214,9 +200,9 @@ export class FormController extends Component {
             beforeLeave: () => this.beforeLeave(),
             beforeUnload: (ev) => this.beforeUnload(ev),
             getLocalState: () => {
-                // TODO: export the whole model?
                 return {
                     activeNotebookPages: !this.model.root.isNew ? activeNotebookPages : {},
+                    modelState: this.model.exportState(),
                     resId: this.model.root.resId,
                 };
             },
@@ -262,6 +248,38 @@ export class FormController extends Component {
         }
     }
 
+    get modelParams() {
+        let mode = this.props.mode || "edit";
+        if (!this.canEdit && this.props.resId) {
+            mode = "readonly";
+        }
+        return {
+            config: {
+                resModel: this.props.resModel,
+                resId: this.props.resId || false,
+                resIds: this.props.resIds || (this.props.resId ? [this.props.resId] : []),
+                fields: this.props.fields,
+                activeFields: {}, // will be generated after loading sub views (see willStart)
+                isMonoRecord: true,
+                mode,
+                context: this.props.context,
+            },
+            state: this.props.state?.modelState,
+            hooks: {
+                onWillLoadRoot: this.onWillLoadRoot.bind(this),
+                onWillSaveRecord: this.onWillSaveRecord.bind(this),
+                onRecordSaved: this.onRecordSaved.bind(this),
+            },
+        };
+    }
+
+    /**
+     * onWillLoadRoot is a callback that will be executed before (re)loading the
+     * data necessary for the root record datapoint. Note that this.model.root
+     * may not exist yet at this point, if this is the first load.
+     */
+    onWillLoadRoot() {}
+
     /**
      * onRecordSaved is a callBack that will be executed after the save
      * if it was done. It will therefore not be executed if the record
@@ -278,17 +296,32 @@ export class FormController extends Component {
      */
     async onWillSaveRecord(record) {}
 
+    async onSaveError(error, { discard }) {
+        const proceed = await new Promise((resolve) => {
+            this.model.dialog.add(FormErrorDialog, {
+                message: error.data.message,
+                onDiscard: () => {
+                    discard();
+                    resolve(true);
+                },
+                onStayHere: () => resolve(false),
+            });
+        });
+        return proceed;
+    }
+
     displayName() {
         return this.model.root.data.display_name || this.env._t("New");
     }
 
     async onPagerUpdate({ offset, resIds }) {
-        await this.model.root.askChanges(); // ensures that isDirty is correct
+        const dirty = await this.model.root.isDirty();
         let canProceed = true;
-        if (this.model.root.isDirty) {
+        if (dirty) {
             canProceed = await this.model.root.save({
+                noReload: true,
                 stayInEdition: true,
-                useSaveErrorDialog: true,
+                onError: this.onSaveError.bind(this),
             });
         }
         if (canProceed) {
@@ -297,11 +330,11 @@ export class FormController extends Component {
     }
 
     async beforeLeave() {
-        if (this.model.root.isDirty) {
+        if (this.model.root.dirty) {
             return this.model.root.save({
                 noReload: true,
                 stayInEdition: true,
-                useSaveErrorDialog: true,
+                onError: this.onSaveError.bind(this),
             });
         }
     }
@@ -381,9 +414,22 @@ export class FormController extends Component {
         };
     }
 
+    // enable the archive feature in Actions menu only if the active field is in the view
+    get archiveEnabled() {
+        return "active" in this.model.root.activeFields
+            ? !this.props.fields.active.readonly
+            : "x_active" in this.model.root.activeFields
+            ? !this.props.fields.x_active.readonly
+            : false;
+    }
+
     async shouldExecuteAction(item) {
-        if ((this.model.root.isDirty || this.model.root.isNew) && !item.skipSave) {
-            return this.model.root.save({ stayInEdition: true, useSaveErrorDialog: true });
+        const dirty = await this.model.root.isDirty();
+        if ((dirty || this.model.root.isNew) && !item.skipSave) {
+            return this.model.root.save({
+                stayInEdition: true,
+                onError: this.onSaveError.bind(this),
+            });
         }
         return true;
     }
@@ -427,14 +473,20 @@ export class FormController extends Component {
     async beforeExecuteActionButton(clickParams) {
         if (clickParams.special !== "cancel") {
             const noReload = this.env.inDialog && clickParams.close;
-            return this.model.root
-                .save({ stayInEdition: true, useSaveErrorDialog: !this.env.inDialog, noReload })
-                .then((saved) => {
-                    if (saved && this.props.onSave) {
-                        this.props.onSave(this.model.root);
-                    }
-                    return saved;
-                });
+            const params = {
+                force: true,
+                stayInEdition: true,
+                noReload,
+            };
+            if (!this.env.inDialog) {
+                params.onError = this.onSaveError.bind(this);
+            }
+            return this.model.root.save(params).then((saved) => {
+                if (saved && this.props.onSave) {
+                    this.props.onSave(this.model.root);
+                }
+                return saved;
+            });
         } else if (this.props.onDiscard) {
             this.props.onDiscard(this.model.root);
         }
@@ -442,22 +494,15 @@ export class FormController extends Component {
 
     async afterExecuteActionButton(clickParams) {}
 
-    async edit() {
-        await this.model.root.switchMode("edit");
-    }
-
     async create() {
-        await this.model.root.askChanges(); // ensures that isDirty is correct
-        let canProceed = true;
-        if (this.model.root.isDirty) {
-            canProceed = await this.model.root.save({
-                stayInEdition: true,
-                useSaveErrorDialog: true,
-            });
-        }
+        const canProceed = await this.model.root.save({
+            stayInEdition: true,
+            onError: this.onSaveError.bind(this),
+        });
+        // FIXME: disable/enable not done in onPagerUpdate
         if (canProceed) {
             const btns = this.disableButtons();
-            await this.model.load({ resId: null });
+            await this.model.load({ resId: false });
             this.enableButtons(btns);
         }
     }
@@ -466,17 +511,18 @@ export class FormController extends Component {
         const btns = this.disableButtons();
         const record = this.model.root;
         let saved = false;
-
-        if (this.props.saveRecord) {
-            saved = await this.props.saveRecord(record, params);
-        } else {
-            saved = await record.save(params);
+        try {
+            if (this.props.saveRecord) {
+                saved = await this.props.saveRecord(record, params);
+            } else {
+                saved = await record.save(params);
+            }
+        } finally {
+            this.enableButtons(btns);
         }
-        this.enableButtons(btns);
         if (saved && this.props.onSave) {
             this.props.onSave(record, params);
         }
-
         return saved;
     }
 
diff --git a/addons/web/static/src/views/form/form_error_dialog/form_error_dialog.js b/addons/web/static/src/views/form/form_error_dialog/form_error_dialog.js
index 9f9a9a40826..b47da3247d5 100644
--- a/addons/web/static/src/views/form/form_error_dialog/form_error_dialog.js
+++ b/addons/web/static/src/views/form/form_error_dialog/form_error_dialog.js
@@ -1,21 +1,10 @@
 /** @odoo-module **/
 
 import { Dialog } from "@web/core/dialog/dialog";
-import { registry } from "@web/core/registry";
 
 import { Component } from "@odoo/owl";
-const errorHandlerRegistry = registry.category("error_handlers");
 
 export class FormErrorDialog extends Component {
-    setup() {
-        const { data, message } = this.props;
-        if (data && data.arguments && data.arguments.length > 0) {
-            this.message = data.arguments[0];
-        } else {
-            this.message = message;
-        }
-    }
-
     async discard() {
         await this.props.onDiscard();
         this.props.close();
@@ -28,31 +17,3 @@ export class FormErrorDialog extends Component {
 }
 FormErrorDialog.template = "web.FormErrorDialog";
 FormErrorDialog.components = { Dialog };
-
-function formSaveErrorHandler(env, error, originalError) {
-    if (originalError.__raisedOnFormSave) {
-        const event = originalError.event;
-        error.unhandledRejectionEvent.preventDefault();
-        if (event.isDefaultPrevented()) {
-            // in theory, here, event was already handled
-            return true;
-        }
-        event.preventDefault();
-
-        env.services.dialog.add(
-            FormErrorDialog,
-            {
-                message: originalError.message.message,
-                data: originalError.message.data,
-                onDiscard: originalError.onDiscard,
-                onStayHere: originalError.onStayHere,
-            },
-            {
-                onClose: originalError.onStayHere,
-            }
-        );
-
-        return true;
-    }
-}
-errorHandlerRegistry.add("formSaveErrorHandler", formSaveErrorHandler);
diff --git a/addons/web/static/src/views/form/form_error_dialog/form_error_dialog.xml b/addons/web/static/src/views/form/form_error_dialog/form_error_dialog.xml
index 90a6783012e..c22906f3c12 100644
--- a/addons/web/static/src/views/form/form_error_dialog/form_error_dialog.xml
+++ b/addons/web/static/src/views/form/form_error_dialog/form_error_dialog.xml
@@ -5,7 +5,7 @@
         <Dialog header="false" size="'md'" contentClass="'o_error_dialog'">
             <div role="alert">
                 <h1 class="text-danger">Oh snap!</h1>
-                <p t-esc="message" class="text-prewrap"/>
+                <p t-esc="props.message" class="text-prewrap"/>
             </div>
             <t t-set-slot="footer">
                 <button class="btn btn-primary" t-on-click="stay">Stay here</button>
diff --git a/addons/web/static/src/views/form/form_renderer.js b/addons/web/static/src/views/form/form_renderer.js
index bcb68d6564a..e798788aa30 100644
--- a/addons/web/static/src/views/form/form_renderer.js
+++ b/addons/web/static/src/views/form/form_renderer.js
@@ -1,5 +1,6 @@
 /** @odoo-module **/
 
+import { evalDomain } from "@web/core/domain";
 import { Notebook } from "@web/core/notebook/notebook";
 import { Setting } from "./setting/setting";
 import { Field } from "@web/views/fields/field";
@@ -12,7 +13,6 @@ import { ViewButton } from "@web/views/view_button/view_button";
 import { useViewCompiler } from "@web/views/view_compiler";
 import { useBounceButton } from "@web/views/view_hook";
 import { Widget } from "@web/views/widgets/widget";
-import { evalDomain } from "../utils";
 import { FormCompiler } from "./form_compiler";
 import { FormLabel } from "./form_label";
 import { StatusBarButtons } from "./status_bar_buttons/status_bar_buttons";
diff --git a/addons/web/static/src/views/form/form_status_indicator/form_status_indicator.js b/addons/web/static/src/views/form/form_status_indicator/form_status_indicator.js
index 54585d78468..cb58594ab64 100644
--- a/addons/web/static/src/views/form/form_status_indicator/form_status_indicator.js
+++ b/addons/web/static/src/views/form/form_status_indicator/form_status_indicator.js
@@ -36,7 +36,7 @@ export class FormStatusIndicator extends Component {
             return this.props.model.root.isValid ? "dirty" : "invalid";
         } else if (!this.props.model.root.isValid) {
             return "invalid";
-        } else if (this.props.model.root.isDirty || this.state.fieldIsDirty) {
+        } else if (this.props.model.root.dirty || this.state.fieldIsDirty) {
             return "dirty";
         } else {
             return "saved";
diff --git a/addons/web/static/src/views/form/form_view.js b/addons/web/static/src/views/form/form_view.js
index edcbbff784a..e0b4c138764 100644
--- a/addons/web/static/src/views/form/form_view.js
+++ b/addons/web/static/src/views/form/form_view.js
@@ -1,8 +1,8 @@
 /** @odoo-module **/
 
 import { registry } from "@web/core/registry";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 import { FormRenderer } from "./form_renderer";
-import { RelationalModel } from "../basic_relational_model";
 import { FormArchParser } from "./form_arch_parser";
 import { FormController } from "./form_controller";
 import { FormCompiler } from "./form_compiler";
diff --git a/addons/web/static/src/views/graph/graph_controller.js b/addons/web/static/src/views/graph/graph_controller.js
index 7744c8436f4..a8f13535a42 100644
--- a/addons/web/static/src/views/graph/graph_controller.js
+++ b/addons/web/static/src/views/graph/graph_controller.js
@@ -1,7 +1,7 @@
 /** @odoo-module **/
 
 import { Layout } from "@web/search/layout";
-import { useModel } from "@web/views/model";
+import { useModelWithSampleData } from "@web/model/model";
 import { standardViewProps } from "@web/views/standard_view_props";
 import { useSetupView } from "@web/views/view_hook";
 import { SearchBar } from "@web/search/search_bar/search_bar";
@@ -12,7 +12,7 @@ import { Component, useRef } from "@odoo/owl";
 
 export class GraphController extends Component {
     setup() {
-        this.model = useModel(this.props.Model, this.props.modelParams);
+        this.model = useModelWithSampleData(this.props.Model, this.props.modelParams);
 
         useSetupView({
             rootRef: useRef("root"),
diff --git a/addons/web/static/src/views/graph/graph_model.js b/addons/web/static/src/views/graph/graph_model.js
index f4f24105f57..9579f554ea4 100644
--- a/addons/web/static/src/views/graph/graph_model.js
+++ b/addons/web/static/src/views/graph/graph_model.js
@@ -5,7 +5,7 @@ import { KeepLast, Race } from "@web/core/utils/concurrency";
 import { rankInterval } from "@web/search/utils/dates";
 import { getGroupBy } from "@web/search/utils/group_by";
 import { GROUPABLE_TYPES } from "@web/search/utils/misc";
-import { Model } from "@web/views/model";
+import { Model } from "@web/model/model";
 import { computeReportMeasures, processMeasure } from "@web/views/utils";
 import { sprintf } from "@web/core/utils/strings";
 import { Domain } from "@web/core/domain";
diff --git a/addons/web/static/src/views/kanban/kanban_arch_parser.js b/addons/web/static/src/views/kanban/kanban_arch_parser.js
index 17e945ad5f7..a54cdba1cf5 100644
--- a/addons/web/static/src/views/kanban/kanban_arch_parser.js
+++ b/addons/web/static/src/views/kanban/kanban_arch_parser.js
@@ -1,15 +1,10 @@
 /** @odoo-module **/
 
 import { extractAttributes, XMLParser } from "@web/core/utils/xml";
+import { stringToOrderBy } from "@web/search/utils/order_by";
 import { Field } from "@web/views/fields/field";
 import { Widget } from "@web/views/widgets/widget";
-import {
-    addFieldDependencies,
-    archParseBoolean,
-    getActiveActions,
-    processButton,
-    stringToOrderBy,
-} from "@web/views/utils";
+import { archParseBoolean, getActiveActions, processButton } from "@web/views/utils";
 
 /**
  * NOTE ON 't-name="kanban-box"':
@@ -61,10 +56,9 @@ export class KanbanArchParser extends XMLParser {
         const type = xmlDoc.getAttribute("type");
         const openAction = action && type ? { action, type } : null;
         const templateDocs = {};
-        const activeFields = {};
         let headerButtons = [];
         const creates = [];
-        let buttonId = 0;
+        let button_id = 0;
         // Root level of the template
         this.visitXML(xmlDoc, (node) => {
             if (node.hasAttribute("t-name")) {
@@ -77,7 +71,7 @@ export class KanbanArchParser extends XMLParser {
                     .map((node) => ({
                         ...processButton(node),
                         type: "button",
-                        id: buttonId++,
+                        id: button_id++,
                     }))
                     .filter((button) => button.modifiers.invisible !== true);
                 return false;
@@ -121,17 +115,15 @@ export class KanbanArchParser extends XMLParser {
                 if (fieldInfo.options.group_by_tooltip) {
                     tooltipInfo[name] = fieldInfo.options.group_by_tooltip;
                 }
-                if (fieldInfo.widget === "handle") {
+                if (fieldInfo.isHandle) {
                     handleField = name;
                 }
-                addFieldDependencies(fieldInfo, activeFields, models[modelName]);
             }
             if (node.tagName === "widget") {
                 const widgetInfo = Widget.parseWidgetNode(node);
                 const widgetId = `widget_${++widgetNextId}`;
                 widgetNodes[widgetId] = widgetInfo;
                 node.setAttribute("widget_id", widgetId);
-                addFieldDependencies(widgetInfo, activeFields, models[modelName]);
             }
 
             // Keep track of last update so images can be reloaded when they may have changed.
@@ -171,25 +163,9 @@ export class KanbanArchParser extends XMLParser {
             defaultOrder = stringToOrderBy(handleField);
         }
 
-        for (const fieldNode of Object.values(fieldNodes)) {
-            const fieldName = fieldNode.name;
-            if (activeFields[fieldName]) {
-                const { alwaysInvisible } = fieldNode;
-                activeFields[fieldName] = {
-                    ...fieldNode,
-                    // a field can only be considered to be always invisible
-                    // if all its nodes are always invisible
-                    alwaysInvisible: activeFields[fieldName].alwaysInvisible && alwaysInvisible,
-                };
-            } else {
-                activeFields[fieldName] = fieldNode;
-            }
-        }
-
         return {
             arch,
             activeActions,
-            activeFields,
             className,
             creates,
             defaultGroupBy,
diff --git a/addons/web/static/src/views/kanban/kanban_compiler.js b/addons/web/static/src/views/kanban/kanban_compiler.js
index b5cba781e87..7c0a3a3b784 100644
--- a/addons/web/static/src/views/kanban/kanban_compiler.js
+++ b/addons/web/static/src/views/kanban/kanban_compiler.js
@@ -131,6 +131,20 @@ export class KanbanCompiler extends ViewCompiler {
             compiled = super.compileField(el, params);
             const fieldId = el.getAttribute("field_id");
             compiled.setAttribute("id", `'${fieldId}_' + __comp__.props.record.id`);
+            // In x2many kanban, records can be edited in a dialog. The same record as the one of
+            // the kanban is used for the form view dialog, so its mode is switched to "edit", but
+            // we don't want to see it in edition in the background. For that reason, we force its
+            // fields to be readonly when the record is in edition, i.e. when it is opened in a form
+            // view dialog.
+            const readonlyAttr = compiled.getAttribute("readonly");
+            if (readonlyAttr) {
+                compiled.setAttribute(
+                    "readonly",
+                    `__comp__.props.record.isInEdition || (${readonlyAttr})`
+                );
+            } else {
+                compiled.setAttribute("readonly", `__comp__.props.record.isInEdition`);
+            }
         }
 
         const { bold, display } = extractAttributes(el, ["bold", "display"]);
diff --git a/addons/web/static/src/views/kanban/kanban_controller.js b/addons/web/static/src/views/kanban/kanban_controller.js
index 45e75822f4b..40f3ffc307a 100644
--- a/addons/web/static/src/views/kanban/kanban_controller.js
+++ b/addons/web/static/src/views/kanban/kanban_controller.js
@@ -1,21 +1,24 @@
 /** @odoo-module **/
 
+import { ConfirmationDialog } from "@web/core/confirmation_dialog/confirmation_dialog";
+import { _t } from "@web/core/l10n/translation";
 import { useService } from "@web/core/utils/hooks";
+import { CogMenu } from "@web/search/cog_menu/cog_menu";
 import { Layout } from "@web/search/layout";
 import { usePager } from "@web/search/pager_hook";
-import { useModel } from "@web/views/model";
+import { SearchBar } from "@web/search/search_bar/search_bar";
+import { useSearchBarToggler } from "@web/search/search_bar/search_bar_toggler";
+import { session } from "@web/session";
+import { useSetupView } from "@web/views/view_hook";
+import { useModelWithSampleData } from "@web/model/model";
 import { standardViewProps } from "@web/views/standard_view_props";
 import { MultiRecordViewButton } from "@web/views/view_button/multi_record_view_button";
 import { useViewButtons } from "@web/views/view_button/view_button_hook";
-import { useSetupView } from "@web/views/view_hook";
+import { addFieldDependencies, extractFieldsFromArchInfo } from "@web/model/relational_model/utils";
 import { KanbanRenderer } from "./kanban_renderer";
 import { useProgressBar } from "./progress_bar_hook";
-import { SearchBar } from "@web/search/search_bar/search_bar";
-import { useSearchBarToggler } from "@web/search/search_bar/search_bar_toggler";
-import { CogMenu } from "@web/search/cog_menu/cog_menu";
 
-import { Component, reactive, useRef } from "@odoo/owl";
-import { addDependencies } from "../utils";
+import { Component, reactive, useRef, useState } from "@odoo/owl";
 
 const QUICK_CREATE_FIELD_TYPES = ["char", "boolean", "many2one", "selection", "many2many"];
 
@@ -24,8 +27,63 @@ const QUICK_CREATE_FIELD_TYPES = ["char", "boolean", "many2one", "selection", "m
 export class KanbanController extends Component {
     setup() {
         this.actionService = useService("action");
+        this.dialog = useService("dialog");
         const { Model, archInfo } = this.props;
-        this.model = useModel(Model, this.modelParams, this.modelOptions);
+
+        class KanbanSampleModel extends Model {
+            setup() {
+                super.setup(...arguments);
+                this.initialSampleGroups = undefined;
+            }
+
+            /**
+             * @override
+             */
+            hasData() {
+                if (this.root.groups) {
+                    if (!this.root.groups.length) {
+                        // While we don't have any data, we want to display the column quick create and
+                        // example background. Return true so that we don't get sample data instead
+                        return true;
+                    }
+                    return this.root.groups.some((group) => group.hasData);
+                }
+                return super.hasData();
+            }
+
+            async load() {
+                if (this.orm.isSample && this.initialSampleGroups) {
+                    this.orm.setGroups(this.initialSampleGroups);
+                }
+                return super.load(...arguments);
+            }
+
+            async _webReadGroup() {
+                const result = await super._webReadGroup(...arguments);
+                if (!this.initialSampleGroups) {
+                    this.initialSampleGroups = JSON.parse(JSON.stringify(result.groups));
+                }
+                return result;
+            }
+
+            removeSampleDataInGroups() {
+                if (this.useSampleModel) {
+                    for (const group of this.root.groups) {
+                        const list = group.list;
+                        list.count = 0;
+                        if (list.records) {
+                            list.records = [];
+                        } else {
+                            list.groups = [];
+                        }
+                    }
+                }
+            }
+        }
+
+        this.model = useState(
+            useModelWithSampleData(KanbanSampleModel, this.modelParams, this.modelOptions)
+        );
         if (archInfo.progressAttributes) {
             const { activeBars } = this.props.state || {};
             this.progressBarState = useProgressBar(
@@ -44,9 +102,8 @@ export class KanbanController extends Component {
             },
             set groupId(groupId) {
                 if (self.model.useSampleModel) {
+                    self.model.removeSampleDataInGroups();
                     self.model.useSampleModel = false;
-                    self.model.root.groups.forEach((g) => g.empty());
-                    self.render();
                 }
                 this._groupId = groupId;
             },
@@ -68,7 +125,7 @@ export class KanbanController extends Component {
             getLocalState: () => {
                 return {
                     activeBars: this.progressBarState?.activeBars,
-                    rootState: this.model.root.exportState(),
+                    modelState: this.model.exportState(),
                 };
             },
         });
@@ -76,16 +133,14 @@ export class KanbanController extends Component {
             const root = this.model.root;
             const { count, hasLimitedCount, isGrouped, limit, offset } = root;
             if (!isGrouped) {
+                console.log(root);
                 return {
                     offset: offset,
                     limit: limit,
                     total: count,
                     onUpdate: async ({ offset, limit }) => {
-                        this.model.root.offset = offset;
-                        this.model.root.limit = limit;
-                        await this.model.root.load();
+                        await this.model.root.load({ offset, limit });
                         await this.onUpdatedPager();
-                        this.render(true); // FIXME WOWL reactivity
                     },
                     updateTotal: hasLimitedCount ? () => root.fetchCount() : undefined,
                 };
@@ -95,29 +150,33 @@ export class KanbanController extends Component {
     }
 
     get modelParams() {
-        const { resModel, fields, archInfo, limit, defaultGroupBy, state } = this.props;
-        const { rootState } = state || {};
-
-        const activeFields = archInfo.activeFields;
-        addDependencies(this.progressBarAggregateFields, activeFields, fields);
+        const { resModel, archInfo, limit, defaultGroupBy } = this.props;
+        const { activeFields, fields } = extractFieldsFromArchInfo(archInfo, this.props.fields);
+        addFieldDependencies(activeFields, fields, this.progressBarAggregateFields);
+        const modelConfig = this.props.state?.modelState?.config || {
+            resModel,
+            activeFields,
+            fields,
+            openGroupsByDefault: true,
+        };
 
         return {
-            activeFields,
-            fields: { ...fields },
-            resModel,
-            handleField: archInfo.handleField,
-            limit: archInfo.limit || limit,
+            config: modelConfig,
+            state: this.props.state?.modelState,
+            limit: archInfo.limit || limit || 40,
+            groupsLimit: Number.MAX_SAFE_INTEGER, // no limit
             countLimit: archInfo.countLimit,
             defaultGroupBy,
-            defaultOrder: archInfo.defaultOrder,
-            viewMode: "kanban",
-            openGroupsByDefault: true,
-            onRecordSaved: this.onRecordSaved.bind(this),
-            rootState,
+            defaultOrderBy: archInfo.defaultOrder,
+            maxGroupByDepth: 1,
+            activeIdsLimit: session.active_ids_limit,
+            hooks: {
+                onRecordSaved: this.onRecordSaved.bind(this),
+            },
         };
     }
 
-    get modelOptions(){
+    get modelOptions() {
         return {};
     }
 
@@ -139,6 +198,15 @@ export class KanbanController extends Component {
         return this.props.className;
     }
 
+    async deleteRecord(record) {
+        this.dialog.add(ConfirmationDialog, {
+            body: _t("Are you sure you want to delete this record?"),
+            confirm: () => this.model.root.deleteRecords([record]),
+            confirmLabel: _t("Delete"),
+            cancel: () => {},
+        });
+    }
+
     async openRecord(record, mode) {
         const activeIds = this.model.root.records.map((datapoint) => datapoint.resId);
         this.props.selectRecord(record.resId, { activeIds, mode });
@@ -219,7 +287,10 @@ KanbanController.template = `web.KanbanView`;
 KanbanController.components = { Layout, KanbanRenderer, MultiRecordViewButton, SearchBar, CogMenu };
 KanbanController.props = {
     ...standardViewProps,
-    defaultGroupBy: { validate: (dgb) => !dgb || typeof dgb === "string", optional: true },
+    defaultGroupBy: {
+        validate: (dgb) => !dgb || typeof dgb === "string",
+        optional: true,
+    },
     editable: { type: Boolean, optional: true },
     forceGlobalClick: { type: Boolean, optional: true },
     onSelectionChanged: { type: Function, optional: true },
diff --git a/addons/web/static/src/views/kanban/kanban_controller.xml b/addons/web/static/src/views/kanban/kanban_controller.xml
index d0a1b9b17a1..963351efc27 100644
--- a/addons/web/static/src/views/kanban/kanban_controller.xml
+++ b/addons/web/static/src/views/kanban/kanban_controller.xml
@@ -44,6 +44,7 @@
                     Compiler="props.Compiler"
                     readonly="true"
                     forceGlobalClick="props.forceGlobalClick"
+                    deleteRecord.bind="deleteRecord"
                     openRecord.bind="openRecord"
                     noContentHelp="props.info.noContentHelp"
                     scrollTop.bind="scrollTop"
diff --git a/addons/web/static/src/views/kanban/kanban_header.js b/addons/web/static/src/views/kanban/kanban_header.js
index 6d20a40138a..fcdf84122b5 100644
--- a/addons/web/static/src/views/kanban/kanban_header.js
+++ b/addons/web/static/src/views/kanban/kanban_header.js
@@ -9,7 +9,8 @@ import { memoize } from "@web/core/utils/functions";
 import { useService } from "@web/core/utils/hooks";
 import { sprintf } from "@web/core/utils/strings";
 import { useDebounced } from "@web/core/utils/timing";
-import { isNull, isRelational } from "@web/views/utils";
+import { isRelational } from "@web/model/relational_model/utils";
+import { isNull } from "@web/views/utils";
 import { ColumnProgress } from "@web/views/view_components/column_progress";
 import { FormViewDialog } from "@web/views/view_dialogs/form_view_dialog";
 
@@ -161,12 +162,12 @@ export class KanbanHeader extends Component {
     }
 
     editGroup() {
-        const { context, displayName, resModel, value } = this.group;
+        const { context, displayName, groupByField, value } = this.group;
         this.props.dialogClose.push(
             this.dialog.add(FormViewDialog, {
                 context,
                 resId: value,
-                resModel,
+                resModel: groupByField.relation,
                 title: sprintf(this.env._t("Edit: %s"), displayName),
                 onRecordSaved: async () => {
                     await this.props.list.load();
diff --git a/addons/web/static/src/views/kanban/kanban_model.js b/addons/web/static/src/views/kanban/kanban_model.js
deleted file mode 100644
index a673a63211b..00000000000
--- a/addons/web/static/src/views/kanban/kanban_model.js
+++ /dev/null
@@ -1,229 +0,0 @@
-/** @odoo-module **/
-
-import {
-    DynamicGroupList,
-    DynamicRecordList,
-    Group,
-    RelationalModel,
-} from "@web/views/relational_model";
-import { isRelational } from "@web/views/utils";
-
-import { EventBus } from "@odoo/owl";
-
-class TransactionInProgress extends Error {}
-
-class NoTransactionInProgress extends Error {}
-
-function makeTransactionManager() {
-    const bus = new EventBus();
-    const transactions = {};
-    return {
-        start: (id) => {
-            if (transactions[id]) {
-                throw new TransactionInProgress(
-                    `Transaction in progress: commit or abort to start a new one.`
-                );
-            }
-            transactions[id] = true;
-            bus.trigger("START");
-        },
-        commit: (id) => {
-            if (!transactions[id]) {
-                throw new NoTransactionInProgress(`No transaction in progress.`);
-            }
-            delete transactions[id];
-            bus.trigger("COMMIT");
-        },
-        abort: (id) => {
-            if (!transactions[id]) {
-                throw new NoTransactionInProgress(`No transaction in progress.`);
-            }
-            delete transactions[id];
-            bus.trigger("ABORT");
-        },
-        register: ({ onStart, onCommit, onAbort }) => {
-            let currentData = null;
-            bus.addEventListener("START", () => onStart && (currentData = onStart()));
-            bus.addEventListener("COMMIT", () => onCommit && onCommit(currentData));
-            bus.addEventListener("ABORT", () => onAbort && onAbort(currentData));
-        },
-    };
-}
-
-class KanbanGroup extends Group {
-    setup(_params, state = {}) {
-        super.setup(...arguments);
-
-        this.tooltip = [];
-
-        this.model.transaction.register({
-            onStart: () => ({
-                count: this.count,
-                records: [...this.list.records],
-            }),
-            onAbort: ({ count, records }) => {
-                this.count = count;
-                this.list.records = records;
-            },
-        });
-    }
-}
-
-export class KanbanDynamicGroupList extends DynamicGroupList {
-    setup(params, state) {
-        super.setup(...arguments);
-        this.previousParams = state.previousParams || "[]";
-
-        this.groupBy = this.groupBy.slice(0, 1);
-        this.limit = null;
-    }
-
-    get currentParams() {
-        return JSON.stringify([this.domain, this.groupBy]);
-    }
-
-    exportState() {
-        return {
-            ...super.exportState(),
-            previousParams: this.currentParams,
-        };
-    }
-
-    /**
-     * After a reload, empty groups are expcted to disappear from the web_read_group.
-     * However, if the parameters are the same (domain + groupBy), we want to
-     * temporarily keep these empty groups in the interface until the next reload
-     * with different parameters.
-     * @override
-     */
-    async load() {
-        const previousGroups = this.groups.map((g, i) => [g, i]);
-        await super.load();
-        if (this.previousParams === this.currentParams) {
-            for (const [group, index] of previousGroups) {
-                const newGroup = this.groups.find((g) => group.valueEquals(g.value));
-                if (!group.deleted && !newGroup) {
-                    group.empty();
-                    this.groups.splice(index, 0, group);
-                }
-            }
-        }
-    }
-
-    /**
-     * @param {string} dataRecordId
-     * @param {string} dataGroupId
-     * @param {string} refId
-     * @param {string} targetGroupId
-     */
-    async moveRecord(dataRecordId, dataGroupId, refId, targetGroupId) {
-        const sourceGroup = this.groups.find((g) => g.id === dataGroupId);
-        const targetGroup = this.groups.find((g) => g.id === targetGroupId);
-
-        if (!sourceGroup || !targetGroup) {
-            return; // Groups have been re-rendered, old ids are ignored
-        }
-
-        const record = sourceGroup.list.records.find((r) => r.id === dataRecordId);
-
-        try {
-            this.model.transaction.start(dataRecordId);
-        } catch (err) {
-            if (err instanceof TransactionInProgress) {
-                return;
-            }
-            throw err;
-        }
-
-        // Move from one group to another
-        if (dataGroupId !== targetGroupId) {
-            const refIndex = targetGroup.list.records.findIndex((r) => r.id === refId);
-            // Quick update: moves the record at the right position and notifies components
-            targetGroup.addRecord(sourceGroup.removeRecord(record), refIndex + 1);
-            const value = isRelational(this.groupByField)
-                ? [targetGroup.value, targetGroup.displayName]
-                : targetGroup.value;
-
-            const abort = () => {
-                this.model.transaction.abort(dataRecordId);
-                this.model.notify();
-            };
-
-            try {
-                await record.update({ [this.groupByField.name]: value }, { silent: true });
-                const saved = await record.save({ noReload: true });
-                if (!saved) {
-                    abort();
-                    this.model.notify();
-                    return;
-                }
-            } catch (err) {
-                abort();
-                throw err;
-            }
-
-            const promises = [];
-            const groupsToReload = [sourceGroup];
-            if (!targetGroup.isFolded) {
-                groupsToReload.push(targetGroup);
-                promises.push(record.load());
-            }
-            await Promise.all(promises);
-        }
-
-        if (!targetGroup.isFolded) {
-            // Only trigger resequence if the group isn't folded
-            await targetGroup.list.resequence(dataRecordId, refId);
-        }
-        this.model.notify();
-
-        this.model.transaction.commit(dataRecordId);
-
-        return true;
-    }
-}
-
-export class KanbanDynamicRecordList extends DynamicRecordList {
-    async moveRecord(dataRecordId, _dataGroupId, refId) {
-        this.model.transaction.start(dataRecordId);
-
-        try {
-            await this.resequence(dataRecordId, refId);
-        } catch (err) {
-            this.model.transaction.abort(dataRecordId);
-            this.model.notify();
-            throw err;
-        }
-
-        this.model.transaction.commit(dataRecordId);
-    }
-}
-
-KanbanDynamicRecordList.DEFAULT_LIMIT = 40;
-
-export class KanbanModel extends RelationalModel {
-    setup(params) {
-        super.setup(...arguments);
-
-        this.transaction = makeTransactionManager();
-    }
-
-    /**
-     * @override
-     */
-    hasData() {
-        if (this.root.groups) {
-            if (!this.root.groups.length) {
-                // While we don't have any data, we want to display the column quick create and
-                // example background. Return true so that we don't get sample data instead
-                return true;
-            }
-            return this.root.groups.some((group) => group.count > 0);
-        }
-        return this.root.records.length > 0;
-    }
-}
-
-KanbanModel.DynamicGroupList = KanbanDynamicGroupList;
-KanbanModel.DynamicRecordList = KanbanDynamicRecordList;
-KanbanModel.Group = KanbanGroup;
diff --git a/addons/web/static/src/views/kanban/kanban_record.js b/addons/web/static/src/views/kanban/kanban_record.js
index 0f2188dc862..835bb771720 100644
--- a/addons/web/static/src/views/kanban/kanban_record.js
+++ b/addons/web/static/src/views/kanban/kanban_record.js
@@ -1,7 +1,7 @@
 /** @odoo-module **/
 
+import { evalDomain } from "@web/core/domain";
 import { ColorList } from "@web/core/colorlist/colorlist";
-import { ConfirmationDialog } from "@web/core/confirmation_dialog/confirmation_dialog";
 import { Dropdown } from "@web/core/dropdown/dropdown";
 import { DropdownItem } from "@web/core/dropdown/dropdown_item";
 import { registry } from "@web/core/registry";
@@ -14,7 +14,7 @@ import { fileTypeMagicWordMap, imageCacheKey } from "@web/views/fields/image/ima
 import { ViewButton } from "@web/views/view_button/view_button";
 import { useViewCompiler } from "@web/views/view_compiler";
 import { Widget } from "@web/views/widgets/widget";
-import { evalDomain, getFormattedValue } from "../utils";
+import { getFormattedValue } from "../utils";
 import {
     KANBAN_BOX_ATTRIBUTE,
     KANBAN_MENU_ATTRIBUTE,
@@ -30,7 +30,9 @@ const { COLORS } = ColorList;
 const formatters = registry.category("formatters");
 
 // These classes determine whether a click on a record should open it.
-export const CANCEL_GLOBAL_CLICK = ["a", ".dropdown", ".oe_kanban_action", "[data-bs-toggle]"].join(",");
+export const CANCEL_GLOBAL_CLICK = ["a", ".dropdown", ".oe_kanban_action", "[data-bs-toggle]"].join(
+    ","
+);
 const ALLOW_GLOBAL_CLICK = [".oe_kanban_global_click", ".oe_kanban_global_click_edit"].join(",");
 
 /**
@@ -295,7 +297,7 @@ export class KanbanRecord extends Component {
      */
     triggerAction(params) {
         const env = this.env;
-        const { archInfo, group, list, openRecord, record } = this.props;
+        const { archInfo, openRecord, deleteRecord, record } = this.props;
         const { type } = params;
         switch (type) {
             case "edit": {
@@ -305,19 +307,7 @@ export class KanbanRecord extends Component {
                 return openRecord(record);
             }
             case "delete": {
-                const listOrGroup = group || list;
-                if (listOrGroup.deleteRecords) {
-                    this.dialog.add(ConfirmationDialog, {
-                        body: env._t("Are you sure you want to delete this record?"),
-                        confirm: () => listOrGroup.deleteRecords([record]),
-                        confirmLabel: env._t("Delete"),
-                        cancel: () => {},
-                    });
-                } else {
-                    // static list case
-                    listOrGroup.removeRecord(record);
-                }
-                return;
+                return deleteRecord(record);
             }
             case "set_cover": {
                 const { autoOpen, fieldName } = params;
@@ -387,6 +377,7 @@ KanbanRecord.components = {
 };
 KanbanRecord.defaultProps = {
     colors: COLORS,
+    deleteRecord: () => {},
     openRecord: () => {},
 };
 KanbanRecord.props = [
@@ -397,6 +388,7 @@ KanbanRecord.props = [
     "forceGlobalClick?",
     "group?",
     "list",
+    "deleteRecord?",
     "openRecord?",
     "readonly?",
     "record",
diff --git a/addons/web/static/src/views/kanban/kanban_record_quick_create.js b/addons/web/static/src/views/kanban/kanban_record_quick_create.js
index c29da4bff9b..f4752c651d2 100644
--- a/addons/web/static/src/views/kanban/kanban_record_quick_create.js
+++ b/addons/web/static/src/views/kanban/kanban_record_quick_create.js
@@ -1,21 +1,21 @@
 /** @odoo-module */
-import { useOwnedDialogs, useService } from "@web/core/utils/hooks";
 import { useHotkey } from "@web/core/hotkeys/hotkey_hook";
+import { useOwnedDialogs, useService } from "@web/core/utils/hooks";
 
 import {
     Component,
     onMounted,
-    useExternalListener,
-    useState,
-    useRef,
     onWillStart,
+    useExternalListener,
+    useRef,
+    useState,
     useSubEnv,
 } from "@odoo/owl";
-import { getDefaultConfig } from "../view";
 import { RPCError } from "@web/core/network/rpc_service";
-import { FormViewDialog } from "../view_dialogs/form_view_dialog";
+import { extractFieldsFromArchInfo } from "@web/model/relational_model/utils";
 import { formView } from "../form/form_view";
-import { useModel } from "../model";
+import { getDefaultConfig } from "../view";
+import { FormViewDialog } from "../view_dialogs/form_view_dialog";
 
 const DEFAULT_QUICK_CREATE_VIEW = {
     // note: the required modifier is written in the format returned by the server
@@ -55,24 +55,31 @@ class KanbanQuickCreateController extends Component {
         this.state = useState({ disabled: false });
         this.addDialog = useOwnedDialogs();
 
-        this.model = useModel(
-            this.props.Model,
-            {
-                resModel: this.props.resModel,
-                resId: false,
-                resIds: [],
-                fields: this.props.fields,
-                activeFields: this.props.archInfo.activeFields,
-                viewMode: "form",
-                rootType: "record",
-                mode: "edit",
-                component: this,
-            },
-            {
-                ignoreUseSampleModel: true,
-            }
+        const { activeFields, fields } = extractFieldsFromArchInfo(
+            this.props.archInfo,
+            this.props.fields
         );
 
+        const modelServices = Object.fromEntries(
+            this.props.Model.services.map((servName) => {
+                return [servName, useService(servName)];
+            })
+        );
+        modelServices.orm = useService("orm");
+        const config = {
+            resModel: this.props.resModel,
+            resId: false,
+            resIds: [],
+            fields,
+            activeFields,
+            isMonoRecord: true,
+            mode: "edit",
+            context: this.props.context,
+        };
+        this.model = useState(new this.props.Model(this.env, { config }, modelServices));
+
+        onWillStart(() => this.model.load());
+
         onMounted(() => {
             this.uiActiveElement = this.uiService.activeElement;
         });
@@ -126,7 +133,7 @@ class KanbanQuickCreateController extends Component {
 
         const keys = Object.keys(this.model.root.activeFields);
         if (keys.length === 1 && keys[0] === "display_name") {
-            const isValid = await this.model.root.checkValidity(true); // needed to put the class o_field_invalid in the field
+            const isValid = await this.model.root.checkValidity(); // needed to put the class o_field_invalid in the field
             if (isValid) {
                 try {
                     [resId] = await this.model.orm.call(
@@ -141,31 +148,35 @@ class KanbanQuickCreateController extends Component {
                     this.showFormDialogInError(e);
                 }
             } else {
-                this.model.notificationService.add(this.model.env._t("Display Name"), {
+                this.model.notification.add(this.model.env._t("Display Name"), {
                     title: this.model.env._t("Invalid fields: "),
                     type: "danger",
                 });
             }
         } else {
-            try {
-                await this.model.root.save({ closable: true, noReload: true, throwOnError: true });
-            } catch (e) {
-                this.showFormDialogInError(e);
-            }
+            await this.model.root.save({
+                closable: true,
+                noReload: true,
+                force: true,
+                onError: (e) => this.showFormDialogInError(e),
+            });
             resId = this.model.root.resId;
         }
 
         if (resId) {
             await this.props.onValidate(resId, mode);
+            if (mode === "add") {
+                await this.model.load({ resId: false });
+            }
         }
         this.state.disabled = false;
     }
 
-    cancel(force) {
+    async cancel(force) {
         if (this.state.disabled) {
             return;
         }
-        if (force || !this.model.root.isDirty) {
+        if (force || !(await this.model.root.isDirty())) {
             this.props.onCancel();
         }
     }
@@ -185,6 +196,7 @@ class KanbanQuickCreateController extends Component {
             title: this.env._t("Create"),
             onRecordSaved: async (record) => {
                 await this.props.onValidate(record.resId, "add");
+                await this.model.load();
             },
         });
     }
@@ -246,7 +258,7 @@ export class KanbanRecordQuickCreate extends Component {
             props.resModel
         );
         const context = props.context || {};
-        context[`default_${props.group.groupByField.name}`] = props.group.getServerValue();
+        context[`default_${props.group.groupByField.name}`] = props.group.serverValue;
         this.quickCreateProps = {
             Model: formView.Model,
             Renderer: formView.Renderer,
diff --git a/addons/web/static/src/views/kanban/kanban_renderer.js b/addons/web/static/src/views/kanban/kanban_renderer.js
index 00e9d22f81a..c6c91cfb569 100644
--- a/addons/web/static/src/views/kanban/kanban_renderer.js
+++ b/addons/web/static/src/views/kanban/kanban_renderer.js
@@ -49,6 +49,7 @@ export class KanbanRenderer extends Component {
         "archInfo",
         "Compiler?", // optional in stable for backward compatibility
         "list",
+        "deleteRecord",
         "openRecord",
         "readonly",
         "forceGlobalClick?",
@@ -214,15 +215,22 @@ export class KanbanRenderer extends Component {
         if (!this.canResequenceRecords) {
             return false;
         }
-        const { fields, groupByField } = this.props.list;
+        const groupByField = this.props.list.groupByField;
         if (!groupByField) {
             return true;
         }
-        const { name, modifiers } = groupByField;
-        const isReadonly =
-            modifiers && "readonly" in modifiers
-                ? modifiers.readonly === true
-                : fields[name].readonly;
+        const fieldNodes = Object.values(this.props.archInfo.fieldNodes).filter(
+            (fieldNode) => fieldNode.name === groupByField.name
+        );
+        let isReadonly;
+        if (
+            fieldNodes.length &&
+            fieldNodes.some((fieldNode) => "readonly" in fieldNode.modifiers)
+        ) {
+            isReadonly = fieldNodes.every((fieldNode) => fieldNode.modifiers.readonly === true);
+        } else {
+            isReadonly = this.props.list.fields[groupByField.name].readonly;
+        }
         return !isReadonly && this.isMovableField(groupByField);
     }
 
@@ -391,7 +399,7 @@ export class KanbanRenderer extends Component {
     }
 
     loadMore(group) {
-        return group.list.loadMore();
+        return group.list.load({ limit: group.list.records.length + group.model.initialLimit });
     }
 
     /**
diff --git a/addons/web/static/src/views/kanban/kanban_renderer.xml b/addons/web/static/src/views/kanban/kanban_renderer.xml
index f42434ac652..75fb59f3d6a 100644
--- a/addons/web/static/src/views/kanban/kanban_renderer.xml
+++ b/addons/web/static/src/views/kanban/kanban_renderer.xml
@@ -47,6 +47,7 @@
                                     forceGlobalClick="props.forceGlobalClick"
                                     group="group"
                                     list="props.list"
+                                    deleteRecord="props.deleteRecord"
                                     openRecord="props.openRecord"
                                     readonly="props.readonly"
                                     record="record"
@@ -74,6 +75,7 @@
                         canResequence="!isProcessing(groupOrRecord.record.id) and canResequenceRecords"
                         forceGlobalClick="props.forceGlobalClick"
                         list="props.list"
+                        deleteRecord="props.deleteRecord"
                         openRecord="props.openRecord"
                         readonly="props.readonly"
                         record="groupOrRecord.record"
diff --git a/addons/web/static/src/views/kanban/kanban_view.js b/addons/web/static/src/views/kanban/kanban_view.js
index 41785d2f501..0cb59157b78 100644
--- a/addons/web/static/src/views/kanban/kanban_view.js
+++ b/addons/web/static/src/views/kanban/kanban_view.js
@@ -1,11 +1,11 @@
 /** @odoo-module **/
 
+import { registry } from "@web/core/registry";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 import { KanbanArchParser } from "./kanban_arch_parser";
 import { KanbanCompiler } from "./kanban_compiler";
 import { KanbanController } from "./kanban_controller";
-import { KanbanModel } from "./kanban_model";
 import { KanbanRenderer } from "./kanban_renderer";
-import { registry } from "@web/core/registry";
 
 export const kanbanView = {
     type: "kanban",
@@ -17,7 +17,7 @@ export const kanbanView = {
 
     ArchParser: KanbanArchParser,
     Controller: KanbanController,
-    Model: KanbanModel,
+    Model: RelationalModel,
     Renderer: KanbanRenderer,
     Compiler: KanbanCompiler,
 
diff --git a/addons/web/static/src/views/kanban/progress_bar_hook.js b/addons/web/static/src/views/kanban/progress_bar_hook.js
index edf53359891..a96ef80aa2a 100644
--- a/addons/web/static/src/views/kanban/progress_bar_hook.js
+++ b/addons/web/static/src/views/kanban/progress_bar_hook.js
@@ -219,9 +219,9 @@ class ProgressBarState {
     }
 
     async _updateAggregates() {
-        const { context, groupBy, domain, resModel, firstGroupBy } = this.model.root;
+        const { context, groupBy, domain, resModel } = this.model.root;
         const fieldsName = this._aggregateFields.map((f) => f.name);
-        const firstGroupByName = firstGroupBy.split(":")[0];
+        const firstGroupByName = groupBy[0].split(":")[0];
         const kwargs = { context };
         const res = await this.model.orm.webReadGroup(
             resModel,
diff --git a/addons/web/static/src/views/legacy_utils.js b/addons/web/static/src/views/legacy_utils.js
deleted file mode 100644
index e605f6bdf9b..00000000000
--- a/addons/web/static/src/views/legacy_utils.js
+++ /dev/null
@@ -1,147 +0,0 @@
-/** @odoo-module **/
-import fieldRegistry from "web.field_registry";
-import { parseArch } from "web.viewUtils";
-import { parse } from "web.field_utils";
-import { traverse } from "web.utils";
-
-import { serializeDate, serializeDateTime } from "@web/core/l10n/dates";
-
-const { date: parseDate, datetime: parseDateTime } = parse;
-
-export function mapWowlValueToLegacy(value, type) {
-    switch (type) {
-        case "date":
-            // from luxon to moment
-            return value ? parseDate(serializeDate(value), null, { isUTC: true }) : false;
-        case "datetime":
-            // from luxon to moment
-            return value ? parseDateTime(serializeDateTime(value), null, { isUTC: true }) : false;
-        case "many2one":
-            return value ? { id: value[0], display_name: value[1] } : false;
-        case "reference":
-            return value
-                ? { id: value.resId, display_name: value.displayName, model: value.resModel }
-                : false;
-        case "one2many":
-        case "many2many":
-            if (value.operation === "REPLACE_WITH") {
-                return { operation: "REPLACE_WITH", ids: value.resIds };
-            }
-            return value;
-        default:
-            return value;
-    }
-}
-
-export function mapViews(views, env) {
-    const res = {};
-    for (const [viewType, viewDescr] of Object.entries(views || {})) {
-        const arch = parseArch(viewDescr.__rawArch);
-        traverse(arch, function (node) {
-            if (typeof node === "string") {
-                return false;
-            }
-            node.attrs.modifiers = node.attrs.modifiers ? JSON.parse(node.attrs.modifiers) : {};
-            return true;
-        });
-        // the basic model expects the former shape of load_views result, where we don't know
-        // all co-model fields, only those in the subview, so we filter the fields here
-        const fields = {};
-        for (const f in viewDescr.activeFields) {
-            fields[f] = viewDescr.fields[f];
-        }
-        res[viewType] = {
-            arch,
-            fields,
-            type: viewType,
-            fieldsInfo: mapActiveFieldsToFieldsInfo(viewDescr.activeFields, fields, viewType, env),
-        };
-        for (const fieldName in res[viewType].fieldsInfo[viewType]) {
-            if (!res[viewType].fields[fieldName]) {
-                res[viewType].fields[fieldName] = {
-                    name: fieldName,
-                    type: res[viewType].fieldsInfo[viewType][fieldName].type,
-                };
-            }
-        }
-    }
-    return res;
-}
-
-export function mapActiveFieldsToFieldsInfo(activeFields, fields, viewType, env) {
-    const fieldsInfo = {};
-    fieldsInfo[viewType] = {};
-    for (const [fieldName, fieldDescr] of Object.entries(activeFields)) {
-        const views = mapViews(fieldDescr.views, env);
-        let Widget;
-        if (fieldDescr.widget) {
-            Widget = fieldRegistry.getAny([`${viewType}.${fieldDescr.widget}`, fieldDescr.widget]);
-        } else {
-            Widget = fieldRegistry.getAny([
-                `${viewType}.${fields[fieldName].type}`,
-                fields[fieldName].type,
-            ]);
-        }
-        Widget = Widget || fieldRegistry.get("abstract");
-        let domain;
-        if (fieldDescr.domain) {
-            domain = fieldDescr.domain.toString();
-        }
-        let mode = fieldDescr.viewMode;
-        if (mode && mode.split(",").length !== 1) {
-            mode = env.isSmall ? "kanban" : "list";
-        }
-        const fieldInfo = {
-            Widget, // remove this when we no longer support legacy fields inside wowl views
-            specialData: fieldDescr.field && fieldDescr.field.legacySpecialData,
-            domain,
-            context: fieldDescr.context,
-            fieldDependencies: [], // ??
-            force_save: fieldDescr.forceSave,
-            mode,
-            modifiers: fieldDescr.modifiers,
-            name: fieldName,
-            options: fieldDescr.options,
-            views,
-            widget: fieldDescr.widget,
-            __WOWL_FIELD_DESCR__: fieldDescr,
-        };
-
-        if (fieldDescr.field && fieldDescr.field.limit) {
-            fieldInfo.limit = fieldDescr.field.limit;
-        }
-
-        if (fieldDescr.modifiers && fieldDescr.modifiers.invisible === true) {
-            fieldInfo.__no_fetch = true;
-        }
-
-        if (!fieldInfo.__no_fetch && fieldDescr.field && fieldDescr.field.relatedFields) {
-            let relatedFields = fieldDescr.field.relatedFields;
-            if (relatedFields instanceof Function) {
-                relatedFields = relatedFields(fieldInfo.__WOWL_FIELD_DESCR__);
-            }
-            relatedFields = Object.fromEntries(relatedFields.map((f) => [f.name, f]));
-            fieldInfo.relatedFields = { ...relatedFields };
-            fieldInfo.viewType = "default";
-            const defaultView = {};
-            for (const fieldName of Object.keys(relatedFields)) {
-                defaultView[fieldName] = {};
-                if (fieldDescr.relatedFields[fieldName]) {
-                    defaultView[fieldName].__WOWL_FIELD_DESCR__ =
-                        fieldDescr.relatedFields[fieldName];
-                }
-            }
-            fieldInfo.fieldsInfo = { default: defaultView };
-        }
-        if (fieldDescr.views && fieldDescr.views[fieldDescr.viewMode]) {
-            fieldInfo.limit = fieldDescr.views[fieldDescr.viewMode].limit || 40;
-            fieldInfo.orderedBy = fieldDescr.views[fieldDescr.viewMode].defaultOrder;
-        }
-        if (fieldDescr.onChange && !fields[fieldName].onChange) {
-            fields[fieldName].onChange = "1";
-        }
-        // FIXME? FieldWidget in kanban undefined
-        fieldsInfo[viewType][fieldName] = fieldInfo;
-    }
-    return fieldsInfo;
-}
diff --git a/addons/web/static/src/views/list/list_arch_parser.js b/addons/web/static/src/views/list/list_arch_parser.js
index dc459ba038f..00f55b15c05 100644
--- a/addons/web/static/src/views/list/list_arch_parser.js
+++ b/addons/web/static/src/views/list/list_arch_parser.js
@@ -1,17 +1,11 @@
 /** @odoo-module */
 
-import {
-    addFieldDependencies,
-    archParseBoolean,
-    getActiveActions,
-    getDecoration,
-    processButton,
-    stringToOrderBy,
-} from "@web/views/utils";
-import { Field } from "@web/views/fields/field";
 import { XMLParser } from "@web/core/utils/xml";
-import { Widget } from "@web/views/widgets/widget";
+import { stringToOrderBy } from "@web/search/utils/order_by";
+import { Field } from "@web/views/fields/field";
+import { archParseBoolean, getActiveActions, getDecoration, processButton } from "@web/views/utils";
 import { encodeObjectForTemplate } from "@web/views/view_compiler";
+import { Widget } from "@web/views/widgets/widget";
 
 export class GroupListArchParser extends XMLParser {
     parse(arch, models, modelName, jsClass) {
@@ -37,11 +31,7 @@ export class GroupListArchParser extends XMLParser {
                 return false;
             }
         });
-        const activeFields = {};
-        for (const fieldNode of Object.values(fieldNodes)) {
-            activeFields[fieldNode.name] = fieldNode;
-        }
-        return { fieldNodes, activeFields, buttons };
+        return { fieldNodes, buttons };
     }
 }
 
@@ -81,7 +71,6 @@ export class ListArchParser extends XMLParser {
         let handleField = null;
         const treeAttr = {};
         let nextId = 0;
-        const activeFields = {};
         const fieldNextIds = {};
         this.visitXML(arch, (node) => {
             if (node.tagName !== "button") {
@@ -116,10 +105,9 @@ export class ListArchParser extends XMLParser {
                 const fieldId = `${fieldInfo.name}_${fieldNextIds[fieldInfo.name]++}`;
                 fieldNodes[fieldId] = fieldInfo;
                 node.setAttribute("field_id", fieldId);
-                if (fieldInfo.widget === "handle") {
+                if (fieldInfo.isHandle) {
                     handleField = fieldInfo.name;
                 }
-                addFieldDependencies(fieldInfo, activeFields, models[modelName]);
                 if (this.isColumnVisible(fieldInfo.modifiers.column_invisible)) {
                     const label = fieldInfo.field.label;
                     columns.push({
@@ -140,7 +128,6 @@ export class ListArchParser extends XMLParser {
                 const widgetId = `widget_${++widgetNextId}`;
                 widgetNodes[widgetId] = widgetInfo;
                 node.setAttribute("widget_id", widgetId);
-                addFieldDependencies(widgetInfo, activeFields, models[modelName]);
 
                 const widgetProps = {
                     name: widgetInfo.name,
@@ -163,7 +150,6 @@ export class ListArchParser extends XMLParser {
                 const groupByArchInfo = groupListArchParser.parse(groupByArch, models, coModelName);
                 groupBy.buttons[fieldName] = groupByArchInfo.buttons;
                 groupBy.fields[fieldName] = {
-                    activeFields: groupByArchInfo.activeFields,
                     fieldNodes: groupByArchInfo.fieldNodes,
                     fields: models[coModelName],
                 };
@@ -238,28 +224,11 @@ export class ListArchParser extends XMLParser {
             treeAttr.defaultOrder = stringToOrderBy(handleField);
         }
 
-        for (const fieldNode of Object.values(fieldNodes)) {
-            const fieldName = fieldNode.name;
-            if (activeFields[fieldName]) {
-                const { alwaysInvisible } = fieldNode;
-                activeFields[fieldName] = {
-                    ...fieldNode,
-                    // a field can only be considered to be always invisible
-                    // if all its nodes are always invisible
-                    alwaysInvisible: activeFields[fieldName].alwaysInvisible && alwaysInvisible,
-                };
-            } else {
-                activeFields[fieldName] = fieldNode;
-            }
-        }
-
         return {
             creates,
-            handleField,
             headerButtons,
             fieldNodes,
             widgetNodes,
-            activeFields,
             columns,
             groupBy,
             xmlDoc,
diff --git a/addons/web/static/src/views/list/list_confirmation_dialog.js b/addons/web/static/src/views/list/list_confirmation_dialog.js
index bd032399f34..97fed788100 100644
--- a/addons/web/static/src/views/list/list_confirmation_dialog.js
+++ b/addons/web/static/src/views/list/list_confirmation_dialog.js
@@ -45,7 +45,6 @@ ListConfirmationDialog.props = {
     nbRecords: Number,
     nbValidRecords: Number,
     record: Object,
-    fieldNodes: Object,
 };
 ListConfirmationDialog.defaultProps = {
     title: _lt("Confirmation"),
diff --git a/addons/web/static/src/views/list/list_confirmation_dialog.xml b/addons/web/static/src/views/list/list_confirmation_dialog.xml
index 37188e404e6..5322567a408 100644
--- a/addons/web/static/src/views/list/list_confirmation_dialog.xml
+++ b/addons/web/static/src/views/list/list_confirmation_dialog.xml
@@ -23,7 +23,7 @@
                                 <tr>
                                     <td>Update to:</td>
                                     <td style="pointer-events: none;">
-                                        <Field name="field.name" record="props.record" type="field.widget" readonly="true" fieldInfo="props.fieldNodes[field.name]"/>
+                                        <Field name="field.name" record="props.record" type="field.widget" readonly="true" fieldInfo="field.fieldNode"/>
                                     </td>
                                 </tr>
                             </t>
diff --git a/addons/web/static/src/views/list/list_controller.js b/addons/web/static/src/views/list/list_controller.js
index 800f20b45a1..9291152f4fd 100644
--- a/addons/web/static/src/views/list/list_controller.js
+++ b/addons/web/static/src/views/list/list_controller.js
@@ -6,13 +6,12 @@ import { evaluateExpr } from "@web/core/py_js/py";
 import { unique } from "@web/core/utils/arrays";
 import { useService, useBus } from "@web/core/utils/hooks";
 import { omit } from "@web/core/utils/objects";
-import { sprintf } from "@web/core/utils/strings";
 import { ActionMenus, STATIC_ACTIONS_GROUP_NUMBER } from "@web/search/action_menus/action_menus";
 import { Layout } from "@web/search/layout";
 import { usePager } from "@web/search/pager_hook";
-import { session } from "@web/session";
-import { useModel } from "@web/views/model";
-import { DynamicRecordList } from "@web/views/relational_model";
+import { useModelWithSampleData } from "@web/model/model";
+import { DynamicRecordList } from "@web/model/relational_model/dynamic_record_list";
+import { extractFieldsFromArchInfo } from "@web/model/relational_model/utils";
 import { standardViewProps } from "@web/views/standard_view_props";
 import { MultiRecordViewButton } from "@web/views/view_button/multi_record_view_button";
 import { ViewButton } from "@web/views/view_button/view_button";
@@ -23,6 +22,7 @@ import { ListConfirmationDialog } from "./list_confirmation_dialog";
 import { SearchBar } from "@web/search/search_bar/search_bar";
 import { useSearchBarToggler } from "@web/search/search_bar/search_bar_toggler";
 import { CogMenu } from "@web/search/cog_menu/cog_menu";
+import { session } from "@web/session";
 
 import {
     Component,
@@ -31,6 +31,7 @@ import {
     onWillStart,
     useEffect,
     useRef,
+    useState,
     useSubEnv,
 } from "@odoo/owl";
 
@@ -40,7 +41,6 @@ export class ListController extends Component {
     setup() {
         this.actionService = useService("action");
         this.dialogService = useService("dialog");
-        this.notificationService = useService("notification");
         this.userService = useService("user");
         this.rpc = useService("rpc");
         this.rootRef = useRef("root");
@@ -49,7 +49,7 @@ export class ListController extends Component {
         this.activeActions = this.archInfo.activeActions;
         this.editable =
             this.activeActions.edit && this.props.editable ? this.archInfo.editable : false;
-        this.model = useModel(this.props.Model, this.modelParams);
+        this.model = useState(useModelWithSampleData(this.props.Model, this.modelParams));
 
         // In multi edition, we save or notify invalidity directly when a field is updated, which
         // occurs on the change event for input fields. But we don't want to do it when clicking on
@@ -80,7 +80,7 @@ export class ListController extends Component {
                 : "x_active" in this.props.fields
                 ? !this.props.fields.x_active.readonly
                 : false;
-        useSubEnv({ model: this.model }); // do this in useModel?
+        useSubEnv({ model: this.model }); // do this in useModelWithSampleData?
         useViewButtons(this.model, this.rootRef, {
             beforeExecuteAction: this.beforeExecuteActionButton.bind(this),
             afterExecuteAction: this.afterExecuteActionButton.bind(this),
@@ -88,13 +88,7 @@ export class ListController extends Component {
         useSetupView({
             rootRef: this.rootRef,
             beforeLeave: async () => {
-                const list = this.model.root;
-                const editedRecord = list.editedRecord;
-                if (editedRecord) {
-                    if (!(await list.unselectRecord(true))) {
-                        return false;
-                    }
-                }
+                return this.model.root.leaveEditMode();
             },
             beforeUnload: async (ev) => {
                 const editedRecord = this.model.root.editedRecord;
@@ -109,8 +103,11 @@ export class ListController extends Component {
             getLocalState: () => {
                 const renderer = this.rootRef.el.querySelector(".o_list_renderer");
                 return {
-                    rootState: this.model.root.exportState(),
-                    rendererScrollPositions: { left: renderer.scrollLeft, top: renderer.scrollTop },
+                    modelState: this.model.exportState(),
+                    rendererScrollPositions: {
+                        left: renderer.scrollLeft,
+                        top: renderer.scrollTop,
+                    },
                 };
             },
             getOrderBy: () => {
@@ -119,8 +116,7 @@ export class ListController extends Component {
         });
 
         usePager(() => {
-            const list = this.model.root;
-            const { count, hasLimitedCount, isGrouped, limit, offset } = list;
+            const { count, hasLimitedCount, isGrouped, limit, offset } = this.model.root;
             return {
                 offset: offset,
                 limit: limit,
@@ -131,13 +127,13 @@ export class ListController extends Component {
                             return;
                         }
                     }
-                    await list.load({ limit, offset });
-                    this.render(true); // FIXME WOWL reactivity
+                    await this.model.root.load({ limit, offset });
                     if (hasNavigated) {
                         this.onPageChangeScroll();
                     }
                 },
-                updateTotal: !isGrouped && hasLimitedCount ? () => list.fetchCount() : undefined,
+                updateTotal:
+                    !isGrouped && hasLimitedCount ? () => this.model.root.fetchCount() : undefined,
             };
         });
 
@@ -155,32 +151,47 @@ export class ListController extends Component {
         onWillPatch(() => {
             this.firstLoad = false;
         });
-        useBus(this.env.searchModel, 'direct-export-data', this.onDirectExportData.bind(this));
+        useBus(this.env.searchModel, "direct-export-data", this.onDirectExportData.bind(this));
     }
 
     get modelParams() {
-        const { rootState } = this.props.state || {};
         const { defaultGroupBy, rawExpand } = this.archInfo;
-        return {
+        const { activeFields, fields } = extractFieldsFromArchInfo(
+            this.archInfo,
+            this.props.fields
+        );
+        const groupByInfo = {};
+        for (const fieldName in this.archInfo.groupBy.fields) {
+            const fieldNodes = this.archInfo.groupBy.fields[fieldName].fieldNodes;
+            const fields = this.archInfo.groupBy.fields[fieldName].fields;
+            groupByInfo[fieldName] = extractFieldsFromArchInfo({ fieldNodes }, fields);
+        }
+
+        const modelConfig = this.props.state?.modelState?.config || {
             resModel: this.props.resModel,
-            fields: { ...this.props.fields },
-            activeFields: this.archInfo.activeFields,
-            handleField: this.archInfo.handleField,
-            viewMode: "list",
-            groupByInfo: this.archInfo.groupBy.fields,
+            fields,
+            activeFields,
+            openGroupsByDefault: rawExpand ? evaluateExpr(rawExpand, this.props.context) : false,
+        };
+
+        return {
+            config: modelConfig,
+            state: this.props.state?.modelState,
+            groupByInfo,
             limit: this.archInfo.limit || this.props.limit,
             countLimit: this.archInfo.countLimit,
-            defaultOrder: this.archInfo.defaultOrder,
+            defaultOrderBy: this.archInfo.defaultOrder,
             defaultGroupBy: this.props.searchMenuTypes.includes("groupBy") ? defaultGroupBy : false,
-            expand: rawExpand ? evaluateExpr(rawExpand, this.props.context) : false,
             groupsLimit: this.archInfo.groupsLimit,
             multiEdit: this.archInfo.multiEdit,
-            rootState,
-            onRecordSaved: this.onRecordSaved.bind(this),
-            onWillSaveRecord: this.onWillSaveRecord.bind(this),
-            onWillSaveMultiRecords: this.onWillSaveMultiRecords.bind(this),
-            onSavedMultiRecords: this.onSavedMultiRecords.bind(this),
-            onWillSetInvalidField: this.onWillSetInvalidField.bind(this),
+            activeIdsLimit: session.active_ids_limit,
+            hooks: {
+                onRecordSaved: this.onRecordSaved.bind(this),
+                onWillSaveRecord: this.onWillSaveRecord.bind(this),
+                onWillSaveMulti: this.onWillSaveMulti.bind(this),
+                onSavedMulti: this.onSavedMulti.bind(this),
+                onWillSetInvalidField: this.onWillSetInvalidField.bind(this),
+            },
         };
     }
 
@@ -206,11 +217,9 @@ export class ListController extends Component {
             if (!(list instanceof DynamicRecordList)) {
                 throw new Error("List should be a DynamicRecordList");
             }
-            if (list.editedRecord) {
-                await list.editedRecord.save();
-            }
+            await list.leaveEditMode();
             if (!list.editedRecord) {
-                await (group || list).createRecord({}, this.editable === "top");
+                await (group || list).addNewRecord(this.editable === "top");
             }
             this.render();
         } else {
@@ -238,21 +247,25 @@ export class ListController extends Component {
         }
     }
 
-    onClickCreate() {
-        this.createRecord();
+    async onClickCreate() {
+        this.disableButtons();
+        await this.createRecord();
+        this.enableButtons();
     }
 
-    onClickDiscard() {
-        const editedRecord = this.model.root.editedRecord;
-        if (editedRecord.isNew) {
-            this.model.root.removeRecord(editedRecord);
-        } else {
-            editedRecord.discard();
+    async onClickDiscard() {
+        this.disableButtons();
+        await this.model.root.leaveEditMode({ discard: true });
+        this.enableButtons();
+    }
+
+    async onClickSave() {
+        this.disableButtons();
+        const saved = await this.model.root.editedRecord.save();
+        if (saved) {
+            await this.model.root.leaveEditMode();
         }
-    }
-
-    onClickSave() {
-        this.model.root.editedRecord.save();
+        this.enableButtons();
     }
 
     onMouseDownDiscard(mouseDownEvent) {
@@ -352,7 +365,7 @@ export class ListController extends Component {
     }
 
     async onSelectDomain() {
-        this.model.root.selectDomain(true);
+        await this.model.root.selectDomain(true);
         if (this.props.onSelectionChanged) {
             const resIds = await this.model.root.getResIds(true);
             this.props.onSelectionChanged(resIds);
@@ -385,7 +398,7 @@ export class ListController extends Component {
 
     get nbTotal() {
         const list = this.model.root;
-        return list.isGrouped ? list.nbTotalRecords : list.count;
+        return list.isGrouped ? list.recordCount : list.count;
     }
 
     get defaultExportList() {
@@ -424,7 +437,10 @@ export class ListController extends Component {
             type: field.field_type || field.type,
         }));
         if (import_compat) {
-            exportedFields.unshift({ name: "id", label: this.env._t("External ID") });
+            exportedFields.unshift({
+                name: "id",
+                label: this.env._t("External ID"),
+            });
         }
         await download({
             data: {
@@ -481,30 +497,10 @@ export class ListController extends Component {
      * @returns {Promise}
      */
     async toggleArchiveState(archive) {
-        let resIds;
-        const isDomainSelected = this.model.root.isDomainSelected;
-        const total = this.model.root.count;
         if (archive) {
-            resIds = await this.model.root.archive(true);
-        } else {
-            resIds = await this.model.root.unarchive(true);
-        }
-        if (
-            isDomainSelected &&
-            resIds.length === session.active_ids_limit &&
-            resIds.length < total
-        ) {
-            this.notificationService.add(
-                sprintf(
-                    this.env._t(
-                        "Of the %s records selected, only the first %s have been archived/unarchived."
-                    ),
-                    resIds.length,
-                    total
-                ),
-                { title: this.env._t("Warning") }
-            );
+            return this.model.root.archive(true);
         }
+        return this.model.root.unarchive(true);
     }
 
     get deleteConfirmationDialogProps() {
@@ -515,28 +511,8 @@ export class ListController extends Component {
                 : this.env._t("Are you sure you want to delete this record?");
         return {
             body,
-            confirm: async () => {
-                const total = root.count;
-                const resIds = await this.model.root.deleteRecords();
-                this.model.notify();
-                if (
-                    root.isDomainSelected &&
-                    resIds.length === session.active_ids_limit &&
-                    resIds.length < total
-                ) {
-                    this.notificationService.add(
-                        sprintf(
-                            this.env._t(
-                                `Only the first %s records have been deleted (out of %s selected)`
-                            ),
-                            resIds.length,
-                            total
-                        ),
-                        { title: this.env._t("Warning") }
-                    );
-                }
-            },
             confirmLabel: this.env._t("Delete"),
+            confirm: () => this.model.root.deleteRecords(),
             cancel: () => {},
         };
     }
@@ -559,7 +535,22 @@ export class ListController extends Component {
 
     async afterExecuteActionButton(clickParams) {}
 
-    onWillSaveMultiRecords(editedRecord, validSelectedRecords) {
+    disableButtons() {
+        const btns = [...this.rootRef.el.querySelectorAll("button:not([disabled])")];
+        for (const btn of btns) {
+            btn.setAttribute("disabled", "1");
+        }
+        this.disabledButtons = btns;
+    }
+
+    enableButtons() {
+        for (const btn of this.disabledButtons) {
+            btn.removeAttribute("disabled");
+        }
+        this.disabledButtons = null;
+    }
+
+    onWillSaveMulti(editedRecord, changes, validSelectedRecords) {
         if (this.hasMousedownDiscard) {
             this.nextActionAfterMouseup = () => this.model.root.multiSave(editedRecord);
             return false;
@@ -570,22 +561,25 @@ export class ListController extends Component {
                 const dialogProps = {
                     confirm: () => resolve(true),
                     cancel: () => {
-                        editedRecord.discard();
+                        this.model.root.leaveEditMode({ discard: true });
                         resolve(false);
                     },
                     isDomainSelected,
-                    fields: Object.keys(editedRecord.getChanges()).map((fieldName) => {
-                        const activeField = editedRecord.activeFields[fieldName];
+                    fields: Object.keys(changes).map((fieldName) => {
+                        const fieldNode = Object.values(this.archInfo.fieldNodes).find(
+                            (fieldNode) => fieldNode.name === fieldName
+                        );
+                        const label = fieldNode && fieldNode.string;
                         return {
                             name: fieldName,
-                            label: activeField.string || editedRecord.fields[fieldName].string,
-                            widget: activeField.widget,
+                            label: label || editedRecord.fields[fieldName].string,
+                            fieldNode,
+                            widget: fieldNode && fieldNode.widget,
                         };
                     }),
                     nbRecords: selection.length,
                     nbValidRecords: validSelectedRecords.length,
                     record: editedRecord,
-                    fieldNodes: this.archInfo.fieldNodes,
                 };
 
                 const focusedCellBeforeDialog = document.activeElement.closest(".o_data_cell");
@@ -594,7 +588,7 @@ export class ListController extends Component {
                         if (focusedCellBeforeDialog) {
                             focusedCellBeforeDialog.focus();
                         }
-                        editedRecord.discard();
+                        this.model.root.leaveEditMode({ discard: true });
                         resolve(false);
                     },
                 });
@@ -611,7 +605,7 @@ export class ListController extends Component {
         return true;
     }
 
-    onSavedMultiRecords(records) {
+    onSavedMulti(records) {
         records.forEach((record) => {
             record.selected = false;
         });
diff --git a/addons/web/static/src/views/list/list_controller.xml b/addons/web/static/src/views/list/list_controller.xml
index 22f4cd5dd37..8159a21f5b8 100644
--- a/addons/web/static/src/views/list/list_controller.xml
+++ b/addons/web/static/src/views/list/list_controller.xml
@@ -80,7 +80,7 @@
                 <button type="button" class="btn btn-primary o_list_button_save" data-hotkey="s" t-on-click.stop="onClickSave">
                     Save
                 </button>
-                <button type="button" class="btn btn-secondary o_list_button_discard" data-hotkey="j" t-on-click="onClickDiscard" t-on-mousedown="onMouseDownDiscard">
+                <button type="button" class="btn btn-secondary o_list_button_discard" data-hotkey="j" t-on-click.stop="onClickDiscard" t-on-mousedown="onMouseDownDiscard">
                     Discard
                 </button>
             </t>
diff --git a/addons/web/static/src/views/list/list_renderer.js b/addons/web/static/src/views/list/list_renderer.js
index 1c4e41f1b5e..c698430d469 100644
--- a/addons/web/static/src/views/list/list_renderer.js
+++ b/addons/web/static/src/views/list/list_renderer.js
@@ -2,7 +2,7 @@
 
 import { browser } from "@web/core/browser/browser";
 import { CheckBox } from "@web/core/checkbox/checkbox";
-import { Domain } from "@web/core/domain";
+import { Domain, evalDomain } from "@web/core/domain";
 import { Dropdown } from "@web/core/dropdown/dropdown";
 import { DropdownItem } from "@web/core/dropdown/dropdown_item";
 import { getActiveHotkey } from "@web/core/hotkeys/hotkey_service";
@@ -12,9 +12,9 @@ import { registry } from "@web/core/registry";
 import { useBus, useService } from "@web/core/utils/hooks";
 import { useSortable } from "@web/core/utils/sortable";
 import { getTabableElements } from "@web/core/utils/ui";
-import { Field } from "@web/views/fields/field";
+import { Field, getPropertyFieldInfo } from "@web/views/fields/field";
 import { getTooltipInfo } from "@web/views/fields/field_tooltip";
-import { evalDomain, getClassNameFromDecoration } from "@web/views/utils";
+import { getClassNameFromDecoration } from "@web/views/utils";
 import { ViewButton } from "@web/views/view_button/view_button";
 import { useBounceButton } from "@web/views/view_hook";
 import { Widget } from "@web/views/widgets/widget";
@@ -110,7 +110,10 @@ export class ListRenderer extends Component {
 
         this.cellToFocus = null;
         this.activeRowId = null;
-        onMounted(() => {
+        onMounted(async () => {
+            // Due to the way elements are mounted in the DOM by Owl (bottom-to-top),
+            // we need to wait the next micro task tick to set the activeElement.
+            await Promise.resolve();
             this.activeElement = this.uiService.activeElement;
         });
         onWillPatch(() => {
@@ -121,7 +124,11 @@ export class ListRenderer extends Component {
             this.allColumns = this.processAllColumn(nextProps.archInfo.columns, nextProps.list);
             this.state.columns = this.getActiveColumns(nextProps.list);
         });
-        onPatched(() => {
+        onPatched(async () => {
+            // HACK: we need to wait for the next tick to be sure that the Field components are patched.
+            // OWL don't wait the patch for the children components if the children trigger a patch by himself.
+            await Promise.resolve();
+
             const editedRecord = this.props.list.editedRecord;
             if (editedRecord && this.activeRowId !== editedRecord.id) {
                 if (this.cellToFocus && this.cellToFocus.record === editedRecord) {
@@ -187,7 +194,7 @@ export class ListRenderer extends Component {
             () => {
                 this.freezeColumnWidths();
             },
-            () => [this.state.columns, this.isEmpty]
+            () => [this.state.columns, this.isEmpty, this.props.list.offset, this.props.list.limit]
         );
         useExternalListener(window, "resize", () => {
             this.columnWidths = null;
@@ -238,32 +245,36 @@ export class ListRenderer extends Component {
     processAllColumn(allColumns, list) {
         return allColumns.flatMap((column) => {
             if (column.type === "field" && list.fields[column.name].type === "properties") {
-                return Object.values(list.activeFields)
-                    .filter(
-                        (activeField) =>
-                            activeField.relatedPropertyField &&
-                            activeField.relatedPropertyField.fieldName === column.name
-                    )
-                    .map((activeField) => ({
-                        ...activeField,
-                        id: `${column.id}_${activeField.name}`,
-                        classNames: column.classNames,
-                        optional: "hide",
-                        type: "field",
-                        hasLabel: true,
-                        label: activeField.string,
-                    }));
+                return this.getPropertyFieldColumns(column, list);
             } else {
                 return [column];
             }
         });
     }
 
+    getPropertyFieldColumns(column, list) {
+        return Object.values(list.fields)
+            .filter(
+                (field) =>
+                    field.relatedPropertyField &&
+                    field.relatedPropertyField.fieldName === column.name
+            )
+            .map((propertyField) => {
+                return {
+                    ...getPropertyFieldInfo(propertyField),
+                    id: `${column.id}_${propertyField.name}`,
+                    classNames: column.classNames,
+                    optional: "hide",
+                    type: "field",
+                    hasLabel: true,
+                    label: propertyField.string,
+                    sortable: false,
+                };
+            });
+    }
+
     getFieldProps(record, column) {
-        if (
-            this.isCellReadonly(column, record) ||
-            (this.props.activeActions?.edit === false && !record.isNew)
-        ) {
+        if (this.isCellReadonly(column, record) || this.isRecordReadonly(record)) {
             return {
                 readonly: true,
             };
@@ -397,8 +408,7 @@ export class ListRenderer extends Component {
         if (!this.props.list.canResequence()) {
             return false;
         }
-        const orderBy = this.props.list.orderBy;
-        const handleField = this.props.archInfo.handleField;
+        const { handleField, orderBy } = this.props.list;
         return !orderBy.length || (orderBy.length && orderBy[0].name === handleField);
     }
 
@@ -425,7 +435,30 @@ export class ListRenderer extends Component {
     }
 
     canUseFormatter(column, record) {
-        return !record.isInEdition && !column.widget;
+        if (column.widget) {
+            return false;
+        }
+        if (record.isInEdition && (record.model.multiEdit || this.isInlineEditable(record))) {
+            // in a x2many non editable list, a record is in edition when it is opened in a dialog,
+            // but in the list we want it to still be displayed in readonly.
+            return false;
+        }
+        return true;
+    }
+
+    isRecordReadonly(record) {
+        if (record.isNew) {
+            return false;
+        }
+        if (this.props.activeActions?.edit === false) {
+            return true;
+        }
+        if (record.isInEdition && !this.isInlineEditable(record) && !record.model.multiEdit) {
+            // in a x2many non editable list, a record is in edition when it is opened in a dialog,
+            // but in the list we want it to still be displayed in readonly.
+            return true;
+        }
+        return false;
     }
 
     focusCell(column, forward = true) {
@@ -499,7 +532,7 @@ export class ListRenderer extends Component {
 
     createKeyOptionalFields() {
         let keyParts = {
-            fields: this.props.list.fieldNames,
+            fields: this.props.list.fieldNames, // FIXME: use something else?
             model: this.props.list.resModel,
             viewMode: "list",
             viewId: this.env.config.viewId,
@@ -617,7 +650,7 @@ export class ListRenderer extends Component {
             let currencyId;
             if (type === "monetary" || widget === "monetary") {
                 const currencyField =
-                    this.props.list.activeFields[fieldName].options.currency_field ||
+                    column.options.currency_field ||
                     this.fields[fieldName].currency_field ||
                     "currency_id";
                 if (!(currencyField in this.props.list.activeFields)) {
@@ -811,7 +844,7 @@ export class ListRenderer extends Component {
             if (required && evalDomain(required, record.evalContext)) {
                 classNames.push("o_required_modifier");
             }
-            if (record.isInvalid(column.name)) {
+            if (record.isFieldInvalid(column.name)) {
                 classNames.push("o_invalid_cell");
             }
             if (this.isCellReadonly(column, record)) {
@@ -1049,11 +1082,11 @@ export class ListRenderer extends Component {
                 this.cellToFocus = null;
             } else {
                 await recordAfterResequence();
-                await record.switchMode("edit");
+                await this.props.list.enterEditMode(record);
                 this.cellToFocus = { column, record };
             }
         } else if (this.props.list.editedRecord && this.props.list.editedRecord !== record) {
-            this.props.list.unselectRecord(true);
+            this.props.list.leaveEditMode();
         } else if (!this.props.archInfo.noOpen) {
             this.props.openRecord(record);
         }
@@ -1063,8 +1096,8 @@ export class ListRenderer extends Component {
         this.keepColumnWidths = true;
         const editedRecord = this.props.list.editedRecord;
         if (editedRecord && editedRecord !== record) {
-            const unselected = await this.props.list.unselectRecord(true);
-            if (!unselected) {
+            const leaved = await this.props.list.leaveEditMode();
+            if (!leaved) {
                 return;
             }
         }
@@ -1143,13 +1176,8 @@ export class ListRenderer extends Component {
 
     /**
      * @param {KeyboardEvent} ev
-     * @param { import('@web/views/relational_model').Group
-     *  | null
-     * } group
-     * @param { import('@web/views/relational_model').Record
-     *  | import('@web/views/basic_relational_model').Record
-     *  | null
-     * } record
+     * @param { import('@web/model/relational_model/group').Group | null } group
+     * @param { import('@web/model/relational_model/record').Record | null } record
      */
     onCellKeydown(ev, group = null, record = null) {
         if (this.props.list.model.useSampleModel) {
@@ -1271,7 +1299,7 @@ export class ListRenderer extends Component {
         let toFocus, futureRecord;
         const index = list.selection.indexOf(record);
         if (this.lastIsDirty && ["tab", "shift+tab", "enter"].includes(hotkey)) {
-            record.switchMode("readonly");
+            list.leaveEditMode();
             return true;
         }
 
@@ -1304,7 +1332,7 @@ export class ListRenderer extends Component {
 
             case "enter":
                 if (list.selection.length === 1) {
-                    record.switchMode("readonly");
+                    list.leaveEditMode();
                     return true;
                 }
                 futureRecord = list.selection[index + 1] || list.selection[0];
@@ -1312,7 +1340,7 @@ export class ListRenderer extends Component {
         }
 
         if (futureRecord) {
-            futureRecord.switchMode("edit");
+            list.enterEditMode(futureRecord);
             return true;
         }
         return false;
@@ -1322,7 +1350,7 @@ export class ListRenderer extends Component {
         const { editable } = this.props;
         const groupIndex = group.list.records.indexOf(record);
         const isLastOfGroup = groupIndex === group.list.records.length - 1;
-        const isDirty = record.isDirty || this.lastIsDirty;
+        const isDirty = record.dirty || this.lastIsDirty;
         const isEnterBehavior = hotkey === "enter" && (!record.canBeAbandoned || isDirty);
         const isTabBehavior = hotkey === "tab" && !record.canBeAbandoned && isDirty;
         if (
@@ -1360,12 +1388,8 @@ export class ListRenderer extends Component {
     /**
      * @param {string} hotkey
      * @param {HTMLTableCellElement} cell
-     * @param { import('@web/views/relational_model').Group
-     *  | null
-     * } group
-     * @param { import('@web/views/relational_model').Record
-     *  | import('@web/views/basic_relational_model').Record
-     * } record
+     * @param { import('@web/model/relational_model/group').Group | null } group
+     * @param { import('@web/model/relational_model/record').Record } record
      * @returns {boolean} true if some behavior has been taken
      */
     onCellKeydownEditMode(hotkey, cell, group, record) {
@@ -1395,8 +1419,8 @@ export class ListRenderer extends Component {
                 const lastIndex = topReCreate ? 0 : list.records.length - 1;
                 if (index === lastIndex) {
                     if (this.displayRowCreates) {
-                        if (record.isNew && !record.isDirty) {
-                            list.unselectRecord(true);
+                        if (record.isNew && !record.dirty) {
+                            list.leaveEditMode();
                             return false;
                         }
                         // add a line
@@ -1405,12 +1429,12 @@ export class ListRenderer extends Component {
                     } else if (
                         this.canCreate &&
                         !record.canBeAbandoned &&
-                        (record.isDirty || this.lastIsDirty)
+                        (record.dirty || this.lastIsDirty)
                     ) {
                         this.add({ group });
                     } else if (cycleOnTab) {
                         if (record.canBeAbandoned) {
-                            list.unselectRecord(true);
+                            list.leaveEditMode();
                         }
                         const futureRecord = list.records[0];
                         if (record === futureRecord) {
@@ -1418,14 +1442,14 @@ export class ListRenderer extends Component {
                             const toFocus = this.findNextFocusableOnRow(row);
                             this.focus(toFocus);
                         } else {
-                            futureRecord.switchMode("edit");
+                            list.enterEditMode(futureRecord);
                         }
                     } else {
                         return false;
                     }
                 } else {
                     const futureRecord = list.records[index + 1];
-                    futureRecord.switchMode("edit");
+                    list.enterEditMode(futureRecord);
                 }
                 break;
             }
@@ -1434,7 +1458,7 @@ export class ListRenderer extends Component {
                 if (index === 0) {
                     if (cycleOnTab) {
                         if (record.canBeAbandoned) {
-                            list.unselectRecord(true);
+                            list.leaveEditMode();
                         }
                         const futureRecord = list.records[list.records.length - 1];
                         if (record === futureRecord) {
@@ -1443,16 +1467,16 @@ export class ListRenderer extends Component {
                             this.focus(toFocus);
                         } else {
                             this.cellToFocus = { forward: false, record: futureRecord };
-                            futureRecord.switchMode("edit");
+                            list.enterEditMode(futureRecord);
                         }
                     } else {
-                        list.unselectRecord(true);
+                        list.leaveEditMode();
                         return false;
                     }
                 } else {
                     const futureRecord = list.records[index - 1];
                     this.cellToFocus = { forward: false, record: futureRecord };
-                    futureRecord.switchMode("edit");
+                    list.enterEditMode(futureRecord);
                 }
                 break;
             }
@@ -1468,19 +1492,22 @@ export class ListRenderer extends Component {
                 }
 
                 if (futureRecord) {
-                    futureRecord.switchMode("edit", { checkValidity: true });
+                    list.leaveEditMode({ validate: true }).then((canProceed) => {
+                        if (canProceed) {
+                            list.enterEditMode(futureRecord);
+                        }
+                    });
                 } else if (this.lastIsDirty || !record.canBeAbandoned || this.displayRowCreates) {
                     this.add({ group });
                 } else {
                     futureRecord = list.records.at(0);
-                    futureRecord.switchMode("edit", { checkValidity: true });
+                    list.enterEditMode(futureRecord);
                 }
                 break;
             }
             case "escape": {
                 // TODO this seems bad: refactor this
-                record.discard();
-                list.unselectRecord(true);
+                list.leaveEditMode({ discard: true });
                 const firstAddButton = this.tableRef.el.querySelector(
                     ".o_field_x2many_list_row_add a"
                 );
@@ -1519,13 +1546,10 @@ export class ListRenderer extends Component {
     /**
      * @param {string} hotkey
      * @param {HTMLTableCellElement} cell
-     * @param { import('@web/views/relational_model').Group
+     * @param { import('@web/model/relational_model/group').Group
      *  | null
      * } group
-     * @param { import('@web/views/relational_model').Record
-     *  | import('@web/views/basic_relational_model').Record
-     *  | null
-     * } record
+     * @param { import('@web/model/relational_model/record').Record | null } record
      * @returns {boolean} true if some behavior has been taken
      */
     onCellKeydownReadOnlyMode(hotkey, cell, group, record) {
@@ -1631,7 +1655,7 @@ export class ListRenderer extends Component {
                         (c) => c.name === cell.getAttribute("name")
                     );
                     this.cellToFocus = { column, record };
-                    record.switchMode("edit");
+                    this.props.list.enterEditMode(record);
                     return true;
                 }
 
@@ -1833,7 +1857,7 @@ export class ListRenderer extends Component {
         if (ev.target.closest(".ui-autocomplete")) {
             return;
         }
-        this.props.list.unselectRecord(true);
+        this.props.list.leaveEditMode();
     }
 
     calculateColumnWidth(column) {
@@ -2000,13 +2024,11 @@ export class ListRenderer extends Component {
      * @param {HTMLElement} [params.previous]
      */
     async sortDrop(dataRowId, { element, previous }) {
-        if (this.props.list.editedRecord) {
-            this.props.list.unselectRecord(true);
-        }
+        await this.props.list.leaveEditMode();
         element.classList.remove("o_row_draggable");
         const refId = previous ? previous.dataset.id : null;
         this.resequencePromise = this.props.list.resequence(dataRowId, refId, {
-            handleField: this.props.archInfo.handleField,
+            handleField: this.props.list.handleField,
         });
         await this.resequencePromise;
         element.classList.add("o_row_draggable");
diff --git a/addons/web/static/src/views/list/list_renderer.xml b/addons/web/static/src/views/list/list_renderer.xml
index cf1983bf7c5..9898864c0a0 100644
--- a/addons/web/static/src/views/list/list_renderer.xml
+++ b/addons/web/static/src/views/list/list_renderer.xml
@@ -77,7 +77,7 @@
                         <t t-set="list" t-value="props.list"/>
                     </t>
                 </tbody>
-                <tfoot t-on-click="() => props.list.unselectRecord(true)" class="o_list_footer cursor-default" t-att-class="{o_sample_data_disabled: props.list.model.useSampleModel}">
+                <tfoot t-on-click="() => props.list.leaveEditMode()" class="o_list_footer cursor-default" t-att-class="{o_sample_data_disabled: props.list.model.useSampleModel}">
                     <tr>
                         <td t-if="hasSelectors"/>
                         <t t-foreach="state.columns" t-as="column" t-key="column.id">
@@ -150,7 +150,7 @@
                         >
                             <a href="#"
                                 role="button"
-                                t-on-click.stop.prevent="() => group.createRecord({}, props.editable === 'top')"
+                                t-on-click.stop.prevent="() => group.addNewRecord({}, props.editable === 'top')"
                                 t-on-keydown.synthetic="(ev) => this.onCellKeydown(ev)"
                             >
                                 Add a line
diff --git a/addons/web/static/src/views/list/list_view.js b/addons/web/static/src/views/list/list_view.js
index 5f34879ba70..fc4110cc797 100644
--- a/addons/web/static/src/views/list/list_view.js
+++ b/addons/web/static/src/views/list/list_view.js
@@ -1,7 +1,7 @@
 /** @odoo-module */
 
 import { registry } from "@web/core/registry";
-import { RelationalModel } from "../relational_model";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 import { ListArchParser } from "./list_arch_parser";
 import { ListController } from "./list_controller";
 import { ListRenderer } from "./list_renderer";
@@ -17,6 +17,8 @@ export const listView = {
     Model: RelationalModel,
     buttonTemplate: "web.ListView.Buttons",
 
+    limit: 80,
+
     props: (genericProps, view) => {
         const { ArchParser } = view;
         const { arch, relatedModels, resModel } = genericProps;
diff --git a/addons/web/static/src/views/pivot/pivot_controller.js b/addons/web/static/src/views/pivot/pivot_controller.js
index 3086bbe3b00..86a63dddc0a 100644
--- a/addons/web/static/src/views/pivot/pivot_controller.js
+++ b/addons/web/static/src/views/pivot/pivot_controller.js
@@ -1,7 +1,7 @@
 /** @odoo-module **/
 
 import { Layout } from "@web/search/layout";
-import { useModel } from "@web/views/model";
+import { useModelWithSampleData } from "@web/model/model";
 import { standardViewProps } from "@web/views/standard_view_props";
 import { useSetupView } from "@web/views/view_hook";
 import { SearchBar } from "@web/search/search_bar/search_bar";
@@ -12,7 +12,7 @@ import { Component, useRef } from "@odoo/owl";
 
 export class PivotController extends Component {
     setup() {
-        this.model = useModel(this.props.Model, this.props.modelParams);
+        this.model = useModelWithSampleData(this.props.Model, this.props.modelParams);
 
         useSetupView({
             rootRef: useRef("root"),
diff --git a/addons/web/static/src/views/pivot/pivot_model.js b/addons/web/static/src/views/pivot/pivot_model.js
index 5e68fe5e31e..401178f09de 100644
--- a/addons/web/static/src/views/pivot/pivot_model.js
+++ b/addons/web/static/src/views/pivot/pivot_model.js
@@ -4,7 +4,7 @@ import { Domain } from "@web/core/domain";
 import { cartesian, sections, sortBy, symmetricalDifference } from "@web/core/utils/arrays";
 import { KeepLast, Race } from "@web/core/utils/concurrency";
 import { DEFAULT_INTERVAL } from "@web/search/utils/dates";
-import { Model } from "@web/views/model";
+import { Model } from "@web/model/model";
 import { computeReportMeasures, processMeasure } from "@web/views/utils";
 
 /**
diff --git a/addons/web/static/src/views/record.js b/addons/web/static/src/views/record.js
index ab9dac7fead..bd166f203f3 100644
--- a/addons/web/static/src/views/record.js
+++ b/addons/web/static/src/views/record.js
@@ -1,67 +1,141 @@
 /** @odoo-module **/
 
-import { useBus, useService } from "@web/core/utils/hooks";
-import { RelationalModel } from "@web/views/relational_model";
-import { Component, xml, onWillStart, onWillUpdateProps } from "@odoo/owl";
+import { useService } from "@web/core/utils/hooks";
+import { pick } from "@web/core/utils/objects";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
+import { getFieldsSpec } from "@web/model/relational_model/utils";
+import { Component, xml, onWillStart, onWillUpdateProps, useState } from "@odoo/owl";
 
 const defaultActiveField = { attrs: {}, options: {}, domain: "[]", string: "" };
 
+class StandaloneRelationalModel extends RelationalModel {
+    load(params = {}) {
+        if (params.values) {
+            const data = params.values;
+            if (params.mode) {
+                this.config.mode = params.mode;
+            }
+            this.root = this._createRoot(this.config, data);
+            return;
+        }
+        return super.load(params);
+    }
+}
+
 class _Record extends Component {
     setup() {
+        this.orm = useService("orm");
         const resModel = this.props.info.resModel;
+        const activeFields = this.getActiveFields();
         const modelParams = {
-            resModel,
-            fields: this.props.fields,
-            viewMode: "form",
-            rootType: "record",
-            activeFields: this.getActiveFields(),
-            onRecordSaved: this.props.info.onRecordSaved || (() => {}),
-            onWillSaveRecord: this.props.info.onWillSaveRecord || (() => {}),
+            config: {
+                resModel,
+                fields: this.props.fields,
+                isMonoRecord: true,
+                activeFields,
+                resId: this.props.info.resId,
+                mode: this.props.info.mode,
+            },
+            hooks: {
+                onRecordSaved: this.props.info.onRecordSaved || (() => {}),
+                onWillSaveRecord: this.props.info.onWillSaveRecord || (() => {}),
+                onRecordChanged: this.props.info.onRecordChanged || (() => {}),
+            },
         };
         const modelServices = Object.fromEntries(
-            RelationalModel.services.map((servName) => {
+            StandaloneRelationalModel.services.map((servName) => {
                 return [servName, useService(servName)];
             })
         );
-        if (resModel) {
-            modelServices.orm = useService("orm");
-        }
+        modelServices.orm = this.orm;
+        this.model = useState(new StandaloneRelationalModel(this.env, modelParams, modelServices));
 
-        this.model = new RelationalModel(this.env, modelParams, modelServices);
-        useBus(this.model.bus, "update", () => this.render(true));
-
-        let loadKey;
-        const load = (props) => {
-            const loadParams = {
-                resId: props.info.resId,
-                mode: props.info.mode,
-                values: props.values,
-            };
-            const nextLoadKey = JSON.stringify(loadParams);
-            if (loadKey === nextLoadKey) {
-                return;
+        const loadWithValues = async (values) => {
+            values = pick(values, ...Object.keys(modelParams.config.activeFields));
+            const proms = [];
+            for (const fieldName in values) {
+                if (["one2many", "many2many"].includes(this.props.fields[fieldName].type)) {
+                    if (values[fieldName].length && typeof values[fieldName][0] === "number") {
+                        const resModel = this.props.fields[fieldName].relation;
+                        const resIds = values[fieldName];
+                        const activeField = modelParams.config.activeFields[fieldName];
+                        if (activeField.related) {
+                            const { activeFields, fields } = activeField.related;
+                            const fieldSpec = getFieldsSpec(activeFields, fields, {});
+                            const kwargs = {
+                                context: activeField.context || {},
+                                specification: fieldSpec,
+                            };
+                            proms.push(
+                                this.orm
+                                    .call(resModel, "web_read", [resIds], kwargs)
+                                    .then((records) => {
+                                        values[fieldName] = records;
+                                    })
+                            );
+                        }
+                    }
+                }
+                if (this.props.fields[fieldName].type === "many2one") {
+                    const loadDisplayName = async (resId) => {
+                        const resModel = this.props.fields[fieldName].relation;
+                        const activeField = modelParams.config.activeFields[fieldName];
+                        const kwargs = {
+                            context: activeField.context || {},
+                            specification: { display_name: {} },
+                        };
+                        const records = await this.orm.call(
+                            resModel,
+                            "web_read",
+                            [[resId]],
+                            kwargs
+                        );
+                        return records[0].display_name;
+                    };
+                    if (typeof values[fieldName] === "number") {
+                        const prom = loadDisplayName(values[fieldName]);
+                        prom.then((displayName) => {
+                            values[fieldName] = {
+                                id: values[fieldName],
+                                display_name: displayName,
+                            };
+                        });
+                        proms.push(prom);
+                    } else if (Array.isArray(values[fieldName])) {
+                        if (values[fieldName][1] === undefined) {
+                            const prom = loadDisplayName(values[fieldName][0]);
+                            prom.then((displayName) => {
+                                values[fieldName] = {
+                                    id: values[fieldName][0],
+                                    display_name: displayName,
+                                };
+                            });
+                            proms.push(prom);
+                        }
+                        values[fieldName] = {
+                            id: values[fieldName][0],
+                            display_name: values[fieldName][1],
+                        };
+                    }
+                }
+                await Promise.all(proms);
             }
-            loadKey = nextLoadKey;
-            return this.model.load(loadParams);
+            return this.model.load({ values });
         };
-        onWillStart(() => load(this.props));
-        onWillUpdateProps((nextProps) => {
-            // don't wait because the keeplast may make willUpdateProps hang forever
-            load(nextProps);
+        onWillStart(() => {
+            if (this.props.values) {
+                return loadWithValues(this.props.values);
+            } else {
+                return this.model.load();
+            }
+        });
+        onWillUpdateProps((nextProps) => {
+            if (nextProps.values) {
+                return loadWithValues(nextProps.values);
+            } else if (nextProps.info.resId !== this.model.root.resId) {
+                return this.model.load({ resId: nextProps.info.resId });
+            }
         });
-
-        if (this.props.info.onRecordChanged) {
-            const load = this.model.load;
-            this.model.load = async (...args) => {
-                const res = await load.call(this.model, ...args);
-                const root = this.model.root;
-                root.onChanges = async () => {
-                    const changes = root.getChanges();
-                    this.props.info.onRecordChanged(root, changes);
-                };
-                return res;
-            };
-        }
     }
 
     getActiveFields() {
diff --git a/addons/web/static/src/views/relational_model.js b/addons/web/static/src/views/relational_model.js
deleted file mode 100644
index 8b72582b4e9..00000000000
--- a/addons/web/static/src/views/relational_model.js
+++ /dev/null
@@ -1,3607 +0,0 @@
-/* @odoo-module */
-
-import { markRaw, markup, toRaw } from "@odoo/owl";
-import { AlertDialog } from "@web/core/confirmation_dialog/confirmation_dialog";
-import { makeContext } from "@web/core/context";
-import { Domain } from "@web/core/domain";
-import { WarningDialog } from "@web/core/errors/error_dialogs";
-import {
-    deserializeDate,
-    deserializeDateTime,
-    serializeDate,
-    serializeDateTime,
-} from "@web/core/l10n/dates";
-import { ORM, x2ManyCommands } from "@web/core/orm_service";
-import { evaluateExpr } from "@web/core/py_js/py";
-import { registry } from "@web/core/registry";
-import { unique } from "@web/core/utils/arrays";
-import { Deferred, KeepLast, Mutex } from "@web/core/utils/concurrency";
-import { pick } from "@web/core/utils/objects";
-import { escape } from "@web/core/utils/strings";
-import { session } from "@web/session";
-import { getFieldFromRegistry } from "@web/views/fields/field";
-import { Model } from "@web/views/model";
-import { evalDomain, isNumeric, isRelational, isX2Many, orderByToString } from "@web/views/utils";
-
-const { DateTime } = luxon;
-
-const preloadedDataRegistry = registry.category("preloadedData");
-
-const { CREATE, UPDATE, DELETE, FORGET, LINK_TO, DELETE_ALL, REPLACE_WITH } = x2ManyCommands;
-const AGGREGATABLE_FIELD_TYPES = ["float", "integer", "monetary"]; // types that can be aggregated in grouped views
-const DEFAULT_HANDLE_FIELD = "sequence";
-
-/**
- * @typedef {import("@web/core/context").ContextDescription} ContextDescription
- * @typedef {import("@web/core/context").ContextDescription} Context
- */
-
-/**
- * @typedef {{
- *  parent?: RawContext;
- *  make: () => Context;
- * }} RawContext
- */
-
-/**
- * @param {RawContext} rawContext
- * @param {Context} defaultContext
- * @returns {Context}
- */
-function processRawContext(rawContext, defaultContext) {
-    const contexts = [];
-    if (!rawContext) {
-        return Object.assign({}, defaultContext);
-    }
-    contexts.push({ ...defaultContext, ...rawContext.make() });
-    while (rawContext.parent) {
-        rawContext = rawContext.parent;
-        const context = rawContext.make();
-        for (const key in context) {
-            if (key.startsWith("default_")) {
-                delete context[key];
-            }
-        }
-        contexts.push(context);
-    }
-
-    return Object.assign({}, ...contexts.reverse());
-}
-
-/**
- * FIXME: don't know where this function should be:
- *   - on a dataPoint: don't want to make it accessible everywhere (e.g. in Fields)
- *   - on the model: would still be accessible by views + I like the current light API of the model
- *
- * Given a model name and res ids, calls the method "action_archive" or
- * "action_unarchive", and executes the returned action any.
- *
- * @param {string} resModel
- * @param {integer[]} resIds
- * @param {boolean} doArchive archive the records if true, otherwise unarchive them
- * @param {Context} context
- */
-async function toggleArchive(model, resModel, resIds, doArchive, context) {
-    const method = doArchive ? "action_archive" : "action_unarchive";
-    const action = await model.orm.call(resModel, method, [resIds], { context });
-    if (action && Object.keys(action).length !== 0) {
-        model.action.doAction(action);
-    }
-}
-
-async function unselectRecord(editedRecord, abandonRecord) {
-    if (editedRecord) {
-        await editedRecord.askChanges();
-        const canBeAbandoned = editedRecord.canBeAbandoned;
-        if (canBeAbandoned) {
-            return abandonRecord(editedRecord.id);
-        } else {
-            return editedRecord.switchMode("readonly");
-        }
-    }
-}
-
-class RequestBatcherORM extends ORM {
-    constructor() {
-        super(...arguments);
-        this.searchReadBatches = {};
-        this.searchReadBatchId = 1;
-        this.batches = {};
-    }
-
-    /**
-     * @param {number[]} ids
-     * @param {any[]} keys
-     * @param {Function} callback
-     * @returns {Promise<any>}
-     */
-    async batch(ids, keys, callback) {
-        const key = JSON.stringify(keys);
-        let batch = this.batches[key];
-        if (!batch) {
-            batch = {
-                deferred: new Deferred(),
-                scheduled: false,
-                ids: [],
-            };
-            this.batches[key] = batch;
-        }
-        batch.ids = unique([...batch.ids, ...ids]);
-
-        if (!batch.scheduled) {
-            batch.scheduled = true;
-            Promise.resolve().then(async () => {
-                delete this.batches[key];
-                let result;
-                try {
-                    result = await callback(batch.ids);
-                } catch (e) {
-                    return batch.deferred.reject(e);
-                }
-                batch.deferred.resolve(result);
-            });
-        }
-
-        return batch.deferred;
-    }
-
-    /**
-     * Entry point to batch display_name "read" calls. If the `resModel` argument has
-     * already been called, the given ids are added to the previous list of ids
-     * to perform a single read of display_name call.
-     *
-     * @param {string} resModel
-     * @param {number[]} resIds
-     * @param {object} context
-     * @returns {Promise<[number, string][]>}
-     */
-    async nameGet(resModel, resIds, kwargs) {
-        const pairs = await this.batch(resIds, ["name_get", resModel, kwargs], (resIds) =>
-            super.nameGet(resModel, resIds, kwargs)
-        );
-        return pairs.filter(([id]) => resIds.includes(id));
-    }
-
-    /**
-     * Entry point to batch "read" calls. If the `fields` and `resModel`
-     * arguments have already been called, the given ids are added to the
-     * previous list of ids to perform a single read call. Once the server
-     * responds, records are then dispatched to the callees based on the
-     * given ids arguments (kept in the closure).
-     *
-     * @param {string} resModel
-     * @param {number[]} resIds
-     * @param {string[]} fields
-     * @returns {Promise<Object[]>}
-     */
-    async read(resModel, resIds, fields, kwargs) {
-        const records = await this.batch(resIds, ["read", resModel, fields, kwargs], (resIds) =>
-            super.read(resModel, resIds, fields, kwargs)
-        );
-        return records.filter((r) => resIds.includes(r.id));
-    }
-
-    /**
-     * Entry point to batch "unlink" calls. If the `resModel` argument has
-     * already been called, the given ids are added to the previous list of ids
-     * to perform a single unlink call.
-     *
-     * @param {string} resModel
-     * @param {number[]} resIds
-     * @returns {Promise<boolean>}
-     */
-    async unlink(resModel, resIds, kwargs) {
-        return this.batch(resIds, ["unlink", resModel, kwargs], (resIds) =>
-            super.unlink(resModel, resIds, kwargs)
-        );
-    }
-
-    /**
-     * @override
-     */
-    async webSearchRead(/*model*/) {
-        // FIXME: discriminate on model? (it is always the same in our usecase)
-        const batchId = this.searchReadBatchId;
-        let batch = this.searchReadBatches[batchId];
-        if (!batch) {
-            batch = {
-                deferred: new Deferred(),
-                count: 0,
-            };
-            Promise.resolve().then(() => this.searchReadBatchId++);
-            this.searchReadBatches[batchId] = batch;
-        }
-        batch.count++;
-        const result = await super.webSearchRead(...arguments);
-        batch.count--;
-        if (batch.count === 0) {
-            delete this.searchReadBatches[batchId];
-            batch.deferred.resolve();
-        }
-        await batch.deferred;
-        return result;
-    }
-}
-
-let nextId = 0;
-class DataPoint {
-    /**
-     * @param {RelationalModel} model
-     * @param {Object} [params={}]
-     * @param {Object} [state={}]
-     */
-    constructor(model, params = {}, state = {}) {
-        this.id = `datapoint_${nextId++}`;
-
-        this.model = model;
-        this.resModel = params.resModel;
-        this.fields = params.fields;
-        if (!("id" in this.fields)) {
-            this.fields.id = { name: "id", type: "integer", readonly: true };
-        }
-        if (!("display_name" in this.fields)) {
-            this.fields.display_name = { name: "display_name", type: "char" };
-        }
-        this.setActiveFields(params.activeFields);
-
-        this.onWillSaveRecord = params.onWillSaveRecord || (() => {});
-        this.onRecordSaved = params.onRecordSaved || (() => {});
-        this.onWillSaveMultiRecords = params.onWillSaveMultiRecords || (() => {});
-        this.onSavedMultiRecords = params.onSavedMultiRecords || (() => {});
-        this.onWillSetInvalidField = params.onWillSetInvalidField || (() => {});
-
-        this.rawContext = params.rawContext;
-        this.defaultContext = params.defaultContext;
-        this.setup(params, state);
-    }
-
-    // -------------------------------------------------------------------------
-    // Getters
-    // -------------------------------------------------------------------------
-
-    get context() {
-        return processRawContext(this.rawContext, this.defaultContext);
-    }
-
-    get fieldNames() {
-        return Object.keys(this.activeFields).filter(
-            (fieldName) => !this.activeFields[fieldName].relatedPropertyField
-        );
-    }
-
-    // -------------------------------------------------------------------------
-    // Public
-    // -------------------------------------------------------------------------
-
-    exportState() {
-        return {};
-    }
-
-    async load() {
-        throw new Error("load must be implemented");
-    }
-
-    /**
-     * @abstract
-     * @param {Object} params
-     * @param {Object} state
-     */
-    setup() {}
-
-    /**
-     * @param {Object} [activeFields={}]
-     */
-    setActiveFields(activeFields) {
-        this.activeFields = activeFields || {};
-    }
-
-    // -------------------------------------------------------------------------
-    // Protected
-    // -------------------------------------------------------------------------
-
-    _parseServerValue(field, value) {
-        switch (field.type) {
-            case "date": {
-                return value ? deserializeDate(value) : false;
-            }
-            case "datetime": {
-                return value ? deserializeDateTime(value) : false;
-            }
-            case "html": {
-                return markup(value || "");
-            }
-            case "selection": {
-                if (value === false) {
-                    // process selection: convert false to 0, if 0 is a valid key
-                    const hasKey0 = field.selection.find((option) => option[0] === 0);
-                    return hasKey0 ? 0 : value;
-                }
-                break;
-            }
-            case "properties": {
-                return value
-                    ? value.map((property) => ({
-                          ...property,
-                          value: this._parseServerValue(property, property.value ?? false),
-                      }))
-                    : [];
-            }
-            case "one2many": {
-                const commands = [];
-                for (const command of value) {
-                    const code = command[0];
-                    if (code === CREATE) {
-                        commands.push([
-                            code,
-                            command[1],
-                            this._cache[field.name]._parseServerValues(command[2]),
-                        ]);
-                    } else {
-                        commands.push(command);
-                    }
-                }
-                return commands;
-            }
-        }
-        return value;
-    }
-
-    _parseServerValues(values) {
-        const parsedValues = {};
-        if (!values) {
-            return parsedValues;
-        }
-        for (const fieldName in values) {
-            const value = values[fieldName];
-            const field = this.fields[fieldName];
-            parsedValues[fieldName] = this._parseServerValue(field, value);
-        }
-        return parsedValues;
-    }
-}
-
-markRaw(DataPoint.prototype);
-
-function clearObject(obj) {
-    for (const key in obj) {
-        delete obj[key];
-    }
-}
-
-export class Record extends DataPoint {
-    setup(params, state) {
-        if ("resId" in params) {
-            this.resId = params.resId;
-        } else if (state) {
-            this.resId = state.resId;
-        }
-        if (!this.resId) {
-            this.resId = false;
-            this.virtualId = params.virtualId || this.model.nextVirtualId;
-        }
-        this.resIds =
-            (params.resIds ? toRaw(params.resIds) : null) || // FIXME WOWL reactivity
-            state.resIds ||
-            (this.resId ? [this.resId] : []);
-
-        this._values = {};
-        this._changes = {};
-        this.data = {};
-
-        this.parentActiveFields = params.parentActiveFields || false;
-        this.onChanges = params.onChanges || (() => {});
-
-        this._invalidFields = new Set();
-        this.preloadedData = {};
-        this.preloadedDataCaches = {};
-        this.isInQuickCreation = params.isInQuickCreation || false;
-        this._onChangePromise = Promise.resolve({});
-
-        this._domains = {};
-
-        this.relationField = params.relationField;
-        this.parentRecord = params.parentRecord;
-
-        this.getParentRecordContext = params.getParentRecordContext;
-
-        this.selected = false;
-        this.mode = params.mode || (this.resId ? state.mode || "readonly" : "edit");
-
-        this._onWillSwitchMode = params.onRecordWillSwitchMode || (() => {});
-
-        this.canBeAbandoned = this.isNew;
-    }
-
-    // -------------------------------------------------------------------------
-    // Getters
-    // -------------------------------------------------------------------------
-
-    get dataContext() {
-        // should not be called befor this.data is ready!
-        const evalContext = { ...this.model.user.context };
-        for (const fieldName of this.fieldNames) {
-            const value = this.data[fieldName];
-            if ([null].includes(value)) {
-                // simplify that?
-                evalContext[fieldName] = false;
-            } else if (isX2Many(this.fields[fieldName])) {
-                const list = this._cache[fieldName];
-                evalContext[fieldName] = list.currentIds;
-                // ---> implied to initialize (resIds, commands) currentIds before loading static list
-            } else if (value && this.fields[fieldName].type === "date") {
-                evalContext[fieldName] = serializeDate(value);
-            } else if (value && this.fields[fieldName].type === "datetime") {
-                evalContext[fieldName] = serializeDateTime(value);
-            } else if (value && this.fields[fieldName].type === "many2one") {
-                evalContext[fieldName] = value[0];
-            } else if (value && this.fields[fieldName].type === "reference") {
-                evalContext[fieldName] = `${value.resModel},${value.resId}`;
-            } else {
-                evalContext[fieldName] = value;
-            }
-        }
-        evalContext.id = this.resId || false;
-        if (this.getParentRecordContext) {
-            evalContext.parent = this.getParentRecordContext();
-        }
-        return evalContext;
-    }
-
-    get evalContext() {
-        if (!this.__evalContext) {
-            // store evalContext and reset it after a tick, as all calls during
-            // the same tick will produce the exact same evalContext
-            this.__evalContext = {
-                // ...
-                ...this.dataContext,
-                ...this.context,
-                active_id: this.resId || false,
-                active_ids: this.resId ? [this.resId] : [],
-                active_model: this.resModel,
-                current_company_id: this.model.company.currentCompany.id,
-            };
-            Promise.resolve().then(() => (this.__evalContext = null));
-        }
-        return this.__evalContext;
-    }
-
-    /**
-     * Since the ORM can support both `active` and `x_active` fields for
-     * the archiving mechanism, check if any such field exists and prioritize
-     * them. The `active` field should always take priority over its custom
-     * version.
-     *
-     * @returns {boolean} true iff the field is active or there is no `active`
-     *   or `x_active` field on the model
-     */
-    get isActive() {
-        if ("active" in this.activeFields) {
-            return this.data.active;
-        } else if ("x_active" in this.activeFields) {
-            return this.data.x_active;
-        }
-        return true;
-    }
-
-    get isDirty() {
-        if (this.canBeAbandoned) {
-            // for a new record, have changes does not necessarily mean to be dirty!
-            return false;
-        }
-
-        const changes = { ...this._changes };
-        for (const fieldName in changes) {
-            const fieldType = this.fields[fieldName].type;
-            if (["one2many", "many2many"].includes(fieldType)) {
-                if (changes[fieldName].getCommands()) {
-                    return true;
-                }
-            } else {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    get isInEdition() {
-        return this.mode === "edit";
-    }
-
-    get isNew() {
-        return !this.resId;
-    }
-
-    // -------------------------------------------------------------------------
-    // Public
-    // -------------------------------------------------------------------------
-
-    /**
-     * To be called **only** when Odoo is about to be closed, and we want to
-     * save potential changes on a given record.
-     *
-     * We can't follow the normal flow (onchange(s) + save, mutexified),
-     * because the 'beforeunload' handler must be *almost* sync (< 10 ms
-     * setTimeout seems fine, but an rpc roundtrip is definitely too long),
-     * so here we bypass the standard mechanism of notifying changes and
-     * saving them:
-     *  - we ask the model to bypass its mutex for upcoming 'notifyChanges' and
-     *   'save' requests
-     *  - we ask all fields to commit their changes (in case there would
-     *    be a focused field with a fresh value)
-     *  - we take all changes that have been reported to the
-     *    controller, but not yet sent to the model because of the mutex,
-     *    and directly notify the model about them, see update.
-     *  - we reset the widgets with all those changes, s.t. a further call
-     *    to 'canBeRemoved' uses the correct data (it asks the widgets if
-     *    they are set/valid, based on their internal state)
-     *  - if the record is dirty, we save directly
-     */
-    async urgentSave() {
-        this._urgentSave = true;
-        this.model.bus.trigger("WILL_SAVE_URGENTLY");
-        return this._save({ stayInEdition: true, noReload: true });
-    }
-
-    async archive() {
-        await toggleArchive(this.model, this.resModel, [this.resId], true, this.context);
-        await this.load();
-        this.model.notify();
-    }
-
-    async askChanges() {
-        const proms = [];
-        this.model.bus.trigger("NEED_LOCAL_CHANGES", { proms });
-        await Promise.all([...proms, this.model.mutex.getUnlockedDef()]);
-    }
-
-    async checkValidity() {
-        if (!this._urgentSave) {
-            await this.askChanges();
-        }
-        return this._checkValidity();
-    }
-
-    _checkValidity() {
-        for (const fieldName in this._requiredFields) {
-            const fieldType = this.fields[fieldName].type;
-            const activeField = this.activeFields[fieldName];
-            if (
-                !evalDomain(this._requiredFields[fieldName], this.evalContext) ||
-                (activeField && activeField.alwaysInvisible)
-            ) {
-                this._removeInvalidFields([fieldName]);
-                continue;
-            }
-
-            const isSet = activeField && activeField.field && activeField.field.isSet;
-
-            if (this._isRequired(fieldName) && isSet && !isSet(this.data[fieldName])) {
-                this.setInvalidField(fieldName);
-                continue;
-            }
-
-            switch (fieldType) {
-                case "boolean":
-                case "float":
-                case "integer":
-                case "monetary":
-                    continue;
-                case "one2many":
-                case "many2many":
-                    if (!this.isX2ManyValid(fieldName)) {
-                        this.setInvalidField(fieldName);
-                    }
-                    break;
-                default:
-                    if (!isSet && this._isRequired(fieldName) && !this.data[fieldName]) {
-                        this.setInvalidField(fieldName);
-                    }
-            }
-        }
-        return !this._invalidFields.size;
-    }
-
-    async delete() {
-        const unlinked = await this.model.orm.unlink(this.resModel, [this.resId], {
-            context: this.context,
-        });
-        if (!unlinked) {
-            return false;
-        }
-        const index = this.resIds.indexOf(this.resId);
-        this.resIds.splice(index, 1);
-        this.resId = this.resIds[Math.min(index, this.resIds.length - 1)] || false;
-        if (this.resId) {
-            await this.load();
-            this.model.notify();
-        } else {
-            this.data = {};
-            this._values = {};
-            this._changes = {};
-            this.preloadedData = {};
-        }
-    }
-
-    discard() {
-        clearObject(this._changes);
-        clearObject(this._domains);
-        for (const fieldName of this.fieldNames) {
-            // activeFields should be changed
-            const field = this.fields[fieldName];
-            if (isX2Many(field)) {
-                this.data[fieldName].discard();
-            } else if (fieldName in this._values) {
-                this.data[fieldName] = this._values[fieldName];
-            }
-        }
-        this._invalidFields.clear();
-
-        if (!this.isNew) {
-            this.switchMode("readonly");
-        }
-        this.model.notify();
-    }
-
-    // FIXME AAB: to discuss: not sure we want to keep resIds in the model (this concerns
-    // "duplicate" and "delete"). Alternative: handle this in form_view (but then what's the
-    // point of calling a Record method to do the operation?)
-    async duplicate() {
-        const kwargs = { context: this.context };
-        const index = this.resIds.indexOf(this.resId);
-        this.resId = await this.model.orm.call(this.resModel, "copy", [this.resId], kwargs);
-        this.resIds.splice(index + 1, 0, this.resId);
-        await this.load();
-        this.switchMode("edit");
-        this.model.notify();
-    }
-
-    exportState() {
-        return {
-            mode: this.mode,
-            resId: this.resId,
-            resIds: this.resIds,
-        };
-    }
-
-    _formatServerValue(fieldType, value) {
-        if (fieldType === "many2one") {
-            return value ? value[0] : false;
-        } else if (fieldType === "date") {
-            return value ? serializeDate(value) : false;
-        } else if (fieldType === "datetime") {
-            return value ? serializeDateTime(value) : false;
-        } else if (fieldType === "reference") {
-            return value && value.resModel && value.resId
-                ? `${value.resModel},${value.resId}`
-                : value || false;
-        } else if (fieldType === "properties") {
-            return value.map((property) => ({
-                ...property,
-                value:
-                    property.type === "many2one"
-                        ? property.value
-                        : this._formatServerValue(property.type, property.value),
-            }));
-        }
-        return value;
-    }
-
-    getChanges(allFields = false, parentChanges = false) {
-        const changes = { ...(allFields ? this.data : this._changes) };
-        for (const fieldName in changes) {
-            if (
-                !allFields &&
-                fieldName in this.activeFields &&
-                !this.activeFields[fieldName].forceSave &&
-                this.isFieldReadonly(fieldName)
-            ) {
-                delete changes[fieldName];
-                continue;
-            }
-            const fieldType = this.fields[fieldName].type;
-            if (["one2many", "many2many"].includes(fieldType)) {
-                const staticList = this._cache[fieldName];
-                changes[fieldName] = staticList.getCommands(allFields); // always ask
-                if (!changes[fieldName]) {
-                    delete changes[fieldName];
-                }
-            } else {
-                changes[fieldName] = this._formatServerValue(fieldType, changes[fieldName]);
-            }
-        }
-
-        const relationalFieldChanges = {};
-        if (allFields && parentChanges && this.relationField && this.parentRecord) {
-            relationalFieldChanges[this.relationField] = this.parentRecord.getChanges(allFields);
-        }
-
-        return {
-            ...this._rawChanges,
-            ...changes,
-            ...relationalFieldChanges,
-        };
-    }
-
-    getFieldDomain(fieldName) {
-        const { domain } = this.fields[fieldName];
-        return domain ? new Domain(domain).toList(this.evalContext) : [];
-    }
-
-    _getFieldContext(fieldName) {
-        return Object.assign(
-            this.context,
-            makeContext([this.activeFields[fieldName].context], this.evalContext)
-        );
-    }
-
-    isFieldDirty(fieldName) {
-        return this.isDirty && !!this._changes[fieldName];
-    }
-
-    /**
-     * FIXME: memoize this at some point?
-     * @param {string} fieldName
-     * @returns {boolean}
-     */
-    isFieldReadonly(fieldName) {
-        const activeField = this.activeFields[fieldName];
-        const { readonly } =
-            activeField && activeField.modifiers && "readonly" in activeField.modifiers
-                ? activeField.modifiers
-                : this.fields[fieldName];
-        return evalDomain(readonly, this.evalContext);
-    }
-
-    isInvalid(fieldName) {
-        return this._invalidFields.has(fieldName);
-    }
-
-    /**
-     * FIXME: memoize this at some point?
-     * @param {string} fieldName
-     * @returns {boolean}
-     */
-    _isInvisible(fieldName) {
-        const activeField = this.activeFields[fieldName];
-        const { invisible } = activeField.modifiers || {};
-        return invisible ? evalDomain(invisible, this.evalContext) : false;
-    }
-
-    /**
-     * FIXME: memoize this at some point?
-     * @param {string} fieldName
-     * @returns {boolean}
-     */
-    _isRequired(fieldName) {
-        const required = this._requiredFields[fieldName];
-        return required ? evalDomain(required, this.evalContext) : false;
-    }
-
-    isX2ManyValid(fieldName) {
-        const value = this.data[fieldName];
-        return value.records.every(async (r) => await r.checkValidity());
-    }
-
-    /**
-     * @param {Object} [params={}]
-     * @param {Object} [params.values]
-     * @param {Object} [params.changes]
-     */
-    async load(params = {}) {
-        this._cache = {};
-        for (const fieldName in this.activeFields) {
-            const field = this.fields[fieldName];
-            if (isX2Many(field)) {
-                const staticList = this._createStaticList(fieldName);
-                this._cache[fieldName] = staticList;
-            }
-        }
-        for (const fieldName in this.data) {
-            if (!(fieldName in this.activeFields)) {
-                delete this.data[fieldName];
-            }
-        }
-
-        if (!(params.values || !this.isNew)) {
-            const changes = params.changes || (await this._onChange());
-            await this._load({ changes });
-        } else {
-            let values = this._parseServerValues(params.values);
-            const missingFields = this.fieldNames.filter((fieldName) => !(fieldName in values));
-            if (missingFields.length) {
-                values = Object.assign({}, values, await this._read(missingFields));
-            }
-            await this._load({ values });
-        }
-    }
-
-    async loadPreloadedData() {
-        const fetchPreloadedData = async (info, fieldName) => {
-            if (!info.loadOnTypes.includes(this.fields[fieldName].type)) {
-                return;
-            }
-
-            const evalContext = this.evalContext;
-            const domain = this.activeFields[fieldName].domain
-                ? new Domain(
-                      evaluateExpr(this.activeFields[fieldName].domain, evalContext)
-                  ).toList()
-                : this.getFieldDomain(fieldName);
-
-            const getExtraKey = info.extraMemoizationKey || (() => null);
-            const key = JSON.stringify([domain.toString(), getExtraKey(this, fieldName)]);
-            if (this.preloadedDataCaches[fieldName] !== key) {
-                const context = this._getFieldContext(fieldName);
-                this.preloadedDataCaches[fieldName] = key;
-                this.preloadedData[fieldName] = await info.preload(
-                    this.model.orm,
-                    this,
-                    fieldName,
-                    { context, domain }
-                );
-            }
-        };
-
-        const proms = [];
-        for (const fieldName in this.activeFields) {
-            const activeField = this.activeFields[fieldName];
-            // @FIXME type should not be get like this
-            const type = activeField.widget || this.fields[fieldName].type;
-            if (!this._isInvisible(fieldName) && preloadedDataRegistry.contains(type)) {
-                proms.push(fetchPreloadedData(preloadedDataRegistry.get(type), fieldName));
-            }
-        }
-        await Promise.all(proms);
-    }
-
-    async loadRelationalData() {
-        const proms = [];
-        for (const fieldName of this.fieldNames) {
-            const field = this.fields[fieldName];
-            if (field.type === "many2one") {
-                proms.push(
-                    this._loadMany2OneData(fieldName, this.data[fieldName]).then((value) => {
-                        this.data[fieldName] = value;
-                        this._values[fieldName] = value;
-                    })
-                );
-            } else if (field.type === "reference") {
-                proms.push(
-                    this._loadReference(fieldName, this.data[fieldName]).then((value) => {
-                        this.data[fieldName] = value;
-                        this._values[fieldName] = value;
-                    })
-                );
-            } else if (isX2Many(field)) {
-                proms.push(this._loadX2ManyData(fieldName));
-            }
-        }
-        await Promise.all(proms);
-    }
-
-    /**
-     *
-     * @param {Object} options
-     * @param {boolean} [options.stayInEdition=false]
-     * @param {boolean} [options.noReload=false] prevents the record from
-     *  reloading after changes are applied, typically used to defer the load.
-     * @returns {Promise<boolean>}
-     */
-    async save(options = { stayInEdition: false, noReload: false }) {
-        return this.model.mutex.exec(() => this._save(options));
-    }
-
-    /**
-     * Overridden to set required fields based on the new active fields.
-     *
-     * @override
-     */
-    setActiveFields(activeFields) {
-        super.setActiveFields(activeFields);
-
-        this._requiredFields = {};
-        for (const [fieldName, activeField] of Object.entries(this.activeFields)) {
-            const { modifiers } = activeField;
-            if (modifiers && modifiers.required) {
-                this._requiredFields[fieldName] = modifiers.required;
-            }
-        }
-    }
-
-    async setInvalidField(fieldName) {
-        const canProceed = this.onWillSetInvalidField(this, fieldName);
-        if (canProceed === false) {
-            return;
-        }
-        if (this.selected && this.model.multiEdit) {
-            if (!this._invalidFields.has(fieldName)) {
-                const dialogProps = {
-                    body: this.model.env._t("No valid record to save"),
-                    confirm: () => {
-                        this.discard();
-                    },
-                };
-                await this.model.dialogService.add(AlertDialog, dialogProps);
-            }
-        }
-        this._invalidFields.add(fieldName);
-        this.model.notify();
-    }
-
-    /**
-     * @param {"edit" | "readonly"} mode
-     * @returns {Promise<Boolean>}
-     */
-    async switchMode(mode) {
-        if (this.mode === mode) {
-            return true;
-        }
-        const canSwitch = await this._onWillSwitchMode(this, mode);
-        if (canSwitch === false) {
-            return false;
-        }
-        if (mode === "readonly") {
-            for (const fieldName in this.activeFields) {
-                const field = this.fields[fieldName];
-                if (isX2Many(field)) {
-                    const editedRecord = this.data[fieldName] && this.data[fieldName].editedRecord;
-                    if (editedRecord) {
-                        editedRecord.switchMode("readonly");
-                    }
-                }
-            }
-        }
-        this.mode = mode;
-        this.model.notify();
-        return true;
-    }
-
-    toggleSelection(selected) {
-        if (typeof selected === "boolean") {
-            this.selected = selected;
-        } else {
-            this.selected = !this.selected;
-        }
-        this.model.notify();
-    }
-
-    async unarchive() {
-        await toggleArchive(this.model, this.resModel, [this.resId], false, this.context);
-        await this.load();
-        this.model.notify();
-    }
-
-    async update(changes, options) {
-        if (this._urgentSave) {
-            return this._update(changes, options);
-        }
-        return this.model.mutex.exec(async () => {
-            await this._update(changes, options);
-        });
-    }
-
-    // -------------------------------------------------------------------------
-    // Protected
-    // -------------------------------------------------------------------------
-
-    async _applyChanges(changes) {
-        for (let [fieldName, value] of Object.entries(changes)) {
-            const field = this.fields[fieldName];
-            if (field && field.relatedPropertyField) {
-                const propertyFieldName = field.relatedPropertyField.fieldName;
-                this.data[propertyFieldName] = this.data[propertyFieldName].map((property) =>
-                    property.name === field.propertyName ? { ...property, value } : property
-                );
-                this._changes[propertyFieldName] = this.data[propertyFieldName];
-                this.data[fieldName] = value;
-            } else if (field && isX2Many(field)) {
-                this._changes[fieldName] = value;
-                await this.data[fieldName].update(value);
-            } else {
-                if (field && field.type === "many2one") {
-                    value = await this.__applyMany2OneChange(fieldName, value);
-                } else if (field && field.type === "reference") {
-                    value = await this._loadReference(fieldName, value);
-                }
-                this.data[fieldName] = value;
-                this._changes[fieldName] = value;
-            }
-        }
-    }
-
-    async __applyMany2OneChange(fieldName, nameGet) {
-        if (!nameGet) {
-            return false;
-        }
-        let [id, label] = nameGet;
-
-        if (!id && !label) {
-            return [false, ""];
-        }
-        const relation = this.fields[fieldName].relation;
-        const activeField = this.activeFields[fieldName];
-        const getContext = () =>
-            processRawContext({
-                parent: this.rawContext,
-                make: () => {
-                    return makeContext([activeField.context], this.evalContext);
-                },
-            });
-        if (!id && label && activeField) {
-            // only display_name given -> do a name_create
-            const res = await this.model.orm.call(relation, "name_create", [label], {
-                context: getContext(),
-            });
-            // Check if a record is really created. Models without defined
-            // _rec_name cannot create record based on name_create.
-            if (!res) {
-                return [false, ""]; // not sure about ""
-            }
-            id = res[0];
-            label = res[1];
-        } else if (id && label === undefined && activeField) {
-            const result = await this.model.orm.nameGet(relation, [id], {
-                context: getContext(),
-            });
-            label = result[0][1];
-        }
-        return [id, label];
-    }
-
-    _applyPropertyDefinitions(fieldName) {
-        const definitions = this.data[fieldName];
-        const propertiesField = this.fields[fieldName];
-
-        for (const definition of definitions) {
-            const propertyFieldName = `${fieldName}.${definition.name}`;
-            if (propertyFieldName in this.fields) {
-                continue;
-            } else if (["many2one", "many2many"].includes(definition.type) && !definition.comodel) {
-                continue;
-            }
-            const widget = this._getWidgetFromDefinition(definition);
-
-            const parent = this.data[propertiesField.definition_record];
-            const relatedPropertyField = {
-                fieldName,
-            };
-            if (parent) {
-                relatedPropertyField.id = parent[0]; //record.id,
-                relatedPropertyField.displayName = parent[1]; //record.display_name,
-            }
-
-            this.fields[propertyFieldName] = {
-                ...pick(definition, "selection", "string", "tags", "type"),
-                name: propertyFieldName,
-                sortable: false,
-                required: false,
-                relatedPropertyField,
-                propertyName: definition.name,
-                relation: definition.comodel,
-            };
-            const field = getFieldFromRegistry(definition.type, widget);
-            let { relatedFields } = field;
-            if (relatedFields) {
-                if (relatedFields instanceof Function) {
-                    relatedFields = relatedFields({ options: {}, attrs: {} });
-                }
-                relatedFields = Object.fromEntries(relatedFields.map((f) => [f.name, f]));
-            }
-            this.activeFields[propertyFieldName] = {
-                ...pick(
-                    this.activeFields[fieldName],
-                    "context",
-                    "modifiers",
-                    "viewType",
-                    "help",
-                    "onChange",
-                    "decorations"
-                ),
-                name: propertyFieldName,
-                string: definition.string,
-                relatedPropertyField,
-                attrs: {},
-                options: {},
-                widget,
-                relatedFields,
-                field,
-            };
-        }
-    }
-
-    _getWidgetFromDefinition(definition) {
-        if (definition.type === "many2many") {
-            return "many2many_tags";
-        } else if (definition.type === "tags") {
-            return "property_tags";
-        } else if (["res.users", "res.partner"].includes(definition.comodel)) {
-            return definition.type === "many2one" ? "many2one_avatar" : "many2many_tags_avatar";
-        }
-        return definition.type;
-    }
-
-    _createStaticList(fieldName) {
-        const field = this.fields[fieldName];
-        const activeField = this.activeFields[fieldName];
-        const { relatedFields, views = {}, viewMode } = activeField;
-        const fields = {
-            ...relatedFields,
-        };
-        const activeFields = (views[viewMode] && views[viewMode].activeFields) || {
-            ...relatedFields,
-        };
-        for (const fieldName in relatedFields) {
-            if (relatedFields[fieldName].active) {
-                activeFields[fieldName] = relatedFields[fieldName]; // a field and an active field are not the same thing
-                // bad idea
-            }
-        }
-        const limit = views[viewMode] && views[viewMode].limit;
-        const orderBy = views[viewMode] && views[viewMode].defaultOrder;
-
-        const editable = views[viewMode] && views[viewMode].editable;
-
-        const list = this.model.createDataPoint("static_list", {
-            resModel: this.fields[fieldName].relation,
-            field,
-            fields,
-            activeFields,
-            getParentRecordContext: () => this.dataContext,
-            limit,
-            orderBy,
-            editable,
-            rawContext: {
-                parent: this.rawContext,
-                make: () => {
-                    return makeContext([activeField.context], {
-                        ...this.evalContext,
-                        ...list.evalContext,
-                    });
-                },
-            },
-            parentRecord: this,
-            relationField: field.relation_field,
-            views,
-            viewMode,
-            onChanges: async () => {
-                const field = this.fields[fieldName];
-                if (field && field.relatedPropertyField) {
-                    const propertyFieldName = field.relatedPropertyField.fieldName;
-                    this.data[propertyFieldName] = this.data[propertyFieldName].map((property) =>
-                        property.name === field.propertyName
-                            ? { ...property, value: list.currentIds }
-                            : property
-                    );
-                    this._changes[propertyFieldName] = this.data[propertyFieldName];
-                } else {
-                    this._changes[fieldName] = list;
-                }
-                const proms = [];
-                if (activeField && activeField.onChange && this.isX2ManyValid(fieldName)) {
-                    const changes = await this._onChange([fieldName]);
-                    const proms = [];
-                    for (const [fieldName, value] of Object.entries(changes)) {
-                        const field = this.fields[fieldName];
-                        // for x2many fields, the onchange returns commands, not ids, so we need to process them
-                        // for now, we simply return an empty list
-                        if (isX2Many(field)) {
-                            this._changes[fieldName] = value;
-                            this.data[fieldName].applyCommands(value);
-                            proms.push(this.data[fieldName].load());
-                        } else {
-                            this._changes[fieldName] = value;
-                            this.data[fieldName] = this._changes[fieldName];
-                        }
-                    }
-                }
-                this.canBeAbandoned = false;
-                await Promise.all(proms);
-                if (this.selected && this.model.multiEdit) {
-                    await this.model.root.multiSave(this);
-                }
-                this.onChanges();
-            },
-        });
-
-        return list;
-    }
-
-    _getDefaultValues() {
-        const defaultValues = {};
-        for (const fieldName of this.fieldNames) {
-            const field = this.fields[fieldName];
-            if (isNumeric(field)) {
-                defaultValues[fieldName] = 0;
-            } else if (["date", "datetime"].includes(field.type)) {
-                defaultValues[fieldName] = false;
-            } else if (isX2Many(field) || field.type === "properties") {
-                defaultValues[fieldName] = [];
-            } else {
-                defaultValues[fieldName] = null;
-            }
-        }
-        return defaultValues;
-    }
-
-    _getOnchangeSpec() {
-        const specs = {};
-        function buildSpec(activeFields, prefix) {
-            for (const [fieldName, activeField] of Object.entries(activeFields)) {
-                if (activeField.relatedPropertyField) {
-                    continue;
-                }
-                const key = prefix ? `${prefix}.${fieldName}` : fieldName;
-                specs[key] = activeField.onChange ? "1" : "";
-                const subViewInfo = activeField.views && activeField.views[activeField.viewMode];
-                if (subViewInfo) {
-                    buildSpec(subViewInfo.activeFields, key);
-                }
-            }
-        }
-        buildSpec(this.activeFields);
-        return specs;
-    }
-
-    /**
-     * @param {Object} params
-     * @param {Object} params.values
-     * @param {Object} params.changes
-     */
-    async _load(params = {}) {
-        this._values = params.values || {};
-        this._changes = params.changes || {};
-        this._rawChanges = { ...this._changes };
-        const defaultValues = this._getDefaultValues();
-        for (const fieldName of this.fieldNames) {
-            delete this._rawChanges[fieldName];
-            const field = this.fields[fieldName];
-            if (isX2Many(field)) {
-                const resIds = this._values[fieldName];
-                const commands = this._changes[fieldName];
-                const staticList = this._cache[fieldName];
-                staticList.setCurrentIds(resIds, commands);
-                this._values[fieldName] = staticList;
-                this._changes[fieldName] = staticList;
-                this.data[fieldName] = staticList;
-            } else {
-                // smth is wrong here for many2one maybe
-                if (fieldName in this._changes) {
-                    this.data[fieldName] = this._changes[fieldName];
-                } else if (fieldName in this._values) {
-                    this.data[fieldName] = this._values[fieldName];
-                } else {
-                    this.data[fieldName] = defaultValues[fieldName];
-                }
-
-                if (field.type === "properties") {
-                    this._applyPropertyDefinitions(fieldName);
-                    for (const property of this.data[fieldName]) {
-                        const fieldPropertyName = `${fieldName}.${property.name}`;
-                        if (!this.activeFields[fieldPropertyName]) {
-                            continue;
-                        }
-                        if (isX2Many(property)) {
-                            const staticList = this._createStaticList(fieldPropertyName);
-                            this._cache[fieldPropertyName] = staticList;
-                            await staticList.setDataRecords(
-                                (property.value || []).map((val) => ({
-                                    id: val[0],
-                                    display_name: val[1] || this.model.env._t("No Access"),
-                                }))
-                            );
-                            this.data[fieldPropertyName] = staticList;
-                        } else if (property.type === "many2one") {
-                            this.data[fieldPropertyName] =
-                                property.value.length && property.value[1] === null
-                                    ? [property.value[0], this.model.env._t("No Access")]
-                                    : property.value;
-                        } else {
-                            this.data[fieldPropertyName] = property.value ?? false;
-                        }
-                    }
-                }
-            }
-        }
-
-        await this.loadRelationalData();
-        await this.loadPreloadedData();
-
-        // every field value should be correct here
-        this._invalidFields.clear();
-    }
-
-    async _loadMany2OneData(fieldName, value) {
-        const relation = this.fields[fieldName].relation;
-        const activeField = this.activeFields[fieldName];
-        if (
-            activeField &&
-            !this._isInvisible(fieldName) &&
-            value &&
-            (!value[1] || (activeField.options || {}).always_reload)
-        ) {
-            const context = this._getFieldContext(fieldName);
-            const result = await this.model.orm.nameGet(relation, [value[0]], { context });
-            return result[0];
-        }
-        return value;
-    }
-
-    async _loadReference(fieldName, value) {
-        // const modelField = this.activeFields[fieldName].options.model_field;
-        // if (modelField) {
-        // }
-        if (value) {
-            if (typeof value === "string") {
-                const [resModel, resId] = value.split(",");
-                value = { resModel, resId: parseInt(resId, 10) };
-            }
-            const { resModel, resId } = value;
-            const context = this._getFieldContext(fieldName);
-            const nameGet = await this.model.orm.nameGet(resModel, [resId], { context });
-            return {
-                resModel,
-                resId,
-                displayName: nameGet[0][1],
-            };
-        } else {
-            return false;
-        }
-    }
-
-    async _loadX2ManyData(fieldName) {
-        if (!this._isInvisible(fieldName)) {
-            await this.data[fieldName].load();
-        }
-    }
-
-    async _onChange(fieldNames) {
-        if (!this.fieldNames.length) {
-            return;
-        }
-
-        const {
-            domain,
-            value: changes,
-            warning,
-        } = await this.model.orm.call(
-            this.resModel,
-            "onchange",
-            [
-                this.resId ? [this.resId] : [],
-                this.getChanges(true, true),
-                fieldNames && fieldNames.length ? fieldNames : [],
-                this._getOnchangeSpec(),
-            ],
-            { context: this.context }
-        );
-        if (warning) {
-            const { type, title, message } = warning;
-            if (type === "dialog") {
-                this.model.dialogService.add(WarningDialog, { title, message });
-            } else {
-                this.model.notificationService.add(message, {
-                    className: warning.className,
-                    sticky: warning.sticky,
-                    title,
-                    type: "warning",
-                });
-            }
-        }
-        if (domain) {
-            // do this outside
-            Object.assign(this._domains, domain);
-        }
-        return this._parseServerValues(changes);
-    }
-
-    async _read(fieldNames) {
-        fieldNames = fieldNames || this.fieldNames;
-        if (!fieldNames.length) {
-            return {};
-        }
-        const [serverValues] = await this.model.orm.read(this.resModel, [this.resId], fieldNames, {
-            context: {
-                bin_size: true,
-                ...this.context,
-            },
-        });
-        return this._parseServerValues(serverValues);
-    }
-
-    _removeInvalidFields(fieldNames) {
-        for (const fieldName of fieldNames) {
-            this._invalidFields.delete(fieldName);
-        }
-    }
-
-    _sanitizeValues(values) {
-        if (this.resModel !== this.model.resModel) {
-            return values;
-        }
-        const sanitizedValues = {};
-        for (const fieldName in values) {
-            if (this.fields[fieldName].type === "char") {
-                sanitizedValues[fieldName] = values[fieldName] || "";
-            } else {
-                sanitizedValues[fieldName] = values[fieldName];
-            }
-        }
-        return sanitizedValues;
-    }
-
-    /**
-     *
-     * @param {Object} options
-     * @param {boolean} [options.stayInEdition=false]
-     * @param {boolean} [options.noReload=false] prevents the record from
-     *  reloading after changes are applied, typically used to defer the load.
-     * @returns {Promise<boolean>}
-     */
-    async _save(options = { stayInEdition: false, noReload: false }) {
-        if (!this._checkValidity()) {
-            const invalidFields = [...this._invalidFields].map((fieldName) => {
-                return `<li>${escape(this.fields[fieldName].string || fieldName)}</li>`;
-            }, this);
-            this.model.notificationService.add(markup(`<ul>${invalidFields.join("")}</ul>`), {
-                title: this.model.env._t("Invalid fields: "),
-                type: "danger",
-            });
-            return false;
-        }
-        if ((await this.onWillSaveRecord(this)) === false) {
-            return false;
-        }
-        const changes = this.getChanges();
-        const keys = Object.keys(changes);
-        const hasChanges = this.isNew || keys.length;
-        const shouldReload = hasChanges ? !options.noReload : false;
-        const context = this.context;
-
-        if (this.isNew) {
-            const [resId] = await this.model.orm.create(this.resModel, [changes], { context });
-            this.resId = resId;
-            delete this.virtualId;
-            this.data.id = this.resId;
-            this.resIds.push(this.resId);
-            this._changes = {};
-        } else if (keys.length > 0) {
-            try {
-                await this.model.orm.write(this.resModel, [this.resId], changes, { context });
-            } catch (e) {
-                if (!this.isInEdition) {
-                    await this.model.reloadRecords(this);
-                }
-                throw e;
-            }
-            this._changes = {};
-        }
-
-        this.isInQuickCreation = false;
-        if (shouldReload) {
-            await this.model.reloadRecords(this);
-        }
-        if (!options.stayInEdition) {
-            this.switchMode("readonly");
-        }
-        await this.onRecordSaved(this);
-        return true;
-    }
-
-    async _update(changes, { silent } = {}) {
-        await this._applyChanges(changes);
-        if (this.selected && this.model.multiEdit) {
-            await this.model.root._multiSave(this);
-        } else {
-            const proms = [];
-            const fieldNames = Object.keys(changes);
-            if (fieldNames.length) {
-                this.onChanges();
-            }
-            this._removeInvalidFields(fieldNames);
-            if (
-                fieldNames.some(
-                    (fieldName) =>
-                        this.activeFields[fieldName] && this.activeFields[fieldName].onChange
-                )
-            ) {
-                const changes = await this._onChange(fieldNames);
-                this._removeInvalidFields(Object.keys(changes));
-                for (const [fieldName, value] of Object.entries(changes)) {
-                    const field = this.fields[fieldName];
-                    // for x2many fields, the onchange returns commands, not ids, so we need to process them
-                    // for now, we simply return an empty list
-                    if (isX2Many(field)) {
-                        this._changes[fieldName] = value;
-                        this.data[fieldName].applyCommands(value);
-                        proms.push(this.data[fieldName].load());
-                    } else {
-                        this._changes[fieldName] = value;
-                        this.data[fieldName] = this._changes[fieldName];
-                    }
-                }
-            }
-            proms.push(this.loadPreloadedData());
-            await Promise.all(proms);
-            this.canBeAbandoned = false;
-            if (!silent) {
-                this.model.notify();
-            }
-        }
-    }
-}
-
-class DynamicList extends DataPoint {
-    setup(params, state) {
-        this.groupBy = params.groupBy || [];
-        this.domain = markRaw(params.domain || []);
-
-        // restore the previously exported initialOrderBy or initialize it to `params.orderBy`
-        // this is what will be exported as `state.initialOrderBy`
-        this.initialOrderBy = state.initialOrderBy || params.orderBy || [];
-
-        if (
-            params.orderBy &&
-            params.orderBy.length &&
-            JSON.stringify(params.orderBy) !== JSON.stringify(state.initialOrderBy)
-        ) {
-            this.orderBy = params.orderBy;
-        } else {
-            this.orderBy = state.orderBy || [];
-        }
-
-        this.offset = state.offset || 0;
-        this.count = 0;
-        this.initialLimit = state.initialLimit || params.limit || this.constructor.DEFAULT_LIMIT;
-        this.limit = state.limit || params.limit || this.constructor.DEFAULT_LIMIT;
-        this.isDomainSelected = false;
-
-        this.editedRecord = null;
-        this.onCreateRecord = params.onCreateRecord || (() => {});
-        this.onRecordWillSwitchMode = async (record, mode, options) => {
-            const editedRecord = this.editedRecord;
-            this.editedRecord = null;
-            if (!params.onRecordWillSwitchMode && editedRecord) {
-                // not really elegant, but we only need the root list to save the record
-                if (editedRecord !== record && editedRecord.canBeAbandoned) {
-                    this.abandonRecord(editedRecord.id);
-                } else {
-                    let isSaved;
-                    try {
-                        isSaved = await editedRecord._save();
-                    } catch (e) {
-                        this.editedRecord = editedRecord;
-                        this.model.notify();
-                        throw e;
-                    }
-                    if (!isSaved) {
-                        this.editedRecord = editedRecord;
-                        this.model.notify();
-                        return false;
-                    }
-                }
-            }
-            if (mode === "edit") {
-                this.editedRecord = record;
-            }
-            if (params.onRecordWillSwitchMode) {
-                return await params.onRecordWillSwitchMode(record, mode, options);
-            }
-        };
-    }
-
-    // -------------------------------------------------------------------------
-    // Getters
-    // -------------------------------------------------------------------------
-
-    get firstGroupBy() {
-        return this.groupBy[0] || false;
-    }
-
-    get groupByField() {
-        if (!this.firstGroupBy) {
-            return false;
-        }
-        const [groupByFieldName, granularity] = this.firstGroupBy.split(":");
-        return {
-            attrs: {},
-            ...this.fields[groupByFieldName],
-            ...this.activeFields[groupByFieldName],
-            granularity: granularity,
-        };
-    }
-
-    get selection() {
-        return this.records.filter((r) => r.selected);
-    }
-
-    // -------------------------------------------------------------------------
-    // Public
-    // -------------------------------------------------------------------------
-
-    abandonRecord(recordId) {
-        const record = this.records.find((r) => r.id === recordId);
-        return this.removeRecord(record);
-    }
-
-    /**
-     * @param {boolean} [isSelected]
-     * @returns {Promise<number[]>}
-     */
-    async archive(isSelected) {
-        const resIds = await this.getResIds(isSelected);
-        await toggleArchive(this.model, this.resModel, resIds, true, this.context);
-        await this.model.load();
-        return resIds;
-    }
-
-    canResequence() {
-        return this.model.handleField || DEFAULT_HANDLE_FIELD in this.fields;
-    }
-
-    exportState() {
-        return {
-            limit: this.limit,
-            initialLimit: this.initialLimit,
-            orderBy: this.orderBy,
-            initialOrderBy: this.initialOrderBy,
-        };
-    }
-
-    /**
-     * @param {boolean} [isSelected]
-     * @returns {Promise<number[]>}
-     */
-    async getResIds(isSelected) {
-        let resIds;
-        if (isSelected) {
-            if (this.isDomainSelected) {
-                resIds = await this.model.orm.search(this.resModel, this.domain, {
-                    limit: session.active_ids_limit,
-                    context: this.context,
-                });
-            } else {
-                resIds = this.selection.map((r) => r.resId);
-            }
-        } else {
-            resIds = this.records.map((r) => r.resId);
-        }
-        return resIds;
-    }
-
-    // Note: changes is only there for documents and won't be necessary with the new model,
-    // so don't use it (we use record.getChanges() instead)
-    async multiSave(record, changes) {
-        return this.model.mutex.exec(() => this._multiSave(record, changes));
-    }
-
-    selectDomain(value) {
-        this.isDomainSelected = value;
-        this.model.notify();
-    }
-
-    async sortBy(fieldName) {
-        if (this.orderBy.length && this.orderBy[0].name === fieldName) {
-            this.orderBy[0].asc = !this.orderBy[0].asc;
-        } else {
-            this.orderBy = this.orderBy.filter((o) => o.name !== fieldName);
-            this.orderBy.unshift({
-                name: fieldName,
-                asc: true,
-            });
-        }
-
-        await this.load();
-        this.model.notify();
-    }
-
-    /**
-     * @param {boolean} [isSelected]
-     * @returns {Promise<number[]>}
-     */
-    async unarchive(isSelected) {
-        const resIds = await this.getResIds(isSelected);
-        await toggleArchive(this.model, this.resModel, resIds, false, this.context);
-        await this.model.load();
-        return resIds;
-    }
-
-    // -------------------------------------------------------------------------
-    // Protected
-    // -------------------------------------------------------------------------
-
-    async _multiSave(record, changes) {
-        const hasManualChanges = Boolean(changes);
-        changes = changes || record.getChanges();
-        if (!changes) {
-            return;
-        }
-        const selection = this.selection;
-        const validSelection = selection.reduce((result, record) => {
-            if (
-                !Object.keys(changes).filter(
-                    (fieldName) =>
-                        record.isFieldReadonly(fieldName) ||
-                        (record._isRequired(fieldName) && !changes[fieldName])
-                ).length
-            ) {
-                result.push(record);
-            }
-            return result;
-        }, []);
-        const canProceed = await this.onWillSaveMultiRecords(record, validSelection);
-        if (canProceed !== false) {
-            if (validSelection.length === 0) {
-                const dialogProps = {
-                    body: this.model.env._t("No valid record to save"),
-                    confirm: () => {
-                        record.discard();
-                    },
-                };
-                return this.model.dialogService.add(AlertDialog, dialogProps);
-            } else if (validSelection.length > 1 || hasManualChanges) {
-                this.editedRecord = null;
-                const resIds = validSelection.map((r) => r.resId);
-                try {
-                    const context = this.context;
-                    await this.model.orm.write(this.resModel, resIds, changes, { context });
-                    await Promise.all(validSelection.map((record) => record.load()));
-                    record.switchMode("readonly");
-                } catch {
-                    record.discard();
-                }
-            } else {
-                await record._save();
-            }
-            this.onSavedMultiRecords(validSelection);
-            this.model.notify();
-        }
-    }
-
-    /**
-     * Calls the method 'resequence' on the given resModel.
-     * The record matching that 'moveId' will be resequenced in the given list of
-     * records, at the start of the list or after the record matching 'targetId' (if any).
-     *
-     * @param {(Group | Record)[]} originalList
-     * @param {string} resModel
-     * @param {string} movedId
-     * @param {string} [targetId]
-     * @returns {Promise<(Group | Record)[]>}
-     */
-    async _resequence(originalList, resModel, movedId, targetId) {
-        if (this.resModel === resModel && !this.canResequence()) {
-            // There is no handle field on the current model
-            return originalList;
-        }
-
-        const handleField = this.model.handleField || DEFAULT_HANDLE_FIELD;
-        const records = [...originalList];
-        const order = this.orderBy.find((o) => o.name === handleField);
-        const asc = !order || order.asc;
-
-        // Find indices
-        const fromIndex = records.findIndex((r) => r.id === movedId);
-        let toIndex = 0;
-        if (targetId !== null) {
-            const targetIndex = records.findIndex((r) => r.id === targetId);
-            toIndex = fromIndex > targetIndex ? targetIndex + 1 : targetIndex;
-        }
-
-        const getSequence = (rec) => rec && rec.data[handleField];
-
-        // Determine what records need to be modified
-        const firstIndex = Math.min(fromIndex, toIndex);
-        const lastIndex = Math.max(fromIndex, toIndex) + 1;
-        let reorderAll = records.some((record) => record.data[handleField] === undefined);
-        if (!reorderAll) {
-            let lastSequence = (asc ? -1 : 1) * Infinity;
-            for (let index = 0; index < records.length; index++) {
-                const sequence = getSequence(records[index]);
-                if (
-                    ((index < firstIndex || index >= lastIndex) &&
-                        ((asc && lastSequence >= sequence) ||
-                            (!asc && lastSequence <= sequence))) ||
-                    (index >= firstIndex && index < lastIndex && lastSequence === sequence)
-                ) {
-                    reorderAll = true;
-                }
-                lastSequence = sequence;
-            }
-        }
-
-        // Perform the resequence in the list of records
-        const [record] = records.splice(fromIndex, 1);
-        records.splice(toIndex, 0, record);
-
-        // Creates the list of to modify
-        let toReorder = records;
-        if (!reorderAll) {
-            toReorder = toReorder.slice(firstIndex, lastIndex).filter((r) => r.id !== movedId);
-            if (fromIndex < toIndex) {
-                toReorder.push(record);
-            } else {
-                toReorder.unshift(record);
-            }
-        }
-        if (!asc) {
-            toReorder.reverse();
-        }
-
-        const ids = toReorder.map((r) => r.resId).filter((s) => s === 0 || (s && !isNaN(s)));
-        const sequences = toReorder.map(getSequence);
-        const offset = sequences.length && Math.min(...sequences);
-
-        // Assemble the params
-        const params = { model: resModel, ids, context: this.context };
-        if (offset) {
-            params.offset = offset;
-        }
-        if (this.model.handleField) {
-            params.field = handleField;
-        }
-
-        // Try to write new sequences on the affected records
-        const wasResequenced = await this.model.keepLast.add(
-            this.model.rpc("/web/dataset/resequence", params)
-        );
-        if (!wasResequenced) {
-            return originalList;
-        }
-
-        // Read the actual values set by the server and update the records
-        const result = await this.model.keepLast.add(
-            this.model.orm.read(resModel, ids, [handleField], { context: this.context })
-        );
-        for (const recordData of result) {
-            const record = records.find((r) => r.resId === recordData.id);
-            const value = { [handleField]: recordData[handleField] };
-            if (record instanceof Record) {
-                await record.update(value, { silent: true });
-            } else {
-                Object.assign(record.data, value);
-            }
-        }
-
-        return records;
-    }
-
-    unselectRecord() {
-        return unselectRecord(this.editedRecord, this.abandonRecord.bind(this));
-    }
-}
-
-DynamicList.DEFAULT_LIMIT = 80;
-
-export class DynamicRecordList extends DynamicList {
-    setup(params, state) {
-        super.setup(...arguments);
-
-        /** @type {Record[]} */
-        this.records = [];
-        this.data = params.data;
-        this.countLimit =
-            state.countLimit || params.countLimit || this.constructor.WEB_SEARCH_READ_COUNT_LIMIT;
-        this.hasLimitedCount = false;
-    }
-
-    // -------------------------------------------------------------------------
-    // Getters
-    // -------------------------------------------------------------------------
-
-    get commonRecordParams() {
-        return {
-            resModel: this.resModel,
-            fields: this.fields,
-            activeFields: this.activeFields,
-            onRecordSaved: this.onRecordSaved,
-            onRecordWillSwitchMode: this.onRecordWillSwitchMode,
-            onWillSaveRecord: this.onWillSaveRecord,
-            onWillSaveMultiRecords: this.onWillSaveMultiRecords,
-            onSavedMultiRecords: this.onSavedMultiRecords,
-            onWillSetInvalidField: this.onWillSetInvalidField,
-            defaultContext: this.defaultContext,
-            rawContext: {
-                parent: this.rawContext,
-                make: () => this.context,
-            },
-        };
-    }
-
-    get evalContext() {
-        return {
-            ...this.context,
-        };
-    }
-
-    // -------------------------------------------------------------------------
-    // Public
-    // -------------------------------------------------------------------------
-
-    /**
-     * @param {number} resId
-     * @param {boolean} [atFirstPosition]
-     * @returns {Promise<Record>} the newly created record
-     */
-    async addExistingRecord(resId, atFirstPosition) {
-        const newRecord = this.model.createDataPoint("record", {
-            ...this.commonRecordParams,
-            resId,
-        });
-        if (this.model.useSampleModel) {
-            this.model.useSampleModel = false;
-            await this.load();
-        }
-        await this.model.keepLast.add(this.model.mutex.exec(() => newRecord.load()));
-        return this.addRecord(newRecord, atFirstPosition ? 0 : this.count);
-    }
-
-    /**
-     * @param {Record} record
-     * @param {number} [index]
-     * @returns {Record}
-     */
-    addRecord(record, index) {
-        this.records.splice(Number.isInteger(index) ? index : this.records.length, 0, record);
-        this.count++;
-        this.model.notify();
-        return record;
-    }
-
-    /**
-     * @param {Object} [params={}]
-     * @param {boolean} [atFirstPosition]
-     * @returns {Promise<Record>} the newly created record
-     */
-    async createRecord(params = {}, atFirstPosition = false) {
-        const newRecord = this.model.createDataPoint("record", {
-            ...this.commonRecordParams,
-            parentActiveFields: this.activeFields,
-            activeFields: this.activeFields,
-            fields: this.fields,
-            ...params,
-        });
-        if (this.model.useSampleModel) {
-            this.model.useSampleModel = false;
-            await this.load();
-        }
-        await this.model.keepLast.add(this.model.mutex.exec(() => newRecord.load()));
-        this.editedRecord = newRecord;
-        this.onRemoveNewRecord = await this.onCreateRecord(newRecord);
-        if (params.isInQuickCreation) {
-            return newRecord;
-        } else {
-            return this.addRecord(newRecord, atFirstPosition ? 0 : this.count);
-        }
-    }
-
-    /**
-     * @param {Record[]} [records=[]]
-     * @returns {Promise<number[]>}
-     */
-    async deleteRecords(records = []) {
-        let deleted = false;
-        let resIds;
-        if (records.length) {
-            resIds = records.map((r) => r.resId);
-        } else {
-            resIds = await this.getResIds(true);
-            records = this.records.filter((r) => resIds.includes(r.resId));
-            if (this.isDomainSelected) {
-                await this.model.orm.unlink(this.resModel, resIds, {
-                    context: this.context,
-                });
-                deleted = true;
-            }
-        }
-        if (!deleted) {
-            await Promise.all(records.map((record) => record.delete()));
-        }
-        for (const record of records) {
-            this.removeRecord(record);
-        }
-        const hasReloaded = await this._adjustOffset();
-        if (resIds.length > 0 && !hasReloaded) {
-            // If the list hasn't been reloaded, force a reload if there are
-            // deleted records.
-            // NOTE that we don't rely on the reload logic of the _adjustOffset
-            // because we don't want the offset to be adjusted. Offset adjustment
-            // should only be done when at the last page.
-            await this.load();
-        }
-        return resIds;
-    }
-
-    empty() {
-        this.records = [];
-        this.count = 0;
-    }
-
-    exportState() {
-        return {
-            ...super.exportState(),
-            offset: this.offset,
-            countLimit: this.countLimit,
-        };
-    }
-
-    /**
-     * Performs a search_count with the current domain to set the count. This is
-     * useful as web_search_read limits the count for performance reasons, so it
-     * might sometimes be less than the real number of records matching the domain.
-     *
-     * @returns {number}
-     */
-    async fetchCount() {
-        const keepLast = this.model.keepLast;
-        this.count = await keepLast.add(this.model.orm.searchCount(this.resModel, this.domain));
-        this.countLimit = Number.MAX_SAFE_INTEGER;
-        this.hasLimitedCount = false;
-        this.model.notify();
-        return this.count;
-    }
-
-    async load(params = {}) {
-        this.limit = params.limit === undefined ? this.limit : params.limit;
-        this.offset = params.offset === undefined ? this.offset : params.offset;
-        this.domain = params.domain === undefined ? this.domain : params.domain;
-        this.records = await this._loadRecords();
-        await this._adjustOffset();
-    }
-
-    async loadMore() {
-        this.limit = this.records.length + this.initialLimit;
-        this.records = await this._loadRecords();
-        this.model.notify();
-    }
-
-    /**
-     * @param {Record} record
-     * @returns {Record}
-     */
-    removeRecord(record) {
-        const index = this.records.findIndex((r) => r === record);
-        if (index < 0) {
-            return;
-        }
-        this.records.splice(index, 1);
-        this.count--;
-        if (this.editedRecord === record) {
-            this.editedRecord = null;
-            if (this.onRemoveNewRecord) {
-                this.onRemoveNewRecord(record);
-                this.onRemoveNewRecord = null;
-            }
-        }
-
-        this.model.notify();
-        return record;
-    }
-
-    async resequence() {
-        this.records = await this._resequence(this.records, this.resModel, ...arguments);
-        this.model.notify();
-    }
-
-    // -------------------------------------------------------------------------
-    // Protected
-    // -------------------------------------------------------------------------
-
-    /**
-     * Reload the model if more records should appear on the current page.
-     *
-     * @returns {Promise<boolean>} Resolves to true if the model reloaded.
-     */
-    async _adjustOffset() {
-        if (this.offset && !this.records.length) {
-            this.offset = Math.max(this.offset - this.limit, 0);
-            await this.load();
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * @returns {Promise<Record[]>}
-     */
-    async _loadRecords() {
-        if (this.countLimit < this.offset + this.limit) {
-            this.countLimit = this.offset + this.limit;
-        }
-        const kwargs = {
-            limit: this.limit,
-            offset: this.offset,
-            order: orderByToString(this.orderBy),
-            context: {
-                bin_size: true,
-                ...this.context,
-            },
-        };
-        if (this.countLimit !== Number.MAX_SAFE_INTEGER) {
-            kwargs.count_limit = this.countLimit + 1;
-        }
-        const { records: rawRecords, length } =
-            this.data ||
-            (await this.model.orm.webSearchRead(
-                this.resModel,
-                this.domain,
-                this.fieldNames,
-                kwargs
-            ));
-
-        const records = await Promise.all(
-            rawRecords.map(async (data) => {
-                const record = this.model.createDataPoint("record", {
-                    ...this.commonRecordParams,
-                    resId: data.id,
-                    rawContext: this.rawContext,
-                    defaultContext: undefined,
-                });
-                await record.load({ values: data });
-                return record;
-            })
-        );
-
-        delete this.data;
-        if (length === this.countLimit + 1) {
-            this.hasLimitedCount = true;
-            this.count = length - 1;
-        } else {
-            this.hasLimitedCount = false;
-            this.count = length;
-        }
-
-        return records;
-    }
-}
-DynamicRecordList.WEB_SEARCH_READ_COUNT_LIMIT = 10000;
-
-export class DynamicGroupList extends DynamicList {
-    setup(params, state) {
-        super.setup(...arguments);
-
-        this.groupByInfo = params.groupByInfo || {}; // FIXME: is this something specific to the list view?
-        this.openGroupsByDefault = params.openGroupsByDefault || false;
-        /** @type {Group[]} */
-        this.groups = state.groups || [];
-        this.isGrouped = true;
-        this.expand = params.expand;
-        this.limitByGroup = this.limit;
-        this.limit =
-            params.groupsLimit ||
-            (this.expand ? this.constructor.DEFAULT_LOAD_LIMIT : this.constructor.DEFAULT_LIMIT);
-        this.onCreateRecord =
-            params.onCreateRecord ||
-            (async (record) => {
-                const editedRecord = this.editedRecord;
-                if (editedRecord && !record.isInQuickCreation) {
-                    if (editedRecord.canBeAbandoned) {
-                        this.abandonRecord(editedRecord.id);
-                    } else {
-                        await editedRecord.save();
-                    }
-                }
-                this.editedRecord = record;
-                const onRemoveRecord = (record) => {
-                    if (this.editedRecord === record) {
-                        this.editedRecord = null;
-                    }
-                };
-                return onRemoveRecord;
-            });
-    }
-
-    // -------------------------------------------------------------------------
-    // Getters
-    // -------------------------------------------------------------------------
-
-    get commonGroupParams() {
-        return {
-            fields: this.fields,
-            activeFields: this.activeFields,
-            resModel: this.resModel,
-            domain: this.domain,
-            groupBy: this.groupBy.slice(1),
-            orderBy: this.orderBy,
-            limit: this.limitByGroup,
-            groupByInfo: this.groupByInfo,
-            rawContext: this.rawContext,
-            onCreateRecord: this.onCreateRecord,
-            onRecordSaved: this.onRecordSaved,
-            onRecordWillSwitchMode: this.onRecordWillSwitchMode,
-            onWillSaveRecord: this.onWillSaveRecord,
-            onWillSaveMultiRecords: this.onWillSaveMultiRecords,
-            onSavedMultiRecords: this.onSavedMultiRecords,
-            onWillSetInvalidField: this.onWillSetInvalidField,
-        };
-    }
-
-    /**
-     * List of loaded records inside groups.
-     */
-    get records() {
-        return this.groups
-            .filter((group) => !group.isFolded)
-            .map((group) => group.records)
-            .flat();
-    }
-
-    // -------------------------------------------------------------------------
-    // Public
-    // -------------------------------------------------------------------------
-
-    /**
-     * @param {Group} group
-     * @param {number} [index]
-     * @returns {Group}
-     */
-    addGroup(group, index) {
-        this.groups.splice(Number.isInteger(index) ? index : this.count, 0, group);
-        this.count++;
-        this.model.notify();
-        return group;
-    }
-
-    /**
-     * @see {_createGroup}
-     */
-    async createGroup(groupName, groupData, isFolded) {
-        await this.model.mutex.exec(() => this._createGroup(groupName, groupData, isFolded));
-    }
-
-    /**
-     * @param {Group[]} groups
-     * @returns {Promise<void>}
-     */
-    async deleteGroups(groups) {
-        let shouldReload = false;
-        await Promise.all(
-            groups.map(async (group) => {
-                await group.delete();
-                if (!this.model.useSampleModel && group.list.records.length) {
-                    shouldReload = true;
-                }
-            })
-        );
-        if (shouldReload) {
-            await this.model.load();
-        } else {
-            for (const group of groups) {
-                this.removeGroup(group);
-            }
-        }
-    }
-
-    async deleteRecords() {
-        const allResIds = [];
-        for (const group of this.groups) {
-            const resIds = await group.list.deleteRecords();
-            group.count = group.count - resIds.length;
-            allResIds.push(...resIds);
-        }
-        // Return the list of all deleted resIds.
-        // Will be used by the calling group to update its count.
-        return allResIds;
-    }
-
-    exportState() {
-        const state = {
-            ...super.exportState(),
-            groups: this.groups,
-        };
-        delete state.limit;
-        return state;
-    }
-
-    hasAggregate(fieldName) {
-        const group = this.groups[0];
-        return group && fieldName in group.aggregates;
-    }
-
-    async load(params = {}) {
-        this.limit = params.limit === undefined ? this.limit : params.limit;
-        this.offset = params.offset === undefined ? this.offset : params.offset;
-        /** @type {[Group, number][]} */
-        this.groups = await this._loadGroups();
-        await Promise.all(this.groups.map((group) => group.load()));
-    }
-
-    get nbTotalRecords() {
-        return this.groups.reduce((acc, group) => acc + group.count, 0);
-    }
-
-    /**
-     * @param {Group} group
-     * @returns {Group}
-     */
-    removeGroup(group) {
-        const index = this.groups.findIndex((g) => g === group);
-        this.groups.splice(index, 1);
-        this.count--;
-        this.model.notify();
-        return group;
-    }
-
-    removeRecord(record) {
-        for (const group of this.groups) {
-            const removedRecord = group.list.removeRecord(record);
-            if (removedRecord) {
-                group.count--;
-                if (removedRecord === this.editedRecord) {
-                    this.editedRecord = null;
-                }
-                return removedRecord;
-            }
-        }
-    }
-
-    async resequence() {
-        const resModel = isRelational(this.groupByField)
-            ? this.groupByField.relation
-            : this.resModel;
-        this.groups = await this._resequence(this.groups, resModel, ...arguments);
-        this.model.notify();
-    }
-
-    async sortBy(fieldName) {
-        if (!this.groups.length) {
-            return;
-        }
-        const everyGroupIsClosed = this.groups.every((group) => group.isFolded);
-        if (
-            everyGroupIsClosed &&
-            !(this.groupBy.includes(fieldName) || this.hasAggregate(fieldName))
-        ) {
-            return;
-        }
-        super.sortBy(fieldName);
-    }
-
-    // ------------------------------------------------------------------------
-    // Protected
-    // ------------------------------------------------------------------------
-
-    /**
-     * @param {string} groupName
-     * @param {{ [relatedFieldName: string]: any }} [groupData={}]
-     * @param {boolean} [isFolded=false]
-     * @returns {Promise<Group>}
-     */
-    async _createGroup(groupName, groupData = {}, isFolded = false) {
-        groupData = { ...groupData, name: groupName };
-        const [id] = await this.model.orm.create(this.groupByField.relation, [groupData], {
-            context: this.context,
-        });
-        const [lastGroup] = this.groups.slice(-1);
-        const group = this.model.createDataPoint("group", {
-            ...this.commonGroupParams,
-            count: 0,
-            value: id,
-            displayName: groupName,
-            aggregates: {},
-            groupByField: this.groupByField,
-            groupDomain: Domain.and([this.domain, [[this.groupByField.name, "=", id]]]).toList(),
-            isFolded,
-            rawContext: this.rawContext,
-        });
-        this.addGroup(group);
-
-        if (lastGroup) {
-            await this.resequence(group.id, lastGroup.id);
-        }
-
-        return group;
-    }
-
-    /**
-     * @param {Object} groupData
-     * @param {string} fieldName
-     * @returns {any}
-     */
-    _getValueFromGroupData(groupData, fieldName) {
-        const field = this.fields[fieldName.split(":")[0]];
-        if (["date", "datetime"].includes(field.type)) {
-            const range = groupData.__range[fieldName];
-            if (!range) {
-                return false;
-            }
-            const dateValue = this._parseServerValue(field, range.to);
-            return dateValue.minus({ [field.type === "date" ? "day" : "second"]: 1 });
-        } else {
-            const value = this._parseServerValue(field, groupData[fieldName]);
-            return Array.isArray(value) ? value[0] : value;
-        }
-    }
-
-    async _loadGroups() {
-        const firstGroupByName = this.firstGroupBy.split(":")[0];
-        const _orderBy = this.orderBy.filter(
-            (o) =>
-                o.name === firstGroupByName ||
-                (this.fieldNames.includes(o.name) &&
-                    this.fields[o.name].group_operator !== undefined)
-        );
-        const orderby = orderByToString(_orderBy);
-        const { groups, length } = await this.model.orm.webReadGroup(
-            this.resModel,
-            this.domain,
-            unique([...this.fieldNames, firstGroupByName]),
-            [this.firstGroupBy],
-            {
-                orderby,
-                lazy: true,
-                expand: this.expand,
-                expand_orderby: this.expand ? orderByToString(this.orderBy) : null,
-                expand_limit: this.expand ? this.limitByGroup : null,
-                offset: this.offset,
-                limit: this.limit,
-                context: this.context,
-            }
-        );
-        this.count = length;
-
-        const groupByField = this.groupByField;
-        let openGroups = 0;
-
-        const groupsParams = groups.map((data) => {
-            const groupParams = {
-                ...this.commonGroupParams,
-                aggregates: {},
-                groupByField,
-            };
-            for (const key in data) {
-                const value = data[key];
-                switch (key) {
-                    case this.firstGroupBy: {
-                        groupParams.__rawValue = value;
-                        groupParams.value = this._getValueFromGroupData(data, key);
-                        if (groupByField.type === "selection") {
-                            groupParams.displayName = Object.fromEntries(groupByField.selection)[
-                                groupParams.value
-                            ];
-                        } else {
-                            groupParams.displayName = Array.isArray(value) ? value[1] : value;
-                        }
-                        if (["many2one", "many2many"].includes(this.groupByField.type)) {
-                            groupParams.recordParams = this.groupByInfo[this.firstGroupBy];
-                        }
-                        break;
-                    }
-                    // When group_by_no_leaf key is present FIELD_ID_count doesn't exist
-                    // we have to get the count from `__count` instead
-                    // see _read_group in models.py
-                    case `__count`:
-                    case `${groupByField.name}_count`: {
-                        groupParams.count = value;
-                        break;
-                    }
-                    case "__domain": {
-                        groupParams.groupDomain = value;
-                        break;
-                    }
-                    case "__fold": {
-                        // optional
-                        groupParams.isFolded =
-                            openGroups >= this.constructor.DEFAULT_LOAD_LIMIT || value;
-                        if (!value) {
-                            openGroups++;
-                        }
-                        break;
-                    }
-                    case "__range": {
-                        groupParams.range = value;
-                        break;
-                    }
-                    case "__data": {
-                        groupParams.data = value;
-                        break;
-                    }
-                    default: {
-                        // other optional aggregated fields
-                        if (key in this.fields) {
-                            if (AGGREGATABLE_FIELD_TYPES.includes(this.fields[key].type)) {
-                                groupParams.aggregates[key] = value;
-                            }
-                        }
-                    }
-                }
-            }
-            const groupValue = groupParams.__rawValue;
-            const previousGroup = this.groups.find((g) => {
-                if (g.deleted) {
-                    return false;
-                }
-                return Array.isArray(g.__rawValue) && Array.isArray(groupValue)
-                    ? g.__rawValue[0] === groupValue[0]
-                    : g.__rawValue === groupValue;
-            });
-            const state = previousGroup ? previousGroup.exportState() : {};
-            return [groupParams, state];
-        });
-
-        // Unfold groups that can still be unfolded by default
-        if (this.openGroupsByDefault || this.expand) {
-            for (const [params, state] of groupsParams) {
-                if (openGroups >= this.constructor.DEFAULT_LOAD_LIMIT) {
-                    break;
-                }
-                const finalState = { ...params, ...state };
-                const hasValue = isRelational(this.groupByField) ? finalState.value : true;
-                if (hasValue && !("isFolded" in finalState)) {
-                    params.isFolded = false;
-                    openGroups++;
-                }
-            }
-        }
-
-        return groupsParams.map(([params, state]) =>
-            this.model.createDataPoint("group", params, state)
-        );
-    }
-}
-
-DynamicGroupList.DEFAULT_LOAD_LIMIT = 10;
-
-export class Group extends DataPoint {
-    setup(params, state) {
-        this.__rawValue = params.__rawValue;
-        this.value = params.value;
-        this.displayName = params.displayName;
-        this.aggregates = params.aggregates;
-        this.groupDomain = params.groupDomain;
-        this.range = params.range;
-        this.count = params.count;
-        this.groupByField = params.groupByField;
-        this.groupByInfo = params.groupByInfo;
-        this.recordParams = params.recordParams;
-        if ("isFolded" in state) {
-            this.isFolded = state.isFolded;
-        } else if ("isFolded" in params) {
-            this.isFolded = params.isFolded;
-        } else {
-            this.isFolded = true;
-        }
-        if ("groupFilterDomain" in state) {
-            this.groupFilterDomain = state.groupFilterDomain;
-        }
-        if (isRelational(this.groupByField)) {
-            // If the groupBy field is a relational field, the group model must
-            // then be the relation of that field.
-            this.resModel = this.groupByField.relation;
-            this.resId = params.value || false;
-            this.data = {};
-        } else {
-            this.data = null;
-        }
-        const listParams = {
-            data: params.data,
-            domain: this.groupFilterDomain
-                ? Domain.and([this.groupDomain, this.groupFilterDomain]).toList()
-                : this.groupDomain,
-            groupBy: params.groupBy,
-            rawContext: params.rawContext,
-            orderBy: params.orderBy,
-            resModel: params.resModel,
-            activeFields: params.activeFields,
-            fields: params.fields,
-            limit: params.limit,
-            countLimit: params.count,
-            groupByInfo: params.groupByInfo,
-            onCreateRecord: params.onCreateRecord,
-            onRecordSaved: this.onRecordSaved,
-            onRecordWillSwitchMode: params.onRecordWillSwitchMode,
-            onWillSaveRecord: this.onWillSaveRecord,
-            onWillSaveMultiRecords: this.onWillSaveMultiRecords,
-            onSavedMultiRecords: this.onSavedMultiRecords,
-            onWillSetInvalidField: this.onWillSetInvalidField,
-            defaultContext: {
-                ...params.defaultContext,
-                [`default_${this.groupByField.name}`]: this.getServerValue(),
-            },
-        };
-        this.list = this.model.createDataPoint("list", listParams, state.listState);
-    }
-
-    get records() {
-        return this.list.records;
-    }
-
-    // ------------------------------------------------------------------------
-    // Public
-    // ------------------------------------------------------------------------
-
-    applyFilter(filter) {
-        this.groupFilterDomain = filter;
-        if (this.groupFilterDomain) {
-            return this.list.load({
-                domain: Domain.and([this.groupDomain, this.groupFilterDomain]).toList(),
-            });
-        } else {
-            return this.list.load({ domain: this.groupDomain });
-        }
-    }
-
-    /**
-     * @see DynamicRecordList.addRecord
-     */
-    addRecord(record, index) {
-        this.count++;
-        return this.list.addRecord(record, index);
-    }
-
-    async addExistingRecord(resId, atFirstPosition = false) {
-        const record = await this.list.addExistingRecord(resId, atFirstPosition);
-        this.count++;
-        return record;
-    }
-
-    createRecord(params = {}, atFirstPosition = false) {
-        this.count++;
-        this.list.createRecord(params, atFirstPosition);
-    }
-
-    async delete() {
-        this.deleted = true;
-        if (this.record) {
-            return this.record.delete();
-        } else {
-            return this.model.orm.unlink(this.resModel, [this.value], {
-                context: this.context,
-            });
-        }
-    }
-
-    /**
-     * @see DynamicRecordList.deleteRecords
-     */
-    async deleteRecords(records) {
-        this.count = this.count - records.length;
-        return this.list.deleteRecords(records);
-    }
-
-    empty() {
-        this.count = 0;
-        this.aggregates = {};
-        this.list.empty();
-    }
-
-    exportState() {
-        return {
-            isFolded: this.isFolded,
-            listState: this.list.exportState(),
-            groupFilterDomain: this.groupFilterDomain,
-        };
-    }
-
-    getServerValue() {
-        const { name, selection, type, granularity } = this.groupByField;
-
-        switch (type) {
-            case "many2one":
-            case "char":
-            case "boolean": {
-                return this.value || false;
-            }
-            case "many2many": {
-                return this.value ? [this.value] : false;
-            }
-            case "selection": {
-                const descriptor = selection.find((opt) => opt[0] === this.value);
-                return descriptor && descriptor[0];
-            }
-            // for a date/datetime field, we take the last moment of the group as the group value
-            case "date":
-            case "datetime": {
-                const groupedBy = granularity ? `${name}:${granularity}` : name;
-                const range = this.range[groupedBy];
-                if (!range) {
-                    return false;
-                }
-                if (type === "date") {
-                    return serializeDate(deserializeDate(range.to).minus({ day: 1 }));
-                } else {
-                    return serializeDateTime(deserializeDateTime(range.to).minus({ second: 1 }));
-                }
-            }
-            default: {
-                return false; // other field types are not handled
-            }
-        }
-    }
-
-    async load() {
-        if (!this.record && this.recordParams) {
-            this.record = this.makeRecord(this.recordParams);
-            await this.record.load();
-        }
-        if (!this.isFolded && this.count) {
-            await this.list.load();
-        }
-    }
-
-    makeRecord(params) {
-        return this.model.createDataPoint("record", {
-            resModel: this.resModel,
-            resId: this.value,
-            rawContext: this.rawContext,
-            onRecordSaved: this.onRecordSaved,
-            onWillSaveRecord: this.onWillSaveRecord,
-            onWillSaveMultiRecords: this.onWillSaveMultiRecords,
-            onSavedMultiRecords: this.onSavedMultiRecords,
-            onWillSetInvalidField: this.onWillSetInvalidField,
-            ...params,
-        });
-    }
-
-    /**
-     * @see DynamicRecordList.removeRecord
-     */
-    removeRecord(record) {
-        this.count--;
-        return this.list.removeRecord(record);
-    }
-
-    async toggle() {
-        this.isFolded = !this.isFolded;
-        await this.model.keepLast.add(this.load());
-        this.model.notify();
-    }
-
-    valueEquals(value) {
-        return this.value instanceof DateTime ? this.value.equals(value) : this.value === value;
-    }
-}
-
-function add(arr, el) {
-    const index = arr.indexOf(el);
-    if (index === -1) {
-        arr.push(el);
-    }
-}
-
-function remove(arr, el) {
-    const index = arr.indexOf(el);
-    if (index > -1) {
-        arr.splice(index, 1);
-    }
-}
-
-const symbolValues = Symbol("values");
-
-export class StaticList extends DataPoint {
-    setup(params, state) {
-        this.offset = params.offset || 0;
-        this.limit = params.limit || state.limit || this.constructor.DEFAULT_LIMIT;
-        this.initialLimit = this.limit;
-        this.editable = params.editable || false; // ("bottom" or "top")
-        this.field = params.field;
-        this.relationField = params.relationField;
-        this.parentRecord = params.parentRecord;
-
-        this.orderBy = params.orderBy || [];
-        this.isOrder = true;
-
-        // async computation that depends on previous params
-        // to be initialized
-        this.records = [];
-
-        this._cache = {};
-        this._mapping = {}; // maps record.resId || record.virtualId to record.id
-
-        this.views = params.views || {};
-        this.viewMode = params.viewMode;
-
-        this.onChanges = params.onChanges || (() => {});
-
-        this.getParentRecordContext = params.getParentRecordContext;
-
-        this.editedRecord = null;
-        this.onRecordWillSwitchMode = async (record, mode, options) => {
-            const editedRecord = this.editedRecord;
-            this.editedRecord = null;
-            if (editedRecord) {
-                // Validity is checked if one of the following is true:
-                // - "switchMode" has been called with explicit "checkValidity"
-                // - the record is dirty
-                // - the record is new and can be abandonned
-                const shouldCheckValidity =
-                    options.checkValidity || editedRecord.isDirty || editedRecord.canBeAbandoned;
-                const isValid = !shouldCheckValidity || (await editedRecord.checkValidity());
-                if (isValid) {
-                    await editedRecord.switchMode("readonly");
-                } else if (editedRecord.id !== record.id && editedRecord.canBeAbandoned) {
-                    this.abandonRecord(editedRecord.id);
-                } else {
-                    this.editedRecord = editedRecord;
-                    return false;
-                }
-            }
-            if (mode === "edit") {
-                this.editedRecord = record;
-            }
-        };
-    }
-
-    //--------------------------------------------------------------------------
-    // Getters
-    //--------------------------------------------------------------------------
-
-    /**
-     * @returns {number}
-     */
-    get count() {
-        if (!this.currentIds) {
-            throw new Error("you rascal");
-        }
-        return this.currentIds.length;
-    }
-
-    get evalContext() {
-        return {
-            // ...
-            parent: this.getParentRecordContext(),
-        };
-    }
-
-    // ------------------------------------------------------------------------
-    // Public
-    // ------------------------------------------------------------------------
-
-    /**
-     * Add a true record in relation
-     * see final API of StaticList in basic_relational_model.js
-     */
-    async add(params) {
-        //
-        // if (!params.resId) {
-        //     throw new Error("you rascal");
-        // }
-        // const { resId } = params;
-        // this.limit++;
-        // this.applyCommand(x2ManyCommands.linkTo(resId));
-        // if (!this._mapping[resId]) {
-        //     const record = this._createRecord(params);
-        //     await record.load();
-        // }
-        // this.isOrder = false;
-        // this.records = this._getRecords();
-        // this.onChanges();
-        // this.model.notify(); // should be in onChanges?
-    }
-
-    /**
-     * Add a new record in relation
-     * @param {Object} params
-     */
-    async addNew(params) {
-        if (params.resId) {
-            throw new Error("you rascal");
-        }
-
-        const record = this._createRecord(params);
-        await record.load();
-
-        record._onWillSwitchMode(record, "edit"); // bof
-
-        this.limit++;
-        this.applyCommand(x2ManyCommands.create(record.virtualId, symbolValues));
-
-        this.isOrder = false;
-        this.records = this._getRecords();
-        this.onChanges();
-        this.model.notify();
-
-        return record;
-    }
-
-    applyCommand(command) {
-        this.applyCommands([command]);
-    }
-
-    /**
-     * @param {Array[]} commands  array of commands
-     */
-    applyCommands(commands) {
-        this._commands = this._getNormalizedCommands(this._commands, commands);
-        this.currentIds = this._getCurrentIds(this.currentIds, commands);
-        this._mapping = this._getNextMapping(this._mapping, commands);
-    }
-
-    /**
-     * @param {RecordId} recordId
-     */
-    async delete(recordIds) {
-        if (!Array.isArray(recordIds)) {
-            recordIds = [recordIds];
-        }
-        const ids = [];
-        for (const recordId of recordIds) {
-            const record = this._cache[recordId];
-            if (record.isNew) {
-                delete this._cache[recordId];
-            }
-            const id = record.resId || record.virtualId;
-            ids.push(id);
-        }
-        if (this.field.type === "many2many") {
-            const nextIds = this.records.filter((rec) => !ids.includes(rec.resId || rec.virtualId));
-            return this.replaceWith(nextIds);
-        }
-        const commands = ids.map((id) => x2ManyCommands.delete(id));
-        this.applyCommands(commands);
-        await this._loadRecords();
-        this.records = this._getRecords();
-        this.onChanges();
-        this.model.notify();
-    }
-
-    discard() {
-        for (const record of Object.values(this._cache)) {
-            if (record.isNew) {
-                delete this._cache[record.id];
-            } else {
-                record.discard();
-            }
-        }
-        this.limit = this.initialLimit;
-        this._commands = [];
-        this._commandsById = {};
-        this.currentIds = [...this._serverIds];
-        this.records = this._getRecords();
-    }
-
-    exportState() {
-        return {
-            limit: this.limit,
-        };
-    }
-
-    async load() {
-        if (!this.count) {
-            this.records = [];
-            return;
-        }
-
-        const orderFieldNames = this.orderBy.map((o) => o.name);
-        const isAscByFieldName = {};
-        for (const o of this.orderBy) {
-            isAscByFieldName[o.name] = o.asc;
-        }
-        const compareRecords = (d1, d2) => {
-            for (const fieldName of orderFieldNames) {
-                let v1 = d1[fieldName];
-                let v2 = d2[fieldName];
-                if (this.fields[fieldName].type === "many2one") {
-                    v1 = v1[1];
-                    v2 = v2[1];
-                }
-                if (v1 !== v2) {
-                    if (v1 < v2) {
-                        return isAscByFieldName[fieldName] ? -1 : 1;
-                    } else {
-                        return isAscByFieldName[fieldName] ? 1 : -1;
-                    }
-                }
-            }
-            return 0;
-        };
-
-        const hasSeveralPages = this.limit < this.count;
-        if (hasSeveralPages && orderFieldNames.length) {
-            // there several pages in the x2many and it is ordered, so we must know the value
-            // for the sorted field for all records and sort the resIds w.r.t. to those values
-            // before fetching the activeFields for the resIds of the current page.
-            // 1) populate values for already fetched records
-            const recordValues = {};
-            const resIds = [];
-            for (const id of this.currentIds) {
-                const recordId = this._mapping[id];
-                if (recordId) {
-                    const record = this._cache[recordId];
-                    recordValues[id] = {};
-                    for (const fieldName of orderFieldNames) {
-                        recordValues[id][fieldName] = record.data[fieldName];
-                    }
-                } else {
-                    resIds.push(id); // id is a resId
-                }
-            }
-            // 2) fetch values for non loaded records
-            if (resIds.length) {
-                const result = await this.model.orm.read(this.resModel, resIds, orderFieldNames, {
-                    context: this.context,
-                });
-                for (const values of result) {
-                    const resId = values.id;
-                    recordValues[resId] = {};
-                    for (const fieldName of orderFieldNames) {
-                        recordValues[resId][fieldName] = values[fieldName];
-                    }
-                }
-            }
-            // 3) sort this.currentIds
-            this.currentIds.sort((id1, id2) => {
-                return compareRecords(recordValues[id1], recordValues[id2]);
-            });
-        }
-
-        await this._loadRecords();
-
-        if (!hasSeveralPages && orderFieldNames.length) {
-            this.currentIds.sort((id1, id2) => {
-                const recId1 = this._mapping[id1];
-                const recId2 = this._mapping[id2];
-                return compareRecords(this._cache[recId1].data, this._cache[recId2].data);
-            });
-        }
-
-        this.records = this._getRecords();
-    }
-
-    moveRecord() {
-        // used only in the context of a basic_relational_model
-    }
-
-    /**
-     * @returns {Array[] | null}
-     */
-    getCommands(allFields = false) {
-        if (this._commands.length) {
-            const commands = [];
-
-            const getRecordValues = (id) => {
-                const recordId = this._mapping[id];
-                if (recordId) {
-                    const record = this._cache[recordId];
-                    return record.getChanges(allFields);
-                } else {
-                    const values = {};
-                    for (const fieldName in this._initialValues[id]) {
-                        const field = this.fields[fieldName];
-                        let fieldValue = this._initialValues[id][fieldName];
-                        if (isX2Many(field)) {
-                            if (fieldValue[0][0] === DELETE_ALL) {
-                                fieldValue = fieldValue.slice(1);
-                            }
-                        }
-                        values[fieldName] = fieldValue;
-                    }
-                    return values;
-                }
-            };
-
-            const hasReplaceWithCommand = this._commands && REPLACE_WITH === this._commands[0][0];
-            if (hasReplaceWithCommand) {
-                commands.push(this._commands[0]);
-            }
-
-            for (const resId of this.currentIds) {
-                const dictCommand = this._commandsById[resId];
-                if (dictCommand) {
-                    if (dictCommand[CREATE]) {
-                        const id = (dictCommand[CREATE] || dictCommand[UPDATE])[1];
-                        commands.push(x2ManyCommands.create(id, getRecordValues(id)));
-                    } else if (dictCommand[UPDATE]) {
-                        const id = dictCommand[UPDATE][1];
-                        commands.push(x2ManyCommands.update(id, getRecordValues(id)));
-                    } else if (dictCommand[LINK_TO]) {
-                        commands.push(x2ManyCommands.linkTo(resId));
-                    }
-                } else if (!hasReplaceWithCommand) {
-                    commands.push(x2ManyCommands.linkTo(resId));
-                }
-            }
-
-            for (const command of this._commands) {
-                const code = command[0];
-                if ([DELETE, FORGET].includes(code)) {
-                    commands.push(command);
-                }
-            }
-
-            if (DELETE_ALL === this._commands[0][0] && !allFields) {
-                for (const resId of this._serverIds) {
-                    if (!this.currentIds.includes(resId)) {
-                        commands.push(x2ManyCommands.delete(resId));
-                    }
-                }
-            }
-            return commands;
-        }
-        return null;
-    }
-
-    getContext() {
-        const commands = [];
-        if (this.field.type === "one2many") {
-            if (this.currentIds) {
-                for (const resId of this.currentIds) {
-                    const record = this._cache[this._mapping[resId]];
-                    if (record && record.isNew) {
-                        commands.push(x2ManyCommands.create(resId, record.data));
-                    } else {
-                        commands.push(x2ManyCommands.linkTo(resId));
-                    }
-                }
-            }
-        } else {
-            if (this.currentIds && this.currentIds.length) {
-                commands.push(x2ManyCommands.replaceWith(this.currentIds));
-            }
-        }
-        return commands;
-    }
-
-    async replaceWith(resIds) {
-        this.applyCommand(x2ManyCommands.replaceWith(resIds));
-        await this.load();
-        await this.onChanges();
-        this.model.notify();
-    }
-
-    setCurrentIds(resIds = [], commands = []) {
-        this._serverIds = resIds;
-        this._commandsById = {}; // to remove?
-        this._commands = this._getNormalizedCommands([], commands); // modifies commands and this._commandsById in places
-        this.currentIds = this._getCurrentIds(this._serverIds, this._commands, true);
-    }
-
-    async setDataRecords(data) {
-        const proms = [];
-        this.currentIds = [];
-        this._commandsById = {};
-        this._commands = this._getNormalizedCommands([], []);
-        for (const values of data) {
-            const record = this._createRecord({ resId: values.id, mode: "readonly" });
-            this.currentIds.push(values.id);
-            proms.push(record.load({ values }));
-        }
-        await Promise.all(proms);
-        this.records = this._getRecords();
-    }
-
-    async sortBy(fieldName) {
-        if (this.orderBy.length && this.orderBy[0].name === fieldName) {
-            if (this.isOrder) {
-                this.orderBy[0].asc = !this.orderBy[0].asc;
-            }
-        } else {
-            this.orderBy = this.orderBy.filter((o) => o.name !== fieldName);
-            this.orderBy.unshift({
-                name: fieldName,
-                asc: true,
-            });
-        }
-
-        this.isOrder = true;
-        await this.load();
-        this.model.notify();
-    }
-
-    //--------------------------------------------------------------------------
-    // Private
-    //--------------------------------------------------------------------------
-
-    // TO DISCUSS AND IMP
-    _getNextMapping(mapping, commands) {
-        let nextMapping = mapping;
-        for (const command of commands) {
-            const code = command[0];
-            const id = command[1];
-
-            switch (code) {
-                case UPDATE:
-                    nextMapping[id] = mapping[id];
-                    break;
-                case LINK_TO:
-                    nextMapping[id] = mapping[id];
-                    break;
-                case DELETE_ALL:
-                    nextMapping = {};
-                    break;
-                case REPLACE_WITH:
-                    break;
-            }
-        }
-        return nextMapping;
-    }
-
-    /**
-     * @param {Object} params
-     * @returns {Record}
-     */
-    _createRecord(params = {}) {
-        const record = this.model.createDataPoint("record", {
-            resModel: this.resModel,
-            fields: this.fields,
-            activeFields: this.activeFields,
-            viewMode: this.viewMode,
-            views: this.views,
-            onRecordWillSwitchMode: this.onRecordWillSwitchMode,
-            onChanges: async () => {
-                this.applyCommand(
-                    x2ManyCommands.update(record.resId || record.virtualId, symbolValues)
-                );
-                this.onChanges();
-            },
-            rawContext: {
-                parent: this.rawContext,
-                make: () => {
-                    return makeContext([params.context], this.evalContext);
-                },
-            },
-            ...params,
-
-            getParentRecordContext: this.getParentRecordContext,
-            parentRecord: this.parentRecord,
-            relationField: this.relationField,
-        });
-        const id = record.resId || record.virtualId; // is resId sometimes changed after record creation? (for a record in a staticList)
-
-        this._mapping[id] = record.id;
-        this._cache[record.id] = record;
-
-        return record;
-    }
-
-    _getCurrentIds(currentIds, commands, serverCommands = false) {
-        let nextIds = [...currentIds];
-        for (const command of commands) {
-            const code = command[0];
-            const id = command[1];
-            switch (code) {
-                case 0: // create
-                    if (nextIds.indexOf(id) === -1) {
-                        const index =
-                            this.editable === "top" && !serverCommands
-                                ? this.offset
-                                : this.offset + this.limit - 1;
-                        nextIds.splice(index, 0, id);
-                    } else {
-                        throw new Error("you rascal");
-                    }
-                    break;
-                case 1: // update
-                    add(nextIds, id);
-                    break;
-                case 2: // delete
-                case 3: // forget
-                    remove(nextIds, id);
-                    break;
-                case 4: // linkTo
-                    add(nextIds, id);
-                    break;
-                case 5: // deleteAll
-                case 6: // replaceWith
-                    nextIds = command[2] || [];
-                    break;
-            }
-        }
-        return nextIds;
-    }
-
-    /**
-     * Returns the array of visible ids (resId or virtualId)
-     * @returns {Record[]}
-     */
-    _getDisplayedIds() {
-        const hasSeveralPages = this.limit < this.count;
-        let displayedIds = this.currentIds.slice(0);
-        if (hasSeveralPages) {
-            displayedIds = this.currentIds.slice(this.offset, this.offset + this.limit);
-        }
-        return displayedIds;
-    }
-
-    /**
-     * Concat two arrays of commands and normalize the result
-     * The first array must be normalized.
-     * ! modifies in place the commands themselves ! TODO fix this
-     * @param {Array[]} normalizedCommands normalized array of commands
-     * @param {Array[]} commands  array of commands
-     * @returns {Array[]} a normalized array of commands
-     */
-    _getNormalizedCommands(normalizedCommands, commands) {
-        let nextCommands = [...normalizedCommands];
-        for (const command of commands) {
-            const code = command[0];
-
-            if (code === CREATE && !command[1]) {
-                // FIXME WOWL: works because we change command in place (also stored in parent _changes)
-                command[1] = this.model.nextVirtualId;
-            }
-
-            const id = command[1];
-
-            if ([CREATE, UPDATE].includes(code)) {
-                if (!this._commandsById[id]) {
-                    if (!this._initialValues) {
-                        this._initialValues = {};
-                    }
-                    this._initialValues[id] = command[2];
-                }
-                command[2] = symbolValues;
-            }
-
-            if ([DELETE_ALL, REPLACE_WITH].includes(code)) {
-                this._commandsById = {};
-                nextCommands = [command];
-                continue;
-            } else if (!this._commandsById[id]) {
-                // possible problem with same ids (0) returned by server in accounting
-                // -> add a test
-                this._commandsById[id] = { [code]: command };
-                nextCommands.push(command);
-                continue;
-            }
-
-            switch (code) {
-                case UPDATE:
-                    // we assume that delete/forget cannot be found in this._commandsById[id]
-                    // we can find create/linkTo/update
-                    // we merge create/update and update/update
-                    if (this._commandsById[id][LINK_TO]) {
-                        this._commandsById[id][UPDATE] = { [UPDATE]: command };
-                        remove(nextCommands, this._commandsById[id][LINK_TO]);
-                        nextCommands.push(command);
-                    }
-                    break;
-                case DELETE:
-                    // we assume that delete/forget cannot be found in this._commandsById[id]
-                    // we can find create/linkTo/update
-                    // if one finds create, we erase everything
-                    // else we add delete and remove linkTo/update
-                    if (this._commandsById[id][UPDATE]) {
-                        remove(nextCommands, this._commandsById[id][UPDATE]);
-                    }
-                    if (this._commandsById[id][CREATE]) {
-                        remove(nextCommands, this._commandsById[id][CREATE]);
-                        delete this._commandsById[id];
-                    } else {
-                        if (this._commandsById[id][LINK_TO]) {
-                            remove(nextCommands, this._commandsById[id][LINK_TO]);
-                        }
-                        this._commandsById[id] = { [DELETE]: command };
-                        nextCommands.push(command);
-                    }
-                    break;
-                case FORGET:
-                    // we assume that delete/forget cannot be found in this._commandsById[id]
-                    // we can find create/linkTo/update
-                    // if one finds linkTo, we erase linkTo and forget
-                    if (this._commandsById[id][LINK_TO]) {
-                        remove(nextCommands, this._commandsById[id][LINK_TO]);
-                        delete this._commandsById[id][LINK_TO];
-                        // do we need to remove update?
-                    } else {
-                        this._commandsById[id][FORGET] = command;
-                        nextCommands.push(command);
-                    }
-                    break;
-                case LINK_TO:
-                    // we assume that that create/delete cannot be found in this._commandsById[id]
-                    if (this._commandsById[id][FORGET]) {
-                        delete this._commandsById[id][FORGET];
-                        remove(nextCommands, this._commandsById[id][FORGET]);
-                    } else {
-                        this._commandsById[id][LINK_TO] = command;
-                        nextCommands.push(command);
-                    }
-                    break;
-            }
-        }
-        return nextCommands;
-    }
-
-    /**
-     * Returns visible records
-     * @returns {Record[]}
-     */
-    _getRecords() {
-        const displayedIds = this._getDisplayedIds();
-        return displayedIds.map((id) => this._cache[this._mapping[id]]);
-    }
-
-    /**
-     * Add missing records to display to cache and load them
-     */
-    async _loadRecords() {
-        const displayedIds = this._getDisplayedIds();
-        const proms = [];
-        for (const id of displayedIds) {
-            const recordId = this._mapping[id];
-            if (!recordId) {
-                const key = typeof id === "number" ? "resId" : "virtualId";
-                const record = this._createRecord({ [key]: id, mode: "readonly" });
-                let changes;
-                const createCommand = this._commandsById[id] && this._commandsById[id][CREATE];
-                if (createCommand) {
-                    changes = this._initialValues[id];
-                }
-                proms.push(record.load({ changes }));
-            }
-        }
-        await Promise.all(proms);
-    }
-
-    unselectRecord() {
-        return unselectRecord(this.editedRecord);
-    }
-}
-
-StaticList.DEFAULT_LIMIT = 40;
-
-export class RelationalModel extends Model {
-    setup(params, { action, dialog, notification, rpc, user, view, company }) {
-        this.action = action;
-        this.dialogService = dialog;
-        this.notificationService = notification;
-        this.rpc = rpc;
-        this.user = user;
-        this.company = company;
-        this.viewService = view;
-        this.orm = new RequestBatcherORM(rpc, user);
-        this.keepLast = new KeepLast();
-        this.mutex = new Mutex();
-
-        this.onCreate = params.onCreate;
-        this.multiEdit = params.multiEdit || false;
-        this.defaultGroupBy = params.defaultGroupBy || false;
-        this.defaultOrderBy = params.defaultOrder;
-        this.handleField = params.handleField;
-        this.rootType = params.rootType || "list";
-        this.initialRootState = params.rootState;
-        this.rootParams = {
-            activeFields: params.activeFields || {},
-            fields: params.fields || {},
-            viewMode: params.viewMode || null,
-            resModel: params.resModel,
-            groupByInfo: params.groupByInfo,
-            onRecordSaved: params.onRecordSaved,
-            onWillSaveRecord: params.onWillSaveRecord,
-            onWillSaveMultiRecords: params.onWillSaveMultiRecords,
-            onSavedMultiRecords: params.onSavedMultiRecords,
-            onWillSetInvalidField: params.onWillSetInvalidField,
-        };
-        if (this.rootType === "record") {
-            this.rootParams.resId = params.resId;
-            this.rootParams.resIds = params.resIds;
-            if (params.mode) {
-                this.rootParams.mode = params.mode;
-            }
-        } else {
-            const { limit, countLimit, groupsLimit, openGroupsByDefault, expand } = params;
-            this.rootParams.openGroupsByDefault = openGroupsByDefault || false;
-            this.rootParams.limit = limit;
-            this.rootParams.countLimit = countLimit && Math.max(limit, countLimit);
-            this.rootParams.groupsLimit = groupsLimit;
-            this.rootParams.expand = expand;
-        }
-
-        // this.db = Object.create(null);
-        this.root = null;
-
-        this.nextId = 1;
-    }
-
-    /**
-     * @param {Object} [params={}]
-     * @param {Comparison | null} [params.comparison]
-     * @param {Context} [params.context]
-     * @param {DomainListRepr} [params.domain]
-     * @param {string[]} [params.groupBy]
-     * @param {Object[]} [params.orderBy]
-     * @param {number} [params.resId] should not be there
-     * @returns {Promise<void>}
-     */
-    async load(params = {}) {
-        const rootParams = { ...this.rootParams, ...params };
-        if (this.defaultOrderBy && !(params.orderBy && params.orderBy.length)) {
-            rootParams.orderBy = this.defaultOrderBy;
-        }
-        if (
-            this.defaultGroupBy &&
-            !this.env.inDialog &&
-            !(params.groupBy && params.groupBy.length)
-        ) {
-            rootParams.groupBy = [this.defaultGroupBy];
-        }
-
-        if (rootParams.context) {
-            // *_view_ref and search_default_* context keys are not destined to us, rather
-            // they were tyîcally "consumed" by the View.
-            // The default_* context keys are, on the contrary, destined for us.
-            rootParams.context = Object.fromEntries(
-                Object.entries(rootParams.context).filter(
-                    ([key]) => !key.endsWith("_view_ref") && !key.startsWith("search_default_")
-                )
-            );
-        }
-        rootParams.rawContext = {
-            make: () => {
-                return makeContext([rootParams.context], {});
-            },
-        };
-        const state = this.root
-            ? Object.assign(this.root.exportState(), { offset: 0 })
-            : this.initialRootState;
-        const newRoot = this.createDataPoint(this.rootType, rootParams, state);
-        await this.keepLast.add(newRoot.load({ values: params.values }));
-        this.root = newRoot;
-        this.rootParams = rootParams;
-        this.notify();
-    }
-
-    /**
-     * @param {"group" | "list" | "record"} type
-     * @param {Record<any, any>} params
-     * @param {Record<any, any>} [state={}]
-     * @returns {DataPoint}
-     */
-    createDataPoint(type, params, state = {}) {
-        let DpClass;
-        switch (type) {
-            case "group": {
-                DpClass = this.constructor.Group;
-                break;
-            }
-            case "list": {
-                if ((params.groupBy || []).length) {
-                    DpClass = this.constructor.DynamicGroupList;
-                } else {
-                    DpClass = this.constructor.DynamicRecordList;
-                }
-                break;
-            }
-            case "record": {
-                DpClass = this.constructor.Record;
-                break;
-            }
-            case "static_list": {
-                DpClass = this.constructor.StaticList;
-                break;
-            }
-        }
-        return new DpClass(this, params, state);
-    }
-
-    hasData() {
-        return this.root.count > 0;
-    }
-
-    get nextVirtualId() {
-        return `virtual_${this.nextId++}`;
-    }
-
-    /**
-     * @override
-     */
-    getGroups() {
-        return this.root.groups && this.root.groups.length ? this.root.groups : null;
-    }
-
-    /**
-     * Reloads a given record and all related records (those sharing the same resId).
-     * A "record-updated" event containing the given and related records is then
-     * triggered on the model.
-     *
-     * @param {Record} record
-     */
-    async reloadRecords(record) {
-        const records = this.rootType === "record" ? [this.root] : this.root.records;
-        const relatedRecords = records.filter(
-            (r) => r.id !== record.id && r.resId === record.resId
-        );
-
-        await Promise.all([record, ...relatedRecords].map((r) => r.load()));
-
-        this.bus.trigger("record-updated", { record, relatedRecords });
-        this.notify();
-    }
-}
-
-RelationalModel.services = ["action", "dialog", "notification", "rpc", "user", "view", "company"];
-RelationalModel.Record = Record;
-RelationalModel.Group = Group;
-RelationalModel.DynamicRecordList = DynamicRecordList;
-RelationalModel.DynamicGroupList = DynamicGroupList;
-RelationalModel.StaticList = StaticList;
diff --git a/addons/web/static/src/views/utils.js b/addons/web/static/src/views/utils.js
index 2ca88ca41f9..7c83e61ae40 100644
--- a/addons/web/static/src/views/utils.js
+++ b/addons/web/static/src/views/utils.js
@@ -1,15 +1,11 @@
 /** @odoo-module */
 
-import { Domain } from "@web/core/domain";
 import { _t } from "@web/core/l10n/translation";
 import { registry } from "@web/core/registry";
 
 export const X2M_TYPES = ["one2many", "many2many"];
-const RELATIONAL_TYPES = [...X2M_TYPES, "many2one"];
 const NUMERIC_TYPES = ["integer", "float", "monetary"];
 
-/** @typedef {import("./relational_model").OrderTerm} OrderTerm */
-
 /**
  * @typedef ViewActiveActions {
  * @property {"view"} type
@@ -69,7 +65,7 @@ export function addDependencies(deps, activeFields, fields) {
             };
         }
         if (!(name in fields)) {
-            fields[name] = { ...dependency };
+            fields[name] = { ...dependency, name };
         }
     }
 }
@@ -173,18 +169,6 @@ export const computeReportMeasures = (fields, fieldAttrs, activeMeasures) => {
     return Object.fromEntries(sortedMeasures);
 };
 
-/**
- * @param {Array[] | boolean} modifier
- * @param {Object} evalContext
- * @returns {boolean}
- */
-export function evalDomain(modifier, evalContext) {
-    if (modifier && typeof modifier !== "boolean") {
-        modifier = new Domain(modifier).contains(evalContext);
-    }
-    return Boolean(modifier);
-}
-
 /**
  * @param {String} fieldName
  * @param {Object} rawAttrs
@@ -242,32 +226,6 @@ export function getDecoration(rootNode) {
     return decorations;
 }
 
-/**
- * @param {number | number[]} idsList
- * @returns {number[]}
- */
-export function getIds(idsList) {
-    if (Array.isArray(idsList)) {
-        if (idsList.length === 2 && typeof idsList[1] === "string") {
-            return [idsList[0]];
-        } else {
-            return idsList;
-        }
-    } else if (idsList) {
-        return [idsList];
-    } else {
-        return [];
-    }
-}
-
-/**
- * @param {any} field
- * @returns {boolean}
- */
-export function isRelational(field) {
-    return field && RELATIONAL_TYPES.includes(field.type);
-}
-
 /**
  * @param {any} field
  * @returns {boolean}
@@ -338,44 +296,6 @@ export function processMeasure(measure) {
     return measure === "__count__" ? "__count" : measure;
 }
 
-/**
- * @typedef {Object} OrderTerm ?
- * @property {string} name
- * @property {boolean} asc
- */
-
-/**
- * @param {OrderTerm[]} orderBy
- * @returns {string}
- */
-export function orderByToString(orderBy) {
-    return orderBy.map((o) => `${o.name} ${o.asc ? "ASC" : "DESC"}`).join(", ");
-}
-
-/**
- * @param {any} string
- * @return {OrderTerm[]}
- */
-export function stringToOrderBy(string) {
-    if (!string) {
-        return [];
-    }
-    return string.split(",").map((order) => {
-        const splitOrder = order.trim().split(" ");
-        if (splitOrder.length === 2) {
-            return {
-                name: splitOrder[0],
-                asc: splitOrder[1].toLowerCase() === "asc",
-            };
-        } else {
-            return {
-                name: splitOrder[0],
-                asc: true,
-            };
-        }
-    });
-}
-
 /**
  * Transforms a string into a valid expression to be injected
  * in a template as a props via setAttribute.
diff --git a/addons/web/static/src/views/view.js b/addons/web/static/src/views/view.js
index 79a18639362..3519f6bcde2 100644
--- a/addons/web/static/src/views/view.js
+++ b/addons/web/static/src/views/view.js
@@ -69,7 +69,7 @@ export function getDefaultConfig() {
     return config;
 }
 
-/** @typedef {import("./relational_model").OrderTerm} OrderTerm */
+/** @typedef {import("./utils").OrderTerm} OrderTerm */
 
 /** @typedef {Object} ViewProps
  *  @property {string} resModel
diff --git a/addons/web/static/src/views/view_button/view_button_hook.js b/addons/web/static/src/views/view_button/view_button_hook.js
index 2117a614ec1..09dcf5a4726 100644
--- a/addons/web/static/src/views/view_button/view_button_hook.js
+++ b/addons/web/static/src/views/view_button/view_button_hook.js
@@ -74,9 +74,8 @@ export function useViewButtons(model, ref, options = {}) {
                     buttonContext,
                     onClose: async () => {
                         if (!closeDialog && status(comp) !== "destroyed") {
-                            const reload = options.reload || (() => model.root.load());
+                            const reload = options.reload || (() => model.load());
                             await reload();
-                            comp.render(true); // FIXME WOWL reactivity
                         }
                     },
                 });
diff --git a/addons/web/static/src/views/view_dialogs/form_view_dialog.js b/addons/web/static/src/views/view_dialogs/form_view_dialog.js
index 24debf95c3b..7d7fbe0d7f7 100644
--- a/addons/web/static/src/views/view_dialogs/form_view_dialog.js
+++ b/addons/web/static/src/views/view_dialogs/form_view_dialog.js
@@ -35,7 +35,7 @@ export class FormViewDialog extends Component {
                 this.props.close();
             },
             saveRecord: async (record, { saveAndNew }) => {
-                const saved = await record.save({ stayInEdition: true, noReload: true });
+                const saved = await record.save({ noReload: true });
                 if (saved) {
                     await this.props.onRecordSaved(record);
                     if (saveAndNew) {
@@ -45,7 +45,7 @@ export class FormViewDialog extends Component {
                                 delete context[k];
                             }
                         });
-                        await record.model.load({ resId: null, context });
+                        await record.model.load({ resId: false, context });
                     } else {
                         this.props.close();
                     }
diff --git a/addons/web/static/src/views/widgets/attach_document/attach_document.js b/addons/web/static/src/views/widgets/attach_document/attach_document.js
index 161998ac370..030f3884598 100644
--- a/addons/web/static/src/views/widgets/attach_document/attach_document.js
+++ b/addons/web/static/src/views/widgets/attach_document/attach_document.js
@@ -57,12 +57,11 @@ export class AttachDocumentWidget extends Component {
     async onFileUploaded(files) {
         const { action, record } = this.props;
         if (action) {
-            const { model, resId, resModel } = record;
+            const { resId, resModel } = record;
             await this.env.services.orm.call(resModel, action, [resId], {
                 attachment_ids: files.map((file) => file.id),
             });
             await record.load();
-            model.notify();
         }
     }
 
diff --git a/addons/web/static/src/views/widgets/widget.js b/addons/web/static/src/views/widgets/widget.js
index ff81d46ff6c..0cb5a77f1c4 100644
--- a/addons/web/static/src/views/widgets/widget.js
+++ b/addons/web/static/src/views/widgets/widget.js
@@ -1,8 +1,8 @@
 /* @odoo-module */
 
+import { evalDomain } from "@web/core/domain";
 import { evaluateExpr } from "@web/core/py_js/py";
 import { registry } from "@web/core/registry";
-import { evalDomain } from "@web/views/utils";
 
 import { Component, xml } from "@odoo/owl";
 const viewWidgetRegistry = registry.category("view_widgets");
diff --git a/addons/web/static/src/webclient/actions/action_service.js b/addons/web/static/src/webclient/actions/action_service.js
index cb489325115..86f860c23ca 100644
--- a/addons/web/static/src/webclient/actions/action_service.js
+++ b/addons/web/static/src/webclient/actions/action_service.js
@@ -673,6 +673,9 @@ function makeActionManager(env) {
                 onError(this.onError);
             }
             onError(error) {
+                if (!this.isMounted) {
+                    reject(error);
+                }
                 cleanDomFromBootstrap();
                 if (this.isMounted) {
                     // the error occurred on the controller which is
@@ -768,7 +771,6 @@ function makeActionManager(env) {
         ControllerComponent.props = {
             "*": true,
         };
-
         let nextDialog = null;
         if (action.target === "new") {
             cleanDomFromBootstrap();
diff --git a/addons/web/static/src/webclient/settings_form_view/settings_form_controller.js b/addons/web/static/src/webclient/settings_form_view/settings_form_controller.js
index 920b6403ad6..03a3638129f 100644
--- a/addons/web/static/src/webclient/settings_form_view/settings_form_controller.js
+++ b/addons/web/static/src/webclient/settings_form_view/settings_form_controller.js
@@ -41,6 +41,16 @@ export class SettingsFormController extends formView.Controller {
         this.initialApp = "module" in this.props.context ? this.props.context.module : "";
     }
 
+    get modelParams() {
+        const headerFields = Object.values(this.archInfo.fieldNodes)
+            .filter((fieldNode) => fieldNode.options.isHeaderField)
+            .map((fieldNode) => fieldNode.name);
+        return {
+            ...super.modelParams,
+            headerFields,
+        };
+    }
+
     /**
      * @override
      */
@@ -49,7 +59,7 @@ export class SettingsFormController extends formView.Controller {
             return true;
         }
         if (
-            this.model.root.isDirty &&
+            (await this.model.root.isDirty()) &&
             !["execute"].includes(clickParams.name) &&
             !clickParams.noSaveDialog
         ) {
@@ -63,8 +73,9 @@ export class SettingsFormController extends formView.Controller {
         return this.env._t("Settings");
     }
 
-    beforeLeave() {
-        if (this.model.root.isDirty) {
+    async beforeLeave() {
+        const dirty = await this.model.root.isDirty();
+        if (dirty) {
             return this._confirmSave();
         }
     }
@@ -116,7 +127,7 @@ export class SettingsFormController extends formView.Controller {
                 },
                 cancel: async () => {
                     await this.model.root.discard();
-                    await this.model.root.save({ stayInEdition: true });
+                    await this.model.root.save();
                     _continue = true;
                     resolve();
                 },
diff --git a/addons/web/static/src/webclient/settings_form_view/settings_form_view.js b/addons/web/static/src/webclient/settings_form_view/settings_form_view.js
index 0ed51eae429..690d2f96e2e 100644
--- a/addons/web/static/src/webclient/settings_form_view/settings_form_view.js
+++ b/addons/web/static/src/webclient/settings_form_view/settings_form_view.js
@@ -1,44 +1,47 @@
 /** @odoo-module **/
 
 import { registry } from "@web/core/registry";
+import { intersection } from "@web/core/utils/arrays";
 import { ControlPanel } from "@web/search/control_panel/control_panel";
 import { formView } from "@web/views/form/form_view";
 import { SettingsFormController } from "./settings_form_controller";
 import { SettingsFormRenderer } from "./settings_form_renderer";
 import { SettingsFormCompiler } from "./settings_form_compiler";
-import BasicModel from "web.BasicModel";
 import { SettingsArchParser } from "./settings_form_arch_parser";
 
-const BaseSettingsModel = BasicModel.extend({
-    isNew(id) {
-        return this.localData[id].model === "res.config.settings"
-            ? true
-            : this._super.apply(this, arguments);
-    },
-    _applyChange: function (recordID, changes, options) {
-        // Check if the changes isHeaderField.
-        const record = this.localData[recordID];
-        let isHeaderField = false;
-        for (const fieldName of Object.keys(changes)) {
-            const fieldInfo = record.fieldsInfo[options.viewType][fieldName];
-            isHeaderField = fieldInfo.options && fieldInfo.options.isHeaderField;
+class SettingRecord extends formView.Model.Record {
+    _update(changes) {
+        const changedFields = Object.keys(changes);
+        let dirty = true;
+        if (intersection(changedFields, this.model._headerFields).length === changedFields.length) {
+            dirty = this.dirty;
         }
-        if (isHeaderField) {
-            options.doNotSetDirty = true;
-        }
-        return this._super.apply(this, arguments);
-    },
-});
+        const prom = super._update(...arguments);
+        this.dirty = dirty;
+        return prom;
+    }
+}
 
-class SettingsRelationalModel extends formView.Model {}
-SettingsRelationalModel.LegacyModel = BaseSettingsModel;
+class SettingModel extends formView.Model {
+    setup(params) {
+        super.setup(...arguments);
+        this._headerFields = params.headerFields;
+    }
+    _getNextConfig() {
+        const nextConfig = super._getNextConfig(...arguments);
+        nextConfig.resId = false;
+        return nextConfig;
+    }
+
+}
+SettingModel.Record = SettingRecord;
 
 export const settingsFormView = {
     ...formView,
     display: {},
     buttonTemplate: "web.SettingsFormView.Buttons",
     ArchParser: SettingsArchParser,
-    Model: SettingsRelationalModel,
+    Model: SettingModel,
     ControlPanel: ControlPanel,
     Controller: SettingsFormController,
     Compiler: SettingsFormCompiler,
diff --git a/addons/web/static/src/webclient/settings_form_view/settings_form_view.xml b/addons/web/static/src/webclient/settings_form_view/settings_form_view.xml
index 49703eefec2..003882caf32 100644
--- a/addons/web/static/src/webclient/settings_form_view/settings_form_view.xml
+++ b/addons/web/static/src/webclient/settings_form_view/settings_form_view.xml
@@ -41,7 +41,7 @@
             <attribute name="class" add="order-first w-auto" separator=" "/>
         </xpath>
         <xpath expr="//div[hasclass('o_cp_buttons')]" position="after">
-            <span t-if="model.root.isDirty" class="text-muted ms-2 o_dirty_warning">Unsaved changes</span>
+            <span t-if="model.root.dirty" class="text-muted ms-2 o_dirty_warning">Unsaved changes</span>
         </xpath>
     </t>
 </templates>
diff --git a/addons/web/static/tests/core/debug/debug_manager_tests.js b/addons/web/static/tests/core/debug/debug_manager_tests.js
index 70e7eef664b..1fd8d4db4e9 100644
--- a/addons/web/static/tests/core/debug/debug_manager_tests.js
+++ b/addons/web/static/tests/core/debug/debug_manager_tests.js
@@ -381,7 +381,7 @@ QUnit.module("DebugMenu", (hooks) => {
         assert.containsOnce(target, ".breadcrumb-item");
         assert.containsOnce(target, ".o_breadcrumb .active");
         assert.strictEqual(target.querySelector(".o_breadcrumb .active").textContent, "Edit view");
-        assert.strictEqual(target.querySelector(".o_field_widget[name=id] input").value, "18");
+        assert.strictEqual(target.querySelector(".o_field_widget[name=id]").textContent, "18");
 
         await click(target, ".breadcrumb .o_back_button");
         assert.containsOnce(target, ".o_breadcrumb .active");
@@ -425,7 +425,7 @@ QUnit.module("DebugMenu", (hooks) => {
         assert.containsOnce(target, ".breadcrumb-item");
         assert.containsOnce(target, ".o_breadcrumb .active");
         assert.strictEqual(target.querySelector(".o_breadcrumb .active").textContent, "Edit view");
-        assert.strictEqual(target.querySelector(".o_field_widget[name=id] input").value, "293");
+        assert.strictEqual(target.querySelector(".o_field_widget[name=id]").textContent, "293");
     });
 
     QUnit.test("edit search view on action without search_view_id", async (assert) => {
@@ -488,7 +488,7 @@ QUnit.module("DebugMenu", (hooks) => {
         assert.containsOnce(target, ".breadcrumb-item");
         assert.containsOnce(target, ".o_breadcrumb .active");
         assert.strictEqual(target.querySelector(".o_breadcrumb .active").textContent, "Edit view");
-        assert.strictEqual(target.querySelector(".o_field_widget[name=id] input").value, "293");
+        assert.strictEqual(target.querySelector(".o_field_widget[name=id]").textContent, "293");
     });
 
     QUnit.test(
diff --git a/addons/web/static/tests/core/orm_service_tests.js b/addons/web/static/tests/core/orm_service_tests.js
index 9de164cfa6d..e958fb6b430 100644
--- a/addons/web/static/tests/core/orm_service_tests.js
+++ b/addons/web/static/tests/core/orm_service_tests.js
@@ -154,7 +154,7 @@ QUnit.test("nameGet method", async (assert) => {
     await env.services.orm.nameGet("sale.order", [2, 5], { context });
     assert.strictEqual(query.route, "/web/dataset/call_kw/sale.order/read");
     assert.deepEqual(query.params, {
-        args: [[2, 5], ['display_name']],
+        args: [[2, 5], ["display_name"]],
         kwargs: {
             context: {
                 complete: true,
@@ -361,7 +361,7 @@ QUnit.test("webSearchRead method", async (assert) => {
     });
 });
 
-QUnit.test("useModel is specialized for component", async (assert) => {
+QUnit.test("orm is specialized for component", async (assert) => {
     const [, /* query */ rpc] = makeFakeRPC();
     serviceRegistry.add("rpc", rpc);
     const env = await makeTestEnv();
diff --git a/addons/web/static/tests/core/utils/hooks_tests.js b/addons/web/static/tests/core/utils/hooks_tests.js
index ea5fec64e8b..3fe046f811c 100644
--- a/addons/web/static/tests/core/utils/hooks_tests.js
+++ b/addons/web/static/tests/core/utils/hooks_tests.js
@@ -503,6 +503,81 @@ QUnit.module("utils", () => {
             assert.strictEqual(nbCalls, 8);
         });
 
+        QUnit.test("useService: async service with protected methods", async function (assert) {
+            let nbCalls = 0;
+            let def = makeDeferred();
+            class MyComponent extends Component {
+                setup() {
+                    this.objectService = useService("object_service");
+                    this.functionService = useService("function_service");
+                }
+            }
+            MyComponent.template = xml`<div/>`;
+
+            serviceRegistry.add("object_service", {
+                name: "object_service",
+                async: ["asyncMethod"],
+                start() {
+                    return {
+                        async asyncMethod() {
+                            nbCalls++;
+                            await def;
+                            return this;
+                        },
+                    };
+                },
+            });
+
+            serviceRegistry.add("function_service", {
+                name: "function_service",
+                async: true,
+                start() {
+                    return async function asyncFunc() {
+                        nbCalls++;
+                        await def;
+                        return this;
+                    };
+                },
+            });
+
+            const env = await makeTestEnv();
+            const target = getFixture();
+
+            const comp = await mount(MyComponent, target, { env });
+            // Functions and methods have the correct this
+            def.resolve();
+            assert.deepEqual(await comp.objectService.asyncMethod(), comp.objectService);
+            assert.deepEqual(await comp.objectService.asyncMethod.call("boundThis"), "boundThis");
+            assert.deepEqual(await comp.functionService(), comp);
+            assert.deepEqual(await comp.functionService.call("boundThis"), "boundThis");
+            assert.strictEqual(nbCalls, 4);
+            // Functions that were called before the component is destroyed but resolved after never resolve
+            let nbResolvedProms = 0;
+            def = makeDeferred();
+            comp.objectService.asyncMethod().then(() => nbResolvedProms++);
+            comp.objectService.asyncMethod.call("boundThis").then(() => nbResolvedProms++);
+            comp.functionService().then(() => nbResolvedProms++);
+            comp.functionService.call("boundThis").then(() => nbResolvedProms++);
+            assert.strictEqual(nbCalls, 8);
+            comp.__owl__.app.destroy();
+            def.resolve();
+            await nextTick();
+            assert.strictEqual(
+                nbResolvedProms,
+                0,
+                "The promises returned by the calls should never resolve"
+            );
+            // Calling the functions after the destruction rejects the promise
+            assert.rejects(comp.objectService.asyncMethod(), "Component is destroyed");
+            assert.rejects(
+                comp.objectService.asyncMethod.call("boundThis"),
+                "Component is destroyed"
+            );
+            assert.rejects(comp.functionService(), "Component is destroyed");
+            assert.rejects(comp.functionService.call("boundThis"), "Component is destroyed");
+            assert.strictEqual(nbCalls, 8);
+        });
+
         QUnit.module("useSpellCheck");
 
         QUnit.test("useSpellCheck: ref is on the textarea", async function (assert) {
diff --git a/addons/web/static/tests/core/utils/timing_tests.js b/addons/web/static/tests/core/utils/timing_tests.js
index 722865eff4e..8d0c15e4289 100644
--- a/addons/web/static/tests/core/utils/timing_tests.js
+++ b/addons/web/static/tests/core/utils/timing_tests.js
@@ -3,6 +3,7 @@
 import { Component, xml } from "@odoo/owl";
 import { browser } from "@web/core/browser/browser";
 import {
+    batched,
     debounce,
     throttleForAnimation,
     useDebounced,
@@ -19,233 +20,432 @@ import {
     destroy,
 } from "../../helpers/utils";
 
+function nextMicroTick() {
+    return Promise.resolve();
+}
+
+function nextAnimationFrame() {
+    return new Promise((resolve) => window.requestAnimationFrame(resolve));
+}
+
+function nextSetTimeout() {
+    return new Promise(setTimeout);
+}
+
 QUnit.module("utils", () => {
-    QUnit.module("timing");
+    QUnit.module("timing", () => {
+        QUnit.test("debounce on an async function", async function (assert) {
+            let callback;
+            patchWithCleanup(browser, {
+                setTimeout: (later) => {
+                    callback = later;
+                },
+            });
+            const imSearchDef = makeDeferred();
+            const myFunc = () => {
+                assert.step("myFunc");
+                return imSearchDef;
+            };
+            const myDebouncedFunc = debounce(myFunc, 3000);
+            myDebouncedFunc().then(() => {
+                throw new Error("Should never be resolved");
+            });
+            myDebouncedFunc().then((x) => {
+                assert.step("resolved " + x);
+            });
+            assert.verifySteps([]);
+            callback();
+            assert.verifySteps(["myFunc"]);
+            imSearchDef.resolve(42);
+            await Promise.resolve(); // wait for promise returned by myFunc
+            await Promise.resolve(); // wait for promise returned by debounce
 
-    QUnit.test("debounce on an async function", async function (assert) {
-        let callback;
-        patchWithCleanup(browser, {
-            setTimeout: (later) => {
-                callback = later;
-            },
-        });
-        const imSearchDef = makeDeferred();
-        const myFunc = () => {
-            assert.step("myFunc");
-            return imSearchDef;
-        };
-        const myDebouncedFunc = debounce(myFunc, 3000);
-        myDebouncedFunc().then(() => {
-            throw new Error("Should never be resolved");
-        });
-        myDebouncedFunc().then((x) => {
-            assert.step("resolved " + x);
-        });
-        assert.verifySteps([]);
-        callback();
-        assert.verifySteps(["myFunc"]);
-        imSearchDef.resolve(42);
-        await Promise.resolve(); // wait for promise returned by myFunc
-        await Promise.resolve(); // wait for promise returned by debounce
-
-        assert.verifySteps(["resolved 42"]);
-    });
-
-    QUnit.test("debounce on a sync function", async function (assert) {
-        let callback;
-        patchWithCleanup(browser, {
-            setTimeout: (later) => {
-                callback = later;
-            },
-        });
-        const myFunc = () => {
-            assert.step("myFunc");
-            return 42;
-        };
-        const myDebouncedFunc = debounce(myFunc, 3000);
-        myDebouncedFunc().then(() => {
-            throw new Error("Should never be resolved");
-        });
-        myDebouncedFunc().then((x) => {
-            assert.step("resolved " + x);
-        });
-        assert.verifySteps([]);
-        callback();
-        assert.verifySteps(["myFunc"]);
-        await Promise.resolve(); // wait for promise returned by myFunc
-        await Promise.resolve(); // wait for promise returned by debounce
-
-        assert.verifySteps(["resolved 42"]);
-    });
-
-    QUnit.test("debounce with immediate", async function (assert) {
-        const { execRegisteredTimeouts } = mockTimeout();
-        const myFunc = () => {
-            assert.step("myFunc");
-            return 42;
-        };
-        const myDebouncedFunc = debounce(myFunc, 3000, { immediate: true });
-        myDebouncedFunc().then((x) => {
-            assert.step("resolved " + x);
-        });
-        assert.verifySteps(["myFunc"]);
-        await Promise.resolve(); // wait for promise returned by debounce
-        await Promise.resolve(); // wait for promise returned chained onto it (step resolved x)
-        assert.verifySteps(["resolved 42"]);
-
-        myDebouncedFunc().then((x) => {
-            assert.step("resolved " + x);
-        });
-        await execRegisteredTimeouts();
-        assert.verifySteps([]); // not called 3000ms did not elapse between the previous call and the first
-
-        myDebouncedFunc().then((x) => {
-            assert.step("resolved " + x);
-        });
-        assert.verifySteps(["myFunc"]);
-        await Promise.resolve(); // wait for promise returned by debounce
-        await Promise.resolve(); // wait for promise returned chained onto it (step resolved x)
-        assert.verifySteps(["resolved 42"]);
-    });
-
-    QUnit.test("debounce with 'animationFrame' delay", async function (assert) {
-        const { execRegisteredTimeouts } = mockTimeout();
-        const { execRegisteredAnimationFrames } = mockAnimationFrame();
-        const myFunc = () => {
-            assert.step("myFunc");
-        };
-        debounce(myFunc, "animationFrame")();
-        assert.verifySteps([]);
-
-        execRegisteredTimeouts(); // should have no effect as we wait for the animation frame
-        assert.verifySteps([]);
-
-        execRegisteredAnimationFrames(); // should call the function
-        assert.verifySteps(["myFunc"]);
-    });
-
-    QUnit.test("debounced call can be cancelled", async function (assert) {
-        assert.expect(3);
-        const { execRegisteredTimeouts } = mockTimeout();
-        const myFunc = () => {
-            assert.step("myFunc");
-        };
-        const myDebouncedFunc = debounce(myFunc, 3000);
-        myDebouncedFunc();
-        myDebouncedFunc.cancel();
-        execRegisteredTimeouts();
-        assert.verifySteps([], "Debounced call was cancelled");
-
-        myDebouncedFunc();
-        execRegisteredTimeouts();
-        assert.verifySteps(["myFunc"], "Debounced call was not cancelled");
-    });
-
-    QUnit.test("throttleForAnimation", async (assert) => {
-        const { advanceFrame, execRegisteredAnimationFrames } = mockAnimationFrame();
-        const throttledFn = throttleForAnimation((val) => {
-            assert.step(`${val}`);
+            assert.verifySteps(["resolved 42"]);
         });
 
-        // A single call is executed immediately
-        throttledFn(1);
-        assert.verifySteps(["1"], "has been called on the leading edge");
-        execRegisteredAnimationFrames();
-        assert.verifySteps([], "has not been called");
+        QUnit.test("debounce on a sync function", async function (assert) {
+            let callback;
+            patchWithCleanup(browser, {
+                setTimeout: (later) => {
+                    callback = later;
+                },
+            });
+            const myFunc = () => {
+                assert.step("myFunc");
+                return 42;
+            };
+            const myDebouncedFunc = debounce(myFunc, 3000);
+            myDebouncedFunc().then(() => {
+                throw new Error("Should never be resolved");
+            });
+            myDebouncedFunc().then((x) => {
+                assert.step("resolved " + x);
+            });
+            assert.verifySteps([]);
+            callback();
+            assert.verifySteps(["myFunc"]);
+            await Promise.resolve(); // wait for promise returned by myFunc
+            await Promise.resolve(); // wait for promise returned by debounce
 
-        // Successive calls
-        throttledFn(1);
-        assert.verifySteps(["1"], "has been called on the leading edge");
-        throttledFn(2);
-        throttledFn(3);
-        assert.verifySteps([], "has not been called");
-        execRegisteredAnimationFrames();
-        assert.verifySteps(["3"], "only the last queued call was executed");
+            assert.verifySteps(["resolved 42"]);
+        });
 
-        // Can be cancelled
-        throttledFn(1);
-        assert.verifySteps(["1"], "has been called on the leading edge");
-        throttledFn(2);
-        throttledFn(3);
-        throttledFn.cancel();
-        execRegisteredAnimationFrames();
-        assert.verifySteps([], "queued throttled function calls were cancelled correctly");
+        QUnit.test("debounce with immediate", async function (assert) {
+            const { execRegisteredTimeouts } = mockTimeout();
+            const myFunc = () => {
+                assert.step("myFunc");
+                return 42;
+            };
+            const myDebouncedFunc = debounce(myFunc, 3000, { immediate: true });
+            myDebouncedFunc().then((x) => {
+                assert.step("resolved " + x);
+            });
+            assert.verifySteps(["myFunc"]);
+            await Promise.resolve(); // wait for promise returned by debounce
+            await Promise.resolve(); // wait for promise returned chained onto it (step resolved x)
+            assert.verifySteps(["resolved 42"]);
 
-        // Successive calls: more precise timing case
-        throttledFn(1);
-        assert.verifySteps(["1"], "has been called on the leading edge");
-        await advanceFrame();
-        throttledFn(2);
-        assert.verifySteps(["2"], "has been called on the leading edge");
-        throttledFn(3);
-        throttledFn(4);
-        await advanceFrame();
-        assert.verifySteps(["4"], "last call is executed on the trailing edge");
-        execRegisteredAnimationFrames();
-        assert.verifySteps([], "has not been called");
-    });
+            myDebouncedFunc().then((x) => {
+                assert.step("resolved " + x);
+            });
+            await execRegisteredTimeouts();
+            assert.verifySteps([]); // not called 3000ms did not elapse between the previous call and the first
 
-    QUnit.module("timing > hooks");
+            myDebouncedFunc().then((x) => {
+                assert.step("resolved " + x);
+            });
+            assert.verifySteps(["myFunc"]);
+            await Promise.resolve(); // wait for promise returned by debounce
+            await Promise.resolve(); // wait for promise returned chained onto it (step resolved x)
+            assert.verifySteps(["resolved 42"]);
+        });
 
-    QUnit.test("useDebounced: cancels on comp destroy", async function (assert) {
-        const { advanceTime } = mockTimeout();
-        class C extends Component {
-            static template = xml`<button class="c" t-on-click="debounced">C</button>`;
-            setup() {
-                this.debounced = useDebounced(() => assert.step("debounced"), 1000);
-            }
-        }
-        const fixture = getFixture();
-        const comp = await mount(C, fixture);
-        assert.verifySteps([]);
-        assert.containsOnce(fixture, "button.c");
+        QUnit.test("debounce with 'animationFrame' delay", async function (assert) {
+            const { execRegisteredTimeouts } = mockTimeout();
+            const { execRegisteredAnimationFrames } = mockAnimationFrame();
+            const myFunc = () => {
+                assert.step("myFunc");
+            };
+            debounce(myFunc, "animationFrame")();
+            assert.verifySteps([]);
 
-        await click(fixture, "button.c");
-        await advanceTime(999);
-        assert.verifySteps([]);
-        await advanceTime(1);
-        assert.verifySteps(["debounced"]);
+            execRegisteredTimeouts(); // should have no effect as we wait for the animation frame
+            assert.verifySteps([]);
 
-        await click(fixture, "button.c");
-        await advanceTime(999);
-        assert.verifySteps([]);
-        destroy(comp);
-        await advanceTime(1);
-        assert.verifySteps([]);
-    });
+            execRegisteredAnimationFrames(); // should call the function
+            assert.verifySteps(["myFunc"]);
+        });
 
-    QUnit.test("useThrottleForAnimation: cancels on comp destroy", async function (assert) {
-        const { advanceFrame, execRegisteredAnimationFrames } = mockAnimationFrame();
-        class C extends Component {
-            static template = xml`<button class="c" t-on-click="throttled">C</button>`;
-            setup() {
-                this.throttled = useThrottleForAnimation(() => assert.step("throttled"), 1000);
-            }
-        }
-        const fixture = getFixture();
-        const comp = await mount(C, fixture);
-        assert.verifySteps([]);
-        assert.containsOnce(fixture, "button.c");
+        QUnit.test("debounced call can be cancelled", async function (assert) {
+            assert.expect(3);
+            const { execRegisteredTimeouts } = mockTimeout();
+            const myFunc = () => {
+                assert.step("myFunc");
+            };
+            const myDebouncedFunc = debounce(myFunc, 3000);
+            myDebouncedFunc();
+            myDebouncedFunc.cancel();
+            execRegisteredTimeouts();
+            assert.verifySteps([], "Debounced call was cancelled");
 
-        // Without destroy
-        await click(fixture, "button.c");
-        assert.verifySteps(["throttled"]);
-        await click(fixture, "button.c");
-        assert.verifySteps([]);
-        await advanceFrame();
-        assert.verifySteps(["throttled"]);
+            myDebouncedFunc();
+            execRegisteredTimeouts();
+            assert.verifySteps(["myFunc"], "Debounced call was not cancelled");
+        });
 
-        // Clean restart
-        execRegisteredAnimationFrames();
-        assert.verifySteps([]);
+        QUnit.test("throttleForAnimation", async (assert) => {
+            const { advanceFrame, execRegisteredAnimationFrames } = mockAnimationFrame();
+            const throttledFn = throttleForAnimation((val) => {
+                assert.step(`${val}`);
+            });
 
-        // With destroy
-        await click(fixture, "button.c");
-        assert.verifySteps(["throttled"]);
-        await click(fixture, "button.c");
-        assert.verifySteps([]);
-        destroy(comp);
-        await advanceFrame();
-        assert.verifySteps([]);
+            // A single call is executed immediately
+            throttledFn(1);
+            assert.verifySteps(["1"], "has been called on the leading edge");
+            execRegisteredAnimationFrames();
+            assert.verifySteps([], "has not been called");
+
+            // Successive calls
+            throttledFn(1);
+            assert.verifySteps(["1"], "has been called on the leading edge");
+            throttledFn(2);
+            throttledFn(3);
+            assert.verifySteps([], "has not been called");
+            execRegisteredAnimationFrames();
+            assert.verifySteps(["3"], "only the last queued call was executed");
+
+            // Can be cancelled
+            throttledFn(1);
+            assert.verifySteps(["1"], "has been called on the leading edge");
+            throttledFn(2);
+            throttledFn(3);
+            throttledFn.cancel();
+            execRegisteredAnimationFrames();
+            assert.verifySteps([], "queued throttled function calls were cancelled correctly");
+
+            // Successive calls: more precise timing case
+            throttledFn(1);
+            assert.verifySteps(["1"], "has been called on the leading edge");
+            await advanceFrame();
+            throttledFn(2);
+            assert.verifySteps(["2"], "has been called on the leading edge");
+            throttledFn(3);
+            throttledFn(4);
+            await advanceFrame();
+            assert.verifySteps(["4"], "last call is executed on the trailing edge");
+            execRegisteredAnimationFrames();
+            assert.verifySteps([], "has not been called");
+        });
+
+        QUnit.module("hooks", () => {
+            QUnit.test("useDebounced: cancels on comp destroy", async function (assert) {
+                const { advanceTime } = mockTimeout();
+                class C extends Component {
+                    static template = xml`<button class="c" t-on-click="debounced">C</button>`;
+                    setup() {
+                        this.debounced = useDebounced(() => assert.step("debounced"), 1000);
+                    }
+                }
+                const fixture = getFixture();
+                const comp = await mount(C, fixture);
+                assert.verifySteps([]);
+                assert.containsOnce(fixture, "button.c");
+
+                await click(fixture, "button.c");
+                await advanceTime(999);
+                assert.verifySteps([]);
+                await advanceTime(1);
+                assert.verifySteps(["debounced"]);
+
+                await click(fixture, "button.c");
+                await advanceTime(999);
+                assert.verifySteps([]);
+                destroy(comp);
+                await advanceTime(1);
+                assert.verifySteps([]);
+            });
+
+            QUnit.test("useThrottleForAnimation: cancels on comp destroy", async function (assert) {
+                const { advanceFrame, execRegisteredAnimationFrames } = mockAnimationFrame();
+                class C extends Component {
+                    static template = xml`<button class="c" t-on-click="throttled">C</button>`;
+                    setup() {
+                        this.throttled = useThrottleForAnimation(
+                            () => assert.step("throttled"),
+                            1000
+                        );
+                    }
+                }
+                const fixture = getFixture();
+                const comp = await mount(C, fixture);
+                assert.verifySteps([]);
+                assert.containsOnce(fixture, "button.c");
+
+                // Without destroy
+                await click(fixture, "button.c");
+                assert.verifySteps(["throttled"]);
+                await click(fixture, "button.c");
+                assert.verifySteps([]);
+                await advanceFrame();
+                assert.verifySteps(["throttled"]);
+
+                // Clean restart
+                execRegisteredAnimationFrames();
+                assert.verifySteps([]);
+
+                // With destroy
+                await click(fixture, "button.c");
+                assert.verifySteps(["throttled"]);
+                await click(fixture, "button.c");
+                assert.verifySteps([]);
+                destroy(comp);
+                await advanceFrame();
+                assert.verifySteps([]);
+            });
+        });
+
+        QUnit.module("batched", () => {
+            QUnit.test("callback is called only once after operations", async (assert) => {
+                let n = 0;
+                const fn = batched(() => n++);
+                assert.strictEqual(n, 0);
+                fn();
+                fn();
+                assert.strictEqual(n, 0);
+
+                await nextMicroTick();
+                assert.strictEqual(n, 1);
+                await nextMicroTick();
+                assert.strictEqual(n, 1);
+            });
+
+            QUnit.test(
+                "calling batched function from within the callback is not treated as part of the original batch",
+                async (assert) => {
+                    let n = 0;
+                    const fn = batched(() => {
+                        n++;
+                        if (n === 1) {
+                            fn();
+                        }
+                    });
+
+                    assert.strictEqual(n, 0);
+                    fn();
+                    assert.strictEqual(n, 0);
+                    await nextMicroTick(); // First batch
+                    assert.strictEqual(n, 1);
+                    await nextMicroTick(); // Second batch initiated from within the callback
+                    assert.strictEqual(n, 2);
+                    await nextMicroTick();
+                    assert.strictEqual(n, 2);
+                }
+            );
+
+            QUnit.test("callback is called twice", async (assert) => {
+                let n = 0;
+                const fn = batched(() => n++);
+                assert.strictEqual(n, 0);
+                fn();
+                assert.strictEqual(n, 0);
+                await nextMicroTick();
+                assert.strictEqual(n, 1);
+                fn();
+                assert.strictEqual(n, 1);
+                await nextMicroTick();
+                assert.strictEqual(n, 2);
+            });
+
+            QUnit.test(
+                "callback is called only once after operations (synchronize at nextAnimationFrame)",
+                async (assert) => {
+                    let n = 0;
+
+                    const fn = batched(
+                        () => n++,
+                        () => new Promise((resolve) => window.requestAnimationFrame(resolve))
+                    );
+                    assert.strictEqual(n, 0);
+                    fn();
+                    fn();
+                    assert.strictEqual(n, 0);
+
+                    await nextAnimationFrame();
+                    assert.strictEqual(n, 1);
+                    await nextAnimationFrame();
+                    assert.strictEqual(n, 1);
+                }
+            );
+
+            QUnit.test(
+                "calling batched function from within the callback is not treated as part of the original batch (synchronize at nextAnimationFrame)",
+                async (assert) => {
+                    let n = 0;
+                    const fn = batched(
+                        () => {
+                            n++;
+                            if (n === 1) {
+                                fn();
+                            }
+                        },
+                        () => new Promise((resolve) => window.requestAnimationFrame(resolve))
+                    );
+
+                    assert.strictEqual(n, 0);
+                    fn();
+                    assert.strictEqual(n, 0);
+                    await nextAnimationFrame(); // First batch
+                    assert.strictEqual(n, 1);
+                    await nextAnimationFrame(); // Second batch initiated from within the callback
+                    assert.strictEqual(n, 2);
+                    await nextAnimationFrame();
+                    assert.strictEqual(n, 2);
+                }
+            );
+
+            QUnit.test(
+                "callback is called twice (synchronize at nextAnimationFrame)",
+                async (assert) => {
+                    let n = 0;
+                    const fn = batched(
+                        () => n++,
+                        () => new Promise((resolve) => window.requestAnimationFrame(resolve))
+                    );
+                    assert.strictEqual(n, 0);
+                    fn();
+                    assert.strictEqual(n, 0);
+                    await nextAnimationFrame();
+                    assert.strictEqual(n, 1);
+                    fn();
+                    assert.strictEqual(n, 1);
+                    await nextAnimationFrame();
+                    assert.strictEqual(n, 2);
+                }
+            );
+
+            QUnit.test(
+                "callback is called only once after operations (synchronize at setTimeout)",
+                async (assert) => {
+                    let n = 0;
+
+                    const fn = batched(
+                        () => n++,
+                        () => new Promise(setTimeout)
+                    );
+                    assert.strictEqual(n, 0);
+                    fn();
+                    fn();
+                    assert.strictEqual(n, 0);
+
+                    await nextSetTimeout();
+                    assert.strictEqual(n, 1);
+                    await nextSetTimeout();
+                    assert.strictEqual(n, 1);
+                }
+            );
+
+            QUnit.test(
+                "calling batched function from within the callback is not treated as part of the original batch (synchronize at setTimeout)",
+                async (assert) => {
+                    let n = 0;
+                    const fn = batched(
+                        () => {
+                            n++;
+                            if (n === 1) {
+                                fn();
+                            }
+                        },
+                        () => new Promise(setTimeout)
+                    );
+
+                    assert.strictEqual(n, 0);
+                    fn();
+                    assert.strictEqual(n, 0);
+                    await nextSetTimeout(); // First batch
+                    assert.strictEqual(n, 1);
+                    await nextSetTimeout(); // Second batch initiated from within the callback
+                    assert.strictEqual(n, 2);
+                    await nextSetTimeout();
+                    assert.strictEqual(n, 2);
+                }
+            );
+
+            QUnit.test("callback is called twice (synchronize at setTimeout)", async (assert) => {
+                let n = 0;
+                const fn = batched(
+                    () => n++,
+                    () => new Promise(setTimeout)
+                );
+                assert.strictEqual(n, 0);
+                fn();
+                assert.strictEqual(n, 0);
+                await nextSetTimeout();
+                assert.strictEqual(n, 1);
+                fn();
+                assert.strictEqual(n, 1);
+                await nextSetTimeout();
+                assert.strictEqual(n, 2);
+            });
+        });
     });
 });
diff --git a/addons/web/static/tests/helpers/mock_server.js b/addons/web/static/tests/helpers/mock_server.js
index 53cd22c3031..df1f2cca40a 100644
--- a/addons/web/static/tests/helpers/mock_server.js
+++ b/addons/web/static/tests/helpers/mock_server.js
@@ -12,7 +12,7 @@ import {
 } from "@web/core/l10n/dates";
 import { evaluateExpr } from "@web/core/py_js/py";
 import { registry } from "@web/core/registry";
-import { intersection } from "@web/core/utils/arrays";
+import { intersection, unique } from "@web/core/utils/arrays";
 import { deepCopy, pick } from "@web/core/utils/objects";
 import { makeFakeRPCService, makeMockFetch } from "./mock_services";
 import { patchWithCleanup } from "./utils";
@@ -599,24 +599,41 @@ export class MockServer {
      * @param {Object} values: an object representing a record
      * @returns {Object}
      */
-    convertToOnChange(modelName, values) {
+    convertToOnChange(modelName, values, specification) {
         Object.entries(values).forEach(([fname, val]) => {
             const field = this.models[modelName].fields[fname];
             if (field.type === "many2one" && typeof val === "number") {
-                const m2oRecord = this.models[field.relation].records.find((r) => r.id === val);
-                values[fname] = [val, m2oRecord.display_name];
+                values[fname] = this.mockWebRead(field.relation, [[val]], {
+                    specification: specification[fname].fields || {},
+                })[0];
             } else if (field.type === "one2many" || field.type === "many2many") {
-                // TESTS ONLY
-                // one2many_ids = [1,2,3] is a simpler way to express it than orm commands
-                const isCommandList = Array.isArray(val) && Array.isArray(val[0]);
-                if (!isCommandList) {
-                    values[fname] = [[6, false, val]];
-                } else {
-                    val.forEach((cmd) => {
-                        if (cmd[0] === 0 || cmd[0] === 1) {
-                            cmd[2] = this.convertToOnChange(field.relation, cmd[2]);
-                        }
+                val.forEach((cmd) => {
+                    switch (cmd[0]) {
+                        case 0: // CREATE
+                        case 1: // UPDATE
+                            cmd[2] = this.convertToOnChange(
+                                field.relation,
+                                cmd[2],
+                                specification[fname].fields || {}
+                            );
+                            break;
+                        case 4: // LINK_TO
+                            cmd[2] = this.mockWebRead(field.relation, [[cmd[1]]], {
+                                specification: specification[fname].fields || {},
+                            })[0];
+                    }
+                });
+            } else if (field.type === "reference") {
+                if (val) {
+                    const [model, i] = val.split(",");
+                    const id = parseInt(i, 10);
+                    const result = this.mockWebRead(model, [[id]], {
+                        specification: specification[fname].fields || {},
                     });
+                    values[fname] = {
+                        ...result[0],
+                        id: { id, model },
+                    };
                 }
             }
         });
@@ -672,7 +689,7 @@ export class MockServer {
                 return this.mockNameCreate(args.model, args.args[0], args.kwargs);
             case "name_search":
                 return this.mockNameSearch(args.model, args.args, args.kwargs);
-            case "onchange":
+            case "onchange2":
                 return this.mockOnchange(args.model, args.args, args.kwargs);
             case "read":
                 return this.mockRead(args.model, args.args);
@@ -688,12 +705,16 @@ export class MockServer {
                 return this.mockSearchRead(args.model, args.args, args.kwargs);
             case "unlink":
                 return this.mockUnlink(args.model, args.args);
+            case "web_read":
+                return this.mockWebRead(args.model, args.args, args.kwargs);
             case "web_search_read":
                 return this.mockWebSearchRead(args.model, args.args, args.kwargs);
             case "read_group":
                 return this.mockReadGroup(args.model, args.kwargs);
             case "web_read_group":
                 return this.mockWebReadGroup(args.model, args.kwargs);
+            case "unity_web_search_read":
+                return this.mockWebSearchReadUnity(args.model, args.args, args.kwargs);
             case "read_progress_bar":
                 return this.mockReadProgressBar(args.model, args.kwargs);
             case "write":
@@ -768,7 +789,12 @@ export class MockServer {
             const field = model.fields[fieldName];
             const key = "default_" + fieldName;
             if (kwargs.context && key in kwargs.context) {
-                result[fieldName] = kwargs.context[key];
+                if (field.type === "one2many" || field.type === "many2many") {
+                    const ids = kwargs.context[key] || [];
+                    result[fieldName] = ids.map((id) => [4, id]);
+                } else {
+                    result[fieldName] = kwargs.context[key];
+                }
                 continue;
             }
             if ("default" in field) {
@@ -839,6 +865,7 @@ export class MockServer {
                 modelFields[modelName] = modelFields[modelName] || new Set();
                 fields.forEach((field) => modelFields[modelName].add(field));
             });
+            delete views[viewType].models;
         });
 
         // For each model, fetch the information of the fields used in the views only
@@ -871,7 +898,6 @@ export class MockServer {
         return [id, name];
     }
 
-
     /**
      * Simulate a 'name_search' operation.
      *
@@ -899,50 +925,69 @@ export class MockServer {
     }
 
     mockOnchange(modelName, args, kwargs) {
-        const currentData = args[1];
-        const onChangeSpec = args[3];
+        const resId = args[0][0];
+        const changes = args[1];
+        const specification = args[3];
         let fields = args[2] ? (Array.isArray(args[2]) ? args[2] : [args[2]]) : [];
+
         const onchanges = this.models[modelName].onchanges || {};
         const firstOnChange = !fields.length;
-        const onchangeVals = {};
-        let defaultVals = undefined;
-        const nullValues = {};
-        if (firstOnChange) {
-            const fieldsFromView = Object.keys(onChangeSpec).reduce((acc, fname) => {
-                fname = fname.split(".", 1)[0];
-                if (!acc.includes(fname)) {
-                    acc.push(fname);
-                }
-                return acc;
-            }, []);
-            const defaultingFields = fieldsFromView.filter((fname) => !(fname in currentData));
-            defaultVals = this.mockDefaultGet(modelName, [defaultingFields], kwargs);
+        const fieldsFromView = Object.keys(specification);
+
+        let serverValues = {};
+        const onchangeValues = {};
+        for (const fieldName in changes) {
+            if (!(fieldName in this.models[modelName].fields)) {
+                throw makeServerError({
+                    type: "ValidationError",
+                    message: `Field ${fieldName} does not exist`,
+                });
+            }
+        }
+        if (resId) {
+            serverValues = this.mockRead(modelName, [args[0], fieldsFromView], kwargs)[0];
+        } else if (firstOnChange) {
             // It is the new semantics: no field in arguments means we are in
             // a default_get + onchange situation
             fields = fieldsFromView;
             fields
-                .filter((fName) => !Object.keys(defaultVals).includes(fName) && fName !== "id")
+                .filter((fName) => !Object.keys(serverValues).includes(fName) && fName !== "id")
                 .forEach((fName) => {
-                    nullValues[fName] = false;
+                    onchangeValues[fName] = false;
                 });
+            const defaultValues = this.mockDefaultGet(modelName, [fieldsFromView], kwargs);
+            for (const fieldName in defaultValues) {
+                const fieldType = this.models[modelName].fields[fieldName].type;
+                if (["one2many", "many2many"].includes(fieldType)) {
+                    const subSpec = specification[fieldName];
+                    for (const command of defaultValues[fieldName]) {
+                        if (command[0] === 0 || command[0] === 1) {
+                            command[2] = pick(command[2], ...Object.keys(subSpec.fields));
+                        }
+                    }
+                }
+            }
+            Object.assign(onchangeValues, defaultValues);
         }
-        Object.assign(currentData, defaultVals);
         fields.forEach((field) => {
             if (field in onchanges) {
-                const changes = Object.assign({}, nullValues, currentData);
-                onchanges[field](changes);
-                Object.entries(changes).forEach(([key, value]) => {
-                    if (currentData[key] !== value) {
-                        onchangeVals[key] = value;
-                    }
-                });
+                const target = Object.assign({}, serverValues, onchangeValues, changes);
+                const handler = {
+                    set(_, key, val) {
+                        if (target[key] !== val) {
+                            onchangeValues[key] = val;
+                            target[key] = val;
+                        }
+                        return true;
+                    },
+                };
+                onchanges[field](new Proxy(target, handler));
             }
         });
-        const value = this.convertToOnChange(
-            modelName,
-            Object.assign(nullValues, defaultVals, onchangeVals)
-        );
-        return { value };
+
+        return {
+            value: this.convertToOnChange(modelName, onchangeValues, specification),
+        };
     }
 
     mockRead(modelName, args) {
@@ -1006,7 +1051,7 @@ export class MockServer {
                 } else if (field.type === "one2many" || field.type === "many2many") {
                     result[fieldName] = record[fieldName] || [];
                 } else {
-                    result[fieldName] = record[fieldName] || false;
+                    result[fieldName] = record[fieldName] !== undefined ? record[fieldName] : false;
                 }
             }
             records.push(result);
@@ -1953,6 +1998,19 @@ export class MockServer {
         return result.records;
     }
 
+    mockWebRead(modelName, args, kwargs) {
+        const ids = args[0];
+        let fieldNames = Object.keys(kwargs.specification);
+        if (!fieldNames.length) {
+            fieldNames = ["id"];
+        }
+        const records = this.mockRead(modelName, [ids, fieldNames], {
+            context: kwargs.context,
+        });
+        this._unityReadRecords(modelName, kwargs.specification, records);
+        return records;
+    }
+
     mockWebSearchRead(modelName, args, kwargs) {
         const result = this.mockSearchReadController({
             model: modelName,
@@ -1970,6 +2028,17 @@ export class MockServer {
         return result;
     }
 
+    mockWebSearchReadUnity(modelName, args, kwargs) {
+        let fieldNames = Object.keys(kwargs.specification);
+        if (!fieldNames.length) {
+            fieldNames = ["id"];
+        }
+        const _kwargs = { ...kwargs, fields: fieldNames };
+        const result = this.mockWebSearchRead(modelName, [], _kwargs);
+        this._unityReadRecords(modelName, kwargs.specification, result.records);
+        return result;
+    }
+
     mockSearchController(params) {
         const model = this.models[params.model];
         let fieldNames = params.fields;
@@ -2106,7 +2175,11 @@ export class MockServer {
                     }
                     this.writeRecord(
                         comodelName,
-                        { [inverseFieldName]: inverseFieldNewValue },
+                        {
+                            [inverseFieldName]: inverseFieldNewValue.length
+                                ? inverseFieldNewValue
+                                : false,
+                        },
                         removedRecordId
                     );
                 }
@@ -2321,7 +2394,9 @@ export class MockServer {
             }
             if (["one2many", "many2many"].includes(field.type)) {
                 let ids = record[fieldName] ? record[fieldName].slice() : [];
-                if (Array.isArray(value)) {
+                // if a field has been modified, its value must always be sent to the server for onchange and write.
+                // take into account that the value can be a empty list of commands.
+                if (Array.isArray(value) && value.length) {
                     if (
                         value.reduce((hasOnlyInt, val) => hasOnlyInt && Number.isInteger(val), true)
                     ) {
@@ -2426,6 +2501,74 @@ export class MockServer {
             }
         }
     }
+
+    _unityReadRecords(modelName, spec, records) {
+        for (const fieldName in spec) {
+            const field = this.models[modelName].fields[fieldName];
+            const relatedFields = spec[fieldName].fields;
+            switch (field.type) {
+                case "reference": {
+                    for (const record of records) {
+                        if (!record[fieldName]) {
+                            continue;
+                        }
+                        const [model, i] = record[fieldName].split(",");
+                        const id = parseInt(i, 10);
+                        record[fieldName] = {};
+                        if (relatedFields && Object.keys(relatedFields).length) {
+                            const result = this.mockWebRead(model, [[id]], {
+                                specification: relatedFields,
+                                context: spec[fieldName].context,
+                            });
+                            record[fieldName] = result[0];
+                        }
+                        record[fieldName].id = { id, model };
+                    }
+                    break;
+                }
+                case "one2many":
+                case "many2many": {
+                    if (relatedFields && Object.keys(relatedFields).length) {
+                        const ids = unique(records.map((r) => r[fieldName]).flat());
+                        const result = this.mockWebRead(field.relation, [ids], {
+                            specification: relatedFields,
+                            context: spec[fieldName].context,
+                        });
+                        const allRelRecords = {};
+                        for (const relRecord of result) {
+                            allRelRecords[relRecord.id] = relRecord;
+                        }
+                        const { limit, order } = spec[fieldName];
+                        for (const record of records) {
+                            const relResIds = record[fieldName];
+                            let relRecords = relResIds.map((resId) => allRelRecords[resId]);
+                            if (order) {
+                                relRecords = this.sortByField(relRecords, field.relation, order);
+                            }
+                            if (limit) {
+                                relRecords = relRecords.map((r, i) => {
+                                    return i < limit ? r : { id: r.id };
+                                });
+                            }
+                            record[fieldName] = relRecords;
+                        }
+                    }
+                    break;
+                }
+                case "many2one": {
+                    for (const record of records) {
+                        if (record[fieldName] !== false) {
+                            const displayName = record[fieldName][1];
+                            record[fieldName] = { id: record[fieldName][0] };
+                            if (relatedFields && relatedFields.display_name) {
+                                record[fieldName].display_name = displayName;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 // -----------------------------------------------------------------------------
diff --git a/addons/web/static/tests/helpers/mock_services.js b/addons/web/static/tests/helpers/mock_services.js
index d6e91325bbd..9cd4713c195 100644
--- a/addons/web/static/tests/helpers/mock_services.js
+++ b/addons/web/static/tests/helpers/mock_services.js
@@ -78,7 +78,7 @@ export function makeFakeRPCService(mockRPC) {
                     rejectFn = reject;
                     rpcService(...arguments)
                         .then((result) => {
-                            env.bus.trigger("RPC:RESPONSE", { data, settings });
+                            env.bus.trigger("RPC:RESPONSE", { data, settings, result });
                             resolve(result);
                         })
                         .catch(reject);
diff --git a/addons/web/static/tests/legacy/views/basic_model_tests.js b/addons/web/static/tests/legacy/views/basic_model_tests.js
deleted file mode 100644
index bcd22b44ffe..00000000000
--- a/addons/web/static/tests/legacy/views/basic_model_tests.js
+++ /dev/null
@@ -1,2498 +0,0 @@
-/** @odoo-module **/
-    
-    import BasicModel from "web.BasicModel";
-    import testUtils from "web.test_utils";
-    import session from "web.session";
-
-    var createModel = testUtils.createModel;
-
-    QUnit.module('LegacyViews', {
-        beforeEach: function () {
-            this.data = {
-                partner: {
-                    fields: {
-                        display_name: { string: "STRING", type: 'char' },
-                        // the following 2 fields must remain in that order to check that
-                        // active has priority over x_active despite the order
-                        x_active: { string: "Custom Active", type: 'boolean', default: true},
-                        active: {string: "Active", type: 'boolean', default: true},
-                        total: { string: "Total", type: 'integer' },
-                        foo: { string: "Foo", type: 'char' },
-                        bar: { string: "Bar", type: 'integer' },
-                        qux: { string: "Qux", type: 'many2one', relation: 'partner' },
-                        product_id: { string: "Favorite product", type: 'many2one', relation: 'product' },
-                        product_ids: { string: "Favorite products", type: 'one2many', relation: 'product' },
-                        category: { string: "Category M2M", type: 'many2many', relation: 'partner_type' },
-                        date: { string: "Date Field", type: 'date' },
-                        reference: { string: "Reference Field", type: 'reference', selection: [["product", "Product"], ["partner_type", "Partner Type"], ["partner", "Partner"]] },
-                    },
-                    records: [
-                        { id: 1, foo: 'blip', bar: 1, product_id: 37, category: [12], display_name: "first partner", date: "2017-01-25" },
-                        { id: 2, foo: 'gnap', bar: 2, product_id: 41, display_name: "second partner" },
-                    ],
-                    onchanges: {},
-                },
-                product: {
-                    fields: {
-                        display_name: { string: "Product Display Name", type: "char" },
-                        name: { string: "Product Name", type: "char" },
-                        category: { string: "Category M2M", type: 'many2many', relation: 'partner_type' },
-                        active: {string: "Active", type: 'boolean', default: true},
-                    },
-                    records: [
-                        { id: 37, display_name: "xphone" },
-                        { id: 41, display_name: "xpad" }
-                    ]
-                },
-                partner_type: {
-                    fields: {
-                        display_name: { string: "Partner Type", type: "char" },
-                        date: { string: "Date Field", type: 'date' },
-                        x_active: { string: "Custom Active", type: 'boolean', default: true},
-                    },
-                    records: [
-                        { id: 12, display_name: "gold", date: "2017-01-25" },
-                        { id: 14, display_name: "silver" },
-                        { id: 15, display_name: "bronze" }
-                    ]
-                },
-                partner_title: {
-                    fields: {
-                        display_name: { string: "Partner Title", type: 'char'},
-                    },
-                    records: [
-                        { id: 42, display_name: "Dr."},
-                    ]
-                }
-            };
-
-            // add related fields to category.
-            this.data.partner.fields.category.relatedFields =
-                $.extend(true, {}, this.data.partner_type.fields);
-            this.params = {
-                res_id: 2,
-                modelName: 'partner',
-                fields: this.data.partner.fields,
-            };
-        },
-    }, function () {
-        QUnit.module('BasicModel');
-
-        QUnit.test('context is given when using a resequence', async function (assert) {
-            assert.expect(2);
-            delete this.params["res_id"];
-            this.data.product.fields.sequence = {string: "Sequence", type: "integer"};
-
-            const model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (route === '/web/dataset/resequence') {
-                        assert.deepEqual(args.context, { active_field: 2 },
-                            "context should be correct after a resequence");
-                    }
-                    else if (args.method === "read") {
-                        assert.deepEqual(args.kwargs.context, { active_field: 2 },
-                            "context should be correct after a 'read' RPC");
-                    }
-                    return this._super.apply(this, arguments);
-                },
-            });
-            const params = Object.assign(this.params, {
-                context: { active_field: 2 },
-                groupedBy: ['product_id'],
-                fieldNames: ['foo'],
-            });
-
-            model.load(params)
-                .then(function (stateID) {
-                    return model.resequence('product', [41, 37], stateID);
-                })
-                .then(function () {
-                    model.destroy();
-                });
-        });
-
-        QUnit.test('can load a record', async function (assert) {
-            assert.expect(7);
-
-            this.params.fieldNames = ['foo'];
-            this.params.context = { active_field: 2 };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    assert.deepEqual(args.kwargs.context, {
-                        active_field: 2,
-                        bin_size: true,
-                        someKey: 'some value',
-                    }, "should have sent the correct context");
-                    return this._super.apply(this, arguments);
-                },
-                session: {
-                    user_context: { someKey: 'some value' },
-                }
-            });
-
-            assert.strictEqual(model.get(1), null, "should return null for non existing key");
-
-            var resultID = await model.load(this.params);
-            // it is a string, because it is used as a key in an object
-            assert.strictEqual(typeof resultID, 'string', "result should be a valid id");
-
-            var record = model.get(resultID);
-            assert.strictEqual(record.res_id, 2, "res_id read should be the same as asked");
-            assert.strictEqual(record.type, 'record', "should be of type 'record'");
-            assert.strictEqual(record.data.foo, "gnap", "should correctly read value");
-            assert.strictEqual(record.data.bar, undefined, "should not fetch the field 'bar'");
-            model.destroy();
-        });
-
-        QUnit.test('rejects loading a record with invalid id', async function (assert) {
-            assert.expect(1);
-
-            this.params.res_id = 99;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-            try {
-                await model.load(this.params);
-            }
-            catch {
-                assert.ok("load should return a rejected deferred for an invalid id");
-            }
-
-            model.destroy();
-        });
-
-        QUnit.test('notify change with many2one', async function (assert) {
-            assert.expect(2);
-
-            this.params.fieldNames = ['foo', 'qux'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.qux, false, "qux field should be false");
-            await model.notifyChanges(resultID, { qux: { id: 1, display_name: "hello" } });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.qux.data.id, 1, "qux field should be 1");
-            model.destroy();
-        });
-
-        QUnit.test('notify change on many2one: unset and reset same value', async function (assert) {
-            assert.expect(3);
-
-            this.data.partner.records[1].qux = 1;
-
-            this.params.fieldNames = ['qux'];
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.qux.data.id, 1, "qux value should be 1");
-
-            await model.notifyChanges(resultID, { qux: false });
-            record = model.get(resultID);
-            assert.strictEqual(record.data.qux, false, "qux should be unset");
-
-            await model.notifyChanges(resultID, { qux: { id: 1, display_name: 'second_partner' } });
-            record = model.get(resultID);
-            assert.strictEqual(record.data.qux.data.id, 1, "qux value should be 1 again");
-            model.destroy();
-        });
-
-        QUnit.test('write on a many2one', async function (assert) {
-            assert.expect(4);
-            var self = this;
-
-            this.params.fieldNames = ['product_id'];
-
-            var rpcCount = 0;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    rpcCount++;
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.product_id.data.display_name, 'xpad',
-                "should be initialized with correct value");
-
-            await model.notifyChanges(resultID, { product_id: { id: 37, display_name: 'xphone' } });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_id.data.display_name, 'xphone',
-                "should be changed with correct value");
-
-            await model.save(resultID);
-
-            assert.strictEqual(self.data.partner.records[1].product_id, 37,
-                "should have really saved the data");
-            assert.strictEqual(rpcCount, 3, "should have done 3 rpc: 1 read, 1 write, 1 read");
-            model.destroy();
-        });
-
-        QUnit.test('basic onchange', async function (assert) {
-            assert.expect(5);
-
-            this.data.partner.fields.foo.onChange = true;
-            this.data.partner.onchanges.foo = function (obj) {
-                obj.bar = obj.foo.length;
-            };
-
-            this.params.fieldNames = ['foo', 'bar'];
-            this.params.context = { hello: 'world' };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'onchange') {
-                        var context = args.kwargs.context;
-                        assert.deepEqual(context, { hello: 'world' },
-                            "context should be sent by the onchange");
-                    }
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'gnap', "foo field is properly initialized");
-            assert.strictEqual(record.data.bar, 2, "bar field is properly initialized");
-
-            await model.notifyChanges(resultID, { foo: 'mary poppins' });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'mary poppins', "onchange has been applied");
-            assert.strictEqual(record.data.bar, 12, "onchange has been applied");
-            model.destroy();
-        });
-
-        QUnit.test('onchange with a many2one', async function (assert) {
-            assert.expect(5);
-
-            this.data.partner.fields.product_id.onChange = true;
-            this.data.partner.onchanges.product_id = function (obj) {
-                if (obj.product_id === 37) {
-                    obj.foo = "space lollipop";
-                }
-            };
-
-            this.params.fieldNames = ['foo', 'product_id'];
-
-            var rpcCount = 0;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'onchange') {
-                        assert.strictEqual(args.args[2], "product_id",
-                            "should send the only changed field as a string, not a list");
-                    }
-                    rpcCount++;
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'gnap', "foo field is properly initialized");
-            assert.strictEqual(record.data.product_id.data.id, 41, "product_id field is properly initialized");
-
-            await model.notifyChanges(resultID, { product_id: { id: 37, display_name: 'xphone' } });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'space lollipop', "onchange has been applied");
-            assert.strictEqual(rpcCount, 2, "should have done 2 rpc: 1 read and 1 onchange");
-            model.destroy();
-        });
-
-        QUnit.test('onchange on a one2many not in view (fieldNames)', async function (assert) {
-            assert.expect(6);
-
-            this.data.partner.fields.foo.onChange = true;
-            this.data.partner.onchanges.foo = function (obj) {
-                obj.bar = obj.foo.length;
-                obj.product_ids = [];
-            };
-
-            this.params.fieldNames = ['foo'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'gnap', "foo field is properly initialized");
-            assert.strictEqual(record.data.bar, undefined, "bar field is not loaded");
-            assert.strictEqual(record.data.product_ids, undefined, "product_ids field is not loaded");
-
-            await model.notifyChanges(resultID, { foo: 'mary poppins' });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'mary poppins', "onchange has been applied");
-            assert.strictEqual(record.data.bar, 12, "onchange has been applied");
-            assert.strictEqual(record.data.product_ids, undefined,
-                "onchange on product_ids (one2many) has not been applied");
-            model.destroy();
-        });
-
-        QUnit.test('notifyChange on a one2many', async function (assert) {
-            assert.expect(9);
-
-            this.data.partner.records[1].product_ids = [37];
-            this.params.fieldNames = ['product_ids'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'read' && args.args[1].length === 1 && args.args[1][0] === 'display_name') {
-                        assert.strictEqual(args.model, 'product');
-                    }
-                    return this._super(route, args);
-                },
-            });
-
-            var o2mParams = {
-                modelName: 'product',
-                fields: this.data.product.fields,
-                fieldNames: ['display_name'],
-            };
-            var resultID = await model.load(this.params);
-            var newRecordID = await model.load(o2mParams);
-            var record = model.get(resultID);
-            var x2mListID = record.data.product_ids.id;
-
-            assert.strictEqual(record.data.product_ids.count, 1,
-                "there should be one record in the relation");
-
-            // trigger a 'ADD' command
-            await model.notifyChanges(resultID, { product_ids: { operation: 'ADD', id: newRecordID } });
-
-            assert.deepEqual(model.localData[x2mListID]._changes, [{
-                operation: 'ADD', id: newRecordID,
-            }], "_changes should be correct");
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.count, 2,
-                "there should be two records in the relation");
-
-            // trigger a 'UPDATE' command
-            await model.notifyChanges(resultID, { product_ids: { operation: 'UPDATE', id: newRecordID } });
-
-            assert.deepEqual(model.localData[x2mListID]._changes, [{
-                operation: 'ADD', id: newRecordID,
-            }, {
-                operation: 'UPDATE', id: newRecordID,
-            }], "_changes should be correct");
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.count, 2,
-                "there should be two records in the relation");
-
-            // trigger a 'DELETE' command on the existing record
-            var existingRecordID = record.data.product_ids.data[0].id;
-            await model.notifyChanges(resultID, { product_ids: { operation: 'DELETE', ids: [existingRecordID] } });
-
-            assert.deepEqual(model.localData[x2mListID]._changes, [{
-                operation: 'ADD', id: newRecordID,
-            }, {
-                operation: 'UPDATE', id: newRecordID,
-            }, {
-                operation: 'DELETE', id: existingRecordID,
-            }],
-                "_changes should be correct");
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.count, 1,
-                "there should be one record in the relation");
-
-            // trigger a 'DELETE' command on the new record
-            await model.notifyChanges(resultID, { product_ids: { operation: 'DELETE', ids: [newRecordID] } });
-
-            assert.deepEqual(model.localData[x2mListID]._changes, [{
-                operation: 'DELETE', id: existingRecordID,
-            }], "_changes should be correct");
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.count, 0,
-                "there should be no record in the relation");
-
-            model.destroy();
-        });
-
-        QUnit.test('notifyChange on a many2one, without display_name', async function (assert) {
-            assert.expect(3);
-
-            this.params.fieldNames = ['product_id'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'read' && args.args[1].length === 1 && args.args[1][0] === 'display_name') {
-                        assert.strictEqual(args.model, 'product');
-                    }
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.product_id.data.display_name, 'xpad',
-                "product_id field is set to xpad");
-
-            await model.notifyChanges(resultID, { product_id: { id: 37 } });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_id.data.display_name, 'xphone',
-                "display_name should have been fetched");
-            model.destroy();
-        });
-
-        QUnit.test('onchange on a char with an unchanged many2one', async function (assert) {
-            assert.expect(2);
-
-            this.data.partner.fields.foo.onChange = true;
-            this.data.partner.onchanges.foo = function (obj) {
-                obj.foo = obj.foo + " alligator";
-            };
-
-            this.params.fieldNames = ['foo', 'product_id'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'onchange') {
-                        assert.strictEqual(args.args[1].product_id, 41, "should send correct value");
-                    }
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            await model.notifyChanges(resultID, { foo: 'cookie' });
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'cookie alligator', "onchange has been applied");
-            model.destroy();
-        });
-
-        QUnit.test('onchange on a char with another many2one not set to a value', async function (assert) {
-            assert.expect(2);
-            this.data.partner.records[0].product_id = false;
-            this.data.partner.fields.foo.onChange = true;
-            this.data.partner.onchanges.foo = function (obj) {
-                obj.foo = obj.foo + " alligator";
-            };
-
-            this.params.fieldNames = ['foo', 'product_id'];
-            this.params.res_id = 1;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.product_id, false, "product_id is not set");
-
-            await model.notifyChanges(resultID, { foo: 'cookie' });
-            record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'cookie alligator', "onchange has been applied");
-            model.destroy();
-        });
-
-        QUnit.test('can get a many2many', async function (assert) {
-            assert.expect(3);
-
-            this.params.res_id = 1;
-            this.params.fieldsInfo = {
-                default: {
-                    category: {
-                        fieldsInfo: { default: { display_name: {} } },
-                        relatedFields: { display_name: { type: "char" } },
-                        viewType: 'default',
-                    },
-                },
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.category.data[0].res_id, 12,
-                "should have loaded many2many res_ids");
-            assert.strictEqual(record.data.category.data[0].data.display_name, "gold",
-                "should have loaded many2many display_name");
-            record = model.get(resultID, { raw: true });
-            assert.deepEqual(record.data.category, [12],
-                "with option raw, category should only return ids");
-            model.destroy();
-        });
-
-        QUnit.test('can use command add and get many2many value with date field', async function (assert) {
-            assert.expect(2);
-
-            this.params.fieldsInfo = {
-                default: {
-                    category: {
-                        fieldsInfo: { default: { date: {} } },
-                        relatedFields: { date: { type: "date" } },
-                        viewType: 'default',
-                    },
-                },
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var changes = {
-                category: { operation: 'ADD_M2M', ids: [{ id: 12 }] }
-            };
-            await model.notifyChanges(resultID, changes);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.category.data.length, 1, "should have added one category");
-            assert.strictEqual(record.data.category.data[0].data.date instanceof moment,
-                true, "should have a date parsed in a moment object");
-            model.destroy();
-        });
-
-        QUnit.test('many2many with ADD_M2M command and context with parent key', async function (assert) {
-            assert.expect(1);
-
-            this.data.partner_type.fields.some_char = { type: "char" };
-            this.params.fieldsInfo = {
-                default: {
-                    category: {
-                        fieldsInfo: { default: { some_char: { context: "{'a': parent.foo}" } } },
-                        relatedFields: { some_char: { type: "char" } },
-                        viewType: 'default',
-                    },
-                    foo: {},
-                },
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var changes = {
-                category: { operation: 'ADD_M2M', ids: [{ id: 12 }] }
-            };
-            await model.notifyChanges(resultID, changes);
-            var record = model.get(resultID);
-            var categoryRecord = record.data.category.data[0];
-            assert.deepEqual(categoryRecord.getContext({ fieldName: 'some_char' }), { a: 'gnap' },
-                "should properly evaluate context");
-            model.destroy();
-        });
-
-        QUnit.test('can fetch a list', async function (assert) {
-            assert.expect(4);
-
-            this.params.fieldNames = ['foo'];
-            this.params.domain = [];
-            this.params.groupedBy = [];
-            this.params.res_id = undefined;
-            this.params.context = { active_field: 2 };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    assert.strictEqual(args.context.active_field, 2,
-                        "should have sent the correct context");
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-
-            assert.strictEqual(record.type, 'list', "record fetched should be a list");
-            assert.strictEqual(record.data.length, 2, "should have fetched 2 records");
-            assert.strictEqual(record.data[0].data.foo, 'blip', "first record should have 'blip' in foo field");
-            model.destroy();
-        });
-
-        QUnit.test('fetch x2manys in list, with not too many rpcs', async function (assert) {
-            assert.expect(3);
-
-            this.data.partner.records[0].category = [12, 15];
-            this.data.partner.records[1].category = [12, 14];
-
-            this.params.fieldNames = ['category'];
-            this.params.domain = [];
-            this.params.groupedBy = [];
-            this.params.res_id = undefined;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    assert.step(route);
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-
-            assert.strictEqual(record.data[0].data.category.data.length, 2,
-                "first record should have 2 categories loaded");
-            assert.verifySteps(["/web/dataset/search_read"],
-                "should have done 2 rpc (searchread and read category)");
-            model.destroy();
-        });
-
-        QUnit.test('can make a default_record with the help of onchange', async function (assert) {
-            assert.expect(5);
-
-            this.params.context = {};
-            this.params.fieldNames = ['product_id', 'category', 'product_ids'];
-            this.params.res_id = undefined;
-            this.params.type = 'record';
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    assert.step(args.method);
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.product_id, false, "m2o default value should be false");
-            assert.deepEqual(record.data.product_ids.data, [], "o2m default should be []");
-            assert.deepEqual(record.data.category.data, [], "m2m default should be []");
-
-            assert.verifySteps(['onchange']);
-
-            model.destroy();
-        });
-
-        QUnit.test('default_get returning a non requested field', async function (assert) {
-            // 'default_get' returns a default value for the fields given in
-            // arguments. It should not return a value for fields that have not be
-            // requested. However, it happens (e.g. res.users), and the webclient
-            // should not crash when this situation occurs (the field should simply
-            // be ignored).
-            assert.expect(2);
-
-            this.params.context = {};
-            this.params.fieldNames = ['category'];
-            this.params.res_id = undefined;
-            this.params.type = 'record';
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    var result = this._super(route, args);
-                    if (args.method === 'default_get') {
-                        result.product_ids = [[6, 0, [37, 41]]];
-                    }
-                    return result;
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.ok('category' in record.data,
-                "should have processed 'category'");
-            assert.notOk('product_ids' in record.data,
-                "should have ignored 'product_ids'");
-
-            model.destroy();
-        });
-
-        QUnit.test('can make a default_record with default relational values', async function (assert) {
-            assert.expect(6);
-
-            this.data.partner.fields.product_id.default = 37;
-            this.data.partner.fields.product_ids.default = [
-                [0, false, { name: 'xmac' }],
-                [0, false, { name: 'xcloud' }]
-            ];
-            this.data.partner.fields.category.default = [
-                [6, false, [12, 14]]
-            ];
-
-            this.params.fieldNames = ['product_id', 'category', 'product_ids'];
-            this.params.res_id = undefined;
-            this.params.type = 'record';
-            this.params.fieldsInfo = {
-                form: {
-                    category: {},
-                    product_id: {},
-                    product_ids: {
-                        fieldsInfo: {
-                            default: { name: {} },
-                        },
-                        relatedFields: this.data.product.fields,
-                        viewType: 'default',
-                    },
-                },
-            };
-            this.params.viewType = 'form';
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    assert.step(args.method);
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.deepEqual(record.data.product_id.data.display_name, 'xphone',
-                "m2o default should be xphone");
-            assert.deepEqual(record.data.product_ids.data.length,
-                2, "o2m default should have two records");
-            assert.deepEqual(record.data.product_ids.data[0].data.name,
-                'xmac', "first o2m default value should be xmac");
-            assert.deepEqual(record.data.category.res_ids, [12, 14],
-                "m2m default should be [12, 14]");
-
-            assert.verifySteps(['onchange']);
-
-            model.destroy();
-        });
-
-        QUnit.test('default_record, with onchange on many2one', async function (assert) {
-            assert.expect(1);
-
-            // the onchange is done by the mockRPC because we want to return a value
-            // of 'false', which does not work with the mockserver mockOnChange method.
-            this.data.partner.onchanges.product_id = true;
-
-            this.params.context = {};
-            this.params.fieldNames = ['product_id'];
-            this.params.res_id = undefined;
-            this.params.type = 'record';
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'onchange') {
-                        return Promise.resolve({ value: { product_id: false } });
-                    }
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.product_id, false, "m2o default value should be false");
-            model.destroy();
-        });
-
-        QUnit.test('default record: batch namegets on same model and res_id', async function (assert) {
-            assert.expect(3);
-
-            var rpcCount = 0;
-            var fields = this.data.partner.fields;
-            fields.other_product_id = Object.assign({}, fields.product_id);
-            fields.product_id.default = 37;
-            fields.other_product_id.default = 41;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    rpcCount++;
-                    return this._super(route, args);
-                },
-            });
-
-            var params = {
-                context: {},
-                fieldNames: ['other_product_id', 'product_id'],
-                fields: fields,
-                modelName: 'partner',
-                type: 'record',
-            };
-
-            var resultID = await model.load(params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.product_id.data.display_name, "xphone",
-                "should have fetched correct name");
-            assert.strictEqual(record.data.other_product_id.data.display_name, "xpad",
-                "should have fetched correct name");
-            assert.strictEqual(rpcCount, 1, "should have done 1 rpc: onchange");
-            model.destroy();
-        });
-
-        QUnit.test('undoing a change keeps the record dirty', async function (assert) {
-            assert.expect(4);
-
-            this.params.fieldNames = ['foo'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.foo, "gnap", "foo field should properly be set");
-            assert.ok(!model.isDirty(resultID), "record should not be dirty");
-            await model.notifyChanges(resultID, { foo: "hello" });
-            assert.ok(model.isDirty(resultID), "record should be dirty");
-            await model.notifyChanges(resultID, { foo: "gnap" });
-            assert.ok(model.isDirty(resultID), "record should be dirty");
-            model.destroy();
-        });
-
-        QUnit.test('isDirty works correctly on list made empty', async function (assert) {
-            assert.expect(3);
-
-            this.params.fieldNames = ['category'];
-            this.params.res_id = 1;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            var category_value = record.data.category;
-            assert.ok(
-                typeof category_value === "object",
-                "category field should have been fetched"
-            );
-            assert.strictEqual(category_value.data.length, 1, "category field should contain one record");
-            await model.notifyChanges(resultID, {
-                category: {
-                    operation: 'DELETE',
-                    ids: [category_value.data[0].id],
-                }
-            });
-            assert.ok(model.isDirty(resultID), "record should be considered dirty");
-            model.destroy();
-        });
-
-        QUnit.test('can duplicate a record', async function (assert) {
-            assert.expect(4);
-
-            this.params.fieldNames = ['foo'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.display_name, "second partner",
-                "record should have correct display name");
-            assert.strictEqual(record.data.foo, "gnap", "foo should be set to correct value");
-            var duplicateID = await model.duplicateRecord(resultID);
-            var duplicate = model.get(duplicateID);
-            assert.strictEqual(duplicate.data.display_name, "second partner (copy)",
-                "record should have been duplicated");
-            assert.strictEqual(duplicate.data.foo, "gnap", "foo should be set to correct value");
-            model.destroy();
-        });
-
-        QUnit.test('record with many2one set to some value, then set it to none', async function (assert) {
-            assert.expect(3);
-
-            this.params.fieldNames = ['product_id'];
-
-            var self = this;
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.product_id.data.display_name, 'xpad', "product_id should be set");
-            await model.notifyChanges(resultID, { product_id: false });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_id, false, "product_id should not be set");
-
-            await model.save(resultID);
-
-            assert.strictEqual(self.data.partner.records[1].product_id, false,
-                "should have saved the new product_id value");
-            model.destroy();
-        });
-
-        QUnit.test('internal state of groups remains when reloading', async function (assert) {
-            assert.expect(10);
-
-            this.params.fieldNames = ['foo'];
-            this.params.domain = [];
-            this.params.limit = 80;
-            this.params.groupedBy = ['product_id'];
-            this.params.res_id = undefined;
-
-            var filterEnabled = false;
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'web_read_group' && filterEnabled) {
-                        // as this is not yet supported by the MockServer, simulates
-                        // a read_group that returns empty groups
-                        // this is the case for several models (e.g. project.task
-                        // grouped by stage_id)
-                        return this._super.apply(this, arguments).then(function (result) {
-                            // artificially filter out records of first group
-                            result.groups[0].product_id_count = 0;
-                            return result;
-                        });
-                    }
-                    return this._super.apply(this, arguments);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.length, 2, "should have 2 groups");
-            var groupID = record.data[0].id;
-            assert.strictEqual(model.localData[groupID].parentID, resultID,
-                "parentID should be correctly set on groups");
-
-            await model.toggleGroup(groupID);
-
-            record = model.get(resultID);
-            assert.ok(record.data[0].isOpen, "first group should be open");
-            assert.strictEqual(record.data[0].data.length, 1,
-                "first group should have one record");
-            assert.strictEqual(record.data[0].limit, 80,
-                "limit should be 80 by default");
-
-            // change the limit and offset of the first group
-            model.localData[record.data[0].id].limit = 10;
-
-            await model.reload(resultID);
-            record = model.get(resultID);
-            assert.ok(record.data[0].isOpen, "first group should still be open");
-            assert.strictEqual(record.data[0].data.length, 1,
-                "first group should still have one record");
-            assert.strictEqual(record.data[0].limit, 10,
-                "new limit should have been kept");
-
-            // filter some records out: the open group should stay open but now
-            // be empty
-            filterEnabled = true;
-            await model.reload(resultID);
-            record = model.get(resultID);
-            assert.strictEqual(record.data[0].count, 0,
-                "first group's count should be 0");
-            assert.strictEqual(record.data[0].data.length, 0,
-                "first group's data should be empty'");
-            model.destroy();
-        });
-
-        QUnit.test('group on date field with magic grouping method', async function (assert) {
-            assert.expect(1);
-
-            this.params.fieldNames = ['foo'];
-            this.params.groupedBy = ['date:month'];
-            this.params.res_id = undefined;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'web_read_group') {
-                        assert.deepEqual(args.kwargs.fields, ['foo', 'date'],
-                            "should have correctly trimmed the magic grouping info from the field name");
-                    }
-                    return this._super.apply(this, arguments);
-                },
-            });
-
-            await model.load(this.params);
-            model.destroy();
-        });
-
-
-        QUnit.test('read group when grouped by a selection field', async function (assert) {
-            assert.expect(5);
-
-            this.data.partner.fields.selection = {
-                type: 'selection',
-                selection: [['a', 'A'], ['b', 'B']],
-            };
-            this.data.partner.records[0].selection = 'a';
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-            var params = {
-                modelName: 'partner',
-                fields: this.data.partner.fields,
-                fieldNames: ['foo'],
-                groupedBy: ['selection'],
-            };
-
-            var resultID = await model.load(params);
-            var dataPoint = model.get(resultID);
-            assert.strictEqual(dataPoint.data.length, 2, "should have two groups");
-
-            var groupFalse = dataPoint.data.find((point) => point.value === false);
-            assert.ok(groupFalse, "should have a group for value false");
-            assert.deepEqual(groupFalse.domain, [['selection', '=', false]],
-                "group's domain should be correct");
-
-            var groupA = dataPoint.data.find((point) => point.value === "A");
-            assert.ok(groupA, "should have a group for value 'a'");
-            assert.deepEqual(groupA.domain, [['selection', '=', 'a']],
-                "group's domain should be correct");
-            model.destroy();
-        });
-
-        QUnit.test('create record, then save', async function (assert) {
-            assert.expect(5);
-
-            this.params.fieldNames = ['product_ids'];
-            this.params.res_id = undefined;
-            this.params.type = 'record';
-            this.params.context = { active_field: 2 };
-
-            var id;
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'create') {
-                        // has to be done before the call to _super
-                        assert.deepEqual(args.args[0].product_ids, [], "should not have any command");
-                        assert.notOk('category' in args.args[0], "should not have other fields");
-
-                        assert.strictEqual(args.kwargs.context.active_field, 2,
-                            "record's context should be correctly passed");
-                    }
-                    var result = this._super(route, args);
-                    if (args.method === 'create') {
-                        result.then(function (res) {
-                            id = res;
-                        });
-                    }
-                    return result;
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            await model.save(record.id, { reload: false });
-            record = model.get(resultID);
-            assert.strictEqual(record.res_id, id, "should have correct id from server");
-            assert.strictEqual(record.data.id, id, "should have correct id from server");
-            model.destroy();
-        });
-
-        QUnit.test('write commands on a one2many', async function (assert) {
-            assert.expect(4);
-
-            this.data.partner.records[1].product_ids = [37];
-
-            this.params.fieldNames = ['product_ids'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'write') {
-                        assert.deepEqual(args.args[0], [2], "should write on res_id = 2");
-                        var commands = args.args[1].product_ids;
-                        assert.deepEqual(commands[0], [4, 37, false], "first command should be a 4");
-                        // TO DO: uncomment next line
-                        // assert.strictEqual(commands[1], [0, false, {name: "toy"}], "second command should be a 0");
-                        assert.strictEqual(commands[1][0], 0, "second command should be a 0");
-                    }
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID, { raw: true });
-            assert.deepEqual(record.data.product_ids, [37], "should have correct initial value");
-
-            var relatedRecordID = await model.makeRecord('product', [{
-                name: 'name',
-                string: "Product Name",
-                type: "char",
-                value: "xpod"
-            }
-            ]);
-            await model.notifyChanges(record.id, {
-                product_ids: { operation: "ADD", id: relatedRecordID }
-            });
-            await model.save(record.id);
-            model.destroy();
-        });
-
-        QUnit.test('create commands on a one2many', async function (assert) {
-            assert.expect(3);
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    return this._super(route, args);
-                },
-            });
-
-            this.params.fieldsInfo = {
-                default: {
-                    product_ids: {
-                        fieldsInfo: {
-                            default: {
-                                display_name: { type: 'string' },
-                            }
-                        },
-                        viewType: 'default',
-                    }
-                }
-            };
-            this.params.res_id = undefined;
-            this.params.type = 'record';
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.data.length, 0,
-                "one2many should start with a list of length 0");
-
-            await model.notifyChanges(record.id, {
-                product_ids: {
-                    operation: "CREATE",
-                    data: {
-                        display_name: 'coucou',
-                    },
-                },
-            });
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.data.length, 1,
-                "one2many should be a list of length 1");
-            assert.strictEqual(record.data.product_ids.data[0].data.display_name, "coucou",
-                "one2many should have correct data");
-            model.destroy();
-        });
-
-        QUnit.test('onchange with a one2many on a new record', async function (assert) {
-            assert.expect(4);
-
-            this.data.partner.fields.total.default = 50;
-            this.data.partner.fields.product_ids.onChange = true;
-            this.data.partner.onchanges.product_ids = function (obj) {
-                obj.total += 100;
-            };
-
-            this.params.fieldNames = ['total', 'product_ids'];
-            this.params.res_id = undefined;
-            this.params.type = 'record';
-            this.params.fieldsInfo = {
-                form: {
-                    product_ids: {
-                        fieldsInfo: {
-                            default: { name: {} },
-                        },
-                        relatedFields: this.data.product.fields,
-                        viewType: 'default',
-                    },
-                    total: {},
-                },
-            };
-            this.params.viewType = 'form';
-
-            var o2mRecordParams = {
-                fields: this.data.product.fields,
-                fieldNames: ['name'],
-                modelName: 'product',
-                type: 'record',
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'onchange' && args.args[1].total === 150) {
-                        assert.deepEqual(args.args[1].product_ids, [[0, args.args[1].product_ids[0][1], { name: "xpod" }]],
-                            "Should have sent the create command in the onchange");
-                    }
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.data.length, 0,
-                "one2many should start with a list of length 0");
-
-            // make a default record for the related model
-            var relatedRecordID = await model.load(o2mRecordParams);
-            // update the subrecord
-            await model.notifyChanges(relatedRecordID, { name: 'xpod' });
-            // add the subrecord to the o2m of the main record
-            await model.notifyChanges(resultID, {
-                product_ids: { operation: "ADD", id: relatedRecordID }
-            });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.data.length, 1,
-                "one2many should be a list of length 1");
-            assert.strictEqual(record.data.product_ids.data[0].data.name, "xpod",
-                "one2many should have correct data");
-            model.destroy();
-        });
-
-        QUnit.test('dates are properly loaded and parsed (record)', async function (assert) {
-            assert.expect(2);
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var params = {
-                fieldNames: ['date'],
-                fields: this.data.partner.fields,
-                modelName: 'partner',
-                res_id: 1,
-            };
-
-            await model.load(params).then(function (resultID) {
-                var record = model.get(resultID);
-                assert.ok(record.data.date instanceof moment,
-                    "fetched date field should have been formatted");
-            });
-
-            params.res_id = 2;
-
-            await model.load(params).then(function (resultID) {
-                var record = model.get(resultID);
-                assert.strictEqual(record.data.date, false,
-                    "unset date field should be false");
-            });
-            model.destroy();
-        });
-
-        QUnit.test('dates are properly loaded and parsed (list)', async function (assert) {
-            assert.expect(2);
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var params = {
-                fieldNames: ['date'],
-                fields: this.data.partner.fields,
-                modelName: 'partner',
-                type: 'list',
-            };
-
-            await model.load(params).then(function (resultID) {
-                var record = model.get(resultID);
-                var firstRecord = record.data[0];
-                var secondRecord = record.data[1];
-                assert.ok(firstRecord.data.date instanceof moment,
-                    "fetched date field should have been formatted");
-                assert.strictEqual(secondRecord.data.date, false,
-                    "if date is not set, it should be false");
-            });
-            model.destroy();
-        });
-
-        QUnit.test('dates are properly loaded and parsed (default_get)', async function (assert) {
-            assert.expect(1);
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var params = {
-                fieldNames: ['date'],
-                fields: this.data.partner.fields,
-                modelName: 'partner',
-                type: 'record',
-            };
-
-            await model.load(params).then(function (resultID) {
-                var record = model.get(resultID);
-                assert.strictEqual(record.data.date, false, "date default value should be false");
-            });
-            model.destroy();
-        });
-
-        QUnit.test('default_get on x2many may return a list of ids', async function (assert) {
-            assert.expect(1);
-
-            this.data.partner.fields.category.default = [12, 14];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var params = {
-                fieldNames: ['category'],
-                fields: this.data.partner.fields,
-                modelName: 'partner',
-                type: 'record',
-            };
-
-            await model.load(params).then(function (resultID) {
-                var record = model.get(resultID);
-                assert.ok(JSON.stringify(record.data.category.res_ids) === JSON.stringify([12, 14]),
-                    "category field should have correct default value");
-            });
-
-            model.destroy();
-        });
-
-        QUnit.test('default_get: fetch many2one with default (empty & not) inside x2manys', async function (assert) {
-            assert.expect(3);
-
-            this.data.partner.fields.category_m2o = {
-                type: 'many2one',
-                relation: 'partner_type',
-            };
-            this.data.partner.fields.o2m = {
-                string: "O2M", type: 'one2many', relation: 'partner', default: [
-                    [6, 0, []],
-                    [0, 0, { category_m2o: false, o2m: [] }],
-                    [0, 0, { category_m2o: 12, o2m: [] }],
-                ],
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var params = {
-                fieldNames: ['o2m'],
-                fields: this.data.partner.fields,
-                fieldsInfo: {
-                    form: {
-                        o2m: {
-                            relatedFields: this.data.partner.fields,
-                            fieldsInfo: {
-                                list: {
-                                    category_m2o: {
-                                        relatedFields: { display_name: {} },
-                                    },
-                                },
-                            },
-                            viewType: 'list',
-                        },
-                    },
-                },
-                modelName: 'partner',
-                type: 'record',
-                viewType: 'form',
-            };
-
-            var resultID = await model.load(params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.o2m.count, 2, "o2m field should contain 2 records");
-            assert.strictEqual(record.data.o2m.data[0].data.category_m2o, false,
-                "first category field should be empty");
-            assert.strictEqual(record.data.o2m.data[1].data.category_m2o.data.display_name, "gold",
-                "second category field should have been correctly fetched");
-
-            model.destroy();
-        });
-
-        QUnit.test('default_get: fetch x2manys inside x2manys', async function (assert) {
-            assert.expect(3);
-
-            this.data.partner.fields.o2m = {
-                string: "O2M", type: 'one2many', relation: 'partner', default: [[6, 0, [1]]],
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var params = {
-                fieldNames: ['o2m'],
-                fields: this.data.partner.fields,
-                fieldsInfo: {
-                    form: {
-                        o2m: {
-                            relatedFields: this.data.partner.fields,
-                            fieldsInfo: {
-                                list: {
-                                    category: {
-                                        relatedFields: { display_name: {} },
-                                    },
-                                },
-                            },
-                            viewType: 'list',
-                        },
-                    },
-                },
-                modelName: 'partner',
-                type: 'record',
-                viewType: 'form',
-            };
-
-            var resultID = await model.load(params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.o2m.count, 1, "o2m field should contain 1 record");
-            var categoryList = record.data.o2m.data[0].data.category;
-            assert.strictEqual(categoryList.count, 1,
-                "category field should contain 1 record");
-            assert.strictEqual(categoryList.data[0].data.display_name,
-                'gold', "category records should have been fetched");
-
-            model.destroy();
-        });
-
-        QUnit.test('contexts and domains can be properly fetched', async function (assert) {
-            assert.expect(8);
-
-            this.data.partner.fields.product_id.context = "{'hello': 'world', 'test': foo}";
-            this.data.partner.fields.product_id.domain = "[['hello', 'like', 'world'], ['test', 'like', foo]]";
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            this.params.fieldNames = ['product_id', 'foo'];
-
-            var resultID = await model.load(this.params);
-            var recordPartner = model.get(resultID);
-            assert.strictEqual(typeof recordPartner.getContext, "function",
-                "partner record should have a getContext function");
-            assert.strictEqual(typeof recordPartner.getDomain, "function",
-                "partner record should have a getDomain function");
-            assert.deepEqual(recordPartner.getContext(), {},
-                "asking for a context without a field name should fetch the session/user/view context");
-            assert.deepEqual(recordPartner.getDomain(), [],
-                "asking for a domain without a field name should fetch the session/user/view domain");
-            assert.deepEqual(
-                recordPartner.getContext({ fieldName: "product_id" }),
-                { hello: "world", test: "gnap" },
-                "asking for a context with a field name should fetch the field context (evaluated)");
-            assert.deepEqual(
-                recordPartner.getDomain({ fieldName: "product_id" }),
-                [["hello", "like", "world"], ["test", "like", "gnap"]],
-                "asking for a domain with a field name should fetch the field domain (evaluated)");
-            model.destroy();
-
-            // Try again with xml override of field domain and context
-            model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            this.params.fieldsInfo = {
-                default: {
-                    foo: {},
-                    product_id: {
-                        context: "{'hello2': 'world', 'test2': foo}",
-                        domain: "[['hello2', 'like', 'world'], ['test2', 'like', foo]]",
-                    },
-                }
-            };
-
-            resultID = await model.load(this.params);
-            recordPartner = model.get(resultID);
-            assert.deepEqual(
-                recordPartner.getContext({ fieldName: "product_id" }),
-                { hello2: "world", test2: "gnap" },
-                "field context should have been overridden by xml attribute");
-            assert.deepEqual(
-                recordPartner.getDomain({ fieldName: "product_id" }),
-                [["hello2", "like", "world"], ["test2", "like", "gnap"]],
-                "field domain should have been overridden by xml attribute");
-            model.destroy();
-        });
-
-        QUnit.test('dont write on readonly fields (write and create)', async function (assert) {
-            assert.expect(6);
-
-            this.params.fieldNames = ['foo', 'bar'];
-            this.data.partner.fields.foo.onChange = true;
-            this.data.partner.onchanges.foo = function (obj) {
-                obj.bar = obj.foo.length;
-            };
-            this.params.fieldsInfo = {
-                default: {
-                    foo: {},
-                    bar: {
-                        modifiers: {
-                            readonly: true,
-                        },
-                    },
-                }
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'write') {
-                        assert.deepEqual(args.args[1], { foo: "verylongstring" },
-                            "should only save foo field");
-                    }
-                    if (args.method === 'create') {
-                        assert.deepEqual(args.args[0], { foo: "anotherverylongstring" },
-                            "should only save foo field");
-                    }
-                    return this._super(route, args);
-                },
-            });
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.bar, 2,
-                "should be initialized with correct value");
-
-            await model.notifyChanges(resultID, { foo: "verylongstring" });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.bar, 14,
-                "should be changed with correct value");
-
-            await model.save(resultID);
-
-            // start again, but with a new record
-            delete this.params.res_id;
-            resultID = await model.load(this.params);
-            record = model.get(resultID);
-            assert.strictEqual(record.data.bar, 0,
-                "should be initialized with correct value (0 as integer)");
-
-            await model.notifyChanges(resultID, { foo: "anotherverylongstring" });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.bar, 21,
-                "should be changed with correct value");
-
-            await model.save(resultID);
-            model.destroy();
-        });
-
-        QUnit.test('dont write on readonly fields unless save attribute is set', async function (assert) {
-            assert.expect(6);
-
-            this.params.fieldNames = ['foo', 'bar'];
-            this.data.partner.fields.foo.onChange = true;
-            this.data.partner.onchanges.foo = function (obj) {
-                obj.bar = obj.foo.length;
-            };
-            this.params.fieldsInfo = {
-                default: {
-                    foo: {},
-                    bar: {
-                        modifiers: {
-                            readonly: true,
-                        },
-                        force_save: true,
-                    },
-                }
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'write') {
-                        assert.deepEqual(args.args[1], { bar: 14, foo: "verylongstring" },
-                            "should only save foo field");
-                    }
-                    if (args.method === 'create') {
-                        assert.deepEqual(args.args[0], { bar: 21, foo: "anotherverylongstring" },
-                            "should only save foo field");
-                    }
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.bar, 2,
-                "should be initialized with correct value");
-
-            await model.notifyChanges(resultID, { foo: "verylongstring" });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.bar, 14,
-                "should be changed with correct value");
-
-            await model.save(resultID);
-
-            // start again, but with a new record
-            delete this.params.res_id;
-            resultID = await model.load(this.params);
-            record = model.get(resultID);
-            assert.strictEqual(record.data.bar, 0,
-                "should be initialized with correct value (0 as integer)");
-
-            await model.notifyChanges(resultID, { foo: "anotherverylongstring" });
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.bar, 21,
-                "should be changed with correct value");
-
-            await model.save(resultID);
-            model.destroy();
-        });
-
-        QUnit.test('default_get with one2many values', async function (assert) {
-            assert.expect(1);
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    if (args.method === 'default_get') {
-                        return Promise.resolve({
-                            product_ids: [[0, 0, { "name": "xdroid" }]]
-                        });
-                    }
-                    return this._super(route, args);
-                },
-            });
-            var params = {
-                fieldNames: ['product_ids'],
-                fields: this.data.partner.fields,
-                modelName: 'partner',
-                type: 'record',
-                fieldsInfo: {
-                    form: {
-                        product_ids: {
-                            fieldsInfo: {
-                                default: { name: {} },
-                            },
-                            relatedFields: this.data.product.fields,
-                            viewType: 'default',
-                        },
-                    },
-                },
-                viewType: 'form',
-            };
-            var resultID = await model.load(params);
-            assert.strictEqual(typeof resultID, 'string', "result should be a valid id");
-            model.destroy();
-        });
-
-        QUnit.test('call makeRecord with a pre-fetched many2one field', async function (assert) {
-            assert.expect(3);
-            var rpcCount = 0;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    rpcCount++;
-                    return this._super(route, args);
-                },
-            });
-
-            model.makeRecord('coucou', [{
-                name: 'partner_id',
-                relation: 'partner',
-                type: 'many2one',
-                value: [1, 'first partner'],
-            }], {
-                    partner_id: {
-                        options: {
-                            no_open: true,
-                        },
-                    },
-                }).then(function (recordID) {
-                    var record = model.get(recordID);
-                    assert.deepEqual(record.fieldsInfo.default.partner_id, { options: { no_open: true } },
-                        "makeRecord should have generated the fieldsInfo");
-                    assert.deepEqual(record.data.partner_id.data, { id: 1, display_name: 'first partner' },
-                        "many2one should contain the partner with id 1");
-                    assert.strictEqual(rpcCount, 0, "makeRecord should not have done any rpc");
-                });
-            model.destroy();
-        });
-
-        QUnit.test('call makeRecord with a many2many field', async function (assert) {
-            assert.expect(5);
-            var rpcCount = 0;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    rpcCount++;
-                    return this._super(route, args);
-                },
-            });
-
-            var recordID = await model.makeRecord('coucou', [{
-                name: 'partner_ids',
-                fields: [{
-                    name: 'id',
-                    type: 'integer',
-                }, {
-                    name: 'display_name',
-                    type: 'char',
-                }],
-                relation: 'partner',
-                type: 'many2many',
-                value: [1, 2],
-            }]);
-            var record = model.get(recordID);
-            assert.deepEqual(record.fieldsInfo.default.partner_ids, {},
-                "makeRecord should have generated the fieldsInfo");
-            assert.strictEqual(record.data.partner_ids.count, 2,
-                "there should be 2 elements in the many2many");
-            assert.strictEqual(record.data.partner_ids.data.length, 2,
-                "many2many should be a list of length 2");
-            assert.deepEqual(record.data.partner_ids.data[0].data, { id: 1, display_name: 'first partner' },
-                "many2many should contain the partner with id 1");
-            assert.strictEqual(rpcCount, 1, "makeRecord should have done 1 rpc");
-            model.destroy();
-        });
-
-        QUnit.test('call makeRecord with a pre-fetched many2many field', async function (assert) {
-            assert.expect(5);
-            var rpcCount = 0;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    rpcCount++;
-                    return this._super(route, args);
-                },
-            });
-
-            var recordID = await model.makeRecord('coucou', [{
-                name: 'partner_ids',
-                fields: [{
-                    name: 'id',
-                    type: 'integer',
-                }, {
-                    name: 'display_name',
-                    type: 'char',
-                }],
-                relation: 'partner',
-                type: 'many2many',
-                value: [{
-                    id: 1,
-                    display_name: "first partner",
-                }, {
-                    id: 2,
-                    display_name: "second partner",
-                }],
-            }]);
-            var record = model.get(recordID);
-            assert.deepEqual(record.fieldsInfo.default.partner_ids, {},
-                "makeRecord should have generated the fieldsInfo");
-            assert.strictEqual(record.data.partner_ids.count, 2,
-                "there should be 2 elements in the many2many");
-            assert.strictEqual(record.data.partner_ids.data.length, 2,
-                "many2many should be a list of length 2");
-            assert.deepEqual(record.data.partner_ids.data[0].data, { id: 1, display_name: 'first partner' },
-                "many2many should contain the partner with id 1");
-            assert.strictEqual(rpcCount, 0, "makeRecord should not have done any rpc");
-            model.destroy();
-        });
-
-        QUnit.test('call makeRecord with a selection field', async function (assert) {
-            assert.expect(4);
-            var rpcCount = 0;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    rpcCount++;
-                    return this._super.apply(this, arguments);
-                },
-            });
-
-            var recordID = await model.makeRecord('partner', [{
-                name: 'status',
-                string: 'Status',
-                type: 'selection',
-                selection: [['draft', 'Draft'], ['done', 'Done'], ['failed', 'Failed']],
-                value: 'done',
-            }]);
-            var record = model.get(recordID);
-            assert.deepEqual(record.fieldsInfo.default.status, {},
-                "makeRecord should have generated the fieldsInfo");
-            assert.strictEqual(record.data.status, 'done',
-                "should have a value 'done'");
-            assert.strictEqual(record.fields.status.selection.length, 3,
-                "should have 3 keys for selection");
-            assert.strictEqual(rpcCount, 0, "makeRecord should have done 0 rpc");
-            model.destroy();
-        });
-
-        QUnit.test('call makeRecord with a reference field', async function (assert) {
-            assert.expect(2);
-            let rpcCount = 0;
-
-            const model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    rpcCount++;
-                    return this._super(route, args);
-                },
-            });
-
-            const field = this.data.partner.fields.reference;
-            const recordID = await model.makeRecord('coucou', [{
-                name: 'reference',
-                type: 'reference',
-                selection: field.selection,
-                value: 'product,37',
-            }]);
-            const record = model.get(recordID);
-            assert.deepEqual(record.data.reference.data, { id: 37, display_name: 'xphone' });
-            assert.strictEqual(rpcCount, 1);
-
-            model.destroy();
-        });
-
-        QUnit.test('check id, active_id, active_ids, active_model values in record\'s context', async function (assert) {
-            assert.expect(2);
-
-            this.data.partner.fields.product_id.context = "{'id': id, 'active_id': active_id, 'active_ids': active_ids, 'active_model': active_model}";
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            this.params.fieldNames = ['product_id'];
-
-            var resultID = await model.load(this.params);
-            var recordPartner = model.get(resultID);
-            assert.deepEqual(
-                recordPartner.getContext({ fieldName: "product_id" }),
-                { id: 2, active_id: 2, active_ids: [2], active_model: "partner" },
-                "wrong values for id, active_id, active_ids or active_model");
-
-            // Try again without record
-            this.params.res_id = undefined;
-
-            resultID = await model.load(this.params);
-            recordPartner = model.get(resultID);
-            assert.deepEqual(
-                recordPartner.getContext({ fieldName: "product_id" }),
-                { id: false, active_id: false, active_ids: [], active_model: "partner" },
-                "wrong values for id, active_id, active_ids or active_model. Have to be defined even if there is no record.");
-
-            model.destroy();
-        });
-
-        QUnit.test('load model with many2many field properly fetched', async function (assert) {
-            assert.expect(2);
-
-            this.params.fieldNames = ['category'];
-            this.params.res_id = 1;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    assert.step(args.method);
-                    return this._super(route, args);
-                },
-            });
-
-            await model.load(this.params);
-            assert.verifySteps(['read'],
-                "there should be only one read");
-            model.destroy();
-        });
-
-        QUnit.test('data should contain all fields in view, default being false', async function (assert) {
-            assert.expect(1);
-
-            this.data.partner.fields.product_ids.default = [
-                [6, 0, []],
-                [0, 0, { name: 'new' }],
-            ];
-            this.data.product.fields.date = { string: "Date", type: "date" };
-
-            var params = {
-                fieldNames: ['product_ids'],
-                modelName: 'partner',
-                fields: this.data.partner.fields,
-                fieldsInfo: {
-                    form: {
-                        product_ids: {
-                            relatedFields: this.data.product.fields,
-                            fieldsInfo: { list: { name: {}, date: {} } },
-                            viewType: 'list',
-                        }
-                    },
-                },
-                res_id: undefined,
-                type: 'record',
-                viewType: 'form',
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            await model.load(params).then(function (resultID) {
-                var record = model.get(resultID);
-                assert.strictEqual(record.data.product_ids.data[0].data.date, false,
-                    "date value should be in data, and should be false");
-            });
-
-            model.destroy();
-        });
-
-        QUnit.test('changes are discarded when reloading from a new record', async function (assert) {
-            // practical use case: click on 'Create' to open a form view in edit
-            // mode (new record), click on 'Discard', then open an existing record
-            assert.expect(2);
-
-            this.data.partner.fields.foo.default = 'default';
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            // load a new record (default_get)
-            var params = Object.assign(this.params, {
-                res_id: undefined,
-                type: 'record',
-                fieldNames: ['foo'],
-            });
-            var resultID = await model.load(params);
-            var record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'default',
-                "should be the default value");
-
-            // reload with id 2
-            resultID = await model.reload(record.id, { currentId: 2 });
-            record = model.get(resultID);
-            assert.strictEqual(record.data.foo, 'gnap',
-                "should be the value of record 2");
-
-            model.destroy();
-        });
-
-        QUnit.test('x2manys in contexts and domains are correctly evaluated', async function (assert) {
-            assert.expect(4);
-
-            this.data.partner.records[0].product_ids = [37, 41];
-            this.params.fieldNames = Object.keys(this.data.partner.fields);
-            this.params.fieldsInfo = {
-                form: {
-                    qux: {
-                        context: "{'category': category, 'product_ids': product_ids}",
-                        domain: "[['id', 'in', category], ['id', 'in', product_ids]]",
-                        relatedFields: this.data.partner.fields,
-                    },
-                    category: {
-                        relatedFields: this.data.partner_type.fields,
-                    },
-                    product_ids: {
-                        relatedFields: this.data.product.fields,
-                    },
-                },
-            };
-            this.params.viewType = 'form';
-            this.params.res_id = 1;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            var context = record.getContext({ fieldName: 'qux' });
-            var domain = record.getDomain({ fieldName: 'qux' });
-
-            assert.deepEqual(context, {
-                category: [12],
-                product_ids: [37, 41],
-            }, "x2many values in context manipulated client-side should be lists of ids");
-            assert.strictEqual(JSON.stringify(context),
-                '{"category":[12],"product_ids":[37,41]}',
-                "x2many values in context sent to the server should be lists of ids");
-            assert.deepEqual(domain, [
-                ['id', 'in', [12]],
-                ['id', 'in', [37, 41]],
-            ], "x2many values in domains should be lists of ids");
-            assert.strictEqual(JSON.stringify(domain),
-                "[[\"id\",\"in\",[12]],[\"id\",\"in\",[37,41]]]",
-                "x2many values in domains should be lists of ids");
-            model.destroy();
-        });
-
-        QUnit.test('fetch references in list, with not too many rpcs', async function (assert) {
-            assert.expect(5);
-
-            this.data.partner.records[0].reference = 'product,37';
-            this.data.partner.records[1].reference = 'product,41';
-
-            this.params.fieldNames = ['reference'];
-            this.params.domain = [];
-            this.params.groupedBy = [];
-            this.params.res_id = undefined;
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    assert.step(route);
-                    if (route === "/web/dataset/call_kw/product/read") {
-                        assert.deepEqual(args.args, [[37, 41], ['display_name']],
-                            "the read display_name should contain the product ids");
-                    }
-                    return this._super(route, args);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-
-            assert.strictEqual(record.data[0].data.reference.data.display_name, "xphone",
-                "display_name should have been correctly fetched");
-            assert.verifySteps(["/web/dataset/search_read", "/web/dataset/call_kw/product/read"],
-                "should have done 2 rpc (searchread and read display_name for product)");
-            model.destroy();
-        });
-
-        QUnit.test('reload a new record', async function (assert) {
-            assert.expect(6);
-
-            this.params.context = {};
-            this.params.fieldNames = ['product_id', 'category', 'product_ids'];
-            this.params.res_id = undefined;
-            this.params.type = 'record';
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route, args) {
-                    assert.step(args.method);
-                    return this._super(route, args);
-                },
-            });
-
-            var recordID = await model.load(this.params);
-            recordID = await model.reload(recordID);
-            assert.verifySteps(['onchange', 'onchange']);
-            var record = model.get(recordID);
-            assert.strictEqual(record.data.product_id, false,
-                "m2o default value should be false");
-            assert.deepEqual(record.data.product_ids.data, [],
-                "o2m default should be []");
-            assert.deepEqual(record.data.category.data, [],
-                "m2m default should be []");
-
-            model.destroy();
-        });
-
-        QUnit.test('default_get with value false for a one2many', async function (assert) {
-            assert.expect(1);
-
-            this.data.partner.fields.product_ids.default = false;
-            this.params.fieldNames = ['product_ids'];
-            this.params.res_id = undefined;
-            this.params.type = 'record';
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.deepEqual(record.data.product_ids.data, [], "o2m default should be []");
-
-            model.destroy();
-        });
-
-        QUnit.test('only x2many lists (static) should be sorted client-side', async function (assert) {
-            assert.expect(1);
-
-            this.params.modelName = 'partner_type';
-            this.params.res_id = undefined;
-            this.params.orderedBy = [{ name: 'display_name', asc: true }];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-                mockRPC: function (route) {
-                    if (route === '/web/dataset/search_read') {
-                        // simulate randomn sort form the server
-                        return Promise.resolve({
-                            length: 3,
-                            records: [
-                                { id: 12, display_name: "gold", date: "2017-01-25" },
-                                { id: 15, display_name: "bronze" },
-                                { id: 14, display_name: "silver" },
-                            ],
-                        });
-                    }
-                    return this._super.apply(this, arguments);
-                },
-            });
-
-            var resultID = await model.load(this.params);
-            var list = model.get(resultID);
-            assert.deepEqual(list.data.map((l) => l.res_id), [12, 15, 14],
-                "should have kept the order from the server");
-            model.destroy();
-        });
-
-        QUnit.test('onchange on a boolean field', async function (assert) {
-            assert.expect(2);
-
-            var newFields = {
-                foobool: {
-                    type: 'boolean',
-                    string: 'foobool',
-                },
-                foobool2: {
-                    type: 'boolean',
-                    string: 'foobool2',
-                },
-            };
-            Object.assign(this.data.partner.fields, newFields);
-
-            this.data.partner.fields.foobool.onChange = true;
-            this.data.partner.onchanges.foobool = function (obj) {
-                if (obj.foobool) {
-                    obj.foobool2 = true;
-                }
-            };
-
-            this.data.partner.records[0].foobool = false;
-            this.data.partner.records[0].foobool2 = true;
-
-            this.params.res_id = 1;
-            this.params.fieldNames = ['foobool', 'foobool2'];
-            this.params.fields = this.data.partner.fields;
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            await model.notifyChanges(resultID, { foobool2: false });
-            record = model.get(resultID);
-            assert.strictEqual(record.data.foobool2, false, "foobool2 field should be false");
-            await model.notifyChanges(resultID, { foobool: true });
-            record = model.get(resultID);
-            assert.strictEqual(record.data.foobool2, true, "foobool2 field should be true");
-            model.destroy();
-        });
-
-        QUnit.test('notifyChange DELETE_ALL on a one2many', async function (assert) {
-            assert.expect(5);
-
-            this.data.partner.records[1].product_ids = [37, 38];
-            this.params.fieldNames = ['product_ids'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var o2mParams = {
-                modelName: 'product',
-                fields: this.data.product.fields,
-            };
-
-            var resultID = await model.load(this.params);
-            var newRecordID = await model.load(o2mParams);
-            var record = model.get(resultID);
-            var x2mListID = record.data.product_ids.id;
-
-            assert.strictEqual(record.data.product_ids.count, 2,
-                "there should be two records in the relation");
-
-            await model.notifyChanges(resultID, {product_ids: {operation: 'ADD', id: newRecordID}});
-
-            assert.deepEqual(model.localData[x2mListID]._changes, [{
-                operation: 'ADD', id: newRecordID,
-            }], "_changes should be correct");
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.count, 3,
-                "there should be three records in the relation");
-
-            await model.notifyChanges(resultID, {product_ids: {operation: 'DELETE_ALL'}});
-
-            assert.deepEqual(model.localData[x2mListID]._changes, [{
-                id: 37,
-                operation: "DELETE"
-            }, {
-                id: 38,
-                operation: "DELETE"
-            }], "_changes should contain the two 'DELETE' operations");
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.count, 0,
-                "there should be no more records in the relation");
-            model.destroy();
-        });
-
-        QUnit.test('notifyChange MULTI on a one2many', async function (assert) {
-            assert.expect(4);
-
-            this.data.partner.records[1].product_ids = [37, 38];
-            this.params.fieldNames = ['product_ids'];
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var o2mParams = {
-                modelName: 'product',
-                fields: this.data.product.fields,
-            };
-
-            var resultID = await model.load(this.params);
-            var newRecordID = await model.load(o2mParams);
-            var record = model.get(resultID);
-            var x2mListID = record.data.product_ids.id;
-
-            assert.strictEqual(record.data.product_ids.count, 2,
-                "there should be two records in the relation");
-
-            await model.notifyChanges(resultID, {product_ids: {
-                operation: 'MULTI',
-                commands: [{
-                    operation: 'DELETE_ALL'
-                }, {
-                    operation: 'ADD',
-                    id: newRecordID
-                }]
-            }});
-
-            assert.deepEqual(model.localData[x2mListID]._changes, [{
-                id: 37,
-                operation: "DELETE"
-            }, {
-                id: 38,
-                operation: "DELETE"
-            }, {
-                operation: 'ADD', id: newRecordID,
-            }], "_changes should be correct");
-
-            record = model.get(resultID);
-            assert.strictEqual(record.data.product_ids.count, 1,
-                "there should be one record in the relation");
-
-            assert.strictEqual(record.data.product_ids.data[0].id, newRecordID,
-                "the id should match");
-        });
-
-        QUnit.test('notifyChange MULTI on a many2many', async function (assert) {
-            assert.expect(3);
-
-            this.params.fieldsInfo = {
-                default: {
-                    category: {
-                        fieldsInfo: {default: {some_char: { context: "{'a': parent.foo}"}}},
-                        relatedFields: {some_char: {type: "char"}},
-                        viewType: 'default',
-                    },
-                    foo: {},
-                },
-            };
-
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            var resultID = await model.load(this.params);
-            var changes = {
-                category: {
-                    operation: 'MULTI',
-                    commands: [{
-                        operation: 'ADD_M2M',
-                        ids: [{id: 23}, {id: 24}, {id: 25}]
-                    }, {
-                        operation: 'ADD_M2M',
-                        ids: [{id: 26}]
-                    }]
-                }
-            };
-            await model.notifyChanges(resultID, changes);
-            var record = model.get(resultID);
-            var categoryRecord = record.data.category;
-
-            assert.strictEqual(categoryRecord.data.length, 4,
-                "there should 2 records in the relation");
-
-            await model.notifyChanges(resultID, {category: {
-                operation: 'MULTI',
-                commands: [{
-                    operation: 'DELETE_ALL'
-                }, {
-                    operation: 'ADD_M2M',
-                    ids: [{id: 27}]
-                }]
-            }});
-            record = model.get(resultID);
-            categoryRecord = record.data.category;
-            assert.strictEqual(categoryRecord.data.length, 1,
-                "there should 1 record in the relation");
-
-            assert.strictEqual(record.data.category.data[0].data.id, 27,
-                "the id should match");
-
-            model.destroy();
-        });
-
-        QUnit.test('identify correct active field', async function(assert) {
-            assert.expect(4);
-            var model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-            // check that active field is returned if present
-            this.params.res_id = 37;
-            this.params.modelName = 'product'
-            this.params.fields = this.data.product.fields;
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.equal(model.getActiveField(record), 'active', 'should have returned "active" field name');
-            // check that active field is not returned if not present
-            this.params.res_id = 42;
-            this.params.modelName = 'partner_title';
-            this.params.fields = this.data.partner_title.fields;
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.equal(model.getActiveField(record), undefined, 'should not have returned any field name');
-            // check that x_active field is returned if x_active present
-            this.params.res_id = 12;
-            this.params.modelName = 'partner_type';
-            this.params.fields = this.data.partner_type.fields;
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.equal(model.getActiveField(record), 'x_active', 'should have returned "x_active" field name');
-
-            // check that active field is returned if both active and x_active present
-            this.params.res_id = 1;
-            this.params.modelName = 'partner';
-            this.params.fields = this.data.partner.fields;
-            var resultID = await model.load(this.params);
-            var record = model.get(resultID);
-            assert.equal(model.getActiveField(record), 'active', 'should have returned "active" field name');
-        });
-    });
-    QUnit.module('Multi Company', function (hooks) {
-        let sessionUserCompaniesBackup;
-        let sessionUserContextBackup;
-        hooks.before(function (assert) {
-            // Backups session parts that this testing module will alter in order to restore it at the end.
-            sessionUserCompaniesBackup = 'user_companies' in session && session.user_companies || false;
-            sessionUserContextBackup = 'user_context' in session && session.user_context || false;
-            session.user_companies = {
-                current_company: 3,
-                allowed_companies: {
-                     1: {
-                         id: 1,
-                         name: 'Company 1',
-                     },
-                     2: {
-                         id: 2,
-                         name: 'Company 2',
-                     },
-                     3: {
-                         id: 3,
-                         name: 'Company 3',
-                     },
-                 },
-            };
-            session.user_context = {
-                allowed_company_ids: [1, 2],
-            };
-        });
-        hooks.after(function (assert) {
-            if (sessionUserCompaniesBackup !== false) {
-                session.user_companies = sessionUserCompaniesBackup || { };
-            } else {
-                delete session.user_companies;
-            }
-            if (sessionUserContextBackup !== false) {
-                session.user_context = sessionUserContextBackup || { };
-            } else {
-                delete session.user_context;
-            }
-        });
-        QUnit.test('basic_model _getEvalContext returns a correct current_company_id', async function(assert) {
-            assert.expect(3);
-
-            const model = await createModel({
-                Model: BasicModel,
-                data: this.data,
-            });
-
-            let context = model._getEvalContext({ });
-            assert.strictEqual(
-                context.current_company_id,
-                session.user_context.allowed_company_ids[0],
-                'basic_model _getEvalContext returns the first entry in session.user_context.allowed_company_ids array');
-
-            session.user_context.allowed_company_ids = [2, 1];
-            context = model._getEvalContext({ });
-            assert.strictEqual(
-                context.current_company_id,
-                session.user_context.allowed_company_ids[0],
-                'basic_model _getEvalContext returns the first entry in session.user_context.allowed_company_ids array');
-
-            delete session.user_context.allowed_company_ids;
-            context = model._getEvalContext({ });
-            assert.strictEqual(
-                context.current_company_id,
-                session.user_companies.current_company,
-                'basic_model _getEvalContext returns session.user_companies.current_company when session.user_context.allowed_company_ids is not set');
-        });
-    });
diff --git a/addons/web/static/tests/mobile/views/fields/many2one_barcode_field_tests.js b/addons/web/static/tests/mobile/views/fields/many2one_barcode_field_tests.js
index 3c156558446..cf3a33f879e 100644
--- a/addons/web/static/tests/mobile/views/fields/many2one_barcode_field_tests.js
+++ b/addons/web/static/tests/mobile/views/fields/many2one_barcode_field_tests.js
@@ -124,7 +124,7 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             async mockRPC(route, args, performRPC) {
                 if (args.method === CREATE && args.model === SALE_ORDER_LINE) {
-                    const selectedId = args.args[0][PRODUCT_FIELD_NAME];
+                    const selectedId = args.args[0][0][PRODUCT_FIELD_NAME];
                     assert.equal(
                         selectedId,
                         selectedRecordTest.id,
diff --git a/addons/web/static/tests/mobile/views/form_view_tests.js b/addons/web/static/tests/mobile/views/form_view_tests.js
index 7095ed7da57..1e7686ef418 100644
--- a/addons/web/static/tests/mobile/views/form_view_tests.js
+++ b/addons/web/static/tests/mobile/views/form_view_tests.js
@@ -319,8 +319,8 @@ QUnit.module("Mobile Views", ({ beforeEach }) => {
                         </sheet>
                     </form>
                 `,
-                mockRPC(route, { method, args: [, , changedField] }) {
-                    if (method === "onchange" && changedField === "display_name") {
+                mockRPC(route, { method, args }) {
+                    if (method === "onchange2" && args[2][0] === "display_name") {
                         return onchangeDef;
                     }
                 },
diff --git a/addons/web/static/tests/mobile/views/kanban_view_tests.js b/addons/web/static/tests/mobile/views/kanban_view_tests.js
index 0cbfb2fd540..3b336bfafc6 100644
--- a/addons/web/static/tests/mobile/views/kanban_view_tests.js
+++ b/addons/web/static/tests/mobile/views/kanban_view_tests.js
@@ -1,7 +1,7 @@
 /** @odoo-module **/
 
 import { makeView, setupViewRegistries } from "@web/../tests/views/helpers";
-import { click, getFixture, patchWithCleanup} from "@web/../tests/helpers/utils";
+import { click, getFixture, patchWithCleanup } from "@web/../tests/helpers/utils";
 import { AnimatedNumber } from "@web/views/view_components/animated_number";
 
 let serverData;
@@ -97,11 +97,7 @@ QUnit.module("Views", (hooks) => {
             "Should have a folded column with a load more button"
         );
         await click(target, ".o_kanban_load_more button");
-        assert.containsNone(
-            target,
-            ".o_kanban_load_more",
-            "Shouldn't have a load more button"
-        );
+        assert.containsNone(target, ".o_kanban_load_more", "Shouldn't have a load more button");
         assert.containsN(target, ".o_kanban_record", 4, "Should have 4 loaded record");
     });
 });
diff --git a/addons/web/static/tests/mobile/views/view_dialog/select_create_dialog_tests.js b/addons/web/static/tests/mobile/views/view_dialog/select_create_dialog_tests.js
index 58c0798e1c3..75738b12600 100644
--- a/addons/web/static/tests/mobile/views/view_dialog/select_create_dialog_tests.js
+++ b/addons/web/static/tests/mobile/views/view_dialog/select_create_dialog_tests.js
@@ -77,7 +77,7 @@ QUnit.module("ViewDialogs", (hooks) => {
                 </form>`,
             async mockRPC(route, args) {
                 if (args.method === "create" && args.model === "sale_order_line") {
-                    const { product_id: selectedId } = args.args[0];
+                    const { product_id: selectedId } = args.args[0][0];
                     assert.strictEqual(selectedId, false, `there should be no product selected`);
                 }
             },
@@ -133,7 +133,7 @@ QUnit.module("ViewDialogs", (hooks) => {
                 </form>`,
             async mockRPC(route, args) {
                 if (args.method === "create" && args.model === "sale_order_line") {
-                    const { product_id: selectedId } = args.args[0];
+                    const { product_id: selectedId } = args.args[0][0];
                     assert.strictEqual(selectedId, 111, `the product should be selected`);
                 }
                 if (args.method === "some_action") {
diff --git a/addons/web/static/tests/mock_server_tests.js b/addons/web/static/tests/mock_server_tests.js
index d2e6d850668..57fd9cabcf8 100644
--- a/addons/web/static/tests/mock_server_tests.js
+++ b/addons/web/static/tests/mock_server_tests.js
@@ -69,7 +69,7 @@ QUnit.module("MockServer", (hooks) => {
                             partner_id: 2,
                             partner_ids: [1],
                             select: "new",
-                            partner_ref: "partner,2"
+                            partner_ref: "partner,2",
                         },
                         {
                             foo: 17,
@@ -1343,8 +1343,8 @@ QUnit.module("MockServer", (hooks) => {
             },
         ];
         const mockServer = new MockServer(data);
-        mockServer.mockWrite("foo", [[2], { many2many_field: [] }]);
-        assert.deepEqual(mockServer.models.bar.records[0].many2many_field, []);
+        mockServer.mockWrite("foo", [[2], { many2many_field: [] }]); // save nothing
+        assert.deepEqual(mockServer.models.bar.records[0].many2many_field, [2]);
     });
 
     QUnit.test("many2one update should update inverse field", async function (assert) {
diff --git a/addons/web/static/tests/views/sample_server_tests.js b/addons/web/static/tests/model/sample_server_tests.js
similarity index 97%
rename from addons/web/static/tests/views/sample_server_tests.js
rename to addons/web/static/tests/model/sample_server_tests.js
index 4e90e42ca5a..aa0abb4e894 100644
--- a/addons/web/static/tests/views/sample_server_tests.js
+++ b/addons/web/static/tests/model/sample_server_tests.js
@@ -1,6 +1,6 @@
 /** @odoo-module **/
 
-import { SampleServer } from "@web/views/sample_server";
+import { SampleServer } from "@web/model/sample_server";
 
 const {
     MAIN_RECORDSET_SIZE,
@@ -300,8 +300,8 @@ QUnit.module(
 
             const server = new DeterministicSampleServer("hobbit", fields.hobbit);
             const existingGroups = [
-                { value: "gardener", profession_count: 0 }, // fake group
-                { value: "adventurer", profession_count: 0 }, // fake group
+                { profession: "gardener", count: 0 }, // fake group
+                { profession: "adventurer", count: 0 }, // fake group
             ];
             server.setExistingGroups(existingGroups);
 
@@ -316,7 +316,7 @@ QUnit.module(
             assert.strictEqual(result.groups.length, 2);
 
             assert.deepEqual(
-                result.groups.map((g) => g.value),
+                result.groups.map((g) => g.profession),
                 ["gardener", "adventurer"]
             );
 
@@ -332,9 +332,9 @@ QUnit.module(
 
             const server = new DeterministicSampleServer("hobbit", fields.hobbit);
             const existingGroups = [
-                { value: "gardener", profession_count: 0 }, // fake group
-                { value: "brewer", profession_count: 0 }, // fake group
-                { value: "adventurer", profession_count: 0 }, // fake group
+                { profession: "gardener", count: 0 }, // fake group
+                { profession: "brewer", count: 0 }, // fake group
+                { profession: "adventurer", count: 0 }, // fake group
             ];
             server.setExistingGroups(existingGroups);
 
@@ -349,7 +349,7 @@ QUnit.module(
             assert.strictEqual(result.groups.length, 3);
 
             assert.deepEqual(
-                result.groups.map((g) => g.value),
+                result.groups.map((g) => g.profession),
                 ["gardener", "brewer", "adventurer"]
             );
 
diff --git a/addons/web/static/tests/qunit.js b/addons/web/static/tests/qunit.js
index 277730e53c1..1a124332ee9 100644
--- a/addons/web/static/tests/qunit.js
+++ b/addons/web/static/tests/qunit.js
@@ -359,6 +359,56 @@ export function setupQUnit() {
         );
     });
 
+    /**
+     * The purpose of this function is to reset the timer nesting level of the execution context
+     * to 0, to prevent situations where a setTimeout with a timeout of 0 may end up being
+     * scheduled after another one that also has a timeout of 0 that was called later.
+     * Example code:
+     * (async () => {
+     *     const timeout = () => new Promise((resolve) => setTimeout(resolve, 0));
+     *     const animationFrame = () => new Promise((resolve) => requestAnimationFrame(resolve));
+     *
+     *     for (let i = 0; i < 4; i++) {
+     *         await timeout();
+     *     }
+     *     timeout().then(() => console.log("after timeout"));
+     *     await animationFrame()
+     *     timeout().then(() => console.log("after animationFrame"));
+     *     // logs "after animationFrame" before "after timeout"
+     * })()
+     *
+     * When the browser runs a task that was the result of a timer (setTimeout or setInterval),
+     * that task has an intrinsic "timer nesting level". If you schedule another task with
+     * a timer from within such a task, the new task has the existing task's timer nesting level,
+     * plus one. When the timer nesting level of a task is greater than 5, the `timeout` parameter
+     * for setTimeout/setInterval will be forced to at least 4 (see step 5 in the timer initialization
+     * steps in the HTML spec: https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timer-initialisation-steps).
+     *
+     * In the above example, every `await timeout()` besides inside the loop schedules a new task
+     * from within a task that was initiated by a timer, causing the nesting level to be 5 after
+     * the loop. The first timeout after the loop is now forced to 4.
+     *
+     * When we await the animation frame promise, we create a task that is *not* initiated by a timer,
+     * reseting the nesting level to 0, causing the timeout following it to properly be treated as 0,
+     * as such the callback that was registered by it is oftentimes executed before the previous one.
+     *
+     * While we can't prevent this from happening within a given test, we want to at least prevent
+     * the timer nesting level to propagate from one test to the next as this can be a cause of
+     * indeterminism. To avoid slowing down the tests by waiting one frame after every test,
+     * we instead use a MessageChannel to add a task with not nesting level to the event queue immediately.
+     */
+    QUnit.testDone(async () => {
+        return new Promise((resolve) => {
+            const channel = new MessageChannel();
+            channel.port1.onmessage = () => {
+                channel.port1.close();
+                channel.port2.close();
+                resolve();
+            };
+            channel.port2.postMessage("");
+        });
+    });
+
     // Append a "Rerun in debug" link.
     // Only works if the test is not hidden.
     QUnit.testDone(async ({ testId }) => {
diff --git a/addons/web/static/tests/search/search_panel_tests.js b/addons/web/static/tests/search/search_panel_tests.js
index 1f147a29e72..16135b5fb45 100644
--- a/addons/web/static/tests/search/search_panel_tests.js
+++ b/addons/web/static/tests/search/search_panel_tests.js
@@ -2070,7 +2070,7 @@ QUnit.module("Search", (hooks) => {
         const webclient = await createWebClient({
             serverData,
             async mockRPC(route, { kwargs, method }) {
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.step(JSON.stringify(kwargs.domain));
                 }
             },
@@ -2118,7 +2118,7 @@ QUnit.module("Search", (hooks) => {
         const webclient = await createWebClient({
             serverData,
             async mockRPC(route, { kwargs, method }) {
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.step(JSON.stringify(kwargs.domain));
                 }
             },
diff --git a/addons/web/static/tests/views/calendar/calendar_arch_parser_tests.js b/addons/web/static/tests/views/calendar/calendar_arch_parser_tests.js
index 2319a49f7bc..ad5882c3462 100644
--- a/addons/web/static/tests/views/calendar/calendar_arch_parser_tests.js
+++ b/addons/web/static/tests/views/calendar/calendar_arch_parser_tests.js
@@ -37,7 +37,7 @@ QUnit.test("defaults", (assert) => {
         quickCreate: true,
         isDateHidden: false,
         isTimeHidden: false,
-        popoverFields: {},
+        popoverFieldNodes: {},
         scale: "week",
         scales: ["day", "week", "month", "year"],
         showUnusualDays: false,
diff --git a/addons/web/static/tests/views/calendar/calendar_view_tests.js b/addons/web/static/tests/views/calendar/calendar_view_tests.js
index a8a8c82a622..49af6e57754 100644
--- a/addons/web/static/tests/views/calendar/calendar_view_tests.js
+++ b/addons/web/static/tests/views/calendar/calendar_view_tests.js
@@ -43,7 +43,6 @@ import { dialogService } from "@web/core/dialog/dialog_service";
 import { localization } from "@web/core/l10n/localization";
 import { registry } from "@web/core/registry";
 import { userService } from "@web/core/user_service";
-import { CharField } from "@web/views/fields/char/char_field";
 import { actionService } from "@web/webclient/actions/action_service";
 import { getTimePickers } from "../../core/datetime/datetime_test_helpers";
 import { CalendarController } from "@web/views/calendar/calendar_controller";
@@ -51,7 +50,6 @@ import { calendarView } from "@web/views/calendar/calendar_view";
 import { onWillRender } from "@odoo/owl";
 
 const fieldRegistry = registry.category("fields");
-const preloadedDataRegistry = registry.category("preloadedData");
 const serviceRegistry = registry.category("services");
 const viewRegistry = registry.category("views");
 
@@ -1400,34 +1398,6 @@ QUnit.module("Views", ({ beforeEach }) => {
         assert.containsNone(target, ".o_cw_popover", "should close a popover");
     });
 
-    QUnit.test(`render popover with widget which has specialData attribute`, async (assert) => {
-        assert.expect(3);
-
-        fieldRegistry.add("specialWidget", { component: CharField });
-        preloadedDataRegistry.add("specialWidget", {
-            loadOnTypes: ["char"],
-            preload: () => {
-                assert.step("_fetchSpecialDataForMyWidget");
-            },
-        });
-
-        await makeView({
-            type: "calendar",
-            resModel: "event",
-            serverData,
-            arch: `
-                <calendar date_start="start" date_stop="stop" all_day="allday" mode="week">
-                    <field name="name" string="Custom Name" widget="specialWidget" />
-                    <field name="partner_id" />
-                </calendar>
-            `,
-        });
-
-        await clickEvent(target, 4);
-        assert.containsOnce(target, ".o_cw_popover", "should open a popover clicking on event");
-        assert.verifySteps(["_fetchSpecialDataForMyWidget"]);
-    });
-
     QUnit.test("render popover: inside fullcalendar popover", async (assert) => {
         assert.expect(13);
 
@@ -4392,14 +4362,16 @@ QUnit.module("Views", ({ beforeEach }) => {
             `,
             mockRPC(route, { args, method }) {
                 if (method === "create") {
-                    assert.deepEqual(args[0], {
-                        allday: false,
-                        name: "foobar",
-                        start: "2016-12-13 07:00:00",
-                        start_date: false,
-                        stop: "2016-12-13 15:00:00",
-                        stop_date: false,
-                    });
+                    assert.deepEqual(args[0], [
+                        {
+                            allday: false,
+                            name: "foobar",
+                            start: "2016-12-13 07:00:00",
+                            start_date: false,
+                            stop: "2016-12-13 15:00:00",
+                            stop_date: false,
+                        },
+                    ]);
                 }
                 if (method === "write") {
                     assert.deepEqual(args[1], {
diff --git a/addons/web/static/tests/views/calendar/helpers.js b/addons/web/static/tests/views/calendar/helpers.js
index e14c0725e1b..942774268ee 100644
--- a/addons/web/static/tests/views/calendar/helpers.js
+++ b/addons/web/static/tests/views/calendar/helpers.js
@@ -231,9 +231,18 @@ function makeFakeModelState() {
         hasAllDaySlot: true,
         hasEditDialog: false,
         quickCreate: false,
-        popoverFields: {
+        popoverFieldNodes: {
             name: Field.parseFieldNode(fakeFieldNode, fakeModels, "event", "calendar"),
         },
+        popoverFields: {
+            name: {
+                context: "{}",
+                invisible: false,
+                readonly: false,
+                required: false,
+                onChange: false,
+            },
+        },
         rangeEnd: makeFakeDate().endOf("month"),
         rangeStart: makeFakeDate().startOf("month"),
         records: makeFakeRecords(),
diff --git a/addons/web/static/tests/views/fields/ace_editor_field_tests.js b/addons/web/static/tests/views/fields/ace_editor_field_tests.js
index 66aac76b21c..09ec7932d78 100644
--- a/addons/web/static/tests/views/fields/ace_editor_field_tests.js
+++ b/addons/web/static/tests/views/fields/ace_editor_field_tests.js
@@ -94,6 +94,7 @@ QUnit.module("Fields", (hooks) => {
 
         await pagerNext(target);
         await nextTick();
+        await nextTick();
 
         assert.ok(target.querySelector(".o_field_code").textContent.includes("blip"));
     });
@@ -121,9 +122,9 @@ QUnit.module("Fields", (hooks) => {
                 },
             });
 
-            assert.verifySteps(["get_views: []", 'read: [[1],["foo","display_name"]]']);
+            assert.verifySteps(["get_views: []", "web_read: [[1]]"]);
             await pagerNext(target);
-            assert.verifySteps(['read: [[2],["foo","display_name"]]']);
+            assert.verifySteps(["web_read: [[2]]"]);
         }
     );
 });
diff --git a/addons/web/static/tests/views/fields/binary_field_tests.js b/addons/web/static/tests/views/fields/binary_field_tests.js
index 6e42e2222aa..00acdb3b857 100644
--- a/addons/web/static/tests/views/fields/binary_field_tests.js
+++ b/addons/web/static/tests/views/fields/binary_field_tests.js
@@ -13,10 +13,14 @@ import {
 } from "@web/../tests/helpers/utils";
 import { makeView, setupViewRegistries } from "@web/../tests/views/helpers";
 import { browser } from "@web/core/browser/browser";
+import { errorService } from "@web/core/errors/error_service";
+import { registry } from "@web/core/registry";
 
 const BINARY_FILE =
     "R0lGODlhDAAMAKIFAF5LAP/zxAAAANyuAP/gaP///wAAAAAAACH5BAEAAAUALAAAAAAMAAwAAAMlWLPcGjDKFYi9lxKBOaGcF35DhWHamZUW0K4mAbiwWtuf0uxFAgA7";
 
+const serviceRegistry = registry.category("services");
+
 let serverData;
 let target;
 
@@ -478,7 +482,8 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("isUploading state should be set to false after upload", async function (assert) {
-        assert.expect(1);
+        serviceRegistry.add("error", errorService);
+
         serverData.models.partner.onchanges = {
             document: function (obj) {
                 if (obj.document) {
@@ -502,5 +507,6 @@ QUnit.module("Fields", (hooks) => {
             "Upload your file",
             "displayed value should be upload your file"
         );
+        assert.containsOnce(target, ".o_error_dialog");
     });
 });
diff --git a/addons/web/static/tests/views/fields/char_field_tests.js b/addons/web/static/tests/views/fields/char_field_tests.js
index 61cf4f4b3a4..1f890b101d4 100644
--- a/addons/web/static/tests/views/fields/char_field_tests.js
+++ b/addons/web/static/tests/views/fields/char_field_tests.js
@@ -749,7 +749,7 @@ QUnit.module("Fields", (hooks) => {
                         </field>
                     </form>`,
                 async mockRPC(route, { method }) {
-                    if (method === "onchange") {
+                    if (method === "onchange2") {
                         await def;
                     }
                 },
diff --git a/addons/web/static/tests/views/fields/color_field_tests.js b/addons/web/static/tests/views/fields/color_field_tests.js
index a1576b7a741..10aff4a9802 100644
--- a/addons/web/static/tests/views/fields/color_field_tests.js
+++ b/addons/web/static/tests/views/fields/color_field_tests.js
@@ -48,7 +48,7 @@ QUnit.module("Fields", (hooks) => {
                     </group>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.step(`onchange ${JSON.stringify(args.args)}`);
                 }
             },
@@ -68,7 +68,7 @@ QUnit.module("Fields", (hooks) => {
         assert.strictEqual(target.querySelector(".o_field_color input").value, "#000000");
         await editInput(target, ".o_field_color input", "#fefefe");
         assert.verifySteps([
-            'onchange [[1],{"id":1,"hex_color":"#fefefe"},"hex_color",{"hex_color":"1"}]',
+            'onchange [[1],{"hex_color":"#fefefe"},["hex_color"],{"hex_color":{},"display_name":{}}]',
         ]);
         assert.strictEqual(target.querySelector(".o_field_color input").value, "#fefefe");
         assert.strictEqual(
@@ -113,31 +113,34 @@ QUnit.module("Fields", (hooks) => {
 
         assert.containsN(
             target,
-            '.o_field_color input:disabled',
+            ".o_field_color input:disabled",
             2,
             "the field should not be editable"
         );
     });
 
-    QUnit.test("color field read-only in model definition, in non-editable list", async function (assert) {
-        serverData.models.partner.fields.hex_color.readonly = true;
-        await makeView({
-            type: "list",
-            serverData,
-            resModel: "partner",
-            arch: `
+    QUnit.test(
+        "color field read-only in model definition, in non-editable list",
+        async function (assert) {
+            serverData.models.partner.fields.hex_color.readonly = true;
+            await makeView({
+                type: "list",
+                serverData,
+                resModel: "partner",
+                arch: `
                 <tree>
                     <field name="hex_color" widget="color" />
                 </tree>`,
-        });
+            });
 
-        assert.containsN(
-            target,
-            '.o_field_color input:disabled',
-            2,
-            "the field should not be editable"
-        );
-    });
+            assert.containsN(
+                target,
+                ".o_field_color input:disabled",
+                2,
+                "the field should not be editable"
+            );
+        }
+    );
 
     QUnit.test("color field change via another field's onchange", async (assert) => {
         serverData.models.partner.onchanges = {
@@ -156,7 +159,7 @@ QUnit.module("Fields", (hooks) => {
                     <field name="hex_color" widget="color" />
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.step(`onchange ${JSON.stringify(args.args)}`);
                 }
             },
@@ -170,7 +173,7 @@ QUnit.module("Fields", (hooks) => {
         assert.strictEqual(target.querySelector(".o_field_color input").value, "#000000");
         await editInput(target, ".o_field_char[name='foo'] input", "someValue");
         assert.verifySteps([
-            'onchange [[1],{"id":1,"foo":"someValue","hex_color":false},"foo",{"foo":"1","hex_color":""}]',
+            'onchange [[1],{"foo":"someValue"},["foo"],{"foo":{},"hex_color":{},"display_name":{}}]',
         ]);
         assert.strictEqual(target.querySelector(".o_field_color input").value, "#fefefe");
         assert.strictEqual(
diff --git a/addons/web/static/tests/views/fields/datetime_field_tests.js b/addons/web/static/tests/views/fields/datetime_field_tests.js
index ecfcaa61aa1..7f20b12092b 100644
--- a/addons/web/static/tests/views/fields/datetime_field_tests.js
+++ b/addons/web/static/tests/views/fields/datetime_field_tests.js
@@ -132,8 +132,8 @@ QUnit.module("Fields", (hooks) => {
                 serverData,
                 arch: '<form><field name="datetime"/></form>',
                 mockRPC(route, { method }) {
-                    if (method === "onchange") {
-                        assert.step("onchange");
+                    if (method === "onchange2") {
+                        assert.step("onchange2");
                     }
                 },
             });
@@ -165,7 +165,7 @@ QUnit.module("Fields", (hooks) => {
                 target.querySelector(".o_field_datetime input").value,
                 "04/22/2018 08:25:00"
             );
-            assert.verifySteps(["onchange"]);
+            assert.verifySteps(["onchange2"]);
         }
     );
 
diff --git a/addons/web/static/tests/views/fields/domain_field_tests.js b/addons/web/static/tests/views/fields/domain_field_tests.js
index 53d4694dc47..17ad261db5a 100644
--- a/addons/web/static/tests/views/fields/domain_field_tests.js
+++ b/addons/web/static/tests/views/fields/domain_field_tests.js
@@ -795,7 +795,13 @@ QUnit.module("Fields", (hooks) => {
         assert.verifySteps(["/web/webclient/load_menus"]);
 
         await doAction(webClient, 1);
-        assert.verifySteps(["/web/action/load", "get_views", "read", "search_count", "fields_get"]);
+        assert.verifySteps([
+            "/web/action/load",
+            "get_views",
+            "web_read",
+            "search_count",
+            "fields_get",
+        ]);
 
         assert.strictEqual(target.querySelector(".o_domain_debug_input").value, rawDomain);
         assert.containsOnce(target, ".o_ds_expr_value", "there should be an expression");
@@ -821,7 +827,7 @@ QUnit.module("Fields", (hooks) => {
 
         // Save
         await clickSave(target);
-        assert.verifySteps(["write", "read", "search_count"]);
+        assert.verifySteps(["write", "web_read", "search_count"]);
         assert.strictEqual(target.querySelector(".o_domain_debug_input").value, rawDomain);
     });
 
diff --git a/addons/web/static/tests/views/fields/email_field_tests.js b/addons/web/static/tests/views/fields/email_field_tests.js
index 5e131e1c781..d51b40c35b4 100644
--- a/addons/web/static/tests/views/fields/email_field_tests.js
+++ b/addons/web/static/tests/views/fields/email_field_tests.js
@@ -212,7 +212,7 @@ QUnit.module("Fields", (hooks) => {
                     </form>`,
                 resId: 1,
                 mockRPC(route, { method }) {
-                    if (method === "onchange") {
+                    if (method === "onchange2") {
                         return Promise.resolve({
                             value: {
                                 foo: "lara.espin@unknown", // onchange to update foo in readonly mode directly
diff --git a/addons/web/static/tests/views/fields/image_field_tests.js b/addons/web/static/tests/views/fields/image_field_tests.js
index 6c0cb35981a..95de86041fc 100644
--- a/addons/web/static/tests/views/fields/image_field_tests.js
+++ b/addons/web/static/tests/views/fields/image_field_tests.js
@@ -31,7 +31,11 @@ QUnit.module("Fields", (hooks) => {
             models: {
                 partner: {
                     fields: {
-                        display_name: { string: "Displayed name", type: "char", searchable: true },
+                        display_name: {
+                            string: "Displayed name",
+                            type: "char",
+                            searchable: true,
+                        },
                         timmy: {
                             string: "pokemon",
                             type: "many2many",
@@ -92,11 +96,15 @@ QUnit.module("Fields", (hooks) => {
                 <form>
                     <field name="document" widget="image" options="{'size': [90, 90]}" />
                 </form>`,
-            mockRPC(route, { args }) {
-                if (route === "/web/dataset/call_kw/partner/read") {
+            mockRPC(route, { args, kwargs }) {
+                if (route === "/web/dataset/call_kw/partner/web_read") {
                     assert.deepEqual(
-                        args[1],
-                        ["write_date", "document", "display_name"],
+                        kwargs.specification,
+                        {
+                            display_name: {},
+                            document: {},
+                            write_date: {},
+                        },
                         "The fields document, display_name and write_date should be present when reading an image"
                     );
                 }
@@ -514,7 +522,10 @@ QUnit.module("Fields", (hooks) => {
     QUnit.test("ImageField in subviews is loaded correctly", async function (assert) {
         serverData.models.partner.records[0].write_date = "2017-02-08 10:00:00";
         serverData.models.partner.records[0].document = MY_IMAGE;
-        serverData.models.partner_type.fields.image = { name: "image", type: "binary" };
+        serverData.models.partner_type.fields.image = {
+            name: "image",
+            type: "binary",
+        };
         serverData.models.partner_type.records[0].image = PRODUCT_IMAGE;
         serverData.models.partner.records[0].timmy = [12];
 
@@ -557,7 +568,10 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("ImageField in x2many list is loaded correctly", async function (assert) {
-        serverData.models.partner_type.fields.image = { name: "image", type: "binary" };
+        serverData.models.partner_type.fields.image = {
+            name: "image",
+            type: "binary",
+        };
         serverData.models.partner_type.records[0].image = PRODUCT_IMAGE;
         serverData.models.partner.records[0].timmy = [12];
 
@@ -668,58 +682,6 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
-    QUnit.test("unique in url doesn't change on onchange", async (assert) => {
-        serverData.models.partner.onchanges = {
-            foo: () => {},
-        };
-
-        const rec = serverData.models.partner.records.find((rec) => rec.id === 1);
-        rec.document = "3 kb";
-        rec.write_date = "2022-08-05 08:37:00";
-
-        await makeView({
-            resId: 1,
-            type: "form",
-            resModel: "partner",
-            serverData,
-            arch: `
-                <form>
-                    <field name="foo" />
-                    <field name="document" widget="image" required="1" />
-                </form>`,
-            mockRPC(route, { method, args }) {
-                assert.step(method);
-                if (method === "onchange") {
-                    return {
-                        value: {
-                            write_date: "", // actual return of the server
-                        },
-                    };
-                }
-                if (method === "write") {
-                    args[1].write_date = "2022-08-05 09:37:00";
-                }
-            },
-        });
-
-        assert.verifySteps(["get_views", "read"]);
-        assert.strictEqual(getUnique(target.querySelector(".o_field_image img")), "1659688620000");
-
-        assert.verifySteps([]);
-        // same unique as before
-        assert.strictEqual(getUnique(target.querySelector(".o_field_image img")), "1659688620000");
-
-        await editInput(target, ".o_field_widget[name='foo'] input", "grrr");
-        assert.verifySteps(["onchange"]);
-        // also same unique
-        assert.strictEqual(getUnique(target.querySelector(".o_field_image img")), "1659688620000");
-
-        await clickSave(target);
-        assert.verifySteps(["write", "read"]);
-
-        assert.strictEqual(getUnique(target.querySelector(".o_field_image img")), "1659688620000");
-    });
-
     QUnit.test("unique in url change on record change", async (assert) => {
         const rec = serverData.models.partner.records.find((rec) => rec.id === 1);
         rec.document = "3 kb";
@@ -750,4 +712,42 @@ QUnit.module("Fields", (hooks) => {
         await pagerNext(target);
         assert.strictEqual(getUnique(target.querySelector(".o_field_image img")), "1659692220000");
     });
+
+    QUnit.test(
+        "unique in url does not change on record change if no_reload option is set",
+        async (assert) => {
+            const rec = serverData.models.partner.records.find((rec) => rec.id === 1);
+            rec.document = "3 kb";
+            rec.write_date = "2022-08-05 08:37:00";
+
+            await makeView({
+                resIds: [1, 2],
+                resId: 1,
+                type: "form",
+                resModel: "partner",
+                serverData,
+                arch: `
+                    <form>
+                        <field name="document" widget="image" required="1" options="{'no_reload': true}" />
+                        <field name="write_date" />
+                    </form>`,
+            });
+
+            function getUnique(target) {
+                const src = target.dataset.src;
+                return new URL(src).searchParams.get("unique");
+            }
+
+            assert.strictEqual(
+                getUnique(target.querySelector(".o_field_image img")),
+                "1659688620000"
+            );
+            await editInput(target, "div[name='write_date'] > div > input", "2022-08-05 08:39:00");
+            await click(target, ".o_form_button_save");
+            assert.strictEqual(
+                getUnique(target.querySelector(".o_field_image img")),
+                "1659688620000"
+            );
+        }
+    );
 });
diff --git a/addons/web/static/tests/views/fields/many2many_binary_field_tests.js b/addons/web/static/tests/views/fields/many2many_binary_field_tests.js
index 796327e478b..e08aec64c71 100644
--- a/addons/web/static/tests/views/fields/many2many_binary_field_tests.js
+++ b/addons/web/static/tests/views/fields/many2many_binary_field_tests.js
@@ -51,7 +51,7 @@ QUnit.module("Fields", (hooks) => {
     QUnit.module("Many2ManyBinaryField");
 
     QUnit.test("widget many2many_binary", async function (assert) {
-        assert.expect(24);
+        assert.expect(22);
 
         const fakeHTTPService = {
             start() {
@@ -95,8 +95,22 @@ QUnit.module("Fields", (hooks) => {
                 if (args.method !== "get_views") {
                     assert.step(route);
                 }
-                if (route === "/web/dataset/call_kw/ir.attachment/read") {
-                    assert.deepEqual(args.args[1], ["name", "mimetype"]);
+                if (args.method === "web_read" && args.model === "turtle") {
+                    assert.deepEqual(args.kwargs.specification, {
+                        display_name: {},
+                        picture_ids: {
+                            fields: {
+                                mimetype: {},
+                                name: {},
+                            },
+                        },
+                    });
+                }
+                if (args.method === "web_read" && args.model === "ir.attachment") {
+                    assert.deepEqual(args.kwargs.specification, {
+                        mimetype: {},
+                        name: {},
+                    });
                 }
             },
         });
@@ -138,10 +152,7 @@ QUnit.module("Fields", (hooks) => {
             "image/*",
             'there should be an attribute "accept" on the input'
         );
-        assert.verifySteps([
-            "/web/dataset/call_kw/turtle/read",
-            "/web/dataset/call_kw/ir.attachment/read",
-        ]);
+        assert.verifySteps(["/web/dataset/call_kw/turtle/web_read"]);
 
         // Set and trigger the change of a file for the input
         const fileInput = target.querySelector('input[type="file"]');
@@ -181,10 +192,9 @@ QUnit.module("Fields", (hooks) => {
             "there should be only one attachment left"
         );
         assert.verifySteps([
-            "/web/dataset/call_kw/ir.attachment/read",
+            "/web/dataset/call_kw/ir.attachment/web_read",
             "/web/dataset/call_kw/turtle/write",
-            "/web/dataset/call_kw/turtle/read",
-            "/web/dataset/call_kw/ir.attachment/read",
+            "/web/dataset/call_kw/turtle/web_read",
         ]);
     });
 
diff --git a/addons/web/static/tests/views/fields/many2many_checkboxes_field_tests.js b/addons/web/static/tests/views/fields/many2many_checkboxes_field_tests.js
index 9acd753e8ea..72175c40983 100644
--- a/addons/web/static/tests/views/fields/many2many_checkboxes_field_tests.js
+++ b/addons/web/static/tests/views/fields/many2many_checkboxes_field_tests.js
@@ -1,6 +1,15 @@
 /** @odoo-module **/
 
-import { click, clickSave, editInput, getFixture } from "@web/../tests/helpers/utils";
+import { browser } from "@web/core/browser/browser";
+import {
+    click,
+    clickSave,
+    editInput,
+    getFixture,
+    getNodesTextContent,
+    nextTick,
+    patchWithCleanup,
+} from "@web/../tests/helpers/utils";
 import { makeView, setupViewRegistries } from "@web/../tests/views/helpers";
 
 let serverData;
@@ -125,6 +134,50 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
+    QUnit.test("Many2ManyCheckBoxesField does not read added record", async function (assert) {
+        serverData.models.partner.records[0].timmy = [];
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            resId: 1,
+            serverData,
+            arch: `
+                <form>
+                    <group>
+                        <field name="timmy" widget="many2many_checkboxes" />
+                    </group>
+                </form>`,
+            mockRPC(route, args) {
+                assert.step(args.method);
+            },
+        });
+
+        assert.containsN(target, "div.o_field_widget div.form-check", 2);
+        assert.deepEqual(
+            getNodesTextContent(target.querySelectorAll(".o_field_widget .form-check-label")),
+            ["gold", "silver"]
+        );
+        assert.containsNone(target, "div.o_field_widget div.form-check input:checked");
+
+        await click(target.querySelector("div.o_field_widget div.form-check input"));
+        assert.containsN(target, "div.o_field_widget div.form-check", 2);
+        assert.deepEqual(
+            getNodesTextContent(target.querySelectorAll(".o_field_widget .form-check-label")),
+            ["gold", "silver"]
+        );
+        assert.containsOnce(target, "div.o_field_widget div.form-check input:checked");
+
+        await clickSave(target);
+        assert.containsN(target, "div.o_field_widget div.form-check", 2);
+        assert.deepEqual(
+            getNodesTextContent(target.querySelectorAll(".o_field_widget .form-check-label")),
+            ["gold", "silver"]
+        );
+        assert.containsOnce(target, "div.o_field_widget div.form-check input:checked");
+
+        assert.verifySteps(["get_views", "web_read", "name_search", "write", "web_read"]);
+    });
+
     QUnit.test(
         "Many2ManyCheckBoxesField: start non empty, then remove twice",
         async function (assert) {
@@ -352,7 +405,7 @@ QUnit.module("Fields", (hooks) => {
     QUnit.test("Many2ManyCheckBoxesField with default values", async function (assert) {
         assert.expect(7);
 
-        serverData.models.partner.fields.timmy.default = [3];
+        serverData.models.partner.fields.timmy.default = [[4, 3]];
         serverData.models.partner.fields.timmy.type = "many2many";
         serverData.models.partner_type.records.push({ id: 3, display_name: "bronze" });
 
@@ -367,7 +420,7 @@ QUnit.module("Fields", (hooks) => {
             mockRPC: function (route, args) {
                 if (args.method === "create") {
                     assert.deepEqual(
-                        args.args[0].timmy,
+                        args.args[0][0].timmy,
                         [[6, false, [12]]],
                         "correct values should have been sent to create"
                     );
@@ -408,4 +461,131 @@ QUnit.module("Fields", (hooks) => {
 
         await clickSave(target);
     });
+
+    QUnit.test("Many2ManyCheckBoxesField batches successive changes", async function (assert) {
+        serverData.models.partner.records[0].timmy = [];
+        serverData.models.partner.onchanges = {
+            timmy: () => {},
+        };
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            resId: 1,
+            serverData,
+            arch: `
+                <form>
+                    <group>
+                        <field name="timmy" widget="many2many_checkboxes" />
+                    </group>
+                </form>`,
+            mockRPC(route, args) {
+                assert.step(args.method);
+            },
+        });
+
+        assert.containsN(target, "div.o_field_widget div.form-check", 2);
+        assert.deepEqual(
+            getNodesTextContent(target.querySelectorAll(".o_field_widget .form-check-label")),
+            ["gold", "silver"]
+        );
+        assert.containsNone(target, "div.o_field_widget div.form-check input:checked");
+
+        let mockSetTimeout;
+        patchWithCleanup(browser, { setTimeout: (fn) => (mockSetTimeout = fn) });
+        await click(target.querySelectorAll("div.o_field_widget div.form-check input")[0]);
+        await click(target.querySelectorAll("div.o_field_widget div.form-check input")[1]);
+        // checkboxes are updated directly
+        assert.containsN(target, "div.o_field_widget div.form-check input:checked", 2);
+        // but no onchanges has been fired yet
+        assert.verifySteps(["get_views", "web_read", "name_search"]);
+        // execute the setTimeout callback
+        mockSetTimeout();
+        await nextTick();
+        assert.verifySteps(["onchange2"]);
+    });
+
+    QUnit.test("Many2ManyCheckBoxesField sends batched changes on save", async function (assert) {
+        serverData.models.partner.records[0].timmy = [];
+        serverData.models.partner.onchanges = {
+            timmy: () => {},
+        };
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            resId: 1,
+            serverData,
+            arch: `
+                <form>
+                    <group>
+                        <field name="timmy" widget="many2many_checkboxes" />
+                    </group>
+                </form>`,
+            mockRPC(route, args) {
+                assert.step(args.method);
+            },
+        });
+
+        assert.containsN(target, "div.o_field_widget div.form-check", 2);
+        assert.deepEqual(
+            getNodesTextContent(target.querySelectorAll(".o_field_widget .form-check-label")),
+            ["gold", "silver"]
+        );
+        assert.containsNone(target, "div.o_field_widget div.form-check input:checked");
+
+        patchWithCleanup(browser, { setTimeout: () => {} }); // never call it
+        await click(target.querySelectorAll("div.o_field_widget div.form-check input")[0]);
+        await click(target.querySelectorAll("div.o_field_widget div.form-check input")[1]);
+        // checkboxes are updated directly
+        assert.containsN(target, "div.o_field_widget div.form-check input:checked", 2);
+        // but no onchanges has been fired yet
+        assert.verifySteps(["get_views", "web_read", "name_search"]);
+        // save
+        await clickSave(target);
+        assert.verifySteps(["onchange2", "write", "web_read"]);
+    });
+
+    QUnit.test("Many2ManyCheckBoxesField in a notebook tab", async function (assert) {
+        serverData.models.partner.records[0].timmy = [];
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            resId: 1,
+            serverData,
+            arch: `
+                <form>
+                    <notebook>
+                        <page string="Page 1">
+                            <field name="timmy" widget="many2many_checkboxes" />
+                        </page>
+                        <page string="Page 2">
+                            <field name="int_field" />
+                        </page>
+                    </notebook>
+                </form>`,
+            mockRPC(route, args) {
+                assert.step(args.method);
+            },
+        });
+
+        assert.containsOnce(target, "div.o_field_widget[name=timmy]");
+        assert.containsN(target, "div.o_field_widget[name=timmy] div.form-check", 2);
+        assert.deepEqual(
+            getNodesTextContent(target.querySelectorAll(".o_field_widget .form-check-label")),
+            ["gold", "silver"]
+        );
+        assert.containsNone(target, "div.o_field_widget[name=timmy] div.form-check input:checked");
+
+        patchWithCleanup(browser, { setTimeout: () => {} }); // never call it
+        await click(target.querySelectorAll("div.o_field_widget div.form-check input")[0]);
+        await click(target.querySelectorAll("div.o_field_widget div.form-check input")[1]);
+        // checkboxes are updated directly
+        assert.containsN(target, "div.o_field_widget div.form-check input:checked", 2);
+        // go to the other tab
+        await click(target.querySelectorAll(".o_notebook .nav-link")[1]);
+        assert.containsNone(target, "div.o_field_widget[name=timmy]");
+        assert.containsOnce(target, "div.o_field_widget[name=int_field]");
+        // save
+        await clickSave(target);
+        assert.verifySteps(["get_views", "web_read", "name_search", "write", "web_read"]);
+    });
 });
diff --git a/addons/web/static/tests/views/fields/many2many_field_tests.js b/addons/web/static/tests/views/fields/many2many_field_tests.js
index a4b54e94219..7fc5c678692 100644
--- a/addons/web/static/tests/views/fields/many2many_field_tests.js
+++ b/addons/web/static/tests/views/fields/many2many_field_tests.js
@@ -220,7 +220,7 @@ QUnit.module("Fields", (hooks) => {
     QUnit.module("Many2ManyField");
 
     QUnit.test("many2many kanban: edition", async function (assert) {
-        assert.expect(31);
+        assert.expect(29);
 
         serverData.views = {
             "partner_type,false,form": '<form><field name="display_name"/></form>',
@@ -267,28 +267,18 @@ QUnit.module("Fields", (hooks) => {
                 }
                 if (route === "/web/dataset/call_kw/partner_type/create") {
                     assert.strictEqual(
-                        args.args[0].display_name,
+                        args.args[0][0].display_name,
                         "A new type",
                         "should create 'A new type'"
                     );
                 }
                 if (route === "/web/dataset/call_kw/partner/write") {
-                    var commands = args.args[1].timmy;
-                    assert.strictEqual(commands.length, 1, "should have generated one command");
-                    assert.strictEqual(
-                        commands[0][0],
-                        6,
-                        "generated command should be REPLACE WITH"
-                    );
+                    const commands = args.args[1].timmy;
                     // get the created type's id
-                    var createdType = serverData.models.partner_type.records.find((record) => {
+                    const createdType = serverData.models.partner_type.records.find((record) => {
                         return record.display_name === "A new type";
                     });
-                    var ids = [12, 15, 18].concat(createdType.id).sort();
-                    assert.ok(
-                        JSON.stringify(commands[0][2].sort()) === JSON.stringify(ids),
-                        "new value should be " + ids
-                    );
+                    assert.deepEqual(commands, [[6, false, [12, 15, 18, createdType.id]]]);
                 }
             },
         });
@@ -658,7 +648,7 @@ QUnit.module("Fields", (hooks) => {
                 mockRPC: async (route, args) => {
                     assert.step(args.method);
                     if (args.method === "create") {
-                        assert.deepEqual(args.args[0], { display_name: "Hello" });
+                        assert.deepEqual(args.args[0][0], { display_name: "Hello" });
                     }
                 },
             });
@@ -671,15 +661,20 @@ QUnit.module("Fields", (hooks) => {
 
             let modal = target.querySelector(".modal");
             await click(modal, ".o_create_button");
-            assert.verifySteps(["get_views", "read", "get_views", "web_search_read", "onchange"]);
-
+            assert.verifySteps([
+                "get_views",
+                "web_read",
+                "get_views",
+                "unity_web_search_read",
+                "onchange2",
+            ]);
             modal = target.querySelector(".modal");
             await editInput(modal, "[name='display_name'] input", "Hello");
             assert.strictEqual(modal.querySelector("[name='display_name'] input").value, "Hello");
 
             await click(modal, ".o_statusbar_buttons [name='myaction']");
             assert.strictEqual(modal.querySelector("[name='display_name'] input").value, "Hello");
-            assert.verifySteps(["create", "read", "action: myaction"]);
+            assert.verifySteps(["create", "web_read", "action: myaction"]);
         }
     );
 
@@ -712,7 +707,7 @@ QUnit.module("Fields", (hooks) => {
                 mockRPC: async (route, args) => {
                     assert.step(args.method);
                     if (args.method === "create") {
-                        assert.deepEqual(args.args[0], { display_name: "Hello" });
+                        assert.deepEqual(args.args[0][0], { display_name: "Hello" });
                     }
                 },
             });
@@ -725,7 +720,13 @@ QUnit.module("Fields", (hooks) => {
 
             let modal = target.querySelector(".modal");
             await click(modal, ".o_create_button");
-            assert.verifySteps(["get_views", "read", "get_views", "web_search_read", "onchange"]);
+            assert.verifySteps([
+                "get_views",
+                "web_read",
+                "get_views",
+                "unity_web_search_read",
+                "onchange2",
+            ]);
 
             modal = target.querySelector(".modal");
             await editInput(modal, "[name='display_name'] input", "Hello");
@@ -751,7 +752,14 @@ QUnit.module("Fields", (hooks) => {
                 ["Hello (edited)"]
             );
 
-            assert.verifySteps(["create", "read", "action: myaction", "write", "read", "read"]);
+            assert.verifySteps([
+                "create",
+                "web_read",
+                "action: myaction",
+                "write",
+                "web_read",
+                "web_read",
+            ]);
         }
     );
 
@@ -776,7 +784,7 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     // done by the SelectCreateDialog
                     assert.deepEqual(args.kwargs.context, {
                         abc: 2,
@@ -794,8 +802,6 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("many2many list (editable): edition", async function (assert) {
-        assert.expect(29);
-
         serverData.models.partner.records[0].timmy = [12, 14];
         serverData.models.partner_type.records.push({ id: 15, display_name: "bronze", color: 6 });
         serverData.models.partner_type.fields.float_field = { string: "Float", type: "float" };
@@ -818,9 +824,7 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method !== "get_views") {
-                    assert.step(route.split("/").at(-1));
-                }
+                assert.step(args.method);
                 if (args.method === "write") {
                     assert.deepEqual(args.args[1].timmy, [
                         [6, false, [12, 15]],
@@ -893,7 +897,7 @@ QUnit.module("Fields", (hooks) => {
             "new name",
             "value of subrecord should have been updated"
         );
-        assert.verifySteps(["read", "read"]);
+        assert.verifySteps(["get_views", "web_read"]);
 
         // add new subrecords
         await click(target.querySelector(".o_field_x2many_list_row_add a"));
@@ -941,11 +945,11 @@ QUnit.module("Fields", (hooks) => {
         );
 
         assert.verifySteps([
-            "web_search_read", // list view in dialog
-            "read", // relational field (updated)
+            "get_views", // list view in dialog
+            "unity_web_search_read", // list view in dialog
+            "web_read", // relational field (updated)
             "write", // save main record
-            "read", // main record
-            "read", // relational field
+            "web_read", // main record
         ]);
     });
 
@@ -1052,10 +1056,10 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             mockRPC(route, args) {
                 if (route === "/web/dataset/call_kw/partner/create") {
-                    assert.deepEqual(args.args[0], { timmy: [[6, false, [12]]] });
+                    assert.deepEqual(args.args[0][0], { timmy: [[6, false, [12]]] });
                 }
                 if (route === "/web/dataset/call_kw/partner/write") {
-                    assert.deepEqual(args.args[1], { timmy: [[6, false, []]] });
+                    assert.deepEqual(args.args[1], { timmy: [[3, 12]] });
                 }
             },
         });
@@ -1375,7 +1379,10 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("many2many list: list of id as default value", async function (assert) {
-        serverData.models.partner.fields.turtles.default = [2, 3];
+        serverData.models.partner.fields.turtles.default = [
+            [4, 2],
+            [4, 3],
+        ];
         serverData.models.partner.fields.turtles.type = "many2many";
 
         await makeView({
@@ -1399,6 +1406,49 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
+    QUnit.test(
+        "context and domain dependent on an x2m must contain the list of current ids for the x2m",
+        async function (assert) {
+            assert.expect(2);
+
+            serverData.models.partner.fields.turtles.default = [
+                [4, 2],
+                [4, 3],
+            ];
+            serverData.models.partner.fields.turtles.type = "many2many";
+            serverData.views = {
+                "turtle,false,list": '<tree><field name="display_name"/></tree>',
+                "turtle,false,search": '<search><field name="display_name"/></search>',
+            };
+
+            await makeView({
+                type: "form",
+                resModel: "partner",
+                serverData,
+                arch: `
+            <form>
+                <field name="turtles" context="{'test': turtles}" domain="[('id', 'in', turtles)]">
+                    <tree>
+                        <field name="turtle_foo"/>
+                    </tree>
+                </field>
+            </form>`,
+                mockRPC(route, args) {
+                    if (args.method === "unity_web_search_read") {
+                        assert.deepEqual(args.kwargs.domain, [
+                            "&",
+                            ["id", "in", [2, 3]],
+                            "!",
+                            ["id", "in", [2, 3]],
+                        ]);
+                        assert.deepEqual(args.kwargs.context.test, [2, 3]);
+                    }
+                },
+            });
+            await addRow(target);
+        }
+    );
+
     QUnit.test("many2many list with x2many: add a record", async function (assert) {
         serverData.models.partner_type.fields.m2m = {
             string: "M2M",
@@ -1428,9 +1478,6 @@ QUnit.module("Fields", (hooks) => {
                 if (args.method !== "get_views") {
                     assert.step(route.split("/").at(-1) + " on " + args.model);
                 }
-                if (args.model === "turtle") {
-                    assert.step(JSON.stringify(args.args[0])); // the read ids
-                }
             },
         });
 
@@ -1464,19 +1511,11 @@ QUnit.module("Fields", (hooks) => {
         );
 
         assert.verifySteps([
-            "read on partner",
-            "web_search_read on partner_type",
-            "read on turtle",
-            "[1,2,3]",
-            "read on partner_type",
-            "read on turtle",
-            "[1,2]",
-            "web_search_read on partner_type",
-            "read on turtle",
-            "[2,3]",
-            "read on partner_type",
-            "read on turtle",
-            "[2,3]",
+            "web_read on partner",
+            "unity_web_search_read on partner_type",
+            "web_read on partner_type",
+            "unity_web_search_read on partner_type",
+            "web_read on partner_type",
         ]);
     });
 
@@ -1535,14 +1574,14 @@ QUnit.module("Fields", (hooks) => {
                 assert.step(args.method);
             },
         });
-        assert.verifySteps(["get_views", "read", "read"]);
+        assert.verifySteps(["get_views", "web_read"]);
 
-        await click($(target).find("td.o_data_cell:first")[0]);
-        assert.verifySteps(["get_views", "read"]);
+        await click(target.querySelector("td.o_data_cell"));
+        assert.verifySteps(["get_views", "web_read"]);
 
-        await click($('.modal-body input[type="checkbox"]')[0]);
-        await click($(".modal .modal-footer .btn-primary").first()[0]);
-        assert.verifySteps(["write", "onchange", "read"]);
+        await click(target.querySelector(".modal-body input[type=checkbox]"));
+        await click(target.querySelector(".modal .modal-footer .btn-primary"));
+        assert.verifySteps(["write", "web_read"]);
 
         // there is nothing left to save -> should not do a 'write' RPC
         await clickSave(target);
@@ -1575,40 +1614,45 @@ QUnit.module("Fields", (hooks) => {
                 mockRPC(route, args) {
                     const { method, kwargs } = args;
                     assert.step(method);
-                    if (method === "onchange") {
+                    if (method === "onchange2") {
                         assert.strictEqual(kwargs.context.default_turtle_trululu, 1);
                         assert.deepEqual(args.args, [
                             [],
                             {},
                             [],
                             {
-                                turtle_trululu: "",
+                                turtle_foo: {},
+                                turtle_trululu: {
+                                    fields: {
+                                        display_name: {},
+                                    },
+                                },
                             },
                         ]);
                     }
                 },
             });
-            assert.verifySteps(["get_views", "read", "read"]);
+            assert.verifySteps(["get_views", "web_read"]);
 
             await addRow(target);
-            assert.verifySteps(["get_views", "web_search_read"]);
+            assert.verifySteps(["get_views", "unity_web_search_read"]);
 
             await click(target, ".o_create_button");
             assert.strictEqual(
                 target.querySelector("[name='turtle_trululu'] input").value,
                 "first record"
             );
-            assert.verifySteps(["get_views", "onchange"]);
+            assert.verifySteps(["get_views", "onchange2"]);
         }
     );
 
     QUnit.test("onchange with 40+ commands for a many2many", async function (assert) {
         // this test ensures that the basic_model correctly handles more LINK_TO
         // commands than the limit of the dataPoint (40 for x2many kanban)
-        assert.expect(25);
+        assert.expect(21);
 
         // create a lot of partner_types that will be linked by the onchange
-        var commands = [[5]];
+        const commands = [];
         for (var i = 0; i < 45; i++) {
             var id = 100 + i;
             serverData.models.partner_type.records.push({ id: id, display_name: "type " + id });
@@ -1642,21 +1686,20 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, args) {
                 assert.step(args.method);
                 if (args.method === "write") {
-                    assert.strictEqual(args.args[1].timmy[0][0], 6, "should send a command 6");
-                    assert.strictEqual(
-                        args.args[1].timmy[0][2].length,
-                        45,
-                        "should replace with 45 ids"
+                    assert.deepEqual(
+                        args.args[1].timmy,
+                        commands.map((c) => [c[0], c[1]]),
+                        "should send all commands"
                     );
                 }
             },
         });
 
-        assert.verifySteps(["get_views", "read"]);
+        assert.verifySteps(["get_views", "web_read"]);
 
         await editInput(target, ".o_field_widget[name=foo] input", "trigger onchange");
 
-        assert.verifySteps(["onchange", "read"]);
+        assert.verifySteps(["onchange2"]);
         assert.strictEqual(
             $(target).find(".o_x2m_control_panel .o_pager_counter").text().trim(),
             "1-40 / 45",
@@ -1669,7 +1712,7 @@ QUnit.module("Fields", (hooks) => {
         );
 
         await click($(target).find(".o_field_widget[name=timmy] .o_pager_next")[0]);
-        assert.verifySteps(["read"]);
+        assert.verifySteps([]);
         assert.strictEqual(
             $(target).find(".o_x2m_control_panel .o_pager_counter").text().trim(),
             "41-45 / 45",
@@ -1718,21 +1761,15 @@ QUnit.module("Fields", (hooks) => {
             "there should be 40 records displayed on page 1"
         );
 
-        assert.verifySteps(["write", "read", "read", "read"]);
+        assert.verifySteps(["write", "web_read", "web_read"]);
     });
 
     QUnit.test("default_get, onchange, onchange on m2m", async function (assert) {
         assert.expect(1);
 
-        serverData.models.partner.onchanges.int_field = function (obj) {
-            if (obj.int_field === 2) {
-                assert.deepEqual(obj.timmy, [
-                    [6, false, [12]],
-                    [1, 12, { display_name: "gold" }],
-                ]);
-            }
-            obj.timmy = [[5], [1, 12, { display_name: "gold" }]];
-        };
+        serverData.models.partner.onchanges.int_field = function () {};
+
+        let firstOnChange = true;
 
         await makeView({
             type: "form",
@@ -1749,6 +1786,24 @@ QUnit.module("Fields", (hooks) => {
                         <field name="int_field"/>
                     </sheet>
                 </form>`,
+            mockRPC(route, args) {
+                if (args.method === "onchange2") {
+                    if (firstOnChange) {
+                        firstOnChange = false;
+                        return {
+                            value: {
+                                timmy: [[1, 12, { display_name: "gold" }]],
+                            },
+                        };
+                    } else {
+                        assert.deepEqual(args.args[1], {
+                            display_name: false,
+                            int_field: 2,
+                            timmy: [[1, 12, { display_name: "gold" }]],
+                        });
+                    }
+                }
+            },
         });
 
         await editInput(target, ".o_field_widget[name=int_field] input", 2);
@@ -1965,7 +2020,7 @@ QUnit.module("Fields", (hooks) => {
                     <field name="timmy" widget="many2many_tags" context="{ 'default_partner_id': active_id, 'ids': active_ids, 'model': active_model, 'company_id': current_company_id}"/>
                 </tree>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.strictEqual(args.kwargs.context.default_partner_id, 1);
                     assert.strictEqual(args.kwargs.context.model, "partner");
                     assert.deepEqual(args.kwargs.context.ids, [1]);
@@ -1976,7 +2031,6 @@ QUnit.module("Fields", (hooks) => {
 
         await click(target.querySelector(".o_data_cell"));
         await editInput(target, ".o_field_many2many_selection input", "indianapolis");
-        await nextTick();
         await clickOpenedDropdownItem(target, "timmy", "Create and edit...");
         assert.containsOnce(target, ".modal .o_field_many2one");
         assert.strictEqual(
@@ -2023,7 +2077,7 @@ QUnit.module("Fields", (hooks) => {
                     <field name="timmy" widget="many2many_tags" context="{ 'default_partner_id': active_id, 'ids': active_ids, 'model': active_model, 'company_id': current_company_id}"/>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.strictEqual(args.kwargs.context.default_partner_id, 1);
                     assert.strictEqual(args.kwargs.context.model, "partner");
                     assert.deepEqual(args.kwargs.context.ids, [1]);
@@ -2088,7 +2142,7 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                     </form>`,
                 mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         assert.strictEqual(args.kwargs.context.default_partner_id, 1);
                         assert.strictEqual(args.kwargs.context.model, "partner");
                         assert.deepEqual(args.kwargs.context.ids, [1]);
diff --git a/addons/web/static/tests/views/fields/many2many_tags_field_tests.js b/addons/web/static/tests/views/fields/many2many_tags_field_tests.js
index e371bd425bd..89347862c85 100644
--- a/addons/web/static/tests/views/fields/many2many_tags_field_tests.js
+++ b/addons/web/static/tests/views/fields/many2many_tags_field_tests.js
@@ -1,6 +1,8 @@
 /** @odoo-module **/
 
 import { makeServerError } from "@web/../tests/helpers/mock_server";
+import { AutoComplete } from "@web/core/autocomplete/autocomplete";
+import { browser } from "@web/core/browser/browser";
 import {
     click,
     clickDiscard,
@@ -18,9 +20,6 @@ import {
     triggerHotkey,
 } from "@web/../tests/helpers/utils";
 import { makeView, setupViewRegistries } from "@web/../tests/views/helpers";
-import { AutoComplete } from "@web/core/autocomplete/autocomplete";
-import { browser } from "@web/core/browser/browser";
-import { many2ManyTagsFieldColorEditable } from "@web/views/fields/many2many_tags/many2many_tags_field";
 
 let serverData;
 let target;
@@ -113,13 +112,14 @@ QUnit.module("Fields", (hooks) => {
     QUnit.module("Many2ManyTagsField");
 
     QUnit.test("Many2ManyTagsField with and without color", async function (assert) {
-        assert.expect(12);
+        assert.expect(14);
 
         serverData.models.partner.fields.partner_ids = {
             string: "Partner",
             type: "many2many",
             relation: "partner",
         };
+        serverData.models.partner.fields.color = { string: "Color index", type: "integer" };
 
         await makeView({
             type: "form",
@@ -130,17 +130,19 @@ QUnit.module("Fields", (hooks) => {
                     <field name="partner_ids" widget="many2many_tags" options="{'color_field': 'color'}"/>
                     <field name="timmy" widget="many2many_tags"/>
                 </form>`,
-            mockRPC: (route, { args, method, model }) => {
-                if (method === "read" && model === "partner_type") {
+            mockRPC: (route, { args, method, model, kwargs }) => {
+                if (method === "web_read" && model === "partner_type") {
+                    assert.deepEqual(args, [[12]]);
                     assert.deepEqual(
-                        args,
-                        [[12], ["display_name"]],
+                        kwargs.specification,
+                        { display_name: {} },
                         "should not read any color field"
                     );
-                } else if (method === "read" && model === "partner") {
+                } else if (method === "web_read" && model === "partner") {
+                    assert.deepEqual(args, [[1]]);
                     assert.deepEqual(
-                        args,
-                        [[1], ["display_name", "color"]],
+                        kwargs.specification,
+                        { display_name: {}, color: {} },
                         "should read color field"
                     );
                 }
@@ -182,7 +184,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("Many2ManyTagsField with color: rendering and edition", async function (assert) {
-        assert.expect(26);
+        assert.expect(24);
 
         serverData.models.partner.records[0].timmy = [12, 14];
         serverData.models.partner_type.records.push({ id: 13, display_name: "red", color: 8 });
@@ -195,7 +197,7 @@ QUnit.module("Fields", (hooks) => {
                     <field name="timmy" widget="many2many_tags" options="{'color_field': 'color', 'no_create_edit': True }"/>
                 </form>`,
             resId: 1,
-            mockRPC: (route, { args, method, model }) => {
+            mockRPC: (route, { args, method, model, kwargs }) => {
                 if (route === "/web/dataset/call_kw/partner/write") {
                     var commands = args[1].timmy;
                     assert.strictEqual(commands.length, 1, "should have generated one command");
@@ -206,11 +208,11 @@ QUnit.module("Fields", (hooks) => {
                     );
                     assert.deepEqual(commands[0][2], [12, 13], "new value should be [12, 13]");
                 }
-                if (method === "read" && model === "partner_type") {
+                if (method === "web_read" && model === "partner_type") {
                     assert.deepEqual(
-                        args[1],
-                        ["display_name", "color"],
-                        "should read the color field"
+                        kwargs.specification,
+                        { display_name: {}, color: {} },
+                        "should read color field"
                     );
                 }
             },
@@ -584,7 +586,7 @@ QUnit.module("Fields", (hooks) => {
             arch: '<form><field name="timmy" widget="many2many_tags"/></form>',
             mockRPC: (route, { args }) => {
                 if (route === "/web/dataset/call_kw/partner/create") {
-                    var commands = args[0].timmy;
+                    const commands = args[0][0].timmy;
                     assert.strictEqual(commands.length, 1, "should have generated one command");
                     assert.strictEqual(
                         commands[0][0],
@@ -723,7 +725,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("Many2ManyTagsField in editable list", async function (assert) {
-        assert.expect(7);
+        assert.expect(5);
 
         serverData.models.partner.records[0].timmy = [12];
 
@@ -737,7 +739,7 @@ QUnit.module("Fields", (hooks) => {
                     <field name="timmy" widget="many2many_tags"/>
                 </tree>`,
             mockRPC: (route, { kwargs, method, model }) => {
-                if (method === "read" && model === "partner_type") {
+                if (method === "web_read" && model === "partner_type") {
                     assert.strictEqual(
                         kwargs.context.take,
                         "five",
@@ -793,43 +795,10 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
-    QUnit.test(
-        "Many2ManyTagsField loads records according to limit defined on widget prototype",
-        async function (assert) {
-            patchWithCleanup(many2ManyTagsFieldColorEditable, {
-                limit: 30,
-            });
-
-            serverData.models.partner.fields.partner_ids = {
-                string: "Partner",
-                type: "many2many",
-                relation: "partner",
-            };
-            serverData.models.partner.records[0].partner_ids = [];
-            for (var i = 15; i < 50; i++) {
-                serverData.models.partner.records.push({ id: i, display_name: "walter" + i });
-                serverData.models.partner.records[0].partner_ids.push(i);
-            }
-            await makeView({
-                type: "form",
-                resModel: "partner",
-                serverData,
-                arch: '<form><field name="partner_ids" widget="many2many_tags"/></form>',
-                resId: 1,
-            });
-
-            assert.strictEqual(
-                target.querySelectorAll('.o_field_widget[name="partner_ids"] .badge').length,
-                30,
-                "should have rendered 30 tags even though 35 records linked"
-            );
-        }
-    );
-
     QUnit.test("Many2ManyTagsField keeps focus when being edited", async function (assert) {
         serverData.models.partner.records[0].timmy = [12];
         serverData.models.partner.onchanges.foo = function (obj) {
-            obj.timmy = [[5]]; // DELETE command
+            obj.timmy = [[3, 12]];
         };
 
         await makeView({
@@ -1180,15 +1149,21 @@ QUnit.module("Fields", (hooks) => {
             arch: '<form><field name="timmy" widget="many2many_tags"/></form>',
             resId: 1,
             mockRPC(route, args) {
-                if (args.method === "read" && args.model === "partner_type") {
-                    assert.step(args.kwargs.context.hello);
+                if (args.method === "web_read" && args.model === "partner") {
+                    assert.step(`${args.method} ${args.model}`);
+                    assert.strictEqual(args.kwargs.specification.timmy.context.hello, "world");
+                }
+
+                if (args.method === "web_read" && args.model === "partner_type") {
+                    assert.step(`${args.method} ${args.model}`);
+                    assert.strictEqual(args.kwargs.context.hello, "world");
                 }
             },
         });
 
-        assert.verifySteps(["world"]);
+        assert.verifySteps(["web_read partner"]);
         await selectDropdownItem(target, "timmy", "silver");
-        assert.verifySteps(["world"]);
+        assert.verifySteps(["web_read partner_type"]);
     });
 
     QUnit.test("Many2ManyTagsField: select multiple records", async function (assert) {
@@ -1380,7 +1355,7 @@ QUnit.module("Fields", (hooks) => {
                     if (args.method === "name_search") {
                         nameSearchProm.resolve();
                     }
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         if (onchangeCalls === 0) {
                             assert.deepEqual(
                                 args.kwargs.context,
@@ -1596,7 +1571,7 @@ QUnit.module("Fields", (hooks) => {
                     throw makeServerError({ type: "ValidationError" });
                 }
                 if (args.method === "create") {
-                    assert.deepEqual(args.args[0], {
+                    assert.deepEqual(args.args[0][0], {
                         color: 8,
                         name: "new partner",
                     });
@@ -1662,6 +1637,7 @@ QUnit.module("Fields", (hooks) => {
             arch: `
                 <tree editable="bottom">
                     <field name="timmy" widget="many2many_tags"/>
+                    <field name="name"/>
                 </tree>`,
         });
 
@@ -1782,6 +1758,55 @@ QUnit.module("Fields", (hooks) => {
         assert.containsOnce(target, "[name='timmy'].o_field_invalid");
     });
 
+    QUnit.test("set a required many2many_tags and save directly", async function (assert) {
+        let def;
+        const form = await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: '<form><field name="timmy" widget="many2many_tags" required="1"/></form>',
+            async mockRPC(route, args) {
+                assert.step(args.method);
+                if (args.method === "web_read") {
+                    await def;
+                }
+            }
+        });
+        patchWithCleanup(form.env.services.notification, {
+            add: () => assert.step("notification"),
+        });
+
+        assert.verifySteps([
+            "get_views",
+            "onchange2",
+        ]);
+
+        assert.containsNone(target, ".o_tag");
+
+        def = makeDeferred();
+        await clickDropdown(target, "timmy");
+        await clickOpenedDropdownItem(target, "timmy", "gold");
+        assert.containsNone(target, ".o_tag");
+
+        assert.verifySteps([
+            "name_search",
+            "web_read",
+        ]);
+
+        await clickSave(target);
+        assert.doesNotHaveClass(target, "[name='timmy']", "o_field_invalid");
+
+        assert.verifySteps([]);
+
+        def.resolve();
+        await nextTick();
+
+        assert.verifySteps([
+            "create",
+            "web_read",
+        ]);
+    });
+
     QUnit.test("Many2ManyTagsField with option 'no_quick_create' set to true", async (assert) => {
         serverData.views = {
             "partner_type,false,form": `<form><field name="name"/><field name="color"/></form>`,
@@ -1875,7 +1900,7 @@ QUnit.module("Fields", (hooks) => {
             arch: `<form><field name="timmy" widget="many2many_tags" context="{ 'append_coucou': True }"/></form>`,
             async mockRPC(route, args, performRPC) {
                 const result = await performRPC(route, args);
-                if (args.method === "read") {
+                if (args.method === "web_read") {
                     if (args.kwargs.context.append_coucou) {
                         assert.step("read with context given");
                         result[0].display_name += " coucou";
@@ -1907,7 +1932,7 @@ QUnit.module("Fields", (hooks) => {
             arch: `<list editable="top"><field name="timmy" widget="many2many_tags" context="{ 'append_coucou': True }"/></list>`,
             async mockRPC(route, args, performRPC) {
                 const result = await performRPC(route, args);
-                if (args.method === "read") {
+                if (args.method === "web_read") {
                     if (args.kwargs.context.append_coucou) {
                         assert.step("read with context given");
                         result[0].display_name += " coucou";
diff --git a/addons/web/static/tests/views/fields/many2one_barcode_field_tests.js b/addons/web/static/tests/views/fields/many2one_barcode_field_tests.js
index b76f4d66a31..c373d3551de 100644
--- a/addons/web/static/tests/views/fields/many2one_barcode_field_tests.js
+++ b/addons/web/static/tests/views/fields/many2one_barcode_field_tests.js
@@ -134,7 +134,7 @@ QUnit.module("Fields", (hooks) => {
             `,
             async mockRPC(route, args, performRPC) {
                 if (args.method === CREATE && args.model === SALE_ORDER_LINE) {
-                    const selectedId = args.args[0][PRODUCT_FIELD_NAME];
+                    const selectedId = args.args[0][0][PRODUCT_FIELD_NAME];
                     assert.equal(
                         selectedId,
                         selectedRecordTest.id,
@@ -173,7 +173,7 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             async mockRPC(route, args, performRPC) {
                 if (args.method === CREATE && args.model === SALE_ORDER_LINE) {
-                    const selectedId = args.args[0][PRODUCT_FIELD_NAME];
+                    const selectedId = args.args[0][0][PRODUCT_FIELD_NAME];
                     assert.equal(
                         selectedId,
                         selectedRecordTest.id,
diff --git a/addons/web/static/tests/views/fields/many2one_field_tests.js b/addons/web/static/tests/views/fields/many2one_field_tests.js
index c69e6fce3b8..1f758f68f02 100644
--- a/addons/web/static/tests/views/fields/many2one_field_tests.js
+++ b/addons/web/static/tests/views/fields/many2one_field_tests.js
@@ -346,14 +346,15 @@ QUnit.module("Fields", (hooks) => {
                     <field name="int_field" />
                     <field name="trululu" context="{'blip': int_field, 'blop': 3}" options="{'always_reload': 1}" />
                 </form>`,
-            mockRPC(route, { method, kwargs }) {
-                if (method === "read") {
+            mockRPC(route, { method, args }) {
+                if (method === "onchange2") {
+                    const context = args[3].trululu.context;
                     assert.strictEqual(
-                        kwargs.context.blip,
+                        context.blip,
                         undefined,
                         "context should not contain dynamic keys depending on the data"
                     );
-                    assert.strictEqual(kwargs.context.blop, 3);
+                    assert.strictEqual(context.blop, 3);
                 }
             },
         });
@@ -422,14 +423,14 @@ QUnit.module("Fields", (hooks) => {
                         </group>
                     </sheet>
                 </form>`,
-            mockRPC(route, { args, method, kwargs }) {
-                if (
-                    method === "read" &&
-                    args[1].length === 1 &&
-                    args[1][0] === "display_name" &&
-                    kwargs.context.show_address
-                ) {
-                    return [{ id: 4, display_name: "aaa\nStreet\nCity ZIP" }];
+            async mockRPC(route, { method, kwargs }) {
+                if (method === "web_read" && kwargs.specification.trululu.context.show_address) {
+                    return [
+                        {
+                            display_name: "",
+                            trululu: { display_name: "aaa\nStreet\nCity ZIP" },
+                        },
+                    ];
                 }
             },
         });
@@ -466,14 +467,18 @@ QUnit.module("Fields", (hooks) => {
                         </group>
                     </sheet>
                 </form>`,
-            mockRPC(route, { args, kwargs, method }) {
-                if (
-                    method === "read" &&
-                    args[1].length === 1 &&
-                    args[1][0] === "display_name" &&
-                    kwargs.context.show_address
-                ) {
-                    return args.map((id) => ({ id, display_name: namegets[id] }));
+            async mockRPC(route, { args, kwargs, method }, performRPC) {
+                if (method === "web_read" && kwargs.specification.trululu.context.show_address) {
+                    const result = await performRPC(...arguments);
+                    result[0].trululu = {
+                        id: result[0].trululu.id,
+                        display_name: namegets[result[0].trululu.id],
+                    };
+                    return result;
+                }
+                if (method === "name_search") {
+                    const result = await performRPC(...arguments);
+                    return result.map(([id]) => [id, namegets[id]]);
                 }
             },
         });
@@ -531,14 +536,21 @@ QUnit.module("Fields", (hooks) => {
                         <field name="display_name" />
                         <field name="turtles" />
                     </form>`,
-                mockRPC(route, { args, kwargs, method }) {
-                    if (
-                        method === "read" &&
-                        args[1].length === 1 &&
-                        args[1][0] === "display_name" &&
-                        kwargs.context.show_address
-                    ) {
-                        return [{ id: 2, display_name: "second record\nrue morgue\nparis 75013" }];
+                mockRPC(route, { kwargs, method, model }) {
+                    if (method === "web_read" && model === "turtle") {
+                        assert.deepEqual(kwargs.specification.turtle_trululu.context, {
+                            show_address: 1,
+                        });
+                        return [
+                            {
+                                id: 1,
+                                display_name: "donatello",
+                                turtle_trululu: {
+                                    id: 2,
+                                    display_name: "second record\nrue morgue\nparis 75013",
+                                },
+                            },
+                        ];
                     }
                 },
             });
@@ -553,55 +565,6 @@ QUnit.module("Fields", (hooks) => {
         }
     );
 
-    QUnit.test(
-        "many2one data is reloaded if there is a context to take into account",
-        async function (assert) {
-            serverData.models.turtle.records[1].turtle_trululu = 2;
-            serverData.views = {
-                "turtle,false,form": `
-                    <form>
-                        <field name="display_name" />
-                        <field name="turtle_trululu" context="{'show_address': 1}" options="{'always_reload': 1}" />
-                    </form>`,
-                "turtle,false,list": `
-                    <tree>
-                        <field name="display_name" />
-                        <field name="turtle_trululu" />
-                    </tree>`,
-            };
-
-            await makeView({
-                type: "form",
-                resModel: "partner",
-                serverData,
-                resId: 1,
-                arch: `
-                    <form edit="0">
-                        <field name="display_name" />
-                        <field name="turtles" />
-                    </form>`,
-                mockRPC(route, { kwargs, method, args }) {
-                    if (
-                        method === "read" &&
-                        args[1].length === 1 &&
-                        args[1][0] === "display_name" &&
-                        kwargs.context.show_address
-                    ) {
-                        return [{ id: 2, display_name: "second record\nrue morgue\nparis 75013" }];
-                    }
-                },
-            });
-            // click the turtle field, opens a modal with the turtle form view
-            await click(target.querySelector(".o_data_row td.o_data_cell"));
-
-            assert.strictEqual(
-                target.querySelector('.modal [name="turtle_trululu"]').textContent,
-                "second recordrue morgueparis 75013",
-                "The partner's address should be displayed"
-            );
-        }
-    );
-
     QUnit.test("many2ones in form views with search more", async function (assert) {
         for (let i = 5; i < 11; i++) {
             serverData.models.partner.records.push({ id: i, display_name: `Partner ${i}` });
@@ -733,7 +696,7 @@ QUnit.module("Fields", (hooks) => {
             await selectDropdownItem(target, "trululu", "Create and edit...");
 
             await clickSave(target.querySelector(".modal"));
-            assert.verifySteps([`create: [{"name":"yy"}]`]);
+            assert.verifySteps([`create: [[{"name":"yy"}]]`]);
             assert.strictEqual(
                 target.querySelector(".o_field_widget[name=trululu] input").value,
                 "yy"
@@ -837,7 +800,7 @@ QUnit.module("Fields", (hooks) => {
                     if (method === "get_formview_id") {
                         return Promise.resolve(false);
                     }
-                    if (method === "onchange") {
+                    if (method === "onchange2") {
                         assert.strictEqual(
                             args[1].user_id,
                             17,
@@ -855,17 +818,18 @@ QUnit.module("Fields", (hooks) => {
                 "wood"
             );
 
+            // TODISCUSS ? Same record, don't change the display name (opti ?)
             // save the modal and make sure an onchange is triggered
             await clickSave(target.querySelectorAll(".modal")[1]);
             assert.verifySteps([
                 "get_views",
-                "read",
+                "web_read",
                 "get_formview_id",
                 "get_views",
-                "read",
+                "web_read",
                 "write",
                 "read",
-                "onchange",
+                "onchange2",
             ]);
         }
     );
@@ -1119,60 +1083,6 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
-    QUnit.test(
-        "empty many2one should not be considered modified on onchange if still empty",
-        async function (assert) {
-            serverData.models.partner.onchanges = {
-                foo: function () {},
-            };
-
-            assert.strictEqual(
-                serverData.models.partner.records[2].trululu,
-                undefined,
-                "no value must be provided for trululu to make sure the test works as expected"
-            );
-
-            await makeView({
-                type: "form",
-                resModel: "partner",
-                resId: 4, // trululu m2o must be empty
-                serverData,
-                arch: `
-                    <form>
-                        <sheet>
-                            <group>
-                                <field name="trululu" />
-                                <field name="foo" /> <!-- onchange will be triggered on this field -->
-                            </group>
-                        </sheet>
-                    </form>`,
-                mockRPC(route, { method, args }) {
-                    if (method === "onchange") {
-                        assert.step("onchange");
-                        return Promise.resolve({
-                            value: {
-                                trululu: false,
-                            },
-                        });
-                    } else if (method === "write") {
-                        assert.step("write");
-                        // non modified trululu should not be sent
-                        // as write value
-                        assert.deepEqual(args[1], { foo: "3" });
-                    }
-                },
-            });
-
-            // trigger the onchange
-            await editInput(target, ".o_field_widget[name='foo'] input", "3");
-            assert.verifySteps(["onchange"]);
-
-            // save
-            await clickSave(target);
-            assert.verifySteps(["write"]);
-        }
-    );
-
     QUnit.test("many2one in edit mode", async function (assert) {
         assert.expect(17);
 
@@ -1448,18 +1358,29 @@ QUnit.module("Fields", (hooks) => {
                         </group>
                     </sheet>
                 </form>`,
-            mockRPC(route, { args, kwargs, method }) {
-                if (method === "read" && args[1].length === 1 && args[1][0] === "display_name") {
+            async mockRPC(route, { args, kwargs, method }, performRPC) {
+                if (method === "web_read") {
                     assert.step(method);
-                    return args.map((id) => ({ id, display_name: namegets[id] }));
+                    const result = await performRPC(...arguments);
+                    result[0].trululu = {
+                        id: result[0].trululu.id,
+                        display_name: namegets[result[0].trululu.id],
+                    };
+                    return result;
                 }
                 if (method === "name_search") {
                     assert.step(method);
-                    return Object.keys(namegets).map((id) => [id, namegets[id]]);
+                    return Object.keys(namegets).map((id) => [parseInt(id), namegets[id]]);
+                }
+                if (method === "write") {
+                    assert.step(method);
+                    assert.deepEqual(args[1], {
+                        trululu: 2,
+                    });
                 }
             },
         });
-        assert.verifySteps(["read"]);
+        assert.verifySteps(["web_read"]);
 
         const input = target.querySelector(".o_field_widget input");
 
@@ -1482,13 +1403,15 @@ QUnit.module("Fields", (hooks) => {
         );
         await click(target.querySelector(".dropdown-menu li"));
 
-        // Check the selection has been taken into account
-        assert.verifySteps(["read"]);
+        assert.verifySteps([]);
         assert.strictEqual(input.value, "fizz");
         assert.strictEqual(
             target.querySelector(".o_field_many2one_extra").innerHTML,
             "<span>buzz</span><br><span>fizzbuzz</span>"
         );
+
+        await clickSave(target);
+        assert.verifySteps(["write", "web_read"]);
     });
 
     QUnit.test("many2one search with trailing and leading spaces", async function (assert) {
@@ -1550,37 +1473,8 @@ QUnit.module("Fields", (hooks) => {
         assert.verifySteps(["search: ", "search: first", "search: first", "search: first"]);
     });
 
-    QUnit.test("many2one field with option always_reload (readonly)", async function (assert) {
-        let count = 0;
-        await makeView({
-            type: "form",
-            resModel: "partner",
-            resId: 2,
-            serverData,
-            arch: `
-                <form>
-                    <field name="trululu" options="{'always_reload': 1}" readonly="1" />
-                </form>`,
-            mockRPC(route, { method, args }) {
-                if (method === "read" && args[1].length === 1 && args[1][0] === "display_name") {
-                    count++;
-                    return Promise.resolve([
-                        { id: 1, display_name: "first record\nand some address" },
-                    ]);
-                }
-            },
-        });
-
-        assert.strictEqual(count, 1, "an extra read should have been done");
-        assert.ok(
-            target.querySelector("a.o_form_uri").textContent.includes("and some address"),
-            "should display additional result"
-        );
-        assert.containsNone(target, ".o_field_many2one_extra");
-    });
-
+    // Should be removed ?
     QUnit.test("many2one field with option always_reload (edit)", async function (assert) {
-        let count = 0;
         await makeView({
             type: "form",
             resModel: "partner",
@@ -1590,17 +1484,18 @@ QUnit.module("Fields", (hooks) => {
                 <form>
                     <field name="trululu" options="{'always_reload': 1}" />
                 </form>`,
-            mockRPC(route, { method, args }) {
-                if (method === "read" && args[1].length === 1 && args[1][0] === "display_name") {
-                    count++;
-                    return Promise.resolve([
-                        { id: 1, display_name: "first record\nand some address" },
-                    ]);
+            async mockRPC(route, { method, args }, performRPC) {
+                if (method === "web_read") {
+                    const result = await performRPC(...arguments);
+                    result[0].trululu = {
+                        ...result[0].trululu,
+                        display_name: "first record\nand some address",
+                    };
+                    return result;
                 }
             },
         });
 
-        assert.strictEqual(count, 1, "an extra read should have been done");
         assert.strictEqual(
             target.querySelector(".o_field_widget[name='trululu'] input").value,
             "first record",
@@ -1711,7 +1606,7 @@ QUnit.module("Fields", (hooks) => {
                 if (method === "create") {
                     assert.step("create");
                     assert.strictEqual(
-                        args[0].trululu,
+                        args[0][0].trululu,
                         newRecordId,
                         "should create with the correct m2o id"
                     );
@@ -1844,7 +1739,7 @@ QUnit.module("Fields", (hooks) => {
                 if (method === "create") {
                     assert.step("create");
                     assert.strictEqual(
-                        args[0].p[0][2].trululu,
+                        args[0][0].p[0][2].trululu,
                         newRecordId,
                         "should create with the correct m2o id"
                     );
@@ -1942,7 +1837,7 @@ QUnit.module("Fields", (hooks) => {
                     await def;
                 }
                 if (method === "create") {
-                    assert.deepEqual(args[0].p[0][2].trululu, newRecordId);
+                    assert.deepEqual(args[0][0].p[0][2].trululu, newRecordId);
                 }
             },
         });
@@ -1961,7 +1856,7 @@ QUnit.module("Fields", (hooks) => {
             "the row should still be in edition"
         );
 
-        await def.resolve();
+        def.resolve();
         await nextTick();
 
         assert.strictEqual(
@@ -2111,7 +2006,6 @@ QUnit.module("Fields", (hooks) => {
                 "",
                 "should have empty string in the required field on this record"
             );
-            // FIXME: I added the await here and 6 lines below
             await click(target.querySelector(".o_data_row .o_data_cell"));
             assert.hasClass(
                 target.querySelectorAll(".o_selected_row .o_data_cell")[1],
@@ -2502,7 +2396,7 @@ QUnit.module("Fields", (hooks) => {
         assert.expect(3);
 
         serverData.models.partner.fields.timmy.default = [
-            [0, 0, { display_name: "brandon is the new timmy", name: "brandon" }],
+            [0, 0, { display_name: "brandon is the new timmy" }],
         ];
         serverData.models.partner.onchanges.timmy = (obj) => {
             obj.int_field = obj.timmy.length;
@@ -2527,19 +2421,10 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, { args, method }) {
                 if (method === "create") {
                     assert.deepEqual(
-                        args[0],
+                        args[0][0],
                         {
-                            int_field: 2,
-                            timmy: [
-                                [6, false, []],
-                                // LPE TODO 1 taskid-2261084: remove this entire comment including code snippet
-                                // when the change in behavior has been thoroughly tested.
-                                // We can't distinguish a value coming from a default_get
-                                // from one coming from the onchange, and so we can either store and
-                                // send it all the time, or never.
-                                // [0, args[0].timmy[1][1], { display_name: displayName, name: 'brandon' }],
-                                [0, args[0].timmy[1][1], { display_name: displayName }],
-                            ],
+                            int_field: 1,
+                            timmy: [[0, args[0][0].timmy[0][1], { display_name: "new value" }]],
                         },
                         "should send the correct values to create"
                     );
@@ -2571,7 +2456,10 @@ QUnit.module("Fields", (hooks) => {
         async function (assert) {
             assert.expect(1);
 
-            serverData.models.partner.fields.turtles.default = [[6, 0, [2, 3]]];
+            serverData.models.partner.fields.turtles.default = [
+                [4, 2],
+                [4, 3],
+            ];
 
             await makeView({
                 type: "form",
@@ -2591,10 +2479,10 @@ QUnit.module("Fields", (hooks) => {
                 mockRPC(route, { args, method }) {
                     if (method === "create") {
                         assert.deepEqual(
-                            args[0].turtles,
+                            args[0][0].turtles,
                             [
-                                [4, 2, false],
-                                [4, 3, false],
+                                [4, 2],
+                                [4, 3],
                             ],
                             "should send proper commands to create method"
                         );
@@ -2709,6 +2597,8 @@ QUnit.module("Fields", (hooks) => {
             relation: "turtle",
         };
         serverData.models.product.records[0].turtle_ids = [1];
+        serverData.models.product.records[0].display_name = "leonardo";
+        serverData.models.product.records[0].name = "xphone";
 
         serverData.models.turtle.fields.partner_types_ids = {
             string: "Partner",
@@ -2720,6 +2610,7 @@ QUnit.module("Fields", (hooks) => {
             type: "many2one",
             relation: "partner_type",
         };
+        serverData.models.turtle.records[0].type_id = 12;
 
         serverData.models.partner_type.fields.partner_ids = {
             string: "Partner",
@@ -2754,20 +2645,9 @@ QUnit.module("Fields", (hooks) => {
                         </tree>
                     </field>
                 </form>`,
-            mockRPC(route) {
-                if (route === "/web/dataset/call_kw/product/read") {
-                    return Promise.resolve([
-                        { id: 37, name: "xphone", display_name: "leonardo", turtle_ids: [1] },
-                    ]);
-                }
-                if (route === "/web/dataset/call_kw/turtle/read") {
-                    return Promise.resolve([{ id: 1, type_id: [12, "gold"] }]);
-                }
+            async mockRPC(route) {
                 if (route === "/web/dataset/call_kw/partner_type/get_formview_id") {
-                    return Promise.resolve(false);
-                }
-                if (route === "/web/dataset/call_kw/partner_type/read") {
-                    return Promise.resolve([{ id: 12, partner_ids: [1, 2], display_name: "gold" }]);
+                    return false;
                 }
                 if (route === "/web/dataset/call_kw/partner_type/write") {
                     assert.step("partner_type write");
@@ -2854,8 +2734,6 @@ QUnit.module("Fields", (hooks) => {
             },
         };
 
-        let count = 0;
-
         await makeView({
             type: "form",
             resModel: "partner",
@@ -2864,28 +2742,25 @@ QUnit.module("Fields", (hooks) => {
                 <form>
                     <field name="trululu" options="{'always_reload': 1}" />
                 </form>`,
-            mockRPC(route, { args, method }) {
-                count++;
-                if (
-                    method === "read" &&
-                    args[1].length === 1 &&
-                    args[1][0] === "display_name" &&
-                    args[0] === 2
-                ) {
-                    // LPE: any call_kw route can take either [ids] or id as the first
-                    // argument as model.browse() in python supports both
-                    // With the basic_model, read is passed only an id, not an array
-                    return Promise.resolve([{ id: 2, display_name: "hello world\nso much noise" }]);
+            async mockRPC(route, { args, method }, performRPC) {
+                assert.step(method);
+                if (method === "onchange2") {
+                    const result = await performRPC(...arguments);
+                    result.value.trululu = {
+                        ...result.value.trululu,
+                        display_name: "hello world\nso much noise",
+                    };
+                    return result;
                 }
             },
         });
 
-        assert.strictEqual(count, 3, "should have done 3 rpcs (get_views, onchange and read)");
         assert.strictEqual(
             target.querySelector(".o_field_widget[name='trululu'] input").value,
             "hello world",
             "should have taken the correct display name"
         );
+        assert.verifySteps(["get_views", "onchange2"]);
     });
 
     QUnit.test(
@@ -3060,7 +2935,7 @@ QUnit.module("Fields", (hooks) => {
                         throw makeServerError({ type: "ValidationError" });
                     }
                     if (method === "create") {
-                        assert.deepEqual(args[0], { name: "xyz" });
+                        assert.deepEqual(args[0][0], { name: "xyz" });
                     }
                 },
             });
@@ -3133,7 +3008,7 @@ QUnit.module("Fields", (hooks) => {
                         throw makeServerError({ type: "ValidationError" });
                     }
                     if (method === "create") {
-                        assert.deepEqual(args[0], { name: "xyz" });
+                        assert.deepEqual(args[0][0], { name: "xyz" });
                     }
                 },
             });
@@ -3714,11 +3589,11 @@ QUnit.module("Fields", (hooks) => {
             assert.containsNone(target, ".modal", "should not have any modal in DOM");
             assert.verifySteps([
                 "get_views",
-                "web_search_read", // to display results in the dialog
+                "unity_web_search_read", // to display results in the dialog
                 "name_search",
-                "onchange",
+                "onchange2",
                 "write",
-                "read",
+                "web_read",
             ]);
         }
     );
@@ -3764,11 +3639,11 @@ QUnit.module("Fields", (hooks) => {
             assert.containsNone(target, ".modal", "should not have any modal in DOM");
             assert.verifySteps([
                 "get_views",
-                "web_search_read", // to display results in the dialog
+                "unity_web_search_read", // to display results in the dialog
                 "name_search",
-                "onchange",
+                "onchange2",
                 "write",
-                "read",
+                "web_read",
             ]);
         }
     );
@@ -3899,7 +3774,7 @@ QUnit.module("Fields", (hooks) => {
             arch: '<form><field name="trululu" /></form>',
             mockRPC(route, { kwargs, method }) {
                 assert.step(method);
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.deepEqual(
                         kwargs.domain,
                         [],
@@ -3918,10 +3793,10 @@ QUnit.module("Fields", (hooks) => {
 
         assert.verifySteps([
             "get_views", // main form view
-            "onchange",
+            "onchange2",
             "name_search", // to display results in the dropdown
             "get_views", // list view in dialog
-            "web_search_read", // to display results in the dialog
+            "unity_web_search_read", // to display results in the dialog
         ]);
     });
 
@@ -3951,7 +3826,7 @@ QUnit.module("Fields", (hooks) => {
             arch: '<form><field name="trululu" /></form>',
             mockRPC(route, { kwargs, method }) {
                 assert.step(method || route);
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.deepEqual(kwargs.domain, expectedDomain);
                 }
             },
@@ -3976,13 +3851,13 @@ QUnit.module("Fields", (hooks) => {
 
         assert.verifySteps([
             "get_views", // main form view
-            "onchange",
+            "onchange2",
             "name_search", // empty search, triggered when the user clicks in the input
             "name_search", // to display results in the dropdown
             "name_search", // to get preselected ids matching the search
             "get_views", // list view in dialog
-            "web_search_read", // to display results in the dialog
-            "web_search_read", // after removal of dynamic filter
+            "unity_web_search_read", // to display results in the dialog
+            "unity_web_search_read", // after removal of dynamic filter
         ]);
     });
 
@@ -4073,7 +3948,8 @@ QUnit.module("Fields", (hooks) => {
 
         // Test whether the value has changed
         assert.strictEqual(
-            target.querySelectorAll(".o_data_cell")[1].textContent,
+            target.querySelector(".o_dialog:not(.o_inactive_modal) div[name=turtle_trululu] input")
+                .value,
             "test",
             "the partner name should have been updated to 'test'"
         );
@@ -4102,7 +3978,7 @@ QUnit.module("Fields", (hooks) => {
             arch: '<form><field name="trululu" /></form>',
             mockRPC(route, { kwargs, method }) {
                 assert.step(method || route);
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.deepEqual(
                         kwargs.domain,
                         [],
@@ -4126,10 +4002,10 @@ QUnit.module("Fields", (hooks) => {
 
         assert.verifySteps([
             "get_views",
-            "onchange",
+            "onchange2",
             "name_search", // to display results in the dropdown
             "get_views", // list view in dialog
-            "web_search_read", // to display results in the dialog
+            "unity_web_search_read", // to display results in the dialog
             "/web/dataset/resequence", // resequencing lines
             "read",
         ]);
diff --git a/addons/web/static/tests/views/fields/monetary_field_tests.js b/addons/web/static/tests/views/fields/monetary_field_tests.js
index 6a3532ea0f7..3906b3b4665 100644
--- a/addons/web/static/tests/views/fields/monetary_field_tests.js
+++ b/addons/web/static/tests/views/fields/monetary_field_tests.js
@@ -679,7 +679,7 @@ QUnit.module("Fields", (hooks) => {
             string: "m2m",
             type: "many2many",
             relation: "partner",
-            default: [[6, false, [2]]],
+            default: [[4, 2]],
         };
         serverData.views = {
             "partner,false,list": `
diff --git a/addons/web/static/tests/views/fields/one2many_field_tests.js b/addons/web/static/tests/views/fields/one2many_field_tests.js
index e630a9d858f..ad16c4b408d 100644
--- a/addons/web/static/tests/views/fields/one2many_field_tests.js
+++ b/addons/web/static/tests/views/fields/one2many_field_tests.js
@@ -27,14 +27,15 @@ import { makeView, makeViewInDialog, setupViewRegistries } from "@web/../tests/v
 import { createWebClient, doAction } from "@web/../tests/webclient/helpers";
 import { browser } from "@web/core/browser/browser";
 import { registry } from "@web/core/registry";
+import { pick } from "@web/core/utils/objects";
 import { getNextTabableElement } from "@web/core/utils/ui";
 import { session } from "@web/session";
-import { RelationalModel } from "@web/views/relational_model";
-import { makeTestEnv } from "@web/../tests/helpers/mock_env";
-import { rpcService } from "@web/core/network/rpc_service";
-import { pick } from "@web/core/utils/objects";
-import BasicModel from "web.BasicModel";
+import { Record } from "@web/model/relational_model/record";
 import { getPickerCell } from "../../core/datetime/datetime_test_helpers";
+import { makeServerError } from "@web/../tests/helpers/mock_server";
+import { errorService } from "../../../src/core/errors/error_service";
+
+const serviceRegistry = registry.category("services");
 
 let serverData;
 let target;
@@ -242,7 +243,10 @@ QUnit.module("Fields", (hooks) => {
             // Needed to have two new records in a single stroke
             serverData.models.partner.onchanges = {
                 foo: function (obj) {
-                    obj.p = [[5], [0, 0, { trululu: false }], [0, 0, { trululu: false }]];
+                    obj.p = [
+                        [0, 0, { trululu: false }],
+                        [0, 0, { trululu: false }],
+                    ];
                 },
             };
 
@@ -279,10 +283,34 @@ QUnit.module("Fields", (hooks) => {
             // of the lines of "p"
             await dragAndDrop("tbody tr:nth-child(2) .o_handle_cell", "tbody tr", "top");
 
-            assert.verifySteps(["onchange partner"]);
+            assert.verifySteps(["onchange2 partner"]);
         }
     );
 
+    QUnit.test("O2M field without relation_field", async function (assert) {
+        delete serverData.models.partner.fields.p.relation_field;
+
+        serverData.models.partner.records[0].p = [2, 4];
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <form>
+                    <field name="p">
+                        <tree>
+                            <field name="foo" invisible="1"/>
+                            <field name="display_name" />
+                        </tree>
+                    </field>
+                </form>`,
+            resId: 1,
+        });
+
+        await addRow(target, ".o_field_x2many_list");
+        assert.containsOnce(target, ".o_dialog");
+    });
+
     QUnit.test(
         "O2M List with pager, decoration and default_order: add and cancel adding",
         async function (assert) {
@@ -501,7 +529,6 @@ QUnit.module("Fields", (hooks) => {
                         2,
                         {
                             partner_ids: [
-                                [6, false, [2, 4]],
                                 [1, 2, { int_field: 0 }],
                                 [1, 4, { int_field: 1 }],
                             ],
@@ -510,7 +537,7 @@ QUnit.module("Fields", (hooks) => {
                 }
             },
         });
-        assert.verifySteps(["get_views", "read", "read"]);
+        assert.verifySteps(["get_views", "web_read"]);
 
         await click(target, ".o_data_cell");
         assert.containsOnce(target, ".modal");
@@ -520,7 +547,7 @@ QUnit.module("Fields", (hooks) => {
             ),
             ["aaa", "second record"]
         );
-        assert.verifySteps(["read", "read"]);
+        assert.verifySteps(["web_read"]);
 
         await dragAndDrop(".modal tr:nth-child(2) .o_handle_cell", "tbody tr", "top");
         assert.deepEqual(
@@ -533,7 +560,7 @@ QUnit.module("Fields", (hooks) => {
 
         await clickSave(target.querySelector(".modal"));
         await clickSave(target);
-        assert.verifySteps(["write", "read", "read"]);
+        assert.verifySteps(["write", "web_read"]);
     });
 
     QUnit.test("one2many list editable with cell readonly modifier", async function (assert) {
@@ -559,8 +586,8 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, args) {
                 if (route === "/web/dataset/call_kw/partner/write") {
                     assert.deepEqual(
-                        args.args[1].p[1][2],
-                        { foo: "ff", qux: 99 },
+                        args.args[1].p[0][2],
+                        { foo: "ff", qux: 99, turtles: [] },
                         "The right values should be written"
                     );
                 }
@@ -601,6 +628,58 @@ QUnit.module("Fields", (hooks) => {
         await clickSave(target);
     });
 
+    QUnit.test(
+        "one2many wait for the onchange of the resequenced finish before save",
+        async function (assert) {
+            assert.expect(4);
+
+            serverData.models.partner.records[0].p = [1, 2];
+            serverData.models.partner.onchanges = {
+                p: function (obj) {
+                    obj.p = [[1, 2, { qux: 99 }]];
+                },
+            };
+            const def = makeDeferred();
+            await makeView({
+                type: "form",
+                resModel: "partner",
+                serverData,
+                arch: `
+                <form>
+                    <field name="p">
+                        <tree>
+                            <field name="int_field" widget="handle"/>
+                            <field name="foo"/>
+                            <field name="qux"/>
+                        </tree>
+                    </field>
+                </form>`,
+                resId: 1,
+                async mockRPC(route, args) {
+                    if (args.method === "onchange2") {
+                        await def;
+                        assert.step("onchange");
+                    }
+                    if (args.method === "write") {
+                        assert.step("write");
+                        assert.deepEqual(args.args[1].p, [
+                            [1, 1, { int_field: 9 }],
+                            [1, 2, { int_field: 10, qux: 99 }],
+                        ]);
+                    }
+                },
+            });
+            // Drag and drop the second line in first position
+            await dragAndDrop("tbody tr:nth-child(2) .o_handle_cell", "tbody tr", "top");
+            await clickSave(target);
+
+            // resolve the onchange promise
+            def.resolve();
+            await nextTick();
+            assert.verifySteps(["onchange", "write"]);
+        }
+    );
+
     QUnit.test("one2many basic properties", async function (assert) {
         serverData.models.partner.records[0].p = [2];
         await makeView({
@@ -627,12 +706,7 @@ QUnit.module("Fields", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "read", "read"]);
-        // assert.containsNone(target, "td.o_list_record_selector");
-        // assert.containsNone(target, ".o_field_x2many_list_row_add");
-        // assert.containsNone(target, "td.o_list_record_remove");
-        // await clickEdit(target);
-
+        assert.verifySteps(["get_views", "web_read"]);
         assert.containsOnce(target, ".o_field_x2many_list_row_add");
         assert.hasAttrValue(target.querySelector(".o_field_x2many_list_row_add"), "colspan", "2");
         assert.containsOnce(target, "td.o_list_record_remove");
@@ -748,11 +822,42 @@ QUnit.module("Fields", (hooks) => {
         }
     );
 
+    QUnit.test("nested x2manys with inline form, but not list", async function (assert) {
+        serverData.views = {
+            "turtle,false,list": `<tree><field name="turtle_foo"/></tree>`,
+            "partner,false,list": `<tree><field name="foo"/></tree>`,
+        };
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <form>
+                    <field name="turtles">
+                        <form>
+                            <field name="turtle_foo"/>
+                            <field name="partner_ids">
+                                <form>
+                                    <field name="foo"/>
+                                </form>
+                            </field>
+                        </form>
+                    </field>
+                </form>`,
+            resId: 1,
+        });
+
+        assert.containsOnce(target, ".o_form_view");
+        assert.containsOnce(target, ".o_data_row");
+
+        await click(target, ".o_data_row .o_data_cell");
+        assert.containsOnce(target, ".o_dialog");
+        assert.containsN(target.querySelector(".o_dialog"), ".o_data_row", 2);
+    });
+
     QUnit.test(
         "use the limit attribute in arch (in field o2m non inline tree view)",
         async function (assert) {
-            assert.expect(2);
-
             serverData.models.partner.records[0].turtles = [1, 2, 3];
             serverData.views = {
                 "turtle,false,list": `<tree limit="2"><field name="turtle_foo"/></tree>`,
@@ -764,12 +869,23 @@ QUnit.module("Fields", (hooks) => {
                 arch: `<form><field name="turtles" widget="one2many"/></form>`,
                 resId: 1,
                 mockRPC(route, args) {
-                    if (args.model === "turtle" && args.method === "read") {
-                        assert.deepEqual(args.args[0], [1, 2]);
+                    assert.step(args.method);
+                    if (args.method === "web_read") {
+                        assert.deepEqual(args.kwargs.specification, {
+                            display_name: {},
+                            turtles: {
+                                fields: {
+                                    turtle_foo: {},
+                                },
+                                limit: 2,
+                                order: "",
+                            },
+                        });
                     }
                 },
             });
             assert.containsN(target, ".o_data_row", 2);
+            assert.verifySteps(["get_views", "get_views", "web_read"]);
         }
     );
 
@@ -854,7 +970,7 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             resId: 1,
             async mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.step("onchange");
                 }
             },
@@ -899,6 +1015,8 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("onchange for embedded one2many in a one2many", async function (assert) {
+        assert.expect(3);
+
         serverData.models.turtle.fields.partner_ids.type = "one2many";
         serverData.models.turtle.records[0].partner_ids = [1];
         serverData.models.partner.records[0].turtles = [1];
@@ -906,16 +1024,11 @@ QUnit.module("Fields", (hooks) => {
         serverData.models.partner.onchanges = {
             turtles: function (obj) {
                 obj.turtles = [
-                    [5, false, false],
                     [
                         1,
                         1,
                         {
-                            turtle_foo: "hop",
-                            partner_ids: [
-                                [5, false, false],
-                                [4, 1, false],
-                            ],
+                            partner_ids: [[4, 2]],
                         },
                     ],
                 ];
@@ -938,14 +1051,26 @@ QUnit.module("Fields", (hooks) => {
             resId: 1,
             mockRPC(route, args) {
                 if (args.method === "write") {
-                    const expectedResultTurtles = [[1, 1, { turtle_foo: "hop" }]];
+                    const expectedResultTurtles = [
+                        [1, 1, { turtle_foo: "hop", partner_ids: [[4, 2]] }],
+                    ];
                     assert.deepEqual(args.args[1].turtles, expectedResultTurtles);
                 }
             },
         });
 
+        assert.deepEqual(target.querySelector(".o_field_many2many_tags").innerText.split("\n"), [
+            "first record",
+        ]);
+
         await click(target.querySelectorAll(".o_data_cell")[1]);
         await editInput(target, ".o_selected_row .o_field_widget[name=turtle_foo] input", "hop");
+
+        assert.deepEqual(target.querySelector(".o_field_many2many_tags").innerText.split("\n"), [
+            "first record",
+            "second record",
+        ]);
+
         await clickSave(target);
     });
 
@@ -960,16 +1085,11 @@ QUnit.module("Fields", (hooks) => {
             serverData.models.partner.onchanges = {
                 turtles: function (obj) {
                     obj.turtles = [
-                        [5, false, false],
                         [
                             1,
                             1,
                             {
-                                turtle_foo: "hop",
-                                partner_ids: [
-                                    [5, false, false],
-                                    [4, 1, false],
-                                ],
+                                partner_ids: [[4, 2]],
                             },
                         ],
                         [
@@ -977,11 +1097,7 @@ QUnit.module("Fields", (hooks) => {
                             2,
                             {
                                 turtle_foo: "blip",
-                                partner_ids: [
-                                    [5, false, false],
-                                    [4, 2, false],
-                                    [4, 4, false],
-                                ],
+                                partner_ids: [[4, 1]],
                             },
                         ],
                     ];
@@ -1005,15 +1121,12 @@ QUnit.module("Fields", (hooks) => {
                 mockRPC(route, args) {
                     if (args.method === "write") {
                         const expectedResultTurtles = [
-                            [1, 1, { turtle_foo: "hop" }],
+                            [1, 1, { turtle_foo: "hop", partner_ids: [[4, 2]] }],
                             [
                                 1,
                                 2,
                                 {
-                                    partner_ids: [
-                                        [4, 2, false],
-                                        [4, 4, false],
-                                    ],
+                                    partner_ids: [[4, 1]],
                                     turtle_foo: "blip",
                                 },
                             ],
@@ -1048,13 +1161,11 @@ QUnit.module("Fields", (hooks) => {
             serverData.models.partner.onchanges = {
                 turtles: function (obj) {
                     obj.turtles = [
-                        [5],
                         [
                             1,
                             2,
                             {
-                                turtle_foo: "hop",
-                                partner_ids: [[5], [4, 2], [4, 4]],
+                                partner_ids: [[4, 4]],
                             },
                         ],
                     ];
@@ -1082,10 +1193,7 @@ QUnit.module("Fields", (hooks) => {
                                 1,
                                 2,
                                 {
-                                    partner_ids: [
-                                        [4, 2, false],
-                                        [4, 4, false],
-                                    ],
+                                    partner_ids: [[4, 4]],
                                     turtle_foo: "hop",
                                 },
                             ],
@@ -1230,32 +1338,28 @@ QUnit.module("Fields", (hooks) => {
         }
     );
 
-    QUnit.test(
-        "onchange (with command 5) for embedded one2many with handle widget",
-        async function (assert) {
-            const ids = [];
-            for (let i = 10; i < 50; i++) {
-                const id = 10 + i;
-                ids.push(id);
-                serverData.models.turtle.records.push({
-                    id: id,
-                    turtle_int: 0,
-                    turtle_foo: "#" + id,
-                });
-            }
-            ids.push(1, 2, 3);
-            serverData.models.partner.records[0].turtles = ids;
-            serverData.models.partner.onchanges = {
-                turtles: function (obj) {
-                    obj.turtles = [[5]].concat(obj.turtles);
-                },
-            };
+    QUnit.test("onchange for embedded one2many with handle widget", async function (assert) {
+        const ids = [];
+        for (let i = 10; i < 50; i++) {
+            const id = 10 + i;
+            ids.push(id);
+            serverData.models.turtle.records.push({
+                id: id,
+                turtle_int: 0,
+                turtle_foo: "#" + id,
+            });
+        }
+        ids.push(1, 2, 3);
+        serverData.models.partner.records[0].turtles = ids;
+        serverData.models.partner.onchanges = {
+            turtles: function (obj) {},
+        };
 
-            await makeView({
-                type: "form",
-                resModel: "partner",
-                serverData,
-                arch: `
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
                     <form>
                         <field name="turtles">
                             <tree editable="bottom" default_order="turtle_int">
@@ -1264,37 +1368,39 @@ QUnit.module("Fields", (hooks) => {
                             </tree>
                         </field>
                     </form>`,
-                resId: 1,
-            });
+            resId: 1,
+        });
 
-            await click(target, "div[name=turtles] .o_pager_next");
+        await click(target, "div[name=turtles] .o_pager_next");
 
-            assert.deepEqual(
-                getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")),
-                ["yop", "blip", "kawa"]
-            );
+        assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")), [
+            "yop",
+            "blip",
+            "kawa",
+        ]);
 
-            await click(target.querySelector(".o_data_cell.o_list_char"));
-            await editInput(target, '.o_list_renderer div[name="turtle_foo"] input', "blurp");
+        await click(target.querySelector(".o_data_cell.o_list_char"));
+        await editInput(target, '.o_list_renderer div[name="turtle_foo"] input', "blurp");
 
-            // Drag and drop the third line in second position
-            await dragAndDrop("tbody tr:nth-child(3) .o_handle_cell", "tbody tr:nth-child(2)");
+        // Drag and drop the third line in second position
+        await dragAndDrop("tbody tr:nth-child(3) .o_handle_cell", "tbody tr:nth-child(2)");
 
-            // need to unselect row...
-            assert.deepEqual(
-                getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")),
-                ["blurp", "kawa", "blip"]
-            );
+        // need to unselect row...
+        assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")), [
+            "blurp",
+            "kawa",
+            "blip",
+        ]);
 
-            await clickSave(target);
-            await click(target, 'div[name="turtles"] .o_pager_next');
+        await clickSave(target);
+        await click(target, 'div[name="turtles"] .o_pager_next');
 
-            assert.deepEqual(
-                getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")),
-                ["blurp", "kawa", "blip"]
-            );
-        }
-    );
+        assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")), [
+            "blurp",
+            "kawa",
+            "blip",
+        ]);
+    });
 
     QUnit.test(
         "onchange with modifiers for embedded one2many on the second page",
@@ -1312,27 +1418,7 @@ QUnit.module("Fields", (hooks) => {
             ids.push(1, 2, 3);
             serverData.models.partner.records[0].turtles = ids;
             serverData.models.partner.onchanges = {
-                turtles: function (obj) {
-                    // TODO: make this test more 'difficult'
-                    // For now, the server only returns UPDATE commands (no LINK TO)
-                    // even though it should do it (for performance reasons)
-                    // var turtles = obj.turtles.splice(0, 20);
-
-                    const turtles = [[5]];
-                    // create UPDATE commands for each records (this is the server
-                    // usual answer for onchange)
-                    for (const k in obj.turtles) {
-                        const change = obj.turtles[k];
-                        const record = serverData.models.turtle.records.find(
-                            (r) => r.id === change[1]
-                        );
-                        if (change[0] === 1) {
-                            Object.assign(record, change[2]);
-                        }
-                        turtles.push([1, record.id, record]);
-                    }
-                    obj.turtles = turtles;
-                },
+                turtles: function (obj) {},
             };
 
             await makeView({
@@ -1402,9 +1488,7 @@ QUnit.module("Fields", (hooks) => {
         ids.splice(41, 0, 1, 2, 3);
         serverData.models.partner.records[0].turtles = ids;
         serverData.models.partner.onchanges = {
-            turtles: function (obj) {
-                obj.turtles = [[5]].concat(obj.turtles);
-            },
+            turtles: function (obj) {},
         };
 
         await makeView({
@@ -1535,9 +1619,7 @@ QUnit.module("Fields", (hooks) => {
         ids.splice(41, 0, 1, 2, 3);
         serverData.models.partner.records[0].turtles = ids;
         serverData.models.partner.onchanges = {
-            turtles: function (obj) {
-                obj.turtles = [[5]].concat(obj.turtles);
-            },
+            turtles: function (obj) {},
         };
 
         // bottom order
@@ -1652,10 +1734,13 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
-    QUnit.test("onchange returning a command 6 for an x2many", async function (assert) {
+    QUnit.test("onchange returning a commands 4 for an x2many", async function (assert) {
         serverData.models.partner.onchanges = {
             foo(obj) {
-                obj.turtles = [[6, false, [1, 2, 3]]];
+                obj.turtles = [
+                    [4, 1],
+                    [4, 3],
+                ];
             },
         };
 
@@ -1685,16 +1770,20 @@ QUnit.module("Fields", (hooks) => {
     QUnit.test(
         "x2many fields inside x2manys are fetched after an onchange",
         async function (assert) {
-            assert.expect(6);
+            assert.expect(5);
 
             serverData.models.turtle.records[0].partner_ids = [1];
             serverData.models.partner.onchanges = {
                 foo: function (obj) {
-                    obj.turtles = [[5], [4, 1], [4, 2], [4, 3]];
+                    obj.turtles = [
+                        [3, 2],
+                        [4, 1],
+                        [4, 2],
+                        [4, 3],
+                    ];
                 },
             };
 
-            let checkRPC = false;
             await makeView({
                 type: "form",
                 resModel: "partner",
@@ -1714,17 +1803,24 @@ QUnit.module("Fields", (hooks) => {
                         </sheet>
                     </form>`,
                 mockRPC(route, args) {
-                    if (checkRPC && args.method === "read" && args.model === "partner") {
-                        assert.deepEqual(
-                            args.args[1],
-                            ["display_name"],
-                            "should only read the display_name for the m2m tags"
-                        );
-                        assert.deepEqual(
-                            args.args[0],
-                            [1],
-                            "should only read the display_name of the unknown record"
-                        );
+                    if (args.method === "onchange2") {
+                        assert.deepEqual(args.args[3], {
+                            // spec
+                            display_name: {},
+                            foo: {},
+                            turtles: {
+                                fields: {
+                                    partner_ids: {
+                                        fields: {
+                                            display_name: {},
+                                        },
+                                    },
+                                    turtle_foo: {},
+                                },
+                                limit: 40,
+                                order: "",
+                            },
+                        });
                     }
                 },
                 resId: 1,
@@ -1744,7 +1840,6 @@ QUnit.module("Fields", (hooks) => {
             );
 
             // change the value of foo to trigger the onchange
-            checkRPC = true; // enable flag to check read RPC for the m2m field
             await editInput(target, ".o_field_widget[name=foo] input", "some value");
 
             assert.containsN(
@@ -1766,16 +1861,18 @@ QUnit.module("Fields", (hooks) => {
     QUnit.test(
         "reference fields inside x2manys are fetched after an onchange",
         async function (assert) {
-            assert.expect(5);
+            assert.expect(4);
 
             serverData.models.turtle.records[1].turtle_ref = "product,41";
             serverData.models.partner.onchanges = {
                 foo: function (obj) {
-                    obj.turtles = [[5], [4, 1], [4, 2], [4, 3]];
+                    obj.turtles = [
+                        [4, 1],
+                        [4, 3],
+                    ];
                 },
             };
 
-            var checkRPC = false;
             await makeView({
                 type: "form",
                 resModel: "partner",
@@ -1794,15 +1891,6 @@ QUnit.module("Fields", (hooks) => {
                             </group>
                         </sheet>
                     </form>`,
-                mockRPC(route, args) {
-                    if (checkRPC && args.method === "read" && args.args[1].length === 1 && args.args[1][0] === "display_name") {
-                        assert.deepEqual(
-                            args.args[0],
-                            [37],
-                            "should only fetch the display_name of the unknown record"
-                        );
-                    }
-                },
                 resId: 1,
             });
 
@@ -1813,13 +1901,12 @@ QUnit.module("Fields", (hooks) => {
             );
 
             // change the value of foo to trigger the onchange
-            checkRPC = true; // enable flag to check read RPC for reference field
             await editInput(target, ".o_field_widget[name=foo] input", "some value");
 
             assert.containsN(target, ".o_data_row", 3);
             assert.deepEqual(
                 [...target.querySelectorAll(".ref_field")].map((el) => el.textContent),
-                ["", "xpad", "xphone"]
+                ["xpad", "", "xphone"]
             );
         }
     );
@@ -1938,6 +2025,7 @@ QUnit.module("Fields", (hooks) => {
     QUnit.test(
         "onchange on one2many with x2many in list (no widget) and form view (list)",
         async function (assert) {
+            assert.expect(7);
             serverData.models.turtle.fields.turtle_foo.default = "a default value";
             serverData.models.partner.onchanges = {
                 foo: function (obj) {
@@ -1965,6 +2053,27 @@ QUnit.module("Fields", (hooks) => {
                             </form>
                         </field>
                     </form>`,
+                mockRPC(route, args) {
+                    if (args.method === "onchange2" && args.model === "partner") {
+                        assert.deepEqual(args.args[3], {
+                            display_name: {},
+                            foo: {},
+                            p: {
+                                fields: {
+                                    turtles: {
+                                        fields: {
+                                            turtle_foo: {},
+                                        },
+                                        limit: 40,
+                                        order: "",
+                                    },
+                                },
+                                limit: 40,
+                                order: "",
+                            },
+                        });
+                    }
+                },
             });
 
             assert.containsOnce(
@@ -1998,6 +2107,7 @@ QUnit.module("Fields", (hooks) => {
     QUnit.test(
         "onchange on one2many with x2many in list (many2many_tags) and form view (list)",
         async function (assert) {
+            assert.expect(7);
             serverData.models.turtle.fields.turtle_foo.default = "a default value";
             serverData.models.partner.onchanges = {
                 foo: function (obj) {
@@ -2025,6 +2135,26 @@ QUnit.module("Fields", (hooks) => {
                             </form>
                         </field>
                     </form>`,
+                mockRPC(route, args) {
+                    if (args.method === "onchange2" && args.model === "partner") {
+                        assert.deepEqual(args.args[3], {
+                            display_name: {},
+                            foo: {},
+                            p: {
+                                fields: {
+                                    turtles: {
+                                        fields: {
+                                            display_name: {},
+                                            turtle_foo: {},
+                                        },
+                                    },
+                                },
+                                limit: 40,
+                                order: "",
+                            },
+                        });
+                    }
+                },
             });
 
             assert.containsOnce(
@@ -2083,15 +2213,11 @@ QUnit.module("Fields", (hooks) => {
             );
             serverData.models.partner.records[0].turtles = [1, 2, 3, 4, 5, 6, 7];
 
-            let model;
-            patchWithCleanup(BasicModel.prototype, {
-                init() {
-                    this._super(...arguments);
-                    model = this;
-                },
-                notifyChanges() {
-                    const changes = arguments[1];
-                    assert.step(String(this.get(changes.turtles.id).res_id));
+            patchWithCleanup(Record.prototype, {
+                _update() {
+                    if (this.resModel === "turtle") {
+                        assert.step(`${this.resId}`);
+                    }
                     return this._super(...arguments);
                 },
             });
@@ -2112,21 +2238,11 @@ QUnit.module("Fields", (hooks) => {
                 resId: 1,
             });
 
-            const formHandle = Object.keys(model.localData).find((k) => /partner/.test(k));
-
             assert.deepEqual(
-                Object.values(model.get(formHandle).data.turtles.data).map((r) => {
-                    return r.data;
-                }),
-                [
-                    { id: 6, turtle_foo: "a3", turtle_int: 2 },
-                    { id: 1, turtle_foo: "yop", turtle_int: 6 },
-                    { id: 2, turtle_foo: "blip", turtle_int: 9 },
-                    { id: 5, turtle_foo: "a2", turtle_int: 9 },
-                    { id: 7, turtle_foo: "a4", turtle_int: 11 },
-                    { id: 4, turtle_foo: "a1", turtle_int: 20 },
-                    { id: 3, turtle_foo: "kawa", turtle_int: 21 },
-                ]
+                [...target.querySelectorAll(".o_data_row [name='turtle_foo']")].map(
+                    (el) => el.textContent
+                ),
+                ["a3", "yop", "blip", "a2", "a4", "a1", "kawa"]
             );
 
             const positions = [
@@ -2143,18 +2259,10 @@ QUnit.module("Fields", (hooks) => {
             }
 
             assert.deepEqual(
-                Object.values(model.get(formHandle).data.turtles.data).map((r) => {
-                    return r.data;
-                }),
-                [
-                    { id: 3, turtle_foo: "kawa", turtle_int: 2 },
-                    { id: 7, turtle_foo: "a4", turtle_int: 3 },
-                    { id: 1, turtle_foo: "yop", turtle_int: 4 },
-                    { id: 2, turtle_foo: "blip", turtle_int: 5 },
-                    { id: 5, turtle_foo: "a2", turtle_int: 6 },
-                    { id: 6, turtle_foo: "a3", turtle_int: 7 },
-                    { id: 4, turtle_foo: "a1", turtle_int: 8 },
-                ]
+                [...target.querySelectorAll(".o_data_row [name='turtle_foo']")].map(
+                    (el) => el.textContent
+                ),
+                ["kawa", "a4", "yop", "blip", "a2", "a3", "a1"]
             );
         }
     );
@@ -2181,7 +2289,6 @@ QUnit.module("Fields", (hooks) => {
                     assert.deepEqual(args.args[1].p, [
                         [1, 2, { int_field: 0 }],
                         [1, 4, { int_field: 1 }],
-                        [4, 1, false],
                     ]);
                 }
             },
@@ -2236,7 +2343,6 @@ QUnit.module("Fields", (hooks) => {
         serverData.models.partner.records[0].p = ids.slice(0, 42);
         serverData.models.partner.records[1].p = ids.slice(42);
 
-        let count = 0;
         await makeView({
             type: "form",
             resModel: "partner",
@@ -2255,25 +2361,21 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method !== "get_views") {
-                    count++;
+                if (args.method === "web_read") {
+                    assert.step(`unity read ${args.args[0]}`);
                 }
             },
             resId: 1,
             resIds: [1, 2],
         });
 
-        // we are on record 1, which has 90 related record (first 40 should be
-        // displayed), 2 RPCs (read) should have been done, one on the main record
-        // and one for the O2M
-        assert.strictEqual(count, 2);
+        assert.verifySteps(["unity read 1"]);
         assert.containsN(target, '.o_kanban_record:not(".o_kanban_ghost")', 40);
 
         // move to record 2, which has 3 related records (and shouldn't contain the
-        // related records of record 1 anymore). Two additional RPCs should have
-        // been done
+        // related records of record 1 anymore)
         await click(target.querySelector(".o_form_view .o_control_panel .o_pager_next"));
-        assert.strictEqual(count, 4);
+        assert.verifySteps(["unity read 2"]);
         assert.containsN(
             target,
             '.o_kanban_record:not(".o_kanban_ghost")',
@@ -2284,7 +2386,7 @@ QUnit.module("Fields", (hooks) => {
         // move back to record 1, which should contain again its first 40 related
         // records
         await click(target.querySelector(".o_form_view .o_control_panel .o_pager_previous"));
-        assert.strictEqual(count, 6);
+        assert.verifySteps(["unity read 1"]);
         assert.containsN(
             target,
             '.o_kanban_record:not(".o_kanban_ghost")',
@@ -2295,7 +2397,7 @@ QUnit.module("Fields", (hooks) => {
         // move to the second page of the o2m: 1 RPC should have been done to fetch
         // the 2 subrecords of page 2, and those records should now be displayed
         await click(target.querySelector(".o_x2m_control_panel .o_pager_next"));
-        assert.strictEqual(count, 7, "one RPC should have been done");
+        assert.verifySteps(["unity read 50,51"]);
         assert.containsN(
             target,
             '.o_kanban_record:not(".o_kanban_ghost")',
@@ -2305,7 +2407,7 @@ QUnit.module("Fields", (hooks) => {
 
         // move to record 2 again and check that everything is correctly updated
         await click(target.querySelector(".o_form_view .o_control_panel .o_pager_next"));
-        assert.strictEqual(count, 9);
+        assert.verifySteps(["unity read 2"]);
         assert.containsN(
             target,
             '.o_kanban_record:not(".o_kanban_ghost")',
@@ -2316,9 +2418,9 @@ QUnit.module("Fields", (hooks) => {
         // move back to record 1 and move to page 2 again: all data should have
         // been correctly reloaded
         await click(target.querySelector(".o_form_view .o_control_panel .o_pager_previous"));
-        assert.strictEqual(count, 11);
+        assert.verifySteps(["unity read 1"]);
         await click(target.querySelector(".o_x2m_control_panel .o_pager_next"));
-        assert.strictEqual(count, 12, "one RPC should have been done");
+        assert.verifySteps(["unity read 50,51"]);
         assert.containsN(
             target,
             '.o_kanban_record:not(".o_kanban_ghost")',
@@ -2328,8 +2430,6 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("edition of one2many field with pager", async function (assert) {
-        assert.expect(30);
-
         const ids = [];
         for (let i = 0; i < 45; i++) {
             const id = 10 + i;
@@ -2368,80 +2468,30 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "read" && checkRead) {
+                if (args.method === "web_read" && checkRead) {
                     readIDs = args.args[0];
                     checkRead = false;
                 }
                 if (args.method === "write") {
+                    assert.step("write");
                     saveCount++;
-                    const nbCommands = args.args[1].p.length;
-                    const nbLinkCommands = args.args[1].p.filter((command) => {
-                        return command[0] === 4;
-                    }).length;
+                    const commands = args.args[1].p;
                     switch (saveCount) {
                         case 1:
-                            assert.strictEqual(
-                                nbCommands,
-                                46,
-                                "should send 46 commands (one for each record)"
-                            );
-                            assert.strictEqual(
-                                nbLinkCommands,
-                                45,
-                                "should send a LINK_TO command for each existing record"
-                            );
-                            assert.deepEqual(
-                                args.args[1].p[45],
-                                [
-                                    0,
-                                    args.args[1].p[45][1],
-                                    {
-                                        display_name: "new record",
-                                    },
-                                ],
-                                "should sent a CREATE command for the new record"
-                            );
+                            assert.deepEqual(commands, [
+                                [0, commands[0][1], { display_name: "new record" }],
+                            ]);
                             break;
                         case 2:
-                            assert.strictEqual(nbCommands, 46, "should send 46 commands");
-                            assert.strictEqual(
-                                nbLinkCommands,
-                                45,
-                                "should send a LINK_TO command for each existing record"
-                            );
-                            assert.deepEqual(
-                                args.args[1].p[45],
-                                [2, 10, false],
-                                "should sent a DELETE command for the deleted record"
-                            );
+                            assert.deepEqual(commands, [[2, 10]]);
                             break;
                         case 3:
-                            assert.strictEqual(nbCommands, 47, "should send 47 commands");
-                            assert.strictEqual(
-                                nbLinkCommands,
-                                43,
-                                "should send a LINK_TO command for each existing record"
-                            );
-                            assert.deepEqual(
-                                args.args[1].p[43],
-                                [0, args.args[1].p[43][1], { display_name: "new record page 1" }],
-                                "should sent correct CREATE command"
-                            );
-                            assert.deepEqual(
-                                args.args[1].p[44],
-                                [0, args.args[1].p[44][1], { display_name: "new record page 2" }],
-                                "should sent correct CREATE command"
-                            );
-                            assert.deepEqual(
-                                args.args[1].p[45],
-                                [2, 11, false],
-                                "should sent correct DELETE command"
-                            );
-                            assert.deepEqual(
-                                args.args[1].p[46],
-                                [2, 52, false],
-                                "should sent correct DELETE command"
-                            );
+                            assert.deepEqual(commands, [
+                                [0, commands[0][1], { display_name: "new record page 1" }],
+                                [2, 11],
+                                [2, 52],
+                                [0, commands[3][1], { display_name: "new record page 2" }],
+                            ]);
                             break;
                     }
                 }
@@ -2583,21 +2633,25 @@ QUnit.module("Fields", (hooks) => {
         );
         // save
         await clickSave(target);
+
+        assert.verifySteps(["write", "write", "write"]);
     });
 
-    QUnit.test("When viewing one2many records in an embedded kanban, the delete button should say 'Delete' and not 'Remove'", async function (assert) {
-        assert.expect(1);
-        serverData.views = {
-            "turtle,false,form": `
+    QUnit.test(
+        "When viewing one2many records in an embedded kanban, the delete button should say 'Delete' and not 'Remove'",
+        async function (assert) {
+            assert.expect(1);
+            serverData.views = {
+                "turtle,false,form": `
                 <form>
                     <h3>Data</h3>
                 </form>`,
-        };
-        await makeView({
-            type: "form",
-            resModel: "partner",
-            serverData,
-            arch: `
+            };
+            await makeView({
+                type: "form",
+                resModel: "partner",
+                serverData,
+                arch: `
                 <form>
                     <field name="turtles">
                         <kanban>
@@ -2612,14 +2666,15 @@ QUnit.module("Fields", (hooks) => {
                         </kanban>
                     </field>
                 </form>`,
-            resId: 1,
-        });
+                resId: 1,
+            });
 
-        // Opening the record to see the footer buttons
-        await click(target.querySelector(".o_kanban_record"));
+            // Opening the record to see the footer buttons
+            await click(target.querySelector(".o_kanban_record"));
 
-        assert.strictEqual(target.querySelector('.o_btn_remove').textContent, 'Delete');
-    });
+            assert.strictEqual(target.querySelector(".o_btn_remove").textContent, "Delete");
+        }
+    );
 
     QUnit.test("open a record in a one2many kanban (mode 'readonly')", async function (assert) {
         serverData.views = {
@@ -2843,7 +2898,7 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange" && args.model === "turtle") {
+                if (args.method === "onchange2" && args.model === "turtle") {
                     // done by the X2ManyFieldDialog
                     assert.deepEqual(args.kwargs.context, {
                         abc: 2,
@@ -2906,9 +2961,9 @@ QUnit.module("Fields", (hooks) => {
 
     QUnit.test("sorting one2many fields", async function (assert) {
         serverData.models.partner.fields.foo.sortable = true;
-        serverData.models.partner.records.push({ id: 23, foo: "abc" });
-        serverData.models.partner.records.push({ id: 24, foo: "xyz" });
-        serverData.models.partner.records.push({ id: 25, foo: "def" });
+        serverData.models.partner.records.push({ id: 23, foo: "abc", int_field: 1 });
+        serverData.models.partner.records.push({ id: 24, foo: "xyz", int_field: 1 });
+        serverData.models.partner.records.push({ id: 25, foo: "def", int_field: 2 });
         serverData.models.partner.records[0].p = [23, 24, 25];
 
         let rpcCount = 0;
@@ -2921,6 +2976,7 @@ QUnit.module("Fields", (hooks) => {
                     <field name="p">
                         <tree>
                             <field name="foo"/>
+                            <field name="int_field"/>
                         </tree>
                     </field>
                 </form>`,
@@ -2931,22 +2987,82 @@ QUnit.module("Fields", (hooks) => {
         });
 
         rpcCount = 0;
-        assert.strictEqual(
-            [...target.querySelectorAll(".o_data_cell")].map((c) => c.textContent).join(" "),
-            "abc xyz def"
+        assert.deepEqual(
+            [...target.querySelectorAll(".o_data_cell[name='foo']")].map((c) => c.textContent),
+            ["abc", "xyz", "def"]
         );
 
-        await click(target.querySelector("table thead .o_column_sortable"));
+        await click(target.querySelector("table thead [data-name='foo'].o_column_sortable"));
         assert.strictEqual(rpcCount, 0, "in memory sort, no RPC should have been done");
-        assert.strictEqual(
-            [...target.querySelectorAll(".o_data_cell")].map((c) => c.textContent).join(" "),
-            "abc def xyz"
+        assert.deepEqual(
+            [...target.querySelectorAll(".o_data_cell[name='foo']")].map((c) => c.textContent),
+            ["abc", "def", "xyz"]
         );
 
-        await click(target.querySelector("table thead .o_column_sortable"));
-        assert.strictEqual(
-            [...target.querySelectorAll(".o_data_cell")].map((c) => c.textContent).join(" "),
-            "xyz def abc"
+        await click(target.querySelector("table thead [data-name='foo'].o_column_sortable"));
+        assert.deepEqual(
+            [...target.querySelectorAll(".o_data_cell[name='foo']")].map((c) => c.textContent),
+            ["xyz", "def", "abc"]
+        );
+
+        await click(target.querySelector("table thead [data-name='int_field'].o_column_sortable"));
+        assert.deepEqual(
+            [...target.querySelectorAll(".o_data_cell[name='foo']")].map((c) => c.textContent),
+            ["xyz", "abc", "def"]
+        );
+
+        await click(target.querySelector("table thead [data-name='int_field'].o_column_sortable"));
+        assert.deepEqual(
+            [...target.querySelectorAll(".o_data_cell[name='foo']")].map((c) => c.textContent),
+            ["def", "xyz", "abc"]
+        );
+    });
+
+    QUnit.test("sorting one2many fields with multi page", async function (assert) {
+        serverData.models.partner.fields.foo.sortable = true;
+        serverData.models.partner.records.push({ id: 23, foo: "abc", int_field: 1 });
+        serverData.models.partner.records.push({ id: 24, foo: "xyz", int_field: 1 });
+        serverData.models.partner.records.push({ id: 25, foo: "def", int_field: 2 });
+        serverData.models.partner.records.push({ id: 26, foo: "otc", int_field: 2 });
+        serverData.models.partner.records[0].p = [23, 24, 25, 26];
+
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <form>
+                    <field name="p">
+                        <tree limit="2">
+                            <field name="foo"/>
+                            <field name="int_field"/>
+                        </tree>
+                    </field>
+                </form>`,
+            resId: 1,
+        });
+
+        assert.deepEqual(
+            [...target.querySelectorAll(".o_data_row")].map((c) => c.textContent),
+            ["abc1", "xyz1"]
+        );
+
+        await click(target.querySelector("table thead [data-name='int_field'].o_column_sortable"));
+        assert.deepEqual(
+            [...target.querySelectorAll(".o_data_row")].map((c) => c.textContent),
+            ["abc1", "xyz1"]
+        );
+
+        await click(target.querySelector("table thead [data-name='foo'].o_column_sortable"));
+        assert.deepEqual(
+            [...target.querySelectorAll(".o_data_row")].map((c) => c.textContent),
+            ["abc1", "def2"]
+        );
+
+        await click(target.querySelector(".o_field_widget[name='p'] .o_pager_next"));
+        assert.deepEqual(
+            [...target.querySelectorAll(".o_data_row")].map((c) => c.textContent),
+            ["otc2", "xyz1"]
         );
     });
 
@@ -3119,7 +3235,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("many2many list: unlink two records", async function (assert) {
-        assert.expect(7);
+        assert.expect(4);
         serverData.models.partner.records[0].p = [1, 2, 4];
         serverData.views = {
             "partner,false,form": `
@@ -3143,19 +3259,7 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, args) {
                 if (route === "/web/dataset/call_kw/partner/write") {
                     const commands = args.args[1].p;
-                    assert.strictEqual(commands.length, 3, "should have generated three commands");
-                    assert.ok(
-                        commands[0][0] === 4 && commands[0][1] === 2,
-                        "should have generated the command 4 (LINK_TO) with id 4"
-                    );
-                    assert.ok(
-                        commands[1][0] === 4 && commands[1][1] === 4,
-                        "should have generated the command 4 (LINK_TO) with id 4"
-                    );
-                    assert.ok(
-                        commands[2][0] === 3 && commands[2][1] === 1,
-                        "should have generated the command 3 (UNLINK) with id 1"
-                    );
+                    assert.deepEqual(commands, [[3, 1]], "should send a command 3 (unlink)");
                 }
             },
         });
@@ -3196,11 +3300,7 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, args) {
                 if (route === "/web/dataset/call_kw/partner/write") {
                     const commands = args.args[1].p;
-                    assert.deepEqual(commands, [
-                        [4, 2, false],
-                        [4, 4, false],
-                        [2, 1, false],
-                    ]);
+                    assert.deepEqual(commands, [[2, 1]]);
                 }
             },
         });
@@ -3218,7 +3318,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("one2many kanban: edition", async function (assert) {
-        assert.expect(20);
+        assert.expect(17);
 
         serverData.models.partner.records[0].p = [2];
         await makeView({
@@ -3253,16 +3353,18 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, args) {
                 if (route === "/web/dataset/call_kw/partner/write") {
                     const commands = args.args[1].p;
-                    assert.strictEqual(commands.length, 2);
-
-                    assert.strictEqual(commands[0][0], 0);
-                    assert.deepEqual(commands[0][2], {
-                        color: "red",
-                        display_name: "new subrecord 3",
-                        foo: "My little Foo Value",
-                    });
-
-                    assert.deepEqual(commands[1], [2, 2, false]);
+                    assert.deepEqual(commands, [
+                        [
+                            0,
+                            commands[0][1],
+                            {
+                                color: "red",
+                                display_name: "new subrecord 3",
+                                foo: "My little Foo Value",
+                            },
+                        ],
+                        [2, 2],
+                    ]);
                 }
             },
         });
@@ -3539,7 +3641,7 @@ QUnit.module("Fields", (hooks) => {
                             <field name="display_name"/>
                             <field name="qux"/>
                         </tree>
-                        <form string="Partners">
+                        <form>
                             <field name="display_name"/>
                         </form>
                     </field>
@@ -3551,7 +3653,7 @@ QUnit.module("Fields", (hooks) => {
                     assert.deepEqual(args.args[1], {
                         p: [
                             [1, 2, { display_name: "new name" }],
-                            [2, 4, false],
+                            [2, 4],
                         ],
                     });
                 }
@@ -3566,8 +3668,8 @@ QUnit.module("Fields", (hooks) => {
         assert.containsN(target, ".o_list_record_remove", 2);
         assert.containsOnce(target, ".o_field_x2many_list_row_add");
 
-        // edit existing subrecord
-        await click(target.querySelectorAll(".o_list_renderer tbody tr td")[1]); // ?
+        // edit first record
+        await click(target.querySelector(".o_list_renderer .o_data_cell"));
 
         await editInput(target, ".modal .o_form_editable input", "new name");
 
@@ -3578,7 +3680,7 @@ QUnit.module("Fields", (hooks) => {
         );
         assert.strictEqual(nbWrite, 0, "should not have write anything in DB");
 
-        // remove subrecords
+        // remove second record
         await click(target.querySelectorAll(".o_list_record_remove")[1]);
         assert.containsOnce(target, "td.o_list_number");
         assert.strictEqual(
@@ -3608,8 +3710,7 @@ QUnit.module("Fields", (hooks) => {
             resId: 1,
             mockRPC(route, args) {
                 if (args.method === "write") {
-                    // WOWL: could be nice to assert this way, but with the basic model, we don't
-                    // control the virtual ids index
+                    // Would be nice to assert this way, but we don't control the virtual ids index
                     // assert.deepEqual(args.args[1].p, [
                     //     [0, "virtual_2", { foo: "gemuse" }],
                     //     [0, "virtual_1", { foo: "kartoffel" }],
@@ -3784,7 +3885,14 @@ QUnit.module("Fields", (hooks) => {
         await clickSave(target);
         assert.containsNone(target, "tr.o_data_row");
 
-        assert.verifySteps(["get_views", "read", "onchange", "onchange"]);
+        assert.verifySteps([
+            "get_views",
+            "web_read",
+            "onchange2",
+            "onchange2",
+            "write",
+            "web_read",
+        ]);
     });
 
     QUnit.test("editable one2many list, adding line when only one page", async function (assert) {
@@ -4068,7 +4176,7 @@ QUnit.module("Fields", (hooks) => {
         triggerHotkey("Enter");
         await nextTick();
         assert.hasClass(target.querySelector('div[name="turtle_foo"]'), "o_field_invalid");
-        assert.verifySteps(["get_views", "read", "onchange"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2"]);
     });
 
     QUnit.test("pressing enter several times in a one2many", async function (assert) {
@@ -4199,7 +4307,14 @@ QUnit.module("Fields", (hooks) => {
             "9"
         );
 
-        assert.verifySteps(["get_views", "read", "onchange", "onchange", "write", "read", "read"]);
+        assert.verifySteps([
+            "get_views",
+            "web_read",
+            "onchange2",
+            "onchange2",
+            "write",
+            "web_read",
+        ]);
     });
 
     QUnit.test("editable o2m, pressing ESC discard current changes", async function (assert) {
@@ -4226,7 +4341,7 @@ QUnit.module("Fields", (hooks) => {
 
         await triggerEvent(target, '[name="turtle_foo"] input', "keydown", { key: "Escape" });
         assert.containsNone(target, "tr.o_data_row");
-        assert.verifySteps(["get_views", "read", "onchange"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2"]);
     });
 
     QUnit.test(
@@ -4258,7 +4373,7 @@ QUnit.module("Fields", (hooks) => {
             await triggerEvent(target, '[name="turtle_foo"] input', "keydown", { key: "Escape" });
 
             assert.containsNone(target, "tr.o_data_row");
-            assert.verifySteps(["get_views", "read", "onchange"]);
+            assert.verifySteps(["get_views", "web_read", "onchange2"]);
         }
     );
 
@@ -4327,12 +4442,12 @@ QUnit.module("Fields", (hooks) => {
                 },
             });
 
-            assert.verifySteps(["get_views", "read", "read"]);
+            assert.verifySteps(["get_views", "web_read"]);
             await click(target.querySelector(".o_data_cell"));
             await editInput(target, ".o_field_widget[name=product_id] input", "");
             assert.verifySteps([], "no onchange should be done as line is invalid");
             await click(target.querySelector(".o_list_record_remove"));
-            assert.verifySteps(["onchange"], "onchange should have been done");
+            assert.verifySteps(["onchange2"], "onchange should have been done");
         }
     );
 
@@ -4342,7 +4457,7 @@ QUnit.module("Fields", (hooks) => {
             foo: "relational record 1",
         });
         serverData.models.partner.records[1].p = [3];
-        serverData.models.partner.onchanges = { p: true };
+        serverData.models.partner.onchanges = { p: () => {} };
 
         await makeView({
             type: "form",
@@ -4358,11 +4473,11 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             resId: 2,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     return Promise.resolve({
                         value: {
                             p: [
-                                [5], // delete all
+                                [2, 3], // delete 3
                                 [0, 0, { foo: "from onchange" }], // create new
                             ],
                         },
@@ -4386,10 +4501,8 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("one2many, default_get and onchange (basic)", async function (assert) {
-        serverData.models.partner.fields.p.default = [
-            [6, 0, []], // replace with zero ids
-        ];
-        serverData.models.partner.onchanges = { p: true };
+        serverData.models.partner.fields.p.default = [];
+        serverData.models.partner.onchanges = { p: () => {} };
 
         await makeView({
             type: "form",
@@ -4404,11 +4517,10 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     return {
                         value: {
                             p: [
-                                [5], // delete all
                                 [0, 0, { foo: "from onchange" }], // create new
                             ],
                         },
@@ -4470,7 +4582,7 @@ QUnit.module("Fields", (hooks) => {
         assert.strictEqual(td.textContent, "9");
         await click(td);
         await editInput(target, 'td [name="turtle_int"] input', "3");
-        assert.verifySteps(["get_views", "read", "read", "onchange"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2"]);
     });
 
     QUnit.test("one2many and onchange (with date)", async function (assert) {
@@ -4504,64 +4616,7 @@ QUnit.module("Fields", (hooks) => {
         await click(getPickerCell("1").at(0));
         await clickSave(target);
 
-        assert.verifySteps(["get_views", "read", "read", "onchange", "write", "read", "read"]);
-    });
-
-    QUnit.test("one2many and onchange (with command DELETE_ALL)", async function (assert) {
-        assert.expect(5);
-
-        serverData.models.partner.onchanges = {
-            foo: function (obj) {
-                obj.p = [[5]];
-            },
-            p: function () {}, // dummy onchange on the o2m to execute _isX2ManyValid()
-        };
-        serverData.models.partner.records[0].p = [2];
-
-        await makeView({
-            type: "form",
-            resModel: "partner",
-            serverData,
-            arch: `
-                <form>
-                    <field name="foo"/>
-                    <field name="p">
-                        <tree editable="bottom">
-                            <field name="display_name"/>
-                        </tree>
-                    </field>
-                </form>`,
-            mockRPC: function (method, args) {
-                if (args.method === "write") {
-                    assert.deepEqual(args.args[1].p, [
-                        [0, args.args[1].p[0][1], { display_name: "z" }],
-                        [2, 2, false],
-                    ]);
-                }
-            },
-            resId: 1,
-        });
-        assert.containsOnce(target, ".o_data_row");
-
-        // empty o2m by triggering the onchange
-        await editInput(target, ".o_field_widget[name=foo] input", "trigger onchange");
-        assert.containsNone(target, ".o_data_row", "rows of the o2m should have been deleted");
-
-        // add two new subrecords
-        await addRow(target);
-        await editInput(target, ".o_field_widget[name=display_name] input", "x");
-        await addRow(target);
-        await editInput(target, ".o_field_widget[name=display_name] input", "y");
-        assert.containsN(target, ".o_data_row", 2);
-
-        // empty o2m by triggering the onchange
-        await editInput(target, ".o_field_widget[name=foo] input", "trigger onchange again");
-        assert.containsNone(target, ".o_data_row", "rows of the o2m should have been deleted");
-
-        await addRow(target);
-        await editInput(target, ".o_field_widget[name=display_name] input", "z");
-
-        await clickSave(target);
+        assert.verifySteps(["get_views", "web_read", "onchange2", "write", "web_read"]);
     });
 
     QUnit.test("one2many and onchange only write modified field", async function (assert) {
@@ -4570,20 +4625,13 @@ QUnit.module("Fields", (hooks) => {
         serverData.models.partner.onchanges = {
             turtles: function (obj) {
                 obj.turtles = [
-                    [5], // delete all
                     [
                         1,
                         3,
                         {
-                            // the server returns all fields
                             display_name: "coucou",
-                            product_id: [37, "xphone"],
-                            turtle_bar: false,
                             turtle_foo: "has changed",
                             turtle_int: 42,
-                            turtle_qux: 9.8,
-                            partner_ids: [],
-                            turtle_ref: "product,37",
                         },
                     ],
                 ];
@@ -4656,26 +4704,21 @@ QUnit.module("Fields", (hooks) => {
             }
             fieldRegistry.add(name, { ...field, component: DeltaField }, { force: true });
         }
-        let deactiveOnchange = true;
+        let onchangeStep = 0;
 
         serverData.models.partner.records[0].turtles = [];
         serverData.models.partner.onchanges = {
             turtles: function (obj) {
-                if (deactiveOnchange) {
-                    return;
-                }
                 // the onchange will either:
                 //  - create a second line if there is only one line
                 //  - edit the second line if there are two lines
-                if (obj.turtles.length === 1) {
+                if (onchangeStep === 1) {
                     obj.turtles = [
-                        [5], // delete all
                         [
-                            0,
+                            1,
                             obj.turtles[0][1],
                             {
                                 display_name: "first",
-                                turtle_int: obj.turtles[0][2].turtle_int,
                             },
                         ],
                         [
@@ -4687,22 +4730,12 @@ QUnit.module("Fields", (hooks) => {
                             },
                         ],
                     ];
-                } else if (obj.turtles.length === 2) {
+                } else if (onchangeStep === 2) {
                     obj.turtles = [
-                        [5], // delete all
                         [
-                            0,
-                            obj.turtles[0][1],
-                            {
-                                display_name: "first",
-                                turtle_int: obj.turtles[0][2].turtle_int,
-                            },
-                        ],
-                        [
-                            0,
+                            1,
                             obj.turtles[1][1],
                             {
-                                display_name: "second",
                                 turtle_int: -obj.turtles[0][2].turtle_int,
                             },
                         ],
@@ -4731,7 +4764,7 @@ QUnit.module("Fields", (hooks) => {
 
         await addRow(target);
         // trigger the first onchange
-        deactiveOnchange = false;
+        onchangeStep = 1;
         await editInput(target, '[name="turtle_int"] input', "10");
         // put the list back in non edit mode
         await click(target, '[name="foo"] input');
@@ -4741,6 +4774,7 @@ QUnit.module("Fields", (hooks) => {
         );
 
         // trigger the second onchange
+        onchangeStep = 2;
         await click(target.querySelector(".o_field_x2many_list tbody tr td"));
         await editInput(target, '[name="turtle_int"] input', "20");
         await click(target, '[name="foo"] input');
@@ -4891,13 +4925,7 @@ QUnit.module("Fields", (hooks) => {
         let checkOnchange = false;
         serverData.models.partner.records[0].p = [2];
         serverData.models.partner.records[1].product_id = 37;
-        serverData.models.partner.onchanges.p = function (obj) {
-            obj.p = [
-                [5], // delete all
-                [1, 2, { product_id: [37, "xphone"] }], // update existing record
-                [0, 0, { product_id: [41, "xpad"] }],
-            ];
-        };
+        serverData.models.partner.onchanges.p = () => {};
         serverData.views = {};
         serverData.views["partner,false,form"] = '<form><field name="product_id"/></form>';
 
@@ -4915,13 +4943,10 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             resId: 1,
             mockRPC(route, args) {
-                if (args.method === "onchange" && checkOnchange) {
+                if (args.method === "onchange2" && checkOnchange) {
                     assert.deepEqual(
                         args.args[1].p,
-                        [
-                            [4, 2, false],
-                            [0, args.args[1].p[1][1], { product_id: 41 }],
-                        ],
+                        [[0, args.args[1].p[0][1], { product_id: 41 }]],
                         "should trigger onchange with correct parameters"
                     );
                 }
@@ -5150,6 +5175,42 @@ QUnit.module("Fields", (hooks) => {
         }
     );
 
+    QUnit.test(
+        "one2many list, multi page, with many2one and with context with parent key",
+        async function (assert) {
+            serverData.models.partner.records[0].turtles = [1, 2, 3];
+
+            await makeView({
+                type: "form",
+                resModel: "partner",
+                serverData,
+                arch: `
+                    <form>
+                        <field name="foo"/>
+                        <field name="turtles">
+                            <tree limit="2">
+                                <field name="product_id" context="{'partner_foo': parent.foo}"/>
+                            </tree>
+                        </field>
+                    </form>`,
+                resId: 1,
+                mockRPC(route, { method, model, kwargs }) {
+                    if (method === "web_read" && model === "turtle") {
+                        assert.step("web_read turtle");
+                        assert.deepEqual(
+                            kwargs.specification.product_id.context,
+                            { partner_foo: "yop" },
+                            "should have correctly evaluated parent foo field"
+                        );
+                    }
+                },
+            });
+
+            await click(target, ".o_x2m_control_panel .o_pager_next");
+            assert.verifySteps(["web_read turtle"]);
+        }
+    );
+
     QUnit.test("one2many list, editable, with a date in the context", async function (assert) {
         assert.expect(1);
 
@@ -5173,7 +5234,7 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             resId: 2,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.strictEqual(
                         args.kwargs.context.date,
                         "2017-01-25",
@@ -5205,7 +5266,7 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             resId: 1,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.deepEqual(
                         args.kwargs.context.turtles,
                         [2],
@@ -5280,7 +5341,7 @@ QUnit.module("Fields", (hooks) => {
                     </form>`,
                 resId: 1,
                 mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         var context = args.kwargs.context;
                         assert.strictEqual(context.hello, "world");
                         assert.strictEqual(context.abc, 10);
@@ -5347,6 +5408,7 @@ QUnit.module("Fields", (hooks) => {
                 </search>`,
         };
 
+        let expectedIds;
         await makeView({
             type: "form",
             resModel: "partner",
@@ -5377,9 +5439,9 @@ QUnit.module("Fields", (hooks) => {
                 }
                 if (route === "/web/dataset/call_kw/partner/write") {
                     assert.strictEqual(args.args[0][0], 1, "should write on the partner record 1");
-                    assert.strictEqual(
-                        args.args[1].turtles[0][0],
-                        6,
+                    assert.deepEqual(
+                        args.args[1].turtles,
+                        [[6, false, expectedIds]],
                         "should send only a 'replace with' command"
                     );
                 }
@@ -5388,34 +5450,35 @@ QUnit.module("Fields", (hooks) => {
 
         await addRow(target);
 
-        assert.strictEqual(
-            $(".modal .o_data_row").length,
+        assert.containsN(
+            target,
+            ".modal .o_data_row",
             2,
             "should have 2 records in the select view (the last one is not displayed because it is already selected)"
         );
 
-        await click($(".modal .o_data_row:first .o_list_record_selector input")[0]);
+        await click(target.querySelector(".modal .o_data_row .o_list_record_selector input"));
         await nextTick(); // additional render due to the change of selection (done in owl, not pure js)
-        await click($(".modal .o_select_button")[0]);
+        await click(target.querySelector(".modal .o_select_button"));
+        expectedIds = [2, 1];
         await clickSave(target);
-        await addRow(target);
 
-        assert.strictEqual(
-            $(".modal .o_data_row").length,
-            1,
+        await addRow(target);
+        assert.containsOnce(
+            target,
+            ".modal .o_data_row",
             "should have 1 record in the select view"
         );
 
-        await click($(".modal-footer button:eq(1)")[0]);
+        await click(target.querySelectorAll(".modal-footer button")[1]);
         await editInput(target, '.modal .o_field_widget[name="turtle_foo"] input', "tototo");
         await editInput(target, '.modal .o_field_widget[name="turtle_int"] input', 50);
         await clickOpenM2ODropdown(target, "product_id");
         await clickM2OHighlightedItem(target, "product_id");
 
-        await click($(".modal-footer button:contains(&):first")[0]);
-
-        assert.strictEqual($(".modal").length, 0, "should close the modals");
+        await click(target.querySelector(".modal-footer button"));
 
+        assert.containsNone(target, ".modal", "should close the modals");
         assert.containsN(target, ".o_data_row", 3, "should have 3 records in one2many list");
         assert.strictEqual(
             $(target.querySelectorAll(".o_data_row")).text(),
@@ -5423,6 +5486,7 @@ QUnit.module("Fields", (hooks) => {
             "should display the record values in one2many list"
         );
 
+        expectedIds = [2, 1, 4];
         await clickSave(target);
     });
 
@@ -5489,8 +5553,8 @@ QUnit.module("Fields", (hooks) => {
                 }
             },
         });
-        //await new Promise(() => {})
-        await click($(target).find(".o_data_cell:first")[0]);
+
+        await click(target.querySelector(".o_data_cell"));
         assert.strictEqual(
             $(".modal .modal-title").first().text().trim(),
             "Open: one2many turtle field",
@@ -5541,7 +5605,7 @@ QUnit.module("Fields", (hooks) => {
                         </field>
                     </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     n++;
                     if (n === 2) {
                         var context = args.kwargs.context;
@@ -5564,6 +5628,7 @@ QUnit.module("Fields", (hooks) => {
             serverData,
             arch: `
                 <form>
+                    <field name="display_name"/>
                     <field name="foo"/>
                     <field name="p">
                         <tree editable="top">
@@ -5573,17 +5638,18 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             resId: 1,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     const fieldValues = args.args[1];
-                    assert.strictEqual(
-                        fieldValues.trululu.foo,
-                        "yop",
-                        "should have properly sent the parent foo value"
+                    assert.deepEqual(
+                        fieldValues.trululu,
+                        { foo: "hello", id: 1 },
+                        "should have properly sent the parent changes"
                     );
                 }
             },
         });
 
+        await editInput(target, "[name=foo] input", "hello");
         await addRow(target);
     });
 
@@ -5594,37 +5660,51 @@ QUnit.module("Fields", (hooks) => {
 
             serverData.models.partner.onchanges = {
                 display_name: function () {},
+                foo: function () {},
             };
             serverData.models.partner.records[0].p = [1];
             serverData.models.partner.records[0].turtles = [2];
+
+            let count = 0;
             await makeView({
                 type: "form",
                 resModel: "partner",
                 serverData,
                 arch: `
                 <form>
+                    <field name="display_name"/>
                     <field name="foo"/>
                     <field name="p">
                         <tree editable="top">
                             <field name="display_name"/>
+                            <field name="foo"/>
                             <field name="turtles" widget="many2many_tags"/>
                         </tree>
                     </field>
                 </form>`,
                 resId: 1,
                 mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         const fieldValues = args.args[1];
-                        assert.strictEqual(fieldValues.trululu.foo, "yop");
-                        // we only send fields that changed inside the reverse many2one
-                        assert.deepEqual(fieldValues.trululu.p, [
-                            [1, 1, { display_name: "new val" }],
-                        ]);
+                        if (count === 1) {
+                            assert.deepEqual(fieldValues.trululu, {
+                                foo: "hello",
+                                id: 1,
+                            });
+                        } else if (count === 2) {
+                            assert.deepEqual(fieldValues.trululu, {
+                                foo: "hello",
+                                id: 1,
+                                p: [[1, 1, { display_name: "new val" }]],
+                            });
+                        }
+                        count++;
                     }
                 },
             });
             assert.containsOnce(target, ".o_data_row");
 
+            await editInput(target, "[name=foo] input", "hello");
             await click(target.querySelector(".o_data_row .o_data_cell"));
             assert.containsOnce(target, ".o_data_row.o_selected_row");
 
@@ -5633,6 +5713,7 @@ QUnit.module("Fields", (hooks) => {
                 ".o_selected_row .o_field_widget[name=display_name] input",
                 "new val"
             );
+            await editInput(target, ".o_selected_row .o_field_widget[name=foo] input", "new foo");
         }
     );
 
@@ -5657,7 +5738,7 @@ QUnit.module("Fields", (hooks) => {
                     </form>`,
                 mockRPC(route, args) {
                     assert.step(args.method);
-                    if (args.method === "onchange" && args.model === "turtle") {
+                    if (args.method === "onchange2" && args.model === "turtle") {
                         var fieldValues = args.args[1];
                         assert.strictEqual(
                             fieldValues.turtle_trululu.foo,
@@ -5668,13 +5749,16 @@ QUnit.module("Fields", (hooks) => {
                 },
             });
             await addRow(target);
-            assert.verifySteps(["get_views", "onchange", "onchange"]);
+            assert.verifySteps(["get_views", "onchange2", "onchange2"]);
         }
     );
 
     QUnit.test("id in one2many obtained in onchange is properly set", async function (assert) {
         serverData.models.partner.onchanges.turtles = function (obj) {
-            obj.turtles = [[5], [1, 3, { turtle_foo: "kawa" }]];
+            obj.turtles = [
+                [4, 3],
+                [1, 3, { turtle_foo: "kawa" }],
+            ];
         };
         await makeView({
             type: "form",
@@ -5716,9 +5800,9 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             mockRPC(route, args) {
                 if (args.method === "create") {
-                    var virtualID = args.args[0].turtles[0][1];
+                    const virtualID = args.args[0][0].turtles[0][1];
                     assert.deepEqual(
-                        args.args[0].turtles,
+                        args.args[0][0].turtles,
                         [[0, virtualID, { turtle_foo: "cat" }]],
                         "should send proper commands"
                     );
@@ -5868,7 +5952,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("many2one and many2many in one2many", async function (assert) {
-        assert.expect(12);
+        assert.expect(8);
 
         serverData.models.turtle.records[1].product_id = 37;
         serverData.models.partner.records[0].turtles = [2, 3];
@@ -5882,11 +5966,6 @@ QUnit.module("Fields", (hooks) => {
                     <group>
                         <field name="int_field"/>
                         <field name="turtles">
-                            <form>
-                                <group>
-                                    <field name="product_id"/>
-                                </group>
-                            </form>
                             <tree editable="top">
                                 <field name="display_name"/>
                                 <field name="product_id"/>
@@ -5898,24 +5977,19 @@ QUnit.module("Fields", (hooks) => {
             resId: 1,
             mockRPC(route, args) {
                 if (args.method === "write") {
-                    const commands = args.args[1].turtles;
-                    assert.strictEqual(commands.length, 2, "should have generated 2 commands");
                     assert.deepEqual(
-                        commands[0],
+                        args.args[1].turtles,
                         [
-                            1,
-                            2,
-                            {
-                                partner_ids: [[6, false, [2, 1]]],
-                                product_id: 41,
-                            },
+                            [
+                                1,
+                                2,
+                                {
+                                    partner_ids: [[6, false, [2, 1]]],
+                                    product_id: 41,
+                                },
+                            ],
                         ],
-                        "generated commands should be correct"
-                    );
-                    assert.deepEqual(
-                        commands[1],
-                        [4, 3, false],
-                        "generated commands should be correct"
+                        "generated command should be correct"
                     );
                 }
             },
@@ -5933,22 +6007,6 @@ QUnit.module("Fields", (hooks) => {
             2,
             "m2m should contain two tags"
         );
-        assert.strictEqual(
-            target.querySelector('.o_data_row td div[name="partner_ids"] .badge .o_tag_badge_text')
-                .innerText,
-            "second record",
-            "m2m values should have been correctly fetched"
-        );
-
-        // await click(target.querySelector(".o_data_row td"));
-        // assert.strictEqual(target.querySelector(".modal .o_field_widget").innerText, "xphone");
-        // await click(target.querySelector(".modal-footer button"));
-
-        assert.containsOnce(
-            target,
-            ".o_form_view .o_form_editable",
-            "should toggle form mode to edit"
-        );
 
         // edit the m2m of first row
         await click(target.querySelector(".o_list_renderer tbody td"));
@@ -6030,12 +6088,10 @@ QUnit.module("Fields", (hooks) => {
 
             assert.verifySteps([
                 "get_views", // main form view
-                "read", // initial read on partner
-                "read", // initial read on turtle
-                "read", // batched read on partner (field partner_ids)
-                "read", // after first delete, read on turtle (to fetch 3rd record)
-                "onchange", // after first delete, onchange on field turtles
-                "onchange", // onchange after second delete
+                "web_read", // initial read on partner
+                "web_read", // after first delete, read on turtle (to fetch 3rd record)
+                "onchange2", // after first delete, onchange on field turtles
+                "onchange2", // onchange after second delete
             ]);
         }
     );
@@ -6048,33 +6104,39 @@ QUnit.module("Fields", (hooks) => {
 
         serverData.models.turtle.onchanges = {
             product_id: function (rec) {
-                if (rec.product_id) {
-                    rec.partner_ids = [[5], [4, rec.product_id === 41 ? 1 : 2]];
+                if (rec.product_id === 41) {
+                    rec.partner_ids = [[4, 1]];
+                } else if (rec.product_id === 37) {
+                    rec.partner_ids = [[4, 2]];
                 }
             },
         };
+        let enableOnchange = false;
         const partnerOnchange = function (rec) {
-            if (!rec.int_field || !rec.turtles.length) {
+            if (!enableOnchange) {
                 return;
             }
             rec.turtles = [
-                [5],
                 [
                     0,
                     0,
                     {
                         display_name: "new line",
                         product_id: [37, "xphone"],
-                        partner_ids: [[5], [4, 1]],
+                        partner_ids: [[4, 1]],
                     },
                 ],
                 [
-                    0,
+                    1,
                     rec.turtles[0][1],
                     {
-                        display_name: rec.turtles[0][2].display_name,
                         product_id: [1, "xenomorphe"],
-                        partner_ids: [[5], [4, 2]],
+                        partner_ids: rec.turtles[0][2].partner_ids.length
+                            ? [
+                                  [3, 1],
+                                  [4, 2],
+                              ]
+                            : [[4, 2]],
                     },
                 ],
             ];
@@ -6140,6 +6202,7 @@ QUnit.module("Fields", (hooks) => {
         );
 
         // enable the many2many onchange and generate it
+        enableOnchange = true;
         await editInput(target, 'div[name="int_field"] input', "10");
 
         assert.deepEqual(
@@ -6148,15 +6211,14 @@ QUnit.module("Fields", (hooks) => {
         );
 
         // disable the many2many onchange
-        await editInput(target, 'div[name="int_field"] input', "0");
+        enableOnchange = false;
 
         // remove and start over
         await click(target.querySelector(".o_list_record_remove button"));
         await click(target.querySelector(".o_list_record_remove button"));
 
         // enable the many2many onchange
-        await editInput(target, 'div[name="int_field"] input', "10");
-
+        enableOnchange = true;
         // add new line (first, xenomorphe)
         await addRow(target);
         await editInput(target, 'div[name="display_name"] input', "first");
@@ -6391,8 +6453,8 @@ QUnit.module("Fields", (hooks) => {
 
     QUnit.test("nested x2many default values", async function (assert) {
         serverData.models.partner.fields.turtles.default = [
-            [0, 0, { partner_ids: [[6, 0, [4]]] }],
-            [0, 0, { partner_ids: [[6, 0, [1]]] }],
+            [0, 0, { partner_ids: [[4, 4]] }],
+            [0, 0, { partner_ids: [[4, 1]] }],
         ];
 
         await makeView({
@@ -6426,10 +6488,10 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("nested x2many (inline form view) and onchanges", async function (assert) {
+        assert.expect(8);
         serverData.models.partner.onchanges.bar = function (obj) {
             if (!obj.bar) {
                 obj.p = [
-                    [5],
                     [
                         0,
                         0,
@@ -6469,6 +6531,27 @@ QUnit.module("Fields", (hooks) => {
                         </form>
                     </field>
                 </form>`,
+            mockRPC(route, args) {
+                if (args.method === "onchange2") {
+                    assert.deepEqual(args.args[3], {
+                        bar: {},
+                        display_name: {},
+                        p: {
+                            fields: {
+                                turtles: {
+                                    fields: {
+                                        turtle_foo: {},
+                                    },
+                                    limit: 40,
+                                    order: "",
+                                },
+                            },
+                            limit: 40,
+                            order: "",
+                        },
+                    });
+                }
+            },
         });
         assert.containsNone(target, ".o_data_row");
 
@@ -6485,72 +6568,6 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
-    QUnit.test("nested x2many (non inline form view) and onchanges", async function (assert) {
-        serverData.models.partner.onchanges.bar = function (obj) {
-            if (!obj.bar) {
-                obj.p = [
-                    [5],
-                    [
-                        0,
-                        0,
-                        {
-                            turtles: [
-                                [
-                                    0,
-                                    0,
-                                    {
-                                        turtle_foo: "new turtle",
-                                    },
-                                ],
-                            ],
-                        },
-                    ],
-                ];
-            }
-        };
-
-        serverData.views = {
-            "partner,false,form": `
-                <form>
-                    <field name="turtles">
-                        <tree>
-                            <field name="turtle_foo"/>
-                        </tree>
-                    </field>
-                </form>`,
-        };
-
-        await makeView({
-            type: "form",
-            resModel: "partner",
-            serverData,
-            arch: `
-                <form>
-                    <field name="bar"/>
-                    <field name="p" widget="one2many">
-                        <tree>
-                            <field name="turtles"/>
-                        </tree>
-                    </field>
-                </form>`,
-        });
-
-        assert.containsNone(target, ".o_data_row");
-
-        await click(target, 'div[name="bar"] input');
-        assert.containsOnce(target, ".o_data_row");
-        assert.strictEqual(target.querySelector(".o_data_row").innerText.trim(), "1 record");
-
-        await click(target.querySelector(".o_data_row td"));
-
-        assert.containsOnce(target, ".modal .o_form_view");
-        assert.containsOnce(target, ".modal .o_form_view .o_data_row");
-        assert.strictEqual(
-            target.querySelector(".modal .o_form_view .o_data_row").innerText.trim(),
-            "new turtle"
-        );
-    });
-
     QUnit.test(
         "nested x2many (non inline views and no widget on inner x2many in list)",
         async function (assert) {
@@ -6815,8 +6832,8 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, args) {
                 if (args.method === "write") {
                     assert.step(args.method);
-                    assert.strictEqual(args.args[1].p.length, 2);
-                    const command = args.args[1].p[1];
+                    assert.strictEqual(args.args[1].p.length, 1);
+                    const command = args.args[1].p[0];
                     assert.strictEqual(command[0], 0);
                     assert.deepEqual(command[2], {
                         foo: "My little Foo Value",
@@ -6968,7 +6985,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("one2many list editable = top", async function (assert) {
-        assert.expect(6);
+        assert.expect(5);
 
         serverData.models.turtle.fields.turtle_foo.default = "default foo turtle";
         await makeView({
@@ -6989,8 +7006,9 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, args) {
                 if (args.method === "write") {
                     const commands = args.args[1].turtles;
-                    assert.strictEqual(commands[0][0], 0, "first command is a create");
-                    assert.strictEqual(commands[1][0], 4, "second command is a link to");
+                    assert.deepEqual(commands, [
+                        [0, commands[0][1], { turtle_foo: "default foo turtle" }],
+                    ]);
                 }
             },
         });
@@ -7014,7 +7032,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("one2many list editable = bottom", async function (assert) {
-        assert.expect(6);
+        assert.expect(5);
         serverData.models.turtle.fields.turtle_foo.default = "default foo turtle";
 
         await makeView({
@@ -7035,8 +7053,9 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, args) {
                 if (args.method === "write") {
                     const commands = args.args[1].turtles;
-                    assert.strictEqual(commands[0][0], 4, "first command is a link to");
-                    assert.strictEqual(commands[1][0], 0, "second command is a create");
+                    assert.deepEqual(commands, [
+                        [0, commands[0][1], { turtle_foo: "default foo turtle" }],
+                    ]);
                 }
             },
         });
@@ -7186,9 +7205,10 @@ QUnit.module("Fields", (hooks) => {
 
     QUnit.test("one2many list editable, onchange and required field", async function (assert) {
         serverData.models.turtle.fields.turtle_foo.required = true;
+        let intFieldVal = 0;
         serverData.models.partner.onchanges = {
             turtles: function (obj) {
-                obj.int_field = obj.turtles.length;
+                obj.int_field = intFieldVal;
             },
         };
         serverData.models.partner.records[0].int_field = 0;
@@ -7218,15 +7238,16 @@ QUnit.module("Fields", (hooks) => {
             "0"
         );
 
+        intFieldVal = 1;
         await addRow(target);
         assert.strictEqual(
             target.querySelector('.o_field_widget[name="int_field"] input').value,
             "0"
         );
-        assert.verifySteps(["get_views", "read", "onchange"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2"]);
 
         await editInput(target, '.o_field_widget[name="turtle_foo"] input', "some text");
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
         assert.strictEqual(
             target.querySelector('.o_field_widget[name="int_field"] input').value,
             "1"
@@ -7246,9 +7267,10 @@ QUnit.module("Fields", (hooks) => {
             serverData.models.turtle.fields.turtle_int.required = true; // required int field (default 0)
             serverData.models.turtle.fields.turtle_int.default = 0;
             serverData.models.turtle.fields.partner_ids.required = true; // required many2many
+            let intFieldVal = 0;
             serverData.models.partner.onchanges = {
                 turtles: function (obj) {
-                    obj.int_field = obj.turtles.length;
+                    obj.int_field = intFieldVal;
                 },
             };
             serverData.models.partner.records[0].int_field = 0;
@@ -7286,6 +7308,7 @@ QUnit.module("Fields", (hooks) => {
                 "int_field should start with value 0"
             );
 
+            intFieldVal = 1;
             // add a new row (which is invalid at first)
             await addRow(target);
             assert.strictEqual(
@@ -7293,7 +7316,7 @@ QUnit.module("Fields", (hooks) => {
                 "0",
                 "int_field should still be 0 (no onchange should have been done yet)"
             );
-            assert.verifySteps(["get_views", "read", "onchange"]);
+            assert.verifySteps(["get_views", "web_read", "onchange2"]);
 
             // fill turtle_foo field
             await editInput(target, '.o_field_widget[name="turtle_foo"] input', "some text");
@@ -7312,7 +7335,7 @@ QUnit.module("Fields", (hooks) => {
                 "1",
                 "int_field should now be 1 (the onchange should have been done"
             );
-            assert.verifySteps(["name_search", "read", "onchange"]);
+            assert.verifySteps(["name_search", "web_read", "onchange2"]);
         }
     );
 
@@ -7321,7 +7344,7 @@ QUnit.module("Fields", (hooks) => {
         async function (assert) {
             serverData.models.partner.onchanges = {
                 turtles: function (obj) {
-                    obj.int_field = obj.turtles.length;
+                    obj.int_field = 44;
                 },
             };
 
@@ -7358,7 +7381,7 @@ QUnit.module("Fields", (hooks) => {
 
             assert.strictEqual(
                 target.querySelector('.o_field_widget[name="int_field"] input').value,
-                "1"
+                "44"
             );
         }
     );
@@ -7368,7 +7391,7 @@ QUnit.module("Fields", (hooks) => {
         async function (assert) {
             serverData.models.partner.onchanges = {
                 turtles: function (obj) {
-                    obj.int_field = obj.turtles.length;
+                    obj.int_field = 44;
                 },
             };
 
@@ -7405,7 +7428,7 @@ QUnit.module("Fields", (hooks) => {
             await editInput(target, '.o_field_widget[name="turtle_int"] input', "1");
             assert.strictEqual(
                 target.querySelector('.o_field_widget[name="int_field"] input').value,
-                "1"
+                "44"
             );
         }
     );
@@ -7435,7 +7458,7 @@ QUnit.module("Fields", (hooks) => {
                         </field>
                     </form>`,
                 async mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         await Promise.resolve(def);
                     }
                 },
@@ -7485,7 +7508,7 @@ QUnit.module("Fields", (hooks) => {
                         </field>
                     </form>`,
                 async mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         await Promise.resolve(def);
                     }
                 },
@@ -7508,13 +7531,18 @@ QUnit.module("Fields", (hooks) => {
         // this test reproduces a subtle behavior that may occur in a form view:
         // the user adds a record in a one2many field, and directly clicks on a
         // datetime field of the form view which has an onchange, which totally
-        // overrides the value of the one2many (commands 5 and 0). The handler
+        // erases the value from the one2many (command 2 + command 0). The handler
         // that switches the edited row to readonly is then called after the
         // new value of the one2many field is applied (the one returned by the
         // onchange), so the row that must go to readonly doesn't exist anymore.
         serverData.models.partner.onchanges = {
             datetime: function (obj) {
-                obj.turtles = [[5], [0, 0, { display_name: "new" }]];
+                if (obj.turtles.length) {
+                    obj.turtles = [
+                        [2, obj.turtles[0][1]],
+                        [0, 0, { display_name: "new" }],
+                    ];
+                }
             },
         };
 
@@ -7576,13 +7604,13 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             resId: 1,
-            mockRPC(route, args) {
-                if (args.method === "onchange") {
+            async mockRPC(route, args) {
+                if (args.method === "onchange2") {
                     assert.step(args.method);
-                    return Promise.resolve({
+                    return {
                         value: {},
                         warning,
-                    });
+                    };
                 }
             },
         });
@@ -7601,7 +7629,7 @@ QUnit.module("Fields", (hooks) => {
         // and a warning again)
         await addRow(target);
 
-        assert.verifySteps(["onchange", "warning", "onchange", "warning"]);
+        assert.verifySteps(["onchange2", "warning", "onchange2", "warning"]);
     });
 
     QUnit.test("editable list: contexts are correctly sent", async function (assert) {
@@ -7625,7 +7653,7 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "read" && args.model === "partner") {
+                if (args.method === "web_read" && args.model === "partner") {
                     assert.deepEqual(
                         args.kwargs.context,
                         {
@@ -7636,18 +7664,7 @@ QUnit.module("Fields", (hooks) => {
                         },
                         "read partner context"
                     );
-                }
-                if (args.method === "read" && args.model === "partner_type") {
-                    assert.deepEqual(
-                        args.kwargs.context,
-                        {
-                            key2: "hello",
-                            active_field: 2,
-                            someKey: "some value",
-                            uid: 7,
-                        },
-                        "read partner_type context"
-                    );
+                    assert.deepEqual(args.kwargs.specification.timmy.context, { key2: "hello" });
                 }
                 if (args.method === "write") {
                     assert.deepEqual(
@@ -7670,9 +7687,9 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("contexts of nested x2manys are correctly sent (add line)", async function (assert) {
-        assert.expect(2);
+        assert.expect(4);
 
-        serverData.models.partner.fields.timmy.default = [12];
+        serverData.models.partner.fields.timmy.default = [[4, 12]];
 
         patchWithCleanup(session, { user_context: { someKey: "some value" } });
 
@@ -7691,7 +7708,7 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.deepEqual(
                         args.kwargs.context,
                         {
@@ -7701,19 +7718,25 @@ QUnit.module("Fields", (hooks) => {
                         },
                         "onchange context"
                     );
+                    assert.deepEqual(args.args[3].timmy.context, {
+                        key: "yop",
+                        key2: "hello",
+                    });
                 }
-                if (args.method === "read" && args.model === "partner_type") {
+                if (args.method === "web_read" && args.model === "partner") {
                     assert.deepEqual(
                         args.kwargs.context,
                         {
                             active_field: 2,
-                            key: "yop",
-                            key2: "hello",
+                            bin_size: true,
                             someKey: "some value",
                             uid: 7,
                         },
                         "read timmy context"
                     );
+                    assert.deepEqual(args.kwargs.specification.p.fields.timmy.context, {
+                        key2: "hello",
+                    });
                 }
             },
             resId: 1,
@@ -7723,6 +7746,50 @@ QUnit.module("Fields", (hooks) => {
         await click(target.querySelector(".o_field_x2many_list_row_add a"));
     });
 
+    QUnit.test("nested x2manys with context referencing parent record", async function (assert) {
+        assert.expect(3);
+
+        serverData.models.partner.records[0].p = [2];
+
+        let onchangeNb = 0;
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <form>
+                    <field name="foo"/>
+                    <field name="p">
+                        <tree>
+                            <field name="display_name"/>
+                        </tree>
+                        <form>
+                            <field name="p" context="{'parent_foo': parent.foo}">
+                                <tree>
+                                    <field name="display_name"/>
+                                </tree>
+                            </field>
+                        </form>
+                    </field>
+                </form>`,
+            mockRPC(route, args) {
+                if (args.method === "onchange2") {
+                    onchangeNb++;
+                    if (onchangeNb === 1) {
+                        assert.deepEqual(args.args[3].p.context, { parent_foo: "yop" });
+                    } else {
+                        assert.strictEqual(args.kwargs.context.parent_foo, "yop");
+                    }
+                }
+            },
+            resId: 1,
+        });
+
+        await click(target.querySelector(".o_field_x2many_list_row_add a"));
+        assert.containsOnce(target, ".o_dialog");
+        await click(target.querySelector(".o_dialog .o_field_x2many_list_row_add a"));
+    });
+
     QUnit.test("resetting invisible one2manys", async function (assert) {
         serverData.models.partner.records[0].turtles = [];
         serverData.models.partner.onchanges.foo = function (obj) {
@@ -7744,14 +7811,17 @@ QUnit.module("Fields", (hooks) => {
             },
         });
         await editInput(target, '[name="foo"] input', "abcd");
-        assert.verifySteps(["get_views", "read", "onchange"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2"]);
     });
 
     QUnit.test(
         "one2many: onchange that returns unknown field in list, but not in form",
         async function (assert) {
+            assert.expect(6);
             serverData.models.partner.onchanges = {
-                name: function () {},
+                name: function (obj) {
+                    obj.p = [[0, 0, { display_name: "new", timmy: [[4, 12]] }]];
+                },
             };
 
             await makeView({
@@ -7772,10 +7842,21 @@ QUnit.module("Fields", (hooks) => {
                         </field>
                     </form>`,
                 mockRPC(route, args) {
-                    if (args.method === "onchange") {
-                        return Promise.resolve({
-                            value: {
-                                p: [[5], [0, 0, { display_name: "new", timmy: [[5], [4, 12]] }]],
+                    if (args.method === "onchange2") {
+                        assert.deepEqual(args.args[3], {
+                            display_name: {},
+                            name: {},
+                            p: {
+                                fields: {
+                                    display_name: {},
+                                    timmy: {
+                                        fields: {
+                                            display_name: {},
+                                        },
+                                    },
+                                },
+                                limit: 40,
+                                order: "",
                             },
                         });
                     }
@@ -7799,7 +7880,7 @@ QUnit.module("Fields", (hooks) => {
         }
     );
 
-    QUnit.test("multi level of nested x2manys, onchange and rawChanges", async function (assert) {
+    QUnit.test("multi level of nested x2manys, onchange", async function (assert) {
         assert.expect(7);
         serverData.models.partner.records[0].p = [1];
         serverData.models.partner.onchanges = {
@@ -7890,7 +7971,7 @@ QUnit.module("Fields", (hooks) => {
         // triggers an onchange on partner, because the new record is valid
         await addRow(target);
 
-        assert.verifySteps(["get_views", "read", "onchange", "onchange"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2", "onchange2"]);
     });
 
     QUnit.test("onchange on a one2many containing a one2many", async function (assert) {
@@ -7923,12 +8004,24 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange" && checkOnchange) {
-                    assert.strictEqual(
-                        args.args[3]["p.p.display_name"],
-                        "",
-                        "onchange specs should be computed recursively"
-                    );
+                if (args.method === "onchange2" && checkOnchange) {
+                    assert.deepEqual(args.args[3], {
+                        display_name: {},
+                        p: {
+                            fields: {
+                                display_name: {},
+                                p: {
+                                    fields: {
+                                        display_name: {},
+                                    },
+                                    limit: 40,
+                                    order: "",
+                                },
+                            },
+                            limit: 40,
+                            order: "",
+                        },
+                    });
                 }
             },
         });
@@ -7941,7 +8034,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("editing tabbed one2many (editable=bottom)", async function (assert) {
-        assert.expect(13);
+        assert.expect(11);
 
         serverData.models.partner.records[0].turtles = [];
         for (let i = 0; i < 42; i++) {
@@ -7969,11 +8062,11 @@ QUnit.module("Fields", (hooks) => {
                 assert.step(args.method);
                 if (args.method === "write") {
                     assert.strictEqual(
-                        args.args[1].turtles[40][0],
+                        args.args[1].turtles[0][0],
                         0,
                         "should send a create command"
                     );
-                    assert.deepEqual(args.args[1].turtles[40][2], { turtle_foo: "rainbow dash" });
+                    assert.deepEqual(args.args[1].turtles[0][2], { turtle_foo: "rainbow dash" });
                 }
             },
         });
@@ -7985,7 +8078,7 @@ QUnit.module("Fields", (hooks) => {
         await clickSave(target);
         assert.containsN(target, "tr.o_data_row", 40);
 
-        assert.verifySteps(["get_views", "read", "read", "onchange", "write", "read", "read"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2", "write", "web_read"]);
     });
 
     QUnit.test("editing tabbed one2many (editable=bottom), again...", async function (assert) {
@@ -8019,7 +8112,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("editing tabbed one2many (editable=top)", async function (assert) {
-        assert.expect(16);
+        assert.expect(14);
 
         serverData.models.partner.records[0].turtles = [];
         serverData.models.turtle.fields.turtle_foo.default = "default foo";
@@ -8047,8 +8140,8 @@ QUnit.module("Fields", (hooks) => {
             mockRPC(route, args) {
                 assert.step(args.method);
                 if (args.method === "write") {
-                    assert.strictEqual(args.args[1].turtles[40][0], 0);
-                    assert.deepEqual(args.args[1].turtles[40][2], { turtle_foo: "rainbow dash" });
+                    assert.strictEqual(args.args[1].turtles[0][0], 0);
+                    assert.deepEqual(args.args[1].turtles[0][2], { turtle_foo: "rainbow dash" });
                 }
             },
         });
@@ -8064,16 +8157,7 @@ QUnit.module("Fields", (hooks) => {
         await clickSave(target);
         assert.containsN(target, "tr.o_data_row", 40);
 
-        assert.verifySteps([
-            "get_views",
-            "read",
-            "read",
-            "read",
-            "onchange",
-            "write",
-            "read",
-            "read",
-        ]);
+        assert.verifySteps(["get_views", "web_read", "web_read", "onchange2", "write", "web_read"]);
     });
 
     QUnit.test(
@@ -8315,13 +8399,13 @@ QUnit.module("Fields", (hooks) => {
                 mockRPC(route, args) {
                     if (args.method === "create") {
                         assert.strictEqual(
-                            args.args[0].p[0][0],
+                            args.args[0][0].p[0][0],
                             0,
                             "should send a command 0 (CREATE) for p"
                         );
                         assert.deepEqual(
-                            args.args[0].p[0][2],
-                            { turtles: [[4, 1, false]] },
+                            args.args[0][0].p[0][2],
+                            { turtles: [[4, 1]] },
                             "should send the correct values"
                         );
                     }
@@ -8340,6 +8424,38 @@ QUnit.module("Fields", (hooks) => {
     QUnit.test("display correct value after validation error", async function (assert) {
         assert.expect(4);
 
+        /*
+         * By-pass QUnit's and test's error handling because the error service needs to be active
+         */
+        const handler = (ev) => {
+            // need to preventDefault to remove error from console (so python test pass)
+            ev.preventDefault();
+        };
+        window.addEventListener("unhandledrejection", handler);
+        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
+
+        patchWithCleanup(QUnit, {
+            onUnhandledRejection: () => {},
+        });
+
+        const originOnunhandledrejection = window.onunhandledrejection;
+        window.onunhandledrejection = () => {};
+        registerCleanup(() => {
+            window.onunhandledrejection = originOnunhandledrejection;
+        });
+        /*
+         * End By pass error handling
+         */
+
+        serviceRegistry.add("error", errorService);
+        function validationHandler(env, error, originalError) {
+            if (originalError.data.name === "odoo.exceptions.ValidationError") {
+                return true;
+            }
+        }
+        const errorHandlerRegistry = registry.category("error_handlers");
+        errorHandlerRegistry.add("validationHandler", validationHandler, { sequence: 1 });
+
         serverData.models.partner.onchanges.turtles = function () {};
 
         await makeView({
@@ -8357,13 +8473,9 @@ QUnit.module("Fields", (hooks) => {
                     </sheet>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     if (args.args[1].turtles[0][2].turtle_foo === "pinky") {
-                        // we simulate a validation error.  In the 'real' web client,
-                        // the server error will be used by the session to display
-                        // an error dialog.  From the point of view of the basic
-                        // model, the promise is just rejected.
-                        return Promise.reject();
+                        throw makeServerError({ type: "ValidationError" });
                     }
                 }
                 if (args.method === "write") {
@@ -8396,7 +8508,7 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("propagate context to sub views without default_* keys", async function (assert) {
-        assert.expect(8);
+        assert.expect(7);
 
         await makeView({
             type: "form",
@@ -8418,7 +8530,7 @@ QUnit.module("Fields", (hooks) => {
                     "shy",
                     "view context key should be used for every rpcs"
                 );
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     if (args.model === "partner") {
                         assert.strictEqual(
                             args.kwargs.context.default_flutter,
@@ -8486,18 +8598,17 @@ QUnit.module("Fields", (hooks) => {
     );
 
     QUnit.test("onchange on nested one2manys", async function (assert) {
-        assert.expect(6);
+        assert.expect(3);
 
         serverData.models.partner.onchanges.display_name = function (obj) {
             if (obj.display_name) {
                 obj.p = [
-                    [5],
                     [
                         0,
                         0,
                         {
                             display_name: "test",
-                            turtles: [[5], [0, 0, { display_name: "test nested" }]],
+                            turtles: [[0, 0, { display_name: "test nested" }]],
                         },
                     ],
                 ];
@@ -8528,26 +8639,23 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             mockRPC(route, args) {
                 if (args.method === "create") {
-                    assert.strictEqual(
-                        args.args[0].p[0][0],
-                        0,
-                        "should send a command 0 (CREATE) for p"
-                    );
-                    assert.strictEqual(
-                        args.args[0].p[0][2].display_name,
-                        "test",
-                        "should send the correct values"
-                    );
-                    assert.strictEqual(
-                        args.args[0].p[0][2].turtles[0][0],
-                        0,
-                        "should send a command 0 (CREATE) for turtles"
-                    );
-                    assert.deepEqual(
-                        args.args[0].p[0][2].turtles[0][2],
-                        { display_name: "test nested" },
-                        "should send the correct values"
-                    );
+                    const commands = args.args[0][0].p;
+                    assert.deepEqual(commands, [
+                        [
+                            0,
+                            commands[0][1],
+                            {
+                                display_name: "test",
+                                turtles: [
+                                    [
+                                        0,
+                                        commands[0][2].turtles[0][1],
+                                        { display_name: "test nested" },
+                                    ],
+                                ],
+                            },
+                        ],
+                    ]);
                 }
             },
         });
@@ -8589,16 +8697,22 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             resId: 1,
-            mockRPC(route, args) {
-                if (args.method === "onchange") {
-                    return Promise.resolve({
+            async mockRPC(route, args) {
+                if (args.method === "onchange2") {
+                    return {
                         value: {
                             turtles: [
-                                [5],
-                                [1, 1, { turtle_foo: "from onchange", partner_ids: [[5]] }],
+                                [2, 2],
+                                [2, 3],
+                                [
+                                    4,
+                                    1,
+                                    { id: 1, turtle_int: 0, turtle_foo: "yop", partner_ids: [] },
+                                ],
+                                [1, 1, { turtle_foo: "from onchange" }],
                             ],
                         },
-                    });
+                    };
                 }
             },
         });
@@ -8629,17 +8743,22 @@ QUnit.module("Fields", (hooks) => {
                         </field>
                     </form>`,
             resId: 1,
-            mockRPC(route, args) {
-                if (args.method === "onchange") {
-                    return Promise.resolve({
+            async mockRPC(route, args) {
+                if (args.method === "onchange2") {
+                    return {
                         value: {
                             turtles: [
-                                [5],
-                                [1, 1, { turtle_foo: "from onchange id2", partner_ids: [[5]] }],
-                                [1, 3, { turtle_foo: "from onchange id3", partner_ids: [[5]] }],
+                                [2, 2],
+                                [
+                                    4,
+                                    1,
+                                    { id: 1, turtle_int: 0, turtle_foo: "yop", partner_ids: [] },
+                                ],
+                                [1, 1, { turtle_foo: "from onchange id2" }],
+                                [1, 3, { turtle_foo: "from onchange id3" }],
                             ],
                         },
-                    });
+                    };
                 }
             },
         });
@@ -8650,7 +8769,7 @@ QUnit.module("Fields", (hooks) => {
         await click(target.querySelector(".o_list_record_remove button"));
         assert.deepEqual(
             getNodesTextContent(target.querySelectorAll(".o_data_row .o_data_cell.o_list_char")),
-            ["from onchange id2", "from onchange id3"]
+            ["from onchange id3", "from onchange id2"]
         );
     });
 
@@ -8798,7 +8917,7 @@ QUnit.module("Fields", (hooks) => {
         async function (assert) {
             serverData.models.partner.records[0].turtles = [3, 2, 1];
 
-            serverData.models.turtle.fields.turtle_int.default = 10;
+            serverData.models.turtle.fields.turtle_int.default = 5;
 
             await makeView({
                 type: "form",
@@ -8820,10 +8939,7 @@ QUnit.module("Fields", (hooks) => {
             // click add a new line
             // check turtle_int for new is the current max of the page
             await addRow(target);
-            assert.strictEqual(
-                target.querySelector('.modal [name="turtle_int"] input').value,
-                "10"
-            );
+            assert.strictEqual(target.querySelector('.modal [name="turtle_int"] input').value, "9");
         }
     );
 
@@ -8860,36 +8976,20 @@ QUnit.module("Fields", (hooks) => {
         }
     );
 
-    QUnit.test(
-        "one2many with sequence field, fetch display from empty list, field text",
-        async function (assert) {
-            // There was a bug where a RPC would fail because no route was set.
-            // The scenario is:
-            // - create a new parent model, which has a one2many
-            // - add at least 2 one2many lines which have:
-            //     - a handle field
-            //     - a many2one, which is not required, and we will leave it empty
-            // - reorder the lines with the handle
-            // -> This will call a resequence, which calls a display_name read.
-            // -> With the bug that would fail, if it's ok the test will pass.
+    QUnit.test("one2many with sequence field and text field", async function (assert) {
+        serverData.models.turtle.fields.turtle_int.default = 10;
+        serverData.models.turtle.fields.product_id.default = 37;
+        serverData.models.turtle.fields.not_required_product_id = {
+            string: "Product",
+            type: "many2one",
+            relation: "product",
+        };
 
-            // This test will also make sure lists with
-            // FieldText (turtle_description) can be reordered with a handle.
-            // More specifically this will trigger a reset on a FieldText
-            // while the field is not in editable mode.
-            serverData.models.turtle.fields.turtle_int.default = 10;
-            serverData.models.turtle.fields.product_id.default = 37;
-            serverData.models.turtle.fields.not_required_product_id = {
-                string: "Product",
-                type: "many2one",
-                relation: "product",
-            };
-
-            await makeView({
-                type: "form",
-                resModel: "partner",
-                serverData,
-                arch: `
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
                     <form>
                         <field name="turtles">
                             <tree editable="bottom">
@@ -8900,34 +9000,34 @@ QUnit.module("Fields", (hooks) => {
                             </tree>
                         </field>
                     </form>`,
-            });
+        });
 
-            // starting condition
-            assert.containsNone(target, ".o_data_cell");
+        // starting condition
+        assert.containsNone(target, ".o_data_cell");
 
-            const inputText1 = "relax";
-            const inputText2 = "max";
-            await addRow(target);
-            await editInput(target, 'div[name="turtle_foo"] input', inputText1);
-            await addRow(target);
-            await editInput(target, 'div[name="turtle_foo"] input', inputText2);
-            await addRow(target);
+        const inputText1 = "relax";
+        const inputText2 = "max";
+        await addRow(target);
+        await editInput(target, 'div[name="turtle_foo"] input', inputText1);
+        await addRow(target);
+        await editInput(target, 'div[name="turtle_foo"] input', inputText2);
+        await addRow(target);
 
-            assert.deepEqual(
-                getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")),
-                [inputText1, inputText2, ""]
-            );
+        assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")), [
+            inputText1,
+            inputText2,
+            "",
+        ]);
 
-            assert.containsN(target, ".ui-sortable-handle", 3);
+        assert.containsN(target, ".ui-sortable-handle", 3);
 
-            await dragAndDrop("tbody tr:nth-child(2) .o_handle_cell", "tbody tr:nth-child(1)");
+        await dragAndDrop("tbody tr:nth-child(2) .o_handle_cell", "tbody tr:nth-child(1)");
 
-            assert.deepEqual(
-                getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")),
-                [inputText2, inputText1] // empty line has been discarded on the drag and drop
-            );
-        }
-    );
+        assert.deepEqual(
+            getNodesTextContent(target.querySelectorAll(".o_data_cell.o_list_char")),
+            [inputText2, inputText1] // empty line has been discarded on the drag and drop
+        );
+    });
 
     QUnit.test("one2many with several pages, onchange and default order", async function (assert) {
         // This test reproduces a specific scenario where a one2many is displayed
@@ -8954,7 +9054,7 @@ QUnit.module("Fields", (hooks) => {
                     );
                     return [1, id, pick(record, "turtle_int", "turtle_foo", "partner_ids")];
                 });
-                obj.turtles = [[5]].concat(res);
+                obj.turtles = res;
             },
         };
 
@@ -8973,7 +9073,7 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                var ids = args.method === "read" ? " [" + args.args[0] + "]" : "";
+                var ids = args.method === "web_read" ? " [" + args.args[0] + "]" : "";
                 assert.step(args.method + ids);
             },
             resId: 1,
@@ -8999,12 +9099,8 @@ QUnit.module("Fields", (hooks) => {
 
         assert.verifySteps([
             "get_views",
-            "read [1]", // main record
-            "read [1,2,3]", // one2many (turtle_foo, all records)
-            "read [2,3]", // one2many (all fields in view, records of first page)
-            "read [2,4]", // many2many inside one2many (partner_ids), first page only
-            "onchange",
-            "read [1]", // AAB FIXME 4 (draft fixing taskid-2323491):
+            "web_read [1]", // main record
+            "onchange2",
             // this test's purpose is to assert that this rpc isn't
             // done, but yet it is. Actually, it wasn't before because mockOnChange
             // returned [1] as command list, instead of [[6, false, [1]]], so basically
@@ -9054,15 +9150,7 @@ QUnit.module("Fields", (hooks) => {
         async function (assert) {
             serverData.models.partner.records[0].turtles = [1, 2, 3];
             serverData.models.partner.onchanges = {
-                turtles: function (obj) {
-                    obj.turtles = [
-                        [5],
-                        [1, 1, { turtle_foo: "yop" }],
-                        [1, 2, { turtle_foo: "blip" }],
-                        [1, 3, { turtle_foo: "kawa" }],
-                        [0, obj.turtles[3][2], { turtle_foo: "abc" }],
-                    ];
-                },
+                turtles: function () {},
             };
 
             await makeView({
@@ -9130,7 +9218,7 @@ QUnit.module("Fields", (hooks) => {
             // swap 2 lines in the one2many
             await dragAndDrop("tbody tr:nth-child(2) .o_handle_cell", "tbody tr", "top");
 
-            assert.verifySteps(["get_views", "get_views", "read", "read", "onchange", "onchange"]);
+            assert.verifySteps(["get_views", "get_views", "web_read", "onchange2", "onchange2"]);
         }
     );
 
@@ -9177,9 +9265,9 @@ QUnit.module("Fields", (hooks) => {
             assert.verifySteps([
                 "get_views", // load main form
                 "get_views", // load sub list
-                "onchange", // main record
-                "onchange", // sub record
-                "onchange", // edition of display_name of sub record
+                "onchange2", // main record
+                "onchange2", // sub record
+                "onchange2", // edition of display_name of sub record
             ]);
         }
     );
@@ -9571,37 +9659,9 @@ QUnit.module("Fields", (hooks) => {
     });
 
     QUnit.test("onchange affecting inline unopened list view", async function (assert) {
-        // when we got onchange result for fields of record that were not
-        // already available because they were in a inline view not already
-        // opened, in a given configuration the change were applied ignoring
-        // existing data, thus a line of a one2many field inside a one2many
-        // field could be duplicated unexplectedly
-
         let numUserOnchange = 0;
         serverData.models.user.onchanges = {
             partner_ids: function (obj) {
-                if (numUserOnchange === 0) {
-                    // simulate proper server onchange after save of modal with new record
-                    obj.partner_ids = [
-                        [5],
-                        [
-                            1,
-                            1,
-                            {
-                                display_name: "first record",
-                                turtles: [[5], [1, 2, { display_name: "donatello" }]],
-                            },
-                        ],
-                        [
-                            1,
-                            2,
-                            {
-                                display_name: "second record",
-                                turtles: [[5], obj.partner_ids[1][2].turtles[0]],
-                            },
-                        ],
-                    ];
-                }
                 numUserOnchange++;
             },
         };
@@ -9644,8 +9704,8 @@ QUnit.module("Fields", (hooks) => {
 
         assert.strictEqual(
             numUserOnchange,
-            2,
-            "there should 2 and only 2 onchange from closing the partner modal"
+            1,
+            "there should 1 and only 1 onchange from closing the partner modal"
         );
 
         await click(target.querySelector(".o_data_row .o_data_cell"));
@@ -9851,7 +9911,7 @@ QUnit.module("Fields", (hooks) => {
             resId: 1,
             mockRPC(route, args) {
                 const { method, kwargs } = args;
-                if (method === "onchange") {
+                if (method === "onchange2") {
                     assert.step("onchange");
                     assert.strictEqual(kwargs.context.default_turtle_foo, "soft");
                 }
@@ -9887,20 +9947,20 @@ QUnit.module("Fields", (hooks) => {
                     </form>`,
             async mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     await Promise.resolve(def);
                 }
             },
         });
 
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
 
         const value = "hello";
 
         // add a new line
         await addRow(target);
 
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
 
         // we want to add a delay to simulate an onchange
         def = makeDeferred();
@@ -9916,7 +9976,7 @@ QUnit.module("Fields", (hooks) => {
         assert.strictEqual(target.querySelector("[name=turtle_foo] input").value, value);
         assert.containsOnce(target, ".o_data_row");
 
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
 
         // unlock onchange
         def.resolve();
@@ -9933,7 +9993,7 @@ QUnit.module("Fields", (hooks) => {
             ""
         );
 
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
     });
 
     QUnit.test("edit a field with a slow onchange in one2many", async function (assert) {
@@ -9956,20 +10016,20 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             async mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     await Promise.resolve(def);
                 }
             },
         });
 
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
 
         const value = "hello";
 
         // add a new line
         await addRow(target);
 
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
 
         // we want to add a delay to simulate an onchange
         def = makeDeferred();
@@ -9983,7 +10043,7 @@ QUnit.module("Fields", (hooks) => {
         // check that nothing changed before the onchange finished
         assert.strictEqual(target.querySelector("[name=turtle_foo] input").value, value);
 
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
 
         // unlock onchange
         def.resolve();
@@ -10036,12 +10096,11 @@ QUnit.module("Fields", (hooks) => {
             );
             assert.verifySteps([
                 "get_views", // main form view
-                "onchange", // main record
-                "onchange", // line 1
-                "onchange", // line 2
+                "onchange2", // main record
+                "onchange2", // line 1
+                "onchange2", // line 2
                 "create",
-                "read", // main record
-                "read", // line 1
+                "web_read", // main record
             ]);
         }
     );
@@ -10353,7 +10412,7 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             resId: 1,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.step("onchange");
                 }
             },
@@ -10395,12 +10454,13 @@ QUnit.module("Fields", (hooks) => {
     QUnit.test(
         "many2manys inside a one2many are fetched in batch after onchange",
         async function (assert) {
-            assert.expect(7);
+            assert.expect(5);
 
             serverData.models.partner.onchanges = {
                 turtles: function (obj) {
                     obj.turtles = [
-                        [5],
+                        [4, 1],
+                        [4, 2],
                         [
                             1,
                             1,
@@ -10409,17 +10469,6 @@ QUnit.module("Fields", (hooks) => {
                                 partner_ids: [[4, 2]],
                             },
                         ],
-                        [
-                            1,
-                            2,
-                            {
-                                turtle_foo: "donatello",
-                                partner_ids: [
-                                    [4, 2],
-                                    [4, 4],
-                                ],
-                            },
-                        ],
                     ];
                 },
             };
@@ -10439,13 +10488,6 @@ QUnit.module("Fields", (hooks) => {
                     </form>`,
                 mockRPC(route, args) {
                     assert.step(args.method || route);
-                    if (args.method === "read") {
-                        assert.deepEqual(
-                            args.args[0],
-                            [2, 4],
-                            "should read the partner_ids once, batched"
-                        );
-                    }
                 },
             });
 
@@ -10455,7 +10497,7 @@ QUnit.module("Fields", (hooks) => {
                 ["second record", "second recordaaa"]
             );
 
-            assert.verifySteps(["get_views", "onchange", "read"]);
+            assert.verifySteps(["get_views", "onchange2"]);
         }
     );
 
@@ -10470,18 +10512,19 @@ QUnit.module("Fields", (hooks) => {
         };
         serverData.models.partner.onchanges = {
             turtles: function (obj) {
-                // when we add a line to turtles, add same line to turtles2
+                // replicate changes on turtles2
                 if (obj.turtles.length) {
-                    obj.turtles = [[5]].concat(obj.turtles);
-                    obj.turtles2 = obj.turtles;
-                }
-            },
-            turtles2: function (obj) {
-                // simulate an onchange on turtles2 as well
-                if (obj.turtles2.length) {
-                    obj.turtles2 = [[5]].concat(obj.turtles2);
+                    const command = obj.turtles2 && obj.turtles2[0];
+                    if (command) {
+                        // second onchange (with ABC): there's already a create command
+                        obj.turtles2 = [[1, command[1], obj.turtles[0][2]]];
+                    } else {
+                        // first onchange (when adding the row): replicate the create command
+                        obj.turtles2 = [[0, false, obj.turtles[0][2]]];
+                    }
                 }
             },
+            turtles2: () => {}, // simulate an onchange on turtles2 as well
         };
 
         await makeView({
@@ -10690,9 +10733,7 @@ QUnit.module("Fields", (hooks) => {
 
             const def = makeDeferred();
             serverData.models.partner.onchanges = {
-                trululu: (obj) => {
-                    obj.p = [[5]].concat(obj.p);
-                },
+                trululu: () => {},
             };
 
             await makeView({
@@ -10729,14 +10770,17 @@ QUnit.module("Fields", (hooks) => {
         }
     );
 
-    QUnit.skip(
+    QUnit.test(
         "one2many with many2many_tags in list and list in form with a limit",
         async function (assert) {
-            // This test is skipped for now, as it doesn't work, and it can't be fixed in the current
-            // architecture (without large changes). However, this is unlikely to happen as the default
-            // limit is 80, and it would be useless to display so many records with a many2many_tags
-            // widget. So it would be nice if we could make it work in the future, but it's no big
-            // deal for now.
+            // This test encodes a limitation of the current model architecture:
+            // we have an nested x2manys, and the inner one is displayed as tags
+            // in the list, and as a list in the form. As both the list and the
+            // form will use the same Record datapoint, the config of their static
+            // list will be the same. We obviously don't want to see the limit
+            // applied on the tags (in the background) when opening the form. So
+            // the stategy is to keep the initial config, and to ignore the
+            // limit set on the list
             serverData.models.partner.records[0].p = [1];
             serverData.models.partner.records[0].turtles = [1, 2, 3];
 
@@ -10764,17 +10808,13 @@ QUnit.module("Fields", (hooks) => {
             });
 
             assert.containsOnce(target, ".o_field_widget[name=p] .o_data_row");
-            assert.containsN(target, ".o_data_row .o_field_many2manytags .badge", 3);
+            assert.containsN(target, ".o_data_row .o_field_many2many_tags .badge", 3);
 
-            await click(target.querySelector(".o_data_row"));
+            await click(target.querySelector(".o_data_cell"));
 
             assert.containsOnce(document.body, ".modal .o_form_view");
-            assert.containsN(document.body, ".modal .o_field_widget[name=turtles] .o_data_row", 2);
-            assert.isVisible(target.querySelector(".modal .o_field_x2many_list .o_pager"));
-            assert.strictEqual(
-                target.querySelector(".modal .o_field_x2many_list .o_pager").textContent.trim(),
-                "1-2 / 3"
-            );
+            assert.containsN(document.body, ".modal .o_field_widget[name=turtles] .o_data_row", 3);
+            assert.isNotVisible(target.querySelector(".modal .o_field_x2many_list .o_pager"));
         }
     );
 
@@ -10783,25 +10823,7 @@ QUnit.module("Fields", (hooks) => {
         async function (assert) {
             serverData.models.partner.onchanges = {
                 bar: function (obj) {
-                    obj.p = [
-                        [5],
-                        [
-                            0,
-                            0,
-                            {
-                                turtles: [
-                                    [5],
-                                    [
-                                        0,
-                                        0,
-                                        {
-                                            display_name: "new turtle",
-                                        },
-                                    ],
-                                ],
-                            },
-                        ],
-                    ];
+                    obj.p = [[0, 0, { turtles: [[0, 0, { display_name: "new turtle" }]] }]];
                 },
             };
 
@@ -10857,13 +10879,11 @@ QUnit.module("Fields", (hooks) => {
             serverData.models.partner.onchanges = {
                 bar: function (obj) {
                     obj.p = [
-                        [5],
                         [
                             0,
                             0,
                             {
                                 turtles: [
-                                    [5],
                                     [
                                         0,
                                         0,
@@ -10930,57 +10950,6 @@ QUnit.module("Fields", (hooks) => {
         }
     );
 
-    QUnit.test("one2many value returned by onchange with unknown fields", async function (assert) {
-        assert.expect(3);
-
-        serverData.models.partner.onchanges = {
-            bar: function (obj) {
-                obj.p = [
-                    [5],
-                    [
-                        0,
-                        0,
-                        {
-                            bar: true,
-                            display_name: "coucou",
-                            trululu: [2, "second record"],
-                            turtles: [[5], [0, 0, { turtle_int: 4 }]],
-                        },
-                    ],
-                ];
-            },
-        };
-
-        await makeView({
-            type: "form",
-            resModel: "partner",
-            serverData,
-            arch: `
-                <form>
-                    <field name="bar"/>
-                    <field name="p" widget="many2many_tags"/>
-                </form>`,
-            mockRPC(route, args) {
-                if (args.method === "create") {
-                    assert.deepEqual(args.args[0].p[0][2], {
-                        bar: true,
-                        display_name: "coucou",
-                        trululu: 2,
-                        turtles: [[5], [0, 0, { turtle_int: 4 }]],
-                    });
-                }
-            },
-        });
-
-        assert.containsOnce(target.querySelector(".o_field_many2many_tags"), ".badge");
-        assert.strictEqual(
-            target.querySelector(".o_field_many2many_tags .o_tag_badge_text").innerText,
-            "coucou"
-        );
-
-        await clickSave(target);
-    });
-
     QUnit.test("nested one2many, onchange, no command value", async function (assert) {
         // This test ensures that we always send all values to onchange rpcs for nested
         // one2manys, even if some field hasn't changed. In this particular test case,
@@ -11016,24 +10985,25 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             async mockRPC(route, args) {
-                if (step === 3 && args.method === "onchange" && args.model === "partner") {
+                if (step === 3 && args.method === "onchange2" && args.model === "partner") {
                     assert.deepEqual(args.args[1].turtles[0][2], {
+                        o2m: [],
                         turtle_bar: false,
-                        o2m: [], // we must send a value for this field
                     });
                 }
                 if (args.model === "turtle") {
                     if (step === 2) {
                         return {
                             value: {
-                                o2m: [[5], [0, false, { display_name: "default" }]],
+                                o2m: [[0, false, { display_name: "default" }]],
                                 turtle_bar: true,
                             },
                         };
                     }
                     if (step === 3) {
+                        const virtualId = args.args[1].o2m[0][1];
                         return {
-                            value: { o2m: [[5]] },
+                            value: { o2m: [[2, virtualId]] },
                         };
                     }
                 }
@@ -11169,7 +11139,7 @@ QUnit.module("Fields", (hooks) => {
                     </sheet>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     if (args.model === "turtle") {
                         assert.deepEqual(
                             args.kwargs.context,
@@ -11221,7 +11191,7 @@ QUnit.module("Fields", (hooks) => {
             target.querySelector(".o_field_widget[name=product_id] input").value,
             "xphone"
         );
-        assert.verifySteps(["get_views on partner", "onchange on partner"]);
+        assert.verifySteps(["get_views on partner", "onchange2 on partner"]);
     });
 
     QUnit.test("x2many default_order multiple fields", async function (assert) {
@@ -11380,12 +11350,8 @@ QUnit.module("Fields", (hooks) => {
 
     QUnit.test("delete a record while adding another one in a multipage", async function (assert) {
         // in a one2many with at least 2 pages, add a new line. Delete the line above it.
-        // (the onchange makes it so that the virtualID is inserted in the middle of the currentResIDs.)
         // it should load the next line to display it on the page.
         serverData.models.partner.records[0].turtles = [2, 3];
-        serverData.models.partner.onchanges.turtles = function (obj) {
-            obj.turtles = [[5]].concat(obj.turtles);
-        };
 
         await makeView({
             type: "form",
@@ -11453,46 +11419,19 @@ QUnit.module("Fields", (hooks) => {
 
         assert.verifySteps([
             "get_views partner",
-            "read partner",
-            "read turtle",
-            "onchange turtle",
-            "onchange partner",
-            "onchange partner",
-            "onchange turtle",
-            "onchange partner",
+            "web_read partner",
+            "onchange2 turtle",
+            "onchange2 partner",
+            "onchange2 partner",
+            "onchange2 turtle",
+            "onchange2 partner",
         ]);
     });
 
     QUnit.test("onchange on unloaded record clearing posterious change", async function (assert) {
-        // when we got onchange result for fields of record that were not
-        // already available because they were in a inline view not already
-        // opened, in a given configuration the change were applied ignoring
-        // posteriously changed data, thus an added/removed/modified line could
-        // be reset to the original onchange data
         let numUserOnchange = 0;
-
         serverData.models.user.onchanges = {
             partner_ids: function (obj) {
-                // simulate actual server onchange after save of modal with new record
-                if (numUserOnchange === 0) {
-                    obj.partner_ids = [...obj.partner_ids];
-                    obj.partner_ids.unshift([5]);
-                    obj.partner_ids[1][2].turtles.unshift([5]);
-                    obj.partner_ids[2] = [
-                        1,
-                        2,
-                        {
-                            display_name: "second record",
-                            trululu: 1,
-                            turtles: [[5]],
-                        },
-                    ];
-                } else if (numUserOnchange === 1) {
-                    obj.partner_ids = [...obj.partner_ids];
-                    obj.partner_ids.unshift([5]);
-                    obj.partner_ids[1][2].turtles.unshift([5]);
-                    obj.partner_ids[2][2].turtles.unshift([5]);
-                }
                 numUserOnchange++;
             },
         };
@@ -11556,6 +11495,14 @@ QUnit.module("Fields", (hooks) => {
             "second partner turtle is Michelangelo"
         );
         await clickDiscard(target.querySelector(".modal"));
+
+        // re-open, edit michelangelo row, click out -> row still there, in readonly
+        await click(target.querySelectorAll(".o_data_row")[1].querySelector(".o_data_cell"));
+        await click(target.querySelector(".modal .o_data_row .o_data_cell"));
+        assert.containsOnce(target, ".modal .o_selected_row");
+        await click(target.querySelector(".modal"));
+        assert.containsOnce(target, ".modal .o_data_row");
+        assert.strictEqual(target.querySelector(".modal .o_data_cell").innerText, "Michelangelo");
     });
 
     QUnit.test("quickly switch between pages in one2many list", async function (assert) {
@@ -11575,7 +11522,7 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             async mockRPC(route, args) {
-                if (args.method === "read") {
+                if (args.method === "web_read") {
                     const recordID = args.args[0][0];
                     await Promise.resolve(readDefs[recordID - 1]);
                 }
@@ -11603,9 +11550,9 @@ QUnit.module("Fields", (hooks) => {
             serverData.models.partner.records[0].p = [2];
             serverData.models.partner.records[0].bar = false;
 
+            let triggerOnchange = false;
             serverData.models.partner.onchanges.p = function (obj) {
-                // set bar to true when line is added
-                if (obj.p.length > 1 && obj.p[1][2].foo === "New line") {
+                if (triggerOnchange) {
                     obj.bar = true;
                 }
             };
@@ -11633,7 +11580,7 @@ QUnit.module("Fields", (hooks) => {
 
             // add a new o2m record
             await addRow(target);
-            target.querySelector(".o_field_one2many input").focus(); // useless?
+            triggerOnchange = true;
             await editInput(target, ".o_field_one2many input", "New line");
             await click(target, ".o_form_view");
 
@@ -12364,7 +12311,6 @@ QUnit.module("Fields", (hooks) => {
                     </field>
                 </form>`,
             resId: 1,
-            mode: "edit",
         });
 
         await click(target.querySelector(".o_data_cell")); // edit the first row
@@ -12413,8 +12359,11 @@ QUnit.module("Fields", (hooks) => {
         };
         serverData.models.turtle.onchanges = {
             turtle_trululu: function (record) {
-                record.product_ids = [37];
-                record.user_ids = [17, 19];
+                record.product_ids = [[4, 37]];
+                record.user_ids = [
+                    [4, 17],
+                    [4, 19],
+                ];
             },
         };
 
@@ -12607,6 +12556,7 @@ QUnit.module("Fields", (hooks) => {
         assert.containsNone(target, ".o_kanban_record:not(.o_kanban_ghost)");
 
         await clickSave(target);
+        assert.verifySteps(["write"]);
     });
 
     QUnit.test("toggle boolean in o2m with the formView in edition", async function (assert) {
@@ -12634,10 +12584,15 @@ QUnit.module("Fields", (hooks) => {
                 assert.step(args.method + " " + args.model);
             },
         });
-        assert.verifySteps(["get_views partner", "read partner", "read turtle"]);
+        assert.verifySteps(["get_views partner", "web_read partner"]);
 
         await click(target, ".o_boolean_toggle");
-        assert.verifySteps(["onchange turtle", "onchange partner", "write turtle", "read turtle"]);
+        assert.verifySteps([
+            "onchange2 turtle",
+            "onchange2 partner",
+            "write turtle",
+            "web_read turtle",
+        ]);
     });
 
     QUnit.test("create a new record with an x2m invisible", async function (assert) {
@@ -12655,19 +12610,56 @@ QUnit.module("Fields", (hooks) => {
                         </field>
                     </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
-                    assert.step(args.method);
+                assert.step(args.method);
+                if (args.method === "onchange2") {
                     assert.deepEqual(args.args[3], {
-                        p: "",
-                        "p.int_field": "",
-                        "p.trululu": "",
+                        display_name: {},
+                        p: {
+                            fields: {
+                                int_field: {},
+                                trululu: {
+                                    fields: {
+                                        display_name: {},
+                                    },
+                                },
+                            },
+                            limit: 40,
+                            order: "",
+                        },
+                    });
+                    return {
+                        value: {
+                            p: [
+                                [
+                                    0,
+                                    false,
+                                    {
+                                        int_field: 4,
+                                        trululu: { id: 1, display_name: "first record" },
+                                    },
+                                ],
+                            ],
+                        },
+                    };
+                }
+                if (args.method === "create") {
+                    const commands = args.args[0][0].p;
+                    assert.deepEqual(commands, [[0, commands[0][1], { int_field: 4, trululu: 1 }]]);
+                }
+                if (args.method === "web_read") {
+                    assert.deepEqual(args.kwargs.specification, {
+                        display_name: {},
+                        p: {},
                     });
                 }
             },
         });
 
         assert.containsNone(target, "[name='p']");
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
+
+        await click(target, ".o_form_button_save");
+        assert.verifySteps(["create", "web_read"]);
     });
 
     QUnit.test("edit a record with an x2m invisible", async function (assert) {
@@ -12687,6 +12679,13 @@ QUnit.module("Fields", (hooks) => {
                     </form>`,
             mockRPC(route, args) {
                 assert.step(`${args.method} ${args.model}`);
+                if (args.method === "web_read") {
+                    assert.deepEqual(args.kwargs.specification, {
+                        display_name: {},
+                        foo: {},
+                        turtles: {},
+                    });
+                }
                 if (args.method === "write") {
                     assert.deepEqual(args.args[1], {
                         foo: "plop",
@@ -12697,11 +12696,11 @@ QUnit.module("Fields", (hooks) => {
         });
 
         assert.containsNone(target, "[name='p']");
-        assert.verifySteps(["get_views partner", "read partner"]);
+        assert.verifySteps(["get_views partner", "web_read partner"]);
 
         await editInput(target, "[name='foo'] input", "plop");
         await clickSave(target);
-        assert.verifySteps(["write partner", "read partner"]);
+        assert.verifySteps(["write partner", "web_read partner"]);
     });
 
     QUnit.test("can't select a record in a one2many", async function (assert) {
@@ -12805,6 +12804,52 @@ QUnit.module("Fields", (hooks) => {
         assert.strictEqual(serverData.models.turtle.records[0].turtle_int, 5);
     });
 
+    QUnit.test("multi page, command forget for record of second page", async function (assert) {
+        serverData.models.partner.records[0].p = [1, 2, 4];
+        serverData.models.partner.onchanges = {
+            int_field: function (obj) {
+                obj.p = [[3, 4]];
+            },
+        };
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <form>
+                    <group>
+                        <field name="int_field"/>
+                        <field name="p">
+                            <tree limit="2">
+                                <field name="display_name"/>
+                            </tree>
+                        </field>
+                    </group>
+                </form>`,
+            resId: 1,
+        });
+
+        assert.strictEqual(target.querySelector("[name=int_field] input").value, "10");
+        assert.containsN(target, ".o_data_row", 2);
+        assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_data_cell")), [
+            "first record",
+            "second record",
+        ]);
+        assert.strictEqual(
+            target.querySelector(".o_x2m_control_panel .o_pager_counter").innerText,
+            "1-2 / 3"
+        );
+
+        // trigger the onchange
+        await editInput(target, "[name=int_field] input", "16");
+        assert.containsN(target, ".o_data_row", 2);
+        assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_data_cell")), [
+            "first record",
+            "second record",
+        ]);
+        assert.containsNone(target, ".o_x2m_control_panel .o_pager");
+    });
+
     QUnit.test("active actions are passed to o2m field", async (assert) => {
         serverData.models.partner.records[0].turtles = [1, 2, 3];
 
@@ -12927,6 +12972,52 @@ QUnit.module("Fields", (hooks) => {
         assert.containsOnce(target, ".modal .o_kanban_record:not('.o_kanban_ghost')");
     });
 
+    QUnit.test("kanban one2many (with widget) in opened view form", async function (assert) {
+        serverData.models.partner.records[0].p = [1];
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: /* xml */ `
+                <form>
+                    <field name="p">
+                        <kanban>
+                            <templates>
+                                <t t-name="kanban-box">
+                                    <div class="oe_kanban_global_click">
+                                        <field name="display_name" widget="char"/>
+                                    </div>
+                                </t>
+                            </templates>
+                        </kanban>
+                        <form>
+                            <field name="display_name"/>
+                        </form>
+                    </field>
+                </form>`,
+            resId: 1,
+        });
+
+        assert.containsOnce(target, ".o_kanban_record:not(.o_kanban_ghost)");
+        assert.strictEqual(target.querySelector(".o_kanban_record").innerText, "first record");
+
+        await click(target.querySelector(".o_kanban_record"));
+        assert.containsOnce(target, ".o_dialog .o_form_view .o_field_widget[name=display_name]");
+        assert.strictEqual(
+            target.querySelector(".o_dialog .o_form_view .o_field_widget[name=display_name] input")
+                .value,
+            "first record"
+        );
+        assert.strictEqual(target.querySelector(".o_kanban_record").innerText, "first record");
+
+        await editInput(
+            target,
+            ".o_dialog .o_form_view .o_field_widget[name=display_name] input",
+            "test"
+        );
+        assert.strictEqual(target.querySelector(".o_kanban_record").innerText, "test");
+    });
+
     QUnit.test("list one2many in opened view form", async function (assert) {
         serverData.models.partner.records[0].p = [1];
         await makeView({
@@ -13089,19 +13180,19 @@ QUnit.module("Fields", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views: partner", "onchange: partner"]);
+        assert.verifySteps(["get_views: partner", "onchange2: partner"]);
         await click(target, ".o_field_x2many_list_row_add a");
-        assert.verifySteps(["get_views: partner_type", "onchange: partner_type"]);
+        assert.verifySteps(["get_views: partner_type", "onchange2: partner_type"]);
         await editInput(
             target.querySelector(".modal"),
             ".o_field_widget[name='display_name'] input",
             "changed"
         );
-        assert.verifySteps(["onchange: partner_type"]);
+        assert.verifySteps(["onchange2: partner_type"]);
         await click(target.querySelector(".modal .o_form_button_save"));
         assert.strictEqual(target.querySelector(".o_data_row").textContent, "changed5");
         await click(target, ".o_form_button_save");
-        assert.verifySteps(["create: partner", "read: partner", "read: partner_type"]);
+        assert.verifySteps(["create: partner", "web_read: partner"]);
         assert.strictEqual(target.querySelector(".o_data_row").textContent, "changed5");
     });
 
@@ -13149,81 +13240,6 @@ QUnit.module("Fields", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
     });
 
-    QUnit.test("test relational_model one2many field formatted correctly", async function (assert) {
-        assert.expect(1);
-
-        const serverData = {
-            models: {
-                turlututu: {
-                    fields: {
-                        foo: {
-                            name: "foo",
-                            type: "int",
-                            onChange: "1",
-                        },
-                        line_ids: {
-                            name: "line_ids",
-                            type: "one2many",
-                            relatedFields: {
-                                date: {
-                                    name: "date",
-                                    type: "date",
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-
-        registry.category("services").add("rpc", rpcService);
-        const env = await makeTestEnv({
-            serverData,
-            mockRPC(route, { args, method }) {
-                if (method === "onchange") {
-                    return {
-                        value: {
-                            line_ids: [[0, 0, { date: "2020-01-01" }]],
-                        },
-                    };
-                }
-            },
-        });
-
-        const model = new RelationalModel(
-            env,
-            {
-                resModel: "turlututu",
-                fields: serverData.models.turlututu.fields,
-                viewMode: "form",
-                rootType: "record",
-                activeFields: serverData.models.turlututu.fields,
-            },
-            env.services
-        );
-
-        await model.load({
-            mode: "edit",
-            values: {
-                id: 0,
-                name: "turlututu",
-                display_name: "turlututu",
-                write_date: false,
-                foo: 0,
-                line_ids: [],
-            },
-        });
-
-        await model.root.update({
-            foo: 1,
-        });
-
-        // The one2many orm commands should be parsed correctly and then, the date value is now a Datetime
-        // and not no longer a string.
-        const record = model.root.data.line_ids.records[0];
-        assert.strictEqual(typeof record.data.date, "object");
-    });
-
     QUnit.test("add a row to an x2many and ask canBeRemoved twice", async function (assert) {
         // This test simulates that the view is asked twice to save its changes because the user
         // is leaving. Before the corresponding fix, the changes in the x2many field weren't
@@ -13246,7 +13262,7 @@ QUnit.module("Fields", (hooks) => {
                 res_model: "partner",
                 type: "ir.actions.act_window",
                 views: [[false, "list"]],
-            }
+            },
         };
         serverData.views = {
             "partner,false,list": `<tree><field name="int_field"/></tree>`,
@@ -13293,4 +13309,203 @@ QUnit.module("Fields", (hooks) => {
         assert.containsOnce(target, ".o_list_view");
         assert.verifySteps([]);
     });
+
+    QUnit.test(
+        "one2many: save a record before the onchange is complete in a form dialog",
+        async function (assert) {
+            serverData.models.turtle.onchanges = {
+                display_name: function () {},
+            };
+
+            serverData.views = {
+                "turtle,false,form": `
+                    <form>
+                        <field name="display_name"/>
+                    </form>`,
+            };
+
+            const def = makeDeferred();
+            await makeView({
+                type: "form",
+                resModel: "partner",
+                serverData,
+                resId: 1,
+                arch: `
+                    <form>
+                        <field name="turtles">
+                            <tree>
+                                <field name="display_name" required="1"/>
+                            </tree>
+                        </field>
+                    </form>`,
+                async mockRPC(route, args) {
+                    if (
+                        args.method === "onchange2" &&
+                        args.args[2].length === 1 &&
+                        args.args[2][0] === "display_name"
+                    ) {
+                        await def;
+                    }
+                },
+            });
+            await addRow(target);
+            assert.containsOnce(target, ".modal");
+
+            await editInput(target, ".o_field_widget[name=display_name] input", "new name");
+            await click(target, ".modal .o_form_button_save");
+            assert.containsOnce(target, ".modal");
+
+            def.resolve();
+            await nextTick();
+            assert.containsNone(target, ".modal");
+            assert.containsN(target, ".o_data_row", 2);
+            assert.deepEqual(
+                [...target.querySelectorAll(".o_data_row [name='display_name']")].map(
+                    (el) => el.textContent
+                ),
+                ["donatello", "new name"]
+            );
+        }
+    );
+
+    QUnit.test("forget command for nested x2manys in form, not in list", async function (assert) {
+        assert.expect(8);
+
+        serverData.models.partner.records[0].p = [1, 2];
+        serverData.models.partner.records[1].turtles = [2];
+        serverData.models.partner.onchanges = {
+            int_field: function (obj) {
+                obj.p = [
+                    [
+                        1,
+                        1,
+                        {
+                            foo: "new foo value (1)",
+                            turtles: [
+                                [
+                                    1,
+                                    2,
+                                    {
+                                        turtle_foo: "new turtle foo value (1)",
+                                        partner_ids: [[3, 4]],
+                                    },
+                                ],
+                            ],
+                        },
+                    ],
+                    [
+                        1,
+                        2,
+                        {
+                            foo: "new foo value (2)",
+                            turtles: [
+                                [
+                                    1,
+                                    2,
+                                    {
+                                        turtle_foo: "new turtle foo value (2)",
+                                        partner_ids: [[3, 2]],
+                                    },
+                                ],
+                            ],
+                        },
+                    ],
+                ];
+            },
+        };
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <form>
+                    <group>
+                        <field name="int_field"/>
+                        <field name="p">
+                            <tree>
+                                <field name="foo"/>
+                            </tree>
+                            <form>
+                                <field name="turtles">
+                                    <tree editable="bottom">
+                                        <field name="turtle_foo"/>
+                                        <field name="partner_ids" widget="many2many_tags"/>
+                                    </tree>
+                                </field>
+                            </form>
+                        </field>
+                    </group>
+                </form>`,
+            mockRPC(route, args) {
+                if (args.method === "write") {
+                    assert.deepEqual(args.args[1], {
+                        int_field: 16,
+                        p: [
+                            [
+                                1,
+                                1,
+                                {
+                                    foo: "new foo value (1)",
+                                    turtles: [
+                                        [
+                                            1,
+                                            2,
+                                            {
+                                                turtle_foo: "new turtle foo value (1)",
+                                                partner_ids: [[3, 4]],
+                                            },
+                                        ],
+                                    ],
+                                },
+                            ],
+                            [
+                                1,
+                                2,
+                                {
+                                    foo: "new foo value (2)",
+                                    turtles: [
+                                        [
+                                            1,
+                                            2,
+                                            {
+                                                turtle_foo: "new turtle foo value (2)",
+                                                partner_ids: [[3, 2]],
+                                            },
+                                        ],
+                                    ],
+                                },
+                            ],
+                        ],
+                    });
+                }
+            },
+            resId: 1,
+        });
+
+        assert.strictEqual(target.querySelector("[name=int_field] input").value, "10");
+
+        // trigger the onchange
+        await editInput(target, "[name=int_field] input", "16");
+        assert.strictEqual(target.querySelector("[name=foo]").innerText, "new foo value (1)");
+        assert.strictEqual(target.querySelectorAll("[name=foo]")[1].innerText, "new foo value (2)");
+
+        // open the second x2many record
+        await click(target.querySelectorAll(".o_data_row")[1].querySelector("td"));
+        assert.containsOnce(target.querySelector(".o_dialog"), ".o_data_row");
+        assert.strictEqual(
+            target.querySelector(".o_dialog .o_data_cell[name=turtle_foo]").innerText,
+            "new turtle foo value (2)"
+        );
+        assert.containsOnce(
+            target.querySelector(".o_dialog .o_data_cell[name=partner_ids]"),
+            ".o_tag"
+        );
+        assert.strictEqual(
+            target.querySelector(".o_dialog .o_data_cell[name=partner_ids] .o_tag").innerText,
+            "aaa"
+        );
+
+        await clickSave(target.querySelector(".o_dialog"));
+        await clickSave(target);
+    });
 });
diff --git a/addons/web/static/tests/views/fields/pdf_viewer_field_tests.js b/addons/web/static/tests/views/fields/pdf_viewer_field_tests.js
index 1657fb7dfed..1359744f33d 100644
--- a/addons/web/static/tests/views/fields/pdf_viewer_field_tests.js
+++ b/addons/web/static/tests/views/fields/pdf_viewer_field_tests.js
@@ -84,7 +84,7 @@ QUnit.module("Fields", (hooks) => {
             arch: '<form><field name="document" widget="pdf_viewer"/></form>',
             async mockRPC(_route, { method, args }) {
                 if (method === "create") {
-                    assert.deepEqual(args[0], { document: btoa("test") });
+                    assert.deepEqual(args[0], [{ document: btoa("test") }]);
                 }
             },
         });
diff --git a/addons/web/static/tests/views/fields/progress_bar_field_tests.js b/addons/web/static/tests/views/fields/progress_bar_field_tests.js
index ad5ca75c211..1fa812e55f3 100644
--- a/addons/web/static/tests/views/fields/progress_bar_field_tests.js
+++ b/addons/web/static/tests/views/fields/progress_bar_field_tests.js
@@ -293,7 +293,7 @@ QUnit.module("Fields", (hooks) => {
 
         assert.verifySteps([
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/read",
+            "/web/dataset/call_kw/partner/web_read",
         ]);
     });
 
@@ -524,7 +524,11 @@ QUnit.module("Fields", (hooks) => {
 
             await editInput(target, ".o_progressbar_value .o_input", "trente sept virgule neuf");
             await clickSave(target);
-            assert.containsOnce(target, ".o_form_dirty", "The form has not been saved");
+            assert.containsOnce(
+                target,
+                ".o_form_status_indicator span.text-danger",
+                "The form has not been saved"
+            );
             assert.strictEqual(
                 target.querySelector(".o_form_button_save").disabled,
                 true,
diff --git a/addons/web/static/tests/views/fields/properties_field_tests.js b/addons/web/static/tests/views/fields/properties_field_tests.js
index 9756d82ba11..6bd37b8f57d 100644
--- a/addons/web/static/tests/views/fields/properties_field_tests.js
+++ b/addons/web/static/tests/views/fields/properties_field_tests.js
@@ -143,7 +143,6 @@ QUnit.module("Fields", (hooks) => {
                             display_name: "third partner",
                             properties: [
                                 { name: "property_1", type: "char" },
-                                { name: "property_2", type: "char", definition_deleted: true },
                                 { name: "property_3", type: "char", definition_changed: true },
                                 { name: "property_4", type: "char" },
                             ],
@@ -152,10 +151,7 @@ QUnit.module("Fields", (hooks) => {
                         {
                             id: 4,
                             display_name: "fourth partner",
-                            properties: [
-                                { name: "property_2", type: "char", definition_deleted: true },
-                                { name: "property_3", type: "char", definition_deleted: true },
-                            ],
+                            properties: [],
                             company_id: 37,
                         },
                     ],
@@ -1184,7 +1180,7 @@ QUnit.module("Fields", (hooks) => {
                 }
             },
         });
-        assert.verifySteps(["get_views", "read", "check_access_rights"]);
+        assert.verifySteps(["get_views", "web_read", "check_access_rights"]);
 
         // check initial properties
         assert.equal(
@@ -1215,7 +1211,7 @@ QUnit.module("Fields", (hooks) => {
         // save
         assert.verifySteps([]);
         await clickSave(target);
-        assert.verifySteps(["write", "read"]);
+        assert.verifySteps(["write", "web_read"]);
     });
 
     /**
@@ -1357,34 +1353,36 @@ QUnit.module("Fields", (hooks) => {
         assert.equal(items.length, 2);
     });
 
-    QUnit.test("properties: kanban view with date and datetime property fields", async function (assert) {
-        serverData.models.partner.records.push({
-            id: 40,
-            display_name: "fifth partner",
-            properties: [
-                {
-                    name: "property_1",
-                    string: "My Date",
-                    type: "date",
-                    value: "2019-01-01",
-                    view_in_kanban: true,
-                },
-                {
-                    name: "property_2",
-                    string: "My DateTime",
-                    type: "datetime",
-                    value: "2019-01-01 10:00:00",
-                    view_in_kanban: true,
-                },
-            ],
-            company_id: 37,
-        });
+    QUnit.test(
+        "properties: kanban view with date and datetime property fields",
+        async function (assert) {
+            serverData.models.partner.records.push({
+                id: 40,
+                display_name: "fifth partner",
+                properties: [
+                    {
+                        name: "property_1",
+                        string: "My Date",
+                        type: "date",
+                        value: "2019-01-01",
+                        view_in_kanban: true,
+                    },
+                    {
+                        name: "property_2",
+                        string: "My DateTime",
+                        type: "datetime",
+                        value: "2019-01-01 10:00:00",
+                        view_in_kanban: true,
+                    },
+                ],
+                company_id: 37,
+            });
 
-        await makeView({
-            type: "kanban",
-            resModel: "partner",
-            serverData,
-            arch: `
+            await makeView({
+                type: "kanban",
+                resModel: "partner",
+                serverData,
+                arch: `
             <kanban>
                 <templates>
                     <t t-name="kanban-box">
@@ -1396,18 +1394,19 @@ QUnit.module("Fields", (hooks) => {
                     </t>
                 </templates>
             </kanban>`,
-        });
+            });
 
-        // check fifth card
-        const property1 = target.querySelector(
-            ".o_kanban_record:nth-child(5) .o_kanban_property_field:nth-child(1) span"
-        );
-        assert.equal(property1.innerText, "01/01/2019");
-        const property2 = target.querySelector(
-            ".o_kanban_record:nth-child(5) .o_kanban_property_field:nth-child(2) span"
-        );
-        assert.equal(property2.innerText, "01/01/2019 11:00:00");
-    });
+            // check fifth card
+            const property1 = target.querySelector(
+                ".o_kanban_record:nth-child(5) .o_kanban_property_field:nth-child(1) span"
+            );
+            assert.equal(property1.innerText, "01/01/2019");
+            const property2 = target.querySelector(
+                ".o_kanban_record:nth-child(5) .o_kanban_property_field:nth-child(2) span"
+            );
+            assert.equal(property2.innerText, "01/01/2019 11:00:00");
+        }
+    );
 
     QUnit.test(
         "properties: kanban view with multiple sources of properties definitions",
@@ -1574,6 +1573,38 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
+    QUnit.test("properties: kanban view without properties", async function (assert) {
+        serverData.models.partner.records = [
+            {
+                id: 40,
+                display_name: "first partner",
+                properties: false,
+                company_id: 37,
+            },
+        ];
+        await makeView({
+            type: "kanban",
+            resModel: "partner",
+            serverData,
+            arch: `
+            <kanban>
+                <templates>
+                    <t t-name="kanban-box">
+                        <div>
+                            <field name="company_id"/> <hr/>
+                            <field name="display_name"/> <hr/>
+                            <field name="properties" widget="properties"/>
+                        </div>
+                    </t>
+                </templates>
+            </kanban>`,
+        });
+        assert.strictEqual(
+            target.querySelector(".o_kanban_record").textContent,
+            "Company 1 first partner "
+        );
+    });
+
     /**
      * Check that the properties are shown when switching view.
      */
diff --git a/addons/web/static/tests/views/fields/radio_field_tests.js b/addons/web/static/tests/views/fields/radio_field_tests.js
index e33ed61b037..f02b949d45b 100644
--- a/addons/web/static/tests/views/fields/radio_field_tests.js
+++ b/addons/web/static/tests/views/fields/radio_field_tests.js
@@ -1,6 +1,6 @@
 /** @odoo-module **/
 
-import { click, clickSave, editInput, getFixture } from "@web/../tests/helpers/utils";
+import { click, clickSave, getFixture } from "@web/../tests/helpers/utils";
 import { makeView, setupViewRegistries } from "@web/../tests/views/helpers";
 
 let serverData;
@@ -86,11 +86,19 @@ QUnit.module("Fields", (hooks) => {
             target.querySelector(".o_field_radio").textContent.replace(/\s+/g, ""),
             "xphonexpad"
         );
-        assert.containsNone(target, "input:checked", "none of the input should be checked");
+        assert.containsNone(
+            target,
+            "input.o_radio_input:checked",
+            "none of the input should be checked"
+        );
 
         await click(target.querySelectorAll("input.o_radio_input")[0]);
 
-        assert.containsOnce(target, "input:checked", "one of the input should be checked");
+        assert.containsOnce(
+            target,
+            "input.o_radio_input:checked",
+            "one of the input should be checked"
+        );
 
         await clickSave(target);
 
@@ -148,7 +156,7 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
         });
 
-        await click(target, "input[type='checkbox']");
+        await click(target, ".o_field_boolean input[type='checkbox']");
 
         assert.containsOnce(
             target,
@@ -161,7 +169,7 @@ QUnit.module("Fields", (hooks) => {
             "the other of the input should be checked"
         );
 
-        await click(target, "input[type='checkbox']");
+        await click(target, ".o_field_boolean input[type='checkbox']");
         assert.containsOnce(
             target,
             "input.o_radio_input[data-value='41']:checked",
@@ -288,61 +296,6 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
-    QUnit.test(
-        "widget radio on a many2one: domain updated by an onchange",
-        async function (assert) {
-            assert.expect(4);
-
-            serverData.models.partner.onchanges = {
-                int_field() {},
-            };
-
-            let domain = [];
-            await makeView({
-                type: "form",
-                resModel: "partner",
-                resId: 1,
-                serverData,
-                arch: `
-                    <form>
-                        <field name="int_field" />
-                        <field name="trululu" widget="radio" />
-                    </form>`,
-                mockRPC(route, { kwargs, method }) {
-                    if (method === "onchange") {
-                        domain = [["id", "in", [10]]];
-                        return Promise.resolve({
-                            value: {
-                                trululu: false,
-                            },
-                            domain: {
-                                trululu: domain,
-                            },
-                        });
-                    }
-                    if (method === "search_read") {
-                        assert.deepEqual(kwargs.domain, domain, "sent domain should be correct");
-                    }
-                },
-            });
-
-            assert.containsN(
-                target,
-                ".o_field_widget[name='trululu'] .o_radio_item",
-                3,
-                "should be 3 radio buttons"
-            );
-
-            // trigger an onchange that will update the domain
-            await editInput(target, ".o_field_widget[name='int_field'] input", "2");
-            assert.containsNone(
-                target,
-                ".o_field_widget[name='trululu'] .o_radio_item",
-                "should be no more radio button"
-            );
-        }
-    );
-
     QUnit.test("field is empty", async function (assert) {
         await makeView({
             type: "form",
diff --git a/addons/web/static/tests/views/fields/reference_field_tests.js b/addons/web/static/tests/views/fields/reference_field_tests.js
index 43e25a10b03..f15fa543527 100644
--- a/addons/web/static/tests/views/fields/reference_field_tests.js
+++ b/addons/web/static/tests/views/fields/reference_field_tests.js
@@ -12,6 +12,7 @@ import {
     clickSave,
     triggerHotkey,
     nextTick,
+    makeDeferred,
 } from "@web/../tests/helpers/utils";
 import { makeView, makeViewInDialog, setupViewRegistries } from "@web/../tests/views/helpers";
 
@@ -247,13 +248,12 @@ QUnit.module("Fields", (hooks) => {
         assert.verifySteps(
             [
                 "get_views",
-                "onchange",
+                "onchange2",
                 "name_search", // for the select
                 "name_search", // for the spawned many2one
                 "name_create",
                 "create",
-                "read",
-                "read",
+                "web_read",
             ],
             "The name_create method should have been called"
         );
@@ -528,10 +528,12 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
                 mockRPC(route, { args, method }) {
                     if (method === "create") {
-                        assert.deepEqual(args[0], {
-                            bar: false,
-                            reference_char: "False,0",
-                        });
+                        assert.deepEqual(args[0], [
+                            {
+                                bar: false,
+                                reference_char: "False,0",
+                            },
+                        ]);
                     }
                 },
             });
@@ -565,10 +567,12 @@ QUnit.module("Fields", (hooks) => {
                 </form>`,
             mockRPC(route, { args, method }) {
                 if (method === "create") {
-                    assert.deepEqual(args[0], {
-                        bar: false,
-                        reference: "partner,4",
-                    });
+                    assert.deepEqual(args[0], [
+                        {
+                            bar: false,
+                            reference: "partner,4",
+                        },
+                    ]);
                 }
             },
         });
@@ -612,14 +616,8 @@ QUnit.module("Fields", (hooks) => {
                         </group>
                     </sheet>
                 </form>`,
-            mockRPC(route, { method, model, args }) {
-                if (method === "read" && args[1].length === 1 && args[1][0] === "display_name") {
-                    assert.step(model);
-                }
-            },
         });
 
-        assert.verifySteps(["product"], "the first display_name read should have been done");
         assert.strictEqual(
             target.querySelector(".o_field_widget[name='reference'] select").value,
             "product",
@@ -634,7 +632,6 @@ QUnit.module("Fields", (hooks) => {
         // trigger onchange
         await editInput(target, ".o_field_widget[name=int_field] input", 12);
 
-        assert.verifySteps(["partner_type"], "the second display_name read should have been done");
         assert.strictEqual(
             target.querySelector(".o_field_widget[name='reference'] select").value,
             "partner_type",
@@ -689,7 +686,6 @@ QUnit.module("Fields", (hooks) => {
                 obj.foo = "product," + obj.int_field;
             },
         };
-
         let nbNameGet = 0;
         await makeView({
             type: "form",
@@ -706,23 +702,26 @@ QUnit.module("Fields", (hooks) => {
                     </sheet>
                 </form>`,
             mockRPC(route, { model, method, args }) {
-                if (model === "product" && method === "read" && args[1].length === 1 && args[1][0] === "display_name") {
+                if (
+                    model === "product" &&
+                    method === "read" &&
+                    args[1].length === 1 &&
+                    args[1][0] === "display_name"
+                ) {
                     nbNameGet++;
                 }
             },
         });
-
-        assert.strictEqual(nbNameGet, 1, "the first display_name read should have been done");
+        assert.strictEqual(nbNameGet, 1, "the first name_get should have been done");
         assert.strictEqual(
             target.querySelector(".o_field_widget[name=foo]").textContent,
             "xphone",
             "foo field should be correctly set"
         );
-
         // trigger onchange
         await editInput(target, ".o_field_widget[name=int_field] input", 41);
-
-        assert.strictEqual(nbNameGet, 2, "the second display_name read should have been done");
+        await nextTick();
+        assert.strictEqual(nbNameGet, 2, "the second name_get should have been done");
         assert.strictEqual(
             target.querySelector(".o_field_widget[name=foo]").textContent,
             "xpad",
@@ -774,7 +773,6 @@ QUnit.module("Fields", (hooks) => {
                     <field name="reference" options="{'model_field': 'model_id'}" />
                 </form>`,
         });
-
         assert.containsNone(
             target,
             "select",
@@ -863,9 +861,14 @@ QUnit.module("Fields", (hooks) => {
                     <field name="display_name"/>
                 </tree>`,
             mockRPC: (route, { method, args }) => {
-                if (method === "onchange") {
+                if (method === "onchange2") {
                     return {
-                        value: { reference: "partner,2" },
+                        value: {
+                            reference: {
+                                id: { id: 2, model: "partner" },
+                                display_name: "second record",
+                            },
+                        },
                     };
                 } else if (method === "create") {
                     assert.strictEqual(args.length, 1);
@@ -914,6 +917,8 @@ QUnit.module("Fields", (hooks) => {
 
             // Select the second product without changing the model
             await click(target, ".o_list_table .reference_field");
+            await nextTick();
+
             await click(target, ".o_list_table .reference_field input");
 
             // Enter to select it
@@ -962,6 +967,7 @@ QUnit.module("Fields", (hooks) => {
             );
 
             await click(target.querySelector(".o_list_table .o_data_cell"));
+            await nextTick();
             await editInput(target, ".o_list_table [name='name'] input", "plop");
             await click(target, ".o_form_view");
             assert.strictEqual(
@@ -1023,4 +1029,33 @@ QUnit.module("Fields", (hooks) => {
             "the selection list of the reference field should exist when hide_model=False and no model_field specified."
         );
     });
+
+    QUnit.test("reference field should await fetch model before render", async function (assert) {
+        serverData.models.partner.records[0].model_id = 20;
+
+        const def = makeDeferred();
+        makeView({
+            type: "form",
+            resModel: "partner",
+            resId: 1,
+            serverData,
+            arch: `
+                <form>
+                    <field name="model_id" invisible="1"/>
+                    <field name="reference" options="{'model_field': 'model_id'}" />
+                </form>`,
+            async mockRPC(route, args) {
+                if (args.method === "read" && args.model === "ir.model") {
+                    await def;
+                }
+            },
+        });
+        await nextTick();
+        await nextTick();
+        assert.containsNone(target, ".o_form_view");
+        def.resolve();
+
+        await nextTick();
+        assert.containsOnce(target, ".o_form_view");
+    });
 });
diff --git a/addons/web/static/tests/views/fields/selection_field_tests.js b/addons/web/static/tests/views/fields/selection_field_tests.js
index fe86f4a7346..8d7b3f70d65 100644
--- a/addons/web/static/tests/views/fields/selection_field_tests.js
+++ b/addons/web/static/tests/views/fields/selection_field_tests.js
@@ -1,6 +1,6 @@
 /** @odoo-module **/
 
-import { click, editSelect, editInput, getFixture, clickSave } from "@web/../tests/helpers/utils";
+import { click, clickSave, editSelect, getFixture } from "@web/../tests/helpers/utils";
 import { makeView, setupViewRegistries } from "@web/../tests/views/helpers";
 
 let serverData;
@@ -147,7 +147,7 @@ QUnit.module("Fields", (hooks) => {
             "should have correct value in color field"
         );
 
-        assert.verifySteps(["get_views", "read", "name_search", "name_search", "onchange"]);
+        assert.verifySteps(["get_views", "web_read", "name_search", "name_search", "onchange2"]);
     });
 
     QUnit.test("unset selection field with 0 as key", async function (assert) {
@@ -257,59 +257,6 @@ QUnit.module("Fields", (hooks) => {
         );
     });
 
-    QUnit.test(
-        "SelectionField on a many2one: domain updated by an onchange",
-        async function (assert) {
-            assert.expect(4);
-
-            serverData.models.partner.onchanges = {
-                int_field() {},
-            };
-
-            let domain = [];
-            await makeView({
-                type: "form",
-                resModel: "partner",
-                resId: 1,
-                serverData,
-                arch: `
-                    <form>
-                        <field name="int_field" />
-                        <field name="trululu" widget="selection" />
-                    </form>`,
-                mockRPC(route, { args, method }) {
-                    if (method === "onchange") {
-                        domain = [["id", "in", [10]]];
-                        return Promise.resolve({
-                            domain: {
-                                trululu: domain,
-                            },
-                        });
-                    }
-                    if (method === "name_search") {
-                        assert.deepEqual(args[1], domain, "sent domain should be correct");
-                    }
-                },
-            });
-
-            assert.containsN(
-                target,
-                ".o_field_widget[name='trululu'] option",
-                4,
-                "should be 4 options in the selection"
-            );
-
-            // trigger an onchange that will update the domain
-            await editInput(target, ".o_field_widget[name='int_field'] input", 2);
-
-            assert.containsOnce(
-                target,
-                ".o_field_widget[name='trululu'] option",
-                "should be 1 option in the selection"
-            );
-        }
-    );
-
     QUnit.test("required selection widget should not have blank option", async function (assert) {
         serverData.models.partner.fields.feedback_value = {
             type: "selection",
diff --git a/addons/web/static/tests/views/fields/statusbar_field_tests.js b/addons/web/static/tests/views/fields/statusbar_field_tests.js
index bb836f0e79e..6c0562217a5 100644
--- a/addons/web/static/tests/views/fields/statusbar_field_tests.js
+++ b/addons/web/static/tests/views/fields/statusbar_field_tests.js
@@ -1,8 +1,5 @@
 /** @odoo-module **/
 
-import { browser } from "@web/core/browser/browser";
-import { registry } from "@web/core/registry";
-import { session } from "@web/session";
 import { makeFakeNotificationService } from "@web/../tests/helpers/mock_services";
 import {
     click,
@@ -13,6 +10,10 @@ import {
     triggerHotkey,
 } from "@web/../tests/helpers/utils";
 import { makeView, setupViewRegistries } from "@web/../tests/views/helpers";
+import { createWebClient, doAction } from "@web/../tests/webclient/helpers";
+import { browser } from "@web/core/browser/browser";
+import { registry } from "@web/core/registry";
+import { session } from "@web/session";
 
 import { EventBus } from "@odoo/owl";
 
@@ -308,9 +309,8 @@ QUnit.module("Fields", (hooks) => {
         });
 
         assert.doesNotHaveClass(target.querySelector(".o_statusbar_status"), "o_field_empty");
-        const tooltipInfo = target.querySelector(".o_field_statusbar").attributes[
-            "data-tooltip-info"
-        ];
+        const tooltipInfo =
+            target.querySelector(".o_field_statusbar").attributes["data-tooltip-info"];
         assert.strictEqual(
             JSON.parse(tooltipInfo.value).field.help,
             "some info about the field",
@@ -622,4 +622,94 @@ QUnit.module("Fields", (hooks) => {
         await click(clickableButtons[clickableButtons.length - 1]);
         assert.verifySteps(["write"]);
     });
+
+    QUnit.test(
+        "For the same record, a single rpc is done to recover the specialData",
+        async function (assert) {
+            serverData.views = {
+                "partner,3,list": '<tree><field name="display_name"/></tree>',
+                "partner,9,search": `<search></search>`,
+                "partner,false,form": `<form>
+                <header>
+                    <field name="trululu" widget="statusbar" readonly="1"/>
+                </header>
+            </form>`,
+            };
+
+            serverData.actions = {
+                1: {
+                    id: 1,
+                    name: "Partners",
+                    res_model: "partner",
+                    type: "ir.actions.act_window",
+                    views: [
+                        [false, "list"],
+                        [false, "form"],
+                    ],
+                },
+            };
+
+            const mockRPC = (route, args) => {
+                if (args.method === "search_read") {
+                    assert.step("search_read");
+                }
+            };
+
+            const webClient = await createWebClient({ serverData, mockRPC });
+            await doAction(webClient, 1);
+
+            await click(target.querySelector(".o_data_row .o_data_cell"));
+            assert.verifySteps(["search_read"]);
+
+            await click(target, ".o_back_button");
+            await click(target.querySelector(".o_data_row .o_data_cell"));
+            assert.verifySteps([]);
+        }
+    );
+
+    QUnit.test(
+        "open form with statusbar, leave and come back to another one with other domain",
+        async function (assert) {
+            serverData.views = {
+                "partner,3,list": '<tree><field name="display_name"/></tree>',
+                "partner,9,search": `<search></search>`,
+                "partner,false,form": `<form>
+                <header>
+                    <field name="trululu" widget="statusbar" domain="[['id', '>', id]]" readonly="1"/>
+                </header>
+            </form>`,
+            };
+
+            serverData.actions = {
+                1: {
+                    id: 1,
+                    name: "Partners",
+                    res_model: "partner",
+                    type: "ir.actions.act_window",
+                    views: [
+                        [false, "list"],
+                        [false, "form"],
+                    ],
+                },
+            };
+
+            const mockRPC = (route, args) => {
+                if (args.method === "search_read") {
+                    assert.step("search_read");
+                }
+            };
+
+            const webClient = await createWebClient({ serverData, mockRPC });
+            await doAction(webClient, 1);
+
+            // open first record
+            await click(target.querySelector(".o_data_row .o_data_cell"));
+            assert.verifySteps(["search_read"]);
+
+            // go back and open second record
+            await click(target, ".o_back_button");
+            await click(target.querySelectorAll(".o_data_row")[1].querySelector(".o_data_cell"));
+            assert.verifySteps(["search_read"]);
+        }
+    );
 });
diff --git a/addons/web/static/tests/views/form/form_compiler_tests.js b/addons/web/static/tests/views/form/form_compiler_tests.js
index 987f5962641..58812e05843 100644
--- a/addons/web/static/tests/views/form/form_compiler_tests.js
+++ b/addons/web/static/tests/views/form/form_compiler_tests.js
@@ -38,7 +38,7 @@ QUnit.module("Form Compiler", (hooks) => {
         const arch = /*xml*/ `<form><div>lol</div></form>`;
         const expected = /*xml*/ `
             <t>
-                <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.isDirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
+                <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.dirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
                     <div>lol</div>
                 </div>
             </t>`;
@@ -52,7 +52,7 @@ QUnit.module("Form Compiler", (hooks) => {
             const arch = /*xml*/ `<form><field field_id="test" name="test"/><label for="test" string=""/></form>`;
             const expected = /*xml*/ `
             <t>
-                <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.isDirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
+                <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.dirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
                     <Field id="'test'" name="'test'" record="__comp__.props.record" fieldInfo="__comp__.props.archInfo.fieldNodes['test']" readonly="__comp__.props.archInfo.activeActions?.edit === false and !__comp__.props.record.isNew"/>
                     <FormLabel id="'test'" fieldName="'test'" record="__comp__.props.record" fieldInfo="__comp__.props.archInfo.fieldNodes['test']" className="&quot;&quot;" string="\`\`" />
                 </div>
@@ -65,7 +65,7 @@ QUnit.module("Form Compiler", (hooks) => {
         const arch = /*xml*/ `<form><div class="someClass">lol<field field_id="display_name" name="display_name"/></div></form>`;
         const expected = /*xml*/ `
             <t>
-                <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.isDirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
+                <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.dirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
                     <div class="someClass">
                         lol
                         <Field id="'display_name'" name="'display_name'" record="__comp__.props.record" fieldInfo="__comp__.props.archInfo.fieldNodes['display_name']" readonly="__comp__.props.archInfo.activeActions?.edit === false and !__comp__.props.record.isNew"/>
@@ -120,12 +120,12 @@ QUnit.module("Form Compiler", (hooks) => {
             </form>`;
         const expected = /*xml*/ `
             <t>
-                <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.isDirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
+                <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.dirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
                     <OuterGroup>
                         <t t-set-slot="item_0" type="'item'" sequence="0" t-slot-scope="scope" isVisible="true" itemSpan="1">
                             <InnerGroup class="scope &amp;&amp; scope.className">
                                 <t t-set-slot="item_0" type="'item'" sequence="0" t-slot-scope="scope" isVisible="true" itemSpan="1">
-                                    <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.isDirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }} {{scope &amp;&amp; scope.className || &quot;&quot; }}">
+                                    <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.dirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }} {{scope &amp;&amp; scope.className || &quot;&quot; }}">
                                         <div><Field id="'test'" name="'test'" record="__comp__.props.record" fieldInfo="__comp__.props.archInfo.fieldNodes['test']" readonly="__comp__.props.archInfo.activeActions?.edit === false and !__comp__.props.record.isNew"/></div>
                                     </div>
                                 </t>
@@ -183,7 +183,7 @@ QUnit.module("Form Compiler", (hooks) => {
 
         const expected = /*xml*/ `
             <t>
-            <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.isDirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
+            <div class="o_form_renderer o_form_nosheet" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-block {{ __comp__.props.record.dirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
                 <div class="o_form_statusbar position-relative d-flex justify-content-between mb-md-2 pb-2 pb-md-0"><StatusBarButtons/></div>
                 <div>someDiv</div>
             </div>
@@ -205,7 +205,7 @@ QUnit.module("Form Compiler", (hooks) => {
 
         const expected = /*xml*/ `
             <t>
-            <div class="o_form_renderer" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-flex {{ __comp__.uiService.size &lt; 6 ? &quot;flex-column&quot; : &quot;flex-nowrap h-100&quot; }} {{ __comp__.props.record.isDirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
+            <div class="o_form_renderer" t-att-class="__comp__.props.class" t-attf-class="{{__comp__.props.record.isInEdition ? 'o_form_editable' : 'o_form_readonly'}} d-flex {{ __comp__.uiService.size &lt; 6 ? &quot;flex-column&quot; : &quot;flex-nowrap h-100&quot; }} {{ __comp__.props.record.dirty ? 'o_form_dirty' : !__comp__.props.record.isNew ? 'o_form_saved' : '' }}" t-ref="compiled_view_root">
                 <div class="o_form_sheet_bg">
                     <div class="o_form_statusbar position-relative d-flex justify-content-between mb-md-2 pb-2 pb-md-0"><StatusBarButtons/></div>
                     <div>someDiv</div>
diff --git a/addons/web/static/tests/views/form/form_view_tests.js b/addons/web/static/tests/views/form/form_view_tests.js
index c7a7c17e15c..00afa023f68 100644
--- a/addons/web/static/tests/views/form/form_view_tests.js
+++ b/addons/web/static/tests/views/form/form_view_tests.js
@@ -39,7 +39,10 @@ import { tooltipService } from "@web/core/tooltip/tooltip_service";
 import { SIZES } from "@web/core/ui/ui_service";
 import { useService } from "@web/core/utils/hooks";
 import { session } from "@web/session";
+import { Field } from "@web/views/fields/field";
 import { CharField } from "@web/views/fields/char/char_field";
+import { DateTimeField } from "@web/views/fields/datetime/datetime_field";
+import { IntegerField } from "@web/views/fields/integer/integer_field";
 import { FormController } from "@web/views/form/form_controller";
 import { companyService } from "@web/webclient/company_service";
 
@@ -582,7 +585,7 @@ QUnit.module("Views", (hooks) => {
         assert.strictEqual(
             target
                 .querySelectorAll(".o_field_one2many")[1]
-                .querySelector(".o_data_row .o_field_widget[name=foo] input").value, // FIXME: ideally, this row should not be in edition
+                .querySelector(".o_data_row .o_data_cell[name=foo]").innerText,
             "yop"
         );
         await editInput(
@@ -593,7 +596,7 @@ QUnit.module("Views", (hooks) => {
         assert.strictEqual(
             target
                 .querySelectorAll(".o_field_one2many")[1]
-                .querySelector(".o_data_row .o_field_widget[name=foo] input").value, // FIXME: ideally, this row should not be in edition
+                .querySelector(".o_data_row .o_data_cell[name=foo]").innerText,
             "hello"
         );
         await click(target.querySelector(".o_field_one2many .o_field_x2many_list_row_add a"));
@@ -606,7 +609,7 @@ QUnit.module("Views", (hooks) => {
         assert.strictEqual(
             target
                 .querySelectorAll(".o_field_one2many")[1]
-                .querySelector(".o_data_row .o_field_widget[name=foo] input").value, // FIXME: ideally, this row should not be in edition
+                .querySelectorAll(".o_data_row .o_data_cell[name=foo]")[1].innerText,
             "My little Foo Value"
         );
     });
@@ -837,15 +840,15 @@ QUnit.module("Views", (hooks) => {
             serverData,
             arch: '<form><field name="foo"/></form>',
             resId: 1,
-            mockRPC(route, args) {
-                if (args.method === "read") {
+            mockRPC(route, { method, kwargs }) {
+                if (method === "web_read") {
                     assert.deepEqual(
-                        args.args[1],
-                        ["foo", "display_name"],
+                        kwargs.specification,
+                        { foo: {}, display_name: {} },
                         "should only fetch requested fields"
                     );
                     assert.strictEqual(
-                        args.kwargs.context.bin_size,
+                        kwargs.context.bin_size,
                         true,
                         "bin_size should always be in the context"
                     );
@@ -1063,7 +1066,7 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             resId: 2,
             mockRPC: (route, { method, model, kwargs }) => {
-                if (["get_views", "onchange"].includes(method)) {
+                if (["get_views", "onchange2"].includes(method)) {
                     const { context } = kwargs;
                     assert.step(`${method} (${model})`);
                     assert.deepEqual(context, expectedContexts.get(model));
@@ -1084,7 +1087,7 @@ QUnit.module("Views", (hooks) => {
 
         // Create a new timmy
         await click(target, ".modal .o_create_button");
-        assert.verifySteps(["get_views (partner_type)", "onchange (partner_type)"]);
+        assert.verifySteps(["get_views (partner_type)", "onchange2 (partner_type)"]);
 
         // Create a new company
         expectedContexts.clear();
@@ -1094,7 +1097,7 @@ QUnit.module("Views", (hooks) => {
             form_view_ref: "bar_rescompany_form_view",
         });
         await click(target, ".modal [name=company_ids] .o_field_x2many_list_row_add a");
-        assert.verifySteps(["get_views (res.company)", "onchange (res.company)"]);
+        assert.verifySteps(["get_views (res.company)", "onchange2 (res.company)"]);
     });
 
     QUnit.test("invisible fields are properly hidden", async function (assert) {
@@ -1233,6 +1236,34 @@ QUnit.module("Views", (hooks) => {
         }
     );
 
+    QUnit.test("invisible attrs char fields", async function (assert) {
+        // For a char/text field, the server can return false or "" (empty string),
+        // depending if the field isn't set in db (NULL) or set to the empty string.
+        // This makes no difference in the UI, but it matters when evaluating modifiers.
+        serverData.models.partner.records[0].display_name = false;
+        serverData.models.partner.records[0].foo = "";
+
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <form>
+                    <div class="a" attrs='{"invisible": [("foo", "=", False)]}'>a</div>
+                    <div class="b" attrs='{"invisible": [("foo", "=", "")]}'>b</div>
+                    <div class="c" attrs='{"invisible": [("display_name", "=", False)]}'>c</div>
+                    <div class="d" attrs='{"invisible": [("display_name", "=", "")]}'>d</div>
+                    <field name="foo" invisible="1"/>
+                </form>`,
+            resId: 1,
+        });
+
+        assert.containsOnce(target, "div.a");
+        assert.containsNone(target, "div.b");
+        assert.containsNone(target, "div.c");
+        assert.containsOnce(target, "div.d");
+    });
+
     QUnit.test(
         "properly handle modifiers and attributes on notebook tags",
         async function (assert) {
@@ -2287,6 +2318,33 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_field_many2one.o_field_invalid", 2);
     });
 
+    QUnit.test("two occurrences of invalid integer fields in form view", async function (assert) {
+        serverData.models.partner.fields.trululu.required = true;
+
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <form>
+                    <group>
+                        <field name="int_field" class="a"/>
+                        <field name="int_field" class="b"/>
+                    </group>
+                </form>`,
+        });
+
+        await editInput(target, ".a input", "abc");
+
+        assert.containsN(target, ".o_form_label.o_field_invalid", 2);
+        assert.containsN(target, ".o_field_integer.o_field_invalid", 2);
+
+        await editInput(target, ".b input", "10");
+
+        assert.containsNone(target, ".o_form_label.o_field_invalid");
+        assert.containsNone(target, ".o_field_integer.o_field_invalid");
+    });
+
     QUnit.test("required field computed by another field in a form view", async function (assert) {
         serverData.models.partner.fields.foo.default = false;
         serverData.models.partner.onchanges = {
@@ -2498,18 +2556,15 @@ QUnit.module("Views", (hooks) => {
         async function (assert) {
             serverData.models.partner.records[0].product_ids = [37];
             serverData.models.partner.records[0].trululu = false;
+            let onchangeApplied = false;
             serverData.models.partner.onchanges = {
                 trululu(record) {
                     // when trululu changes, push another record in product_ids.
                     // only push a second record once.
-
-                    if (record.product_ids.map((command) => command[1]).includes(41)) {
-                        return;
+                    if (!onchangeApplied) {
+                        record.product_ids = [[4, 41]];
+                        onchangeApplied = true;
                     }
-                    // copy the list to force it as different from the original
-                    record.product_ids = record.product_ids.slice();
-                    record.product_ids.unshift([5]);
-                    record.product_ids.push([4, 41, false]);
                 },
             };
 
@@ -2833,7 +2888,7 @@ QUnit.module("Views", (hooks) => {
             "qux input is properly formatted"
         );
 
-        assert.verifySteps(["get_views", "onchange", "create", "read", "write", "read"]);
+        assert.verifySteps(["get_views", "onchange2", "create", "web_read", "write", "web_read"]);
     });
 
     QUnit.test("separators", async function (assert) {
@@ -2896,6 +2951,33 @@ QUnit.module("Views", (hooks) => {
         assert.containsNone(target, ".o_dialog .o_form_view .o_control_panel");
     });
 
+    QUnit.test("form views in dialogs do not add display_name field", async function (assert) {
+        assert.expect(3);
+
+        serverData.views = {
+            "partner,false,form": `<form><field name="foo"/></form>`,
+        };
+        serverData.actions = {
+            1: {
+                id: 1,
+                name: "Partner",
+                res_model: "partner",
+                type: "ir.actions.act_window",
+                views: [[false, "form"]],
+                target: "new",
+            },
+        };
+        const mockRPC = function (route, args) {
+            if (args.method === "onchange2") {
+                assert.deepEqual(args.args[3], { foo: {} });
+            }
+        };
+        const webClient = await createWebClient({ serverData, mockRPC });
+        await doAction(webClient, 1);
+        assert.containsOnce(target, ".o_dialog .o_form_view");
+        assert.containsNone(target, ".o_dialog .o_form_view .o_control_panel");
+    });
+
     QUnit.test("form views in dialogs closes on save", async function (assert) {
         serverData.models.partner.records[0].foo = undefined;
         delete serverData.models.partner.fields.foo.default;
@@ -3047,14 +3129,14 @@ QUnit.module("Views", (hooks) => {
         // click on p (will succeed and reload)
         await click(target.querySelector(".o_form_statusbar button.p"));
 
-        // click on s (will fail and reload)
+        // click on s (will fail)
         await click(target.querySelector(".o_form_statusbar button.s"));
 
         assert.verifySteps([
             "get_views",
-            "read", // initial read
+            "web_read", // initial read
             "post",
-            "read", // reload (successfully clicked on p)
+            "web_read", // reload (successfully clicked on p)
             "some_method",
         ]);
     });
@@ -3163,7 +3245,7 @@ QUnit.module("Views", (hooks) => {
                 });
                 owl.onWillUpdateProps(async () => {
                     assert.step("willUpdateProps");
-                    if (rpcCount === 2) {
+                    if (rpcCount === 1) {
                         return new Promise(() => {});
                     }
                 });
@@ -3195,13 +3277,13 @@ QUnit.module("Views", (hooks) => {
                 }
             },
         });
-        assert.verifySteps(["read1", "willStart"]);
+        assert.verifySteps(["web_read1", "willStart"]);
 
         await click(target.querySelector(".o_form_statusbar button.p"));
-        assert.verifySteps(["willUpdateProps", "read2", "willUpdateProps"]);
+        assert.verifySteps(["web_read2", "willUpdateProps"]);
 
         await click(target.querySelector(".o_form_statusbar button.p"));
-        assert.verifySteps(["willUpdateProps", "read3", "willUpdateProps"]);
+        assert.verifySteps(["web_read3", "willUpdateProps"]);
     });
 
     QUnit.test("buttons in form view, new record", async function (assert) {
@@ -3247,11 +3329,11 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
 
         await click(target.querySelector(".o_form_statusbar button.p"));
 
-        assert.verifySteps(["create", "read", "execute_action", "read"]);
+        assert.verifySteps(["create", "web_read", "execute_action", "web_read"]);
     });
 
     QUnit.test("buttons in form view, new record, with field id in view", async function (assert) {
@@ -3302,7 +3384,14 @@ QUnit.module("Views", (hooks) => {
 
         await click(target.querySelector(".o_form_statusbar button.p"));
 
-        assert.verifySteps(["get_views", "onchange", "create", "read", "execute_action", "read"]);
+        assert.verifySteps([
+            "get_views",
+            "onchange2",
+            "create",
+            "web_read",
+            "execute_action",
+            "web_read",
+        ]);
     });
 
     QUnit.test("buttons with data-hotkey attribute", async function (assert) {
@@ -3385,7 +3474,7 @@ QUnit.module("Views", (hooks) => {
             async mockRPC(route, args) {
                 if (args.method === "write") {
                     args.args[1].foo = "apple";
-                } else if (args.method === "read") {
+                } else if (args.method === "web_read") {
                     // Block the 'read' call
                     await Promise.resolve(def);
                 }
@@ -3505,16 +3594,31 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             resId: 1,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.deepEqual(
                         args.args[3],
                         {
-                            foo: "1",
-                            p: "",
-                            "p.bar": "",
-                            "p.product_id": "",
-                            timmy: "",
-                            "timmy.name": "",
+                            display_name: {},
+                            foo: {},
+                            p: {
+                                fields: {
+                                    bar: {},
+                                    product_id: {
+                                        fields: {
+                                            display_name: {},
+                                        },
+                                    },
+                                },
+                                limit: 40,
+                                order: "",
+                            },
+                            timmy: {
+                                fields: {
+                                    name: {},
+                                },
+                                limit: 40,
+                                order: "",
+                            },
                         },
                         "should send only the fields used in the views"
                     );
@@ -3548,13 +3652,11 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             resId: 1,
             mockRPC(route, args) {
-                if (args.method === "onchange" && checkOnchange) {
+                if (args.method === "onchange2" && checkOnchange) {
                     assert.deepEqual(
                         args.args[1],
                         {
-                            display_name: "first record",
                             foo: "tralala",
-                            id: 1,
                             p: [
                                 [
                                     0,
@@ -3656,8 +3758,6 @@ QUnit.module("Views", (hooks) => {
     QUnit.test(
         "default record with a one2many and an onchange on sub field",
         async function (assert) {
-            assert.expect(4);
-
             serverData.models.partner.onchanges.foo = function () {};
 
             await makeView({
@@ -3672,19 +3772,25 @@ QUnit.module("Views", (hooks) => {
                     </form>`,
                 mockRPC(route, args) {
                     assert.step(args.method);
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         assert.deepEqual(
                             args.args[3],
                             {
-                                p: "",
-                                "p.foo": "1",
+                                display_name: {},
+                                p: {
+                                    fields: {
+                                        foo: {},
+                                    },
+                                    limit: 40,
+                                    order: "",
+                                },
                             },
                             "onchangeSpec should be correct (with sub fields)"
                         );
                     }
                 },
             });
-            assert.verifySteps(["get_views", "onchange"]);
+            assert.verifySteps(["get_views", "onchange2"]);
         }
     );
 
@@ -3707,14 +3813,14 @@ QUnit.module("Views", (hooks) => {
                     </field>
                 </form>`,
             mockRPC: function (route, args) {
-                if (route === "/web/dataset/call_kw/partner/onchange") {
+                if (route === "/web/dataset/call_kw/partner/onchange2") {
                     assert.deepEqual(args.kwargs.context, {
                         default_state: "ab",
                         lang: "en",
                         tz: "taht",
                         uid: 7,
                     });
-                } else if (route === "/web/dataset/call_kw/product/onchange") {
+                } else if (route === "/web/dataset/call_kw/product/onchange2") {
                     assert.deepEqual(args.kwargs.context, {
                         default_product_uom_qty: 68,
                         lang: "en",
@@ -3812,7 +3918,7 @@ QUnit.module("Views", (hooks) => {
         });
 
         assert.strictEqual(target.querySelector("input").value, "default foo value");
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
     });
 
     QUnit.test("make default record with non empty one2many", async function (assert) {
@@ -3837,7 +3943,11 @@ QUnit.module("Views", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === 'read' && args.args[1].length === 1 && args.args[1][0] === 'display_name') {
+                if (
+                    args.method === "read" &&
+                    args.args[1].length === 1 &&
+                    args.args[1][0] === "display_name"
+                ) {
                     nameGetCount++;
                 }
             },
@@ -3868,7 +3978,11 @@ QUnit.module("Views", (hooks) => {
             serverData,
             arch: '<form><field name="trululu"/></form>',
             mockRPC(route, args) {
-                if (args.method === 'read' && args.args[1].length === 1 && args.args[1][0] === 'display_name') {
+                if (
+                    args.method === "read" &&
+                    args.args[1].length === 1 &&
+                    args.args[1][0] === "display_name"
+                ) {
                     throw new Error("Should not call display_name read");
                 }
             },
@@ -3879,6 +3993,7 @@ QUnit.module("Views", (hooks) => {
             "aaa",
             "default value should be correctly displayed"
         );
+        assert.verifySteps([]);
     });
 
     QUnit.test("form view properly change its title", async function (assert) {
@@ -3950,11 +4065,11 @@ QUnit.module("Views", (hooks) => {
 
         assert.verifySteps([
             "get_views",
-            "read",
+            "web_read",
             "action_archive",
-            "read",
+            "web_read",
             "action_unarchive",
-            "read",
+            "web_read",
         ]);
     });
 
@@ -4094,14 +4209,9 @@ QUnit.module("Views", (hooks) => {
                 if (args.method === "do_archive") {
                     return false;
                 }
-                if (args.method === "read" && args.model === "partner") {
+                if (args.method === "web_read" && args.model === "partner") {
                     if (readPartner === 1) {
-                        return [
-                            {
-                                id: 1,
-                                active: "archived",
-                            },
-                        ];
+                        return [{ id: 1, active: "archived" }];
                     }
                     readPartner++;
                 }
@@ -4116,7 +4226,11 @@ QUnit.module("Views", (hooks) => {
         });
 
         assert.strictEqual(target.querySelector("[name='active'] input").value, "true");
-        assert.verifySteps(["/web/webclient/load_menus", "get_views: partner", "read: partner"]);
+        assert.verifySteps([
+            "/web/webclient/load_menus",
+            "get_views: partner",
+            "web_read: partner",
+        ]);
         await toggleActionMenu(target);
         assert.containsOnce(target, ".o_cp_action_menus span:contains(Archive)");
 
@@ -4124,13 +4238,13 @@ QUnit.module("Views", (hooks) => {
         assert.containsOnce(document.body, ".modal");
         assert.verifySteps([]);
         await click(document.body.querySelector(".modal-footer .btn-primary"));
-        assert.verifySteps(["action_archive: partner", "get_views: product", "onchange: product"]);
+        assert.verifySteps(["action_archive: partner", "get_views: product", "onchange2: product"]);
         await click(target, ".modal footer .myButton");
         assert.verifySteps([
             "create: product",
-            "read: product",
+            "web_read: product",
             "do_archive: product",
-            "read: partner",
+            "web_read: partner",
         ]);
         assert.containsNone(target, ".modal");
         assert.strictEqual(target.querySelector("[name='active'] input").value, "archived");
@@ -4217,7 +4331,7 @@ QUnit.module("Views", (hooks) => {
             actionMenus: {},
             context: { hey: "hoy" },
             mockRPC(route, args) {
-                if (args.method === "read") {
+                if (args.method === "web_read") {
                     assert.step(args.kwargs.context.hey);
                 }
             },
@@ -4306,7 +4420,7 @@ QUnit.module("Views", (hooks) => {
 
         assert.containsOnce(target, ".o_form_editable", "form view should be in edit mode");
         assert.strictEqual(count, 2, "should have triggered a execute action");
-        assert.verifySteps(["get_views", "read", "write", "read"]);
+        assert.verifySteps(["get_views", "web_read", "write", "web_read"]);
     });
 
     QUnit.test("clicking on stat buttons save and reload in edit mode", async function (assert) {
@@ -4434,7 +4548,7 @@ QUnit.module("Views", (hooks) => {
 
         await editInput(target, ".o_field_widget[name=foo] input", "tralala");
         await click(target.querySelector(".o_content button.btn-primary"));
-        assert.verifySteps(["get_views", "read", "write", "read", "execute_action"]);
+        assert.verifySteps(["get_views", "web_read", "write", "web_read", "execute_action"]);
     });
 
     QUnit.test("missing widgets do not crash", async function (assert) {
@@ -4710,11 +4824,7 @@ QUnit.module("Views", (hooks) => {
         // click on discard
         await clickDiscard(target);
         assert.containsNone(target, ".modal", "modal should not be displayed");
-        assert.strictEqual(
-            target.querySelector(".o_field_widget[name=product_id] input").value,
-            "",
-            "the string xphone should not be present after discarding"
-        );
+        assert.containsNone(target, ".o_data_row");
     });
 
     QUnit.test(
@@ -4992,7 +5102,7 @@ QUnit.module("Views", (hooks) => {
         // edit the foo field
         await editInput(target, ".o_field_widget[name=foo] input", "new value");
         assert.strictEqual(
-            target.querySelector("input").value,
+            target.querySelector(".o_field_widget[name=foo] input").value,
             "new value",
             "input should contain new value"
         );
@@ -5027,6 +5137,31 @@ QUnit.module("Views", (hooks) => {
         assert.strictEqual(nbWrite, 1, "one write RPC should have been done");
     });
 
+    QUnit.test("do not reload after save when using pager", async function (assert) {
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: '<form><field name="foo"></field></form>',
+            resIds: [1, 2],
+            resId: 1,
+            mockRPC(route, args) {
+                assert.step(args.method);
+            },
+        });
+
+        assert.strictEqual(target.querySelector(".o_pager_value").textContent, "1");
+        assert.strictEqual(target.querySelector(".o_pager_limit").textContent, "2");
+
+        // edit the foo field
+        await editInput(target, ".o_field_widget[name=foo] input", "new value");
+        // click on the pager to switch to the next record (will save record)
+        await click(target.querySelector(".o_pager_next"));
+
+        assert.strictEqual(target.querySelector(".o_pager_value").textContent, "2");
+        assert.verifySteps(["get_views", "web_read", "write", "web_read"]);
+    });
+
     QUnit.test("switching to another record from an invalid one", async function (assert) {
         await makeView({
             type: "form",
@@ -5040,7 +5175,7 @@ QUnit.module("Views", (hooks) => {
             resId: 1,
             mockRPC(route) {
                 if (route === "/web/dataset/call_kw/partner/write") {
-                    throw new Error("Shouldn't call write as the record is invalid");
+                    assert.step("write");
                 }
             },
         });
@@ -5061,6 +5196,7 @@ QUnit.module("Views", (hooks) => {
         assert.strictEqual(target.querySelector(".o_pager_limit").textContent, "2");
         assert.hasClass(target.querySelector(".o_field_widget[name=foo]"), "o_field_invalid");
         assert.containsOnce(target, ".o_notification_manager .o_notification");
+        assert.verifySteps([]);
     });
 
     QUnit.test("keynav: switching to another record from an invalid one", async function (assert) {
@@ -5073,7 +5209,7 @@ QUnit.module("Views", (hooks) => {
             resId: 1,
             mockRPC(route) {
                 if (route === "/web/dataset/call_kw/partner/write") {
-                    throw new Error("Shouldn't call write as the record is invalid");
+                    assert.step("write");
                 }
             },
         });
@@ -5095,6 +5231,7 @@ QUnit.module("Views", (hooks) => {
         assert.strictEqual(target.querySelector(".o_pager_limit").textContent, "2");
         assert.hasClass(target.querySelector(".o_field_widget[name=foo]"), "o_field_invalid");
         assert.containsOnce(target, ".o_notification_manager .o_notification");
+        assert.verifySteps([]);
     });
 
     QUnit.test("switching to another record from an invalid one (2)", async function (assert) {
@@ -5665,7 +5802,7 @@ QUnit.module("Views", (hooks) => {
         await click(document.body.querySelector(".modal-footer button.btn-primary"));
         assert.containsNone(document.body, ".modal", "no confirm modal should be displayed");
 
-        assert.verifySteps(["get_views", "read", "unlink", "history-back"]);
+        assert.verifySteps(["get_views", "web_read", "unlink", "history-back"]);
     });
 
     QUnit.test("empty required fields cannot be saved", async function (assert) {
@@ -5707,7 +5844,7 @@ QUnit.module("Views", (hooks) => {
             arch: `<form><field name="foo"/><field name="int_field"/></form>`,
             resId: 2,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     return Promise.resolve({
                         value: { int_field: 10 },
                         warning: {
@@ -5751,7 +5888,7 @@ QUnit.module("Views", (hooks) => {
                 arch: `<form><field name="foo"/><field name="int_field"/></form>`,
                 resId: 2,
                 mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         return Promise.resolve({
                             value: { int_field: 10 },
                             warning: {
@@ -5800,7 +5937,7 @@ QUnit.module("Views", (hooks) => {
             serverData,
             arch: `<form><field name="foo"/><field name="int_field"/></form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     return Promise.resolve({
                         value: { int_field: 10 },
                         warning: {
@@ -5819,45 +5956,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsOnce(document.body, ".o_notification");
     });
 
-    QUnit.test(
-        "do nothing if add a line in one2many result in a onchange with a warning",
-        async function (assert) {
-            serverData.models.partner.onchanges = { foo: true };
-
-            await makeView({
-                type: "form",
-                resModel: "partner",
-                serverData,
-                arch: `
-                    <form>
-                        <field name="p">
-                            <tree editable="top">
-                                <field name="foo"/>
-                            </tree>
-                        </field>
-                    </form>`,
-                resId: 2,
-                mockRPC(route, args) {
-                    if (args.method === "onchange") {
-                        return Promise.resolve({
-                            value: {},
-                            warning: {
-                                title: "Warning",
-                                message: "You must first select a partner",
-                            },
-                        });
-                    }
-                },
-            });
-
-            // click to add a record in the o2m
-            await click(target.querySelector(".o_field_x2many_list_row_add a"));
-            assert.containsNone(target, "tr.o_data_row", "should not have added a line");
-            assert.containsOnce(target, ".o_notification .text-warning");
-        }
-    );
-
-    QUnit.skip("button box is rendered in create mode", async function (assert) {
+    QUnit.test("button box is rendered in create mode", async function (assert) {
         await makeView({
             type: "form",
             resModel: "partner",
@@ -5953,7 +6052,6 @@ QUnit.module("Views", (hooks) => {
         serverData.models.partner.onchanges = {
             int_field: function (obj) {
                 obj.p = [
-                    [5],
                     [1, 2, { display_name: "updated record 1", int_field: obj.int_field }],
                     [1, 4, { display_name: "updated record 2", int_field: obj.int_field * 2 }],
                 ];
@@ -5977,7 +6075,7 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             resId: 1,
             async mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     await def;
                 }
             },
@@ -6078,11 +6176,14 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("properly apply onchange on many2many fields", async function (assert) {
-        assert.expect(15);
+        assert.expect(11);
 
         serverData.models.partner.onchanges = {
             foo: function (obj) {
-                obj.timmy = [[5], [4, 12], [4, 14]];
+                obj.timmy = [
+                    [4, 12],
+                    [4, 14],
+                ];
             },
         };
         await makeView({
@@ -6098,13 +6199,13 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "read" && args.model === "partner_type") {
-                    assert.deepEqual(args.args[0], [12, 14], "should read both m2m with one RPC");
-                }
                 if (args.method === "write") {
                     assert.deepEqual(
                         args.args[1].timmy,
-                        [[6, false, [12, 14]]],
+                        [
+                            [4, 12],
+                            [4, 14],
+                        ],
                         "should correctly save the changed m2m values"
                     );
                 }
@@ -6133,7 +6234,7 @@ QUnit.module("Views", (hooks) => {
 
         await clickSave(target);
 
-        assert.verifySteps(["get_views", "read", "onchange", "read", "write", "read", "read"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2", "write", "web_read"]);
     });
 
     QUnit.test(
@@ -6172,7 +6273,7 @@ QUnit.module("Views", (hooks) => {
     );
 
     QUnit.test("display_name not sent for onchanges if not in view", async function (assert) {
-        assert.expect(7);
+        assert.expect(6);
 
         serverData.models.partner.records[0].timmy = [12];
         serverData.models.partner.onchanges = {
@@ -6181,7 +6282,6 @@ QUnit.module("Views", (hooks) => {
         serverData.models.partner_type.onchanges = {
             name: function () {},
         };
-        let readInModal = false;
         await makeView({
             type: "form",
             resModel: "partner",
@@ -6200,64 +6300,68 @@ QUnit.module("Views", (hooks) => {
                     </group>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "read" && args.model === "partner") {
+                if (args.method === "web_read" && args.model === "partner") {
                     assert.deepEqual(
-                        args.args[1],
-                        ["foo", "timmy", "display_name"],
+                        args.kwargs.specification,
+                        {
+                            display_name: {},
+                            foo: {},
+                            timmy: {
+                                fields: {
+                                    name: {},
+                                    color: {},
+                                },
+                                limit: 40,
+                                order: "",
+                            },
+                        },
                         "should read display_name even if not in the view"
                     );
                 }
-                if (args.method === "read" && args.model === "partner_type") {
-                    if (!readInModal) {
-                        assert.deepEqual(
-                            args.args[1],
-                            ["name"],
-                            "should not read display_name for records in the list"
-                        );
-                    } else {
-                        assert.deepEqual(
-                            args.args[1],
-                            ["color", "display_name"],
-                            "should read display_name when opening the subrecord"
-                        );
-                    }
+                if (args.method === "web_read" && args.model === "partner_type") {
+                    assert.deepEqual(
+                        args.kwargs.specification,
+                        {
+                            color: {},
+                            name: {},
+                        },
+                        "should read display_name when opening the subrecord"
+                    );
                 }
-                if (args.method === "onchange" && args.model === "partner") {
+                if (args.method === "onchange2" && args.model === "partner") {
                     assert.deepEqual(
                         args.args[1],
                         {
-                            id: 1,
                             foo: "coucou",
-                            timmy: [[6, false, [12]]],
                         },
-                        "should only send the value of fields in the view (+ id)"
+                        "should only send the changes"
                     );
-                    assert.deepEqual(
-                        args.args[3],
-                        {
-                            foo: "1",
-                            timmy: "",
-                            "timmy.name": "1",
-                            "timmy.color": "",
+                    assert.deepEqual(args.args[3], {
+                        display_name: {},
+                        foo: {},
+                        timmy: {
+                            fields: {
+                                name: {},
+                                color: {},
+                            },
+                            limit: 40,
+                            order: "",
                         },
-                        "only the fields in the view should be in the onchange spec"
-                    );
+                    });
                 }
-                if (args.method === "onchange" && args.model === "partner_type") {
+                if (args.method === "onchange2" && args.model === "partner_type") {
                     assert.deepEqual(
                         args.args[1],
                         {
-                            id: 12,
                             name: "new name",
-                            color: 2,
                         },
-                        "should only send the value of fields in the view (+ id)"
+                        "should only send the changes"
                     );
                     assert.deepEqual(
                         args.args[3],
                         {
-                            name: "1",
-                            color: "",
+                            name: {},
+                            color: {},
                         },
                         "only the fields in the view should be in the onchange spec"
                     );
@@ -6270,7 +6374,6 @@ QUnit.module("Views", (hooks) => {
         await editInput(target, ".o_field_widget[name=foo] input", "coucou");
 
         // open a subrecord and trigger an onchange
-        readInModal = true;
         await click(target.querySelector(".o_data_row .o_data_cell"));
         await editInput(target, ".modal .o_field_widget[name=name] input", "new name");
     });
@@ -6361,7 +6464,7 @@ QUnit.module("Views", (hooks) => {
             "input int_field is marked as invalid"
         );
 
-        assert.verifySteps(["get_views", "read", "onchange"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2"]);
     });
 
     QUnit.test("rpc complete after destroying parent", async function (assert) {
@@ -6431,7 +6534,7 @@ QUnit.module("Views", (hooks) => {
             arch: `<form><field name="foo"/><field name="int_field"/></form>`,
             resId: 2,
             async mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.step("onchange is done");
                     await def;
                 }
@@ -6450,8 +6553,8 @@ QUnit.module("Views", (hooks) => {
         assert.containsNone(target, ".modal");
         assert.strictEqual(
             target.querySelector('.o_field_widget[name="foo"] input').value,
-            "blip",
-            "field foo should still be displayed to initial value"
+            "1234",
+            "field foo should still be displayed to changed value"
         );
 
         // complete the onchange
@@ -6518,7 +6621,7 @@ QUnit.module("Views", (hooks) => {
         );
     });
 
-    QUnit.test("unchanged relational data is sent for onchanges", async function (assert) {
+    QUnit.test("unchanged relational data is not sent for onchanges", async function (assert) {
         assert.expect(1);
 
         serverData.models.partner.records[1].p = [4];
@@ -6544,96 +6647,14 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             resId: 2,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
-                    assert.deepEqual(
-                        args.args[1].p,
-                        [[4, 4, false]],
-                        "should send a command for field p even if it hasn't changed"
-                    );
+                if (args.method === "onchange2") {
+                    assert.deepEqual(args.args[1], { foo: "trigger an onchange" });
                 }
             },
         });
         await editInput(target, ".o_field_widget[name=foo] input", "trigger an onchange");
     });
 
-    QUnit.test("onchanges on unknown fields of o2m are ignored", async function (assert) {
-        // many2one fields need to be postprocessed (the onchange returns [id,
-        // display_name]), but if we don't know the field, we can't know it's a
-        // many2one, so it isn't ignored, its value is an array instead of a
-        // dataPoint id, which may cause errors later (e.g. when saving).
-        assert.expect(2);
-
-        serverData.models.partner.records[1].p = [4];
-        serverData.models.partner.onchanges = {
-            foo: function () {},
-        };
-        await makeView({
-            type: "form",
-            resModel: "partner",
-            serverData,
-            arch: `
-                <form>
-                    <field name="foo"/>
-                    <field name="int_field"/>
-                    <field name="p">
-                        <tree>
-                            <field name="foo"/>
-                            <field name="bar"/>
-                        </tree>
-                        <form>
-                            <field name="foo"/>
-                            <field name="product_id"/>
-                        </form>
-                    </field>
-                </form>`,
-            resId: 2,
-            mockRPC(route, args) {
-                if (args.method === "onchange") {
-                    return Promise.resolve({
-                        value: {
-                            p: [
-                                [5],
-                                [
-                                    1,
-                                    4,
-                                    {
-                                        foo: "foo changed",
-                                        product_id: [37, "xphone"],
-                                    },
-                                ],
-                            ],
-                        },
-                    });
-                }
-                if (args.method === "write") {
-                    assert.deepEqual(
-                        args.args[1].p,
-                        [
-                            [
-                                1,
-                                4,
-                                {
-                                    foo: "foo changed",
-                                },
-                            ],
-                        ],
-                        "should only write value of known fields"
-                    );
-                }
-            },
-        });
-
-        await editInput(target, ".o_field_widget[name=foo] input", "trigger an onchange");
-
-        assert.strictEqual(
-            target.querySelector(".o_data_row td").textContent,
-            "foo changed",
-            "onchange should have been correctly applied on field in o2m list"
-        );
-
-        await clickSave(target);
-    });
-
     QUnit.test("onchange value are not discarded on o2m edition", async function (assert) {
         assert.expect(4);
 
@@ -6662,10 +6683,10 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             resId: 2,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     return Promise.resolve({
                         value: {
-                            p: [[5], [1, 4, { foo: "foo changed" }]],
+                            p: [[1, 4, { foo: "foo changed" }]],
                         },
                     });
                 }
@@ -6718,11 +6739,10 @@ QUnit.module("Views", (hooks) => {
         "args of onchanges in o2m fields are correct (inline edition)",
         async function (assert) {
             serverData.models.partner.records[1].p = [4];
-            serverData.models.partner.fields.p.relation_field = "rel_field";
             serverData.models.partner.fields.int_field.default = 14;
             serverData.models.partner.onchanges = {
                 int_field: function (obj) {
-                    obj.foo = "[" + obj.rel_field.foo + "] " + obj.int_field;
+                    obj.foo = "[blip] " + obj.int_field;
                 },
             };
             await makeView({
@@ -6771,11 +6791,10 @@ QUnit.module("Views", (hooks) => {
         "args of onchanges in o2m fields are correct (dialog edition)",
         async function (assert) {
             serverData.models.partner.records[1].p = [4];
-            serverData.models.partner.fields.p.relation_field = "rel_field";
             serverData.models.partner.fields.int_field.default = 14;
             serverData.models.partner.onchanges = {
                 int_field: function (obj) {
-                    obj.foo = "[" + obj.rel_field.foo + "] " + obj.int_field;
+                    obj.foo = "[blip] " + obj.int_field;
                 },
             };
             await makeView({
@@ -6857,7 +6876,7 @@ QUnit.module("Views", (hooks) => {
                         <field name="int_field" context="{'int_ctx': 1}"/>
                     </form>`,
                 mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         assert.strictEqual(
                             args.kwargs.context.test,
                             1,
@@ -6921,8 +6940,6 @@ QUnit.module("Views", (hooks) => {
             start() {
                 return {
                     doActionButton(args) {
-                        // button context should have been evaluated, the x2many
-                        // should be in the form of x2m commands when serialized
                         assert.equal(JSON.stringify(args.buttonContext), '{"test":[12]}');
                     },
                 };
@@ -7167,40 +7184,6 @@ QUnit.module("Views", (hooks) => {
         assert.containsOnce(target, ".o-form-buttonbox.my_class");
     });
 
-    QUnit.test("one2many default value creation", async function (assert) {
-        assert.expect(1);
-
-        serverData.models.partner.records[0].product_ids = [37];
-        serverData.models.partner.fields.product_ids.default = [
-            [0, 0, { name: "xdroid", partner_type_id: 12 }],
-        ];
-
-        await makeView({
-            type: "form",
-            resModel: "partner",
-            serverData,
-            arch: `
-                <form>
-                    <field name="product_ids" nolabel="1">
-                        <tree editable="top" create="0">
-                            <field name="name" readonly="1"/>
-                        </tree>
-                    </field>
-                </form>`,
-            mockRPC(route, args) {
-                if (args.method === "create") {
-                    const command = args.args[0].product_ids[0];
-                    assert.strictEqual(
-                        command[2].partner_type_id,
-                        12,
-                        "the default partner_type_id should be equal to 12"
-                    );
-                }
-            },
-        });
-        await clickSave(target);
-    });
-
     QUnit.test("many2manys inside one2manys are saved correctly", async function (assert) {
         assert.expect(1);
 
@@ -7218,7 +7201,7 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             mockRPC(route, args) {
                 if (args.method === "create") {
-                    const command = args.args[0].p;
+                    const command = args.args[0][0].p;
                     assert.deepEqual(
                         command,
                         [
@@ -7267,16 +7250,16 @@ QUnit.module("Views", (hooks) => {
                 mockRPC(route, args) {
                     if (args.method === "create") {
                         assert.deepEqual(
-                            args.args[0].p,
+                            args.args[0][0].p,
                             [
                                 [
                                     0,
-                                    args.args[0].p[0][1],
+                                    args.args[0][0].p[0][1],
                                     {
                                         p: [
                                             [
                                                 0,
-                                                args.args[0].p[0][2].p[0][1],
+                                                args.args[0][0].p[0][2].p[0][1],
                                                 { display_name: "xtv" },
                                             ],
                                         ],
@@ -7434,12 +7417,15 @@ QUnit.module("Views", (hooks) => {
                     // foo should be saved because of the "force_save" attribute
                     // qux should be saved because it isn't readonly
                     // int_field should not be saved as it is readonly
-                    assert.deepEqual(args.args[0].p, [[0, 1, { foo: "some value", qux: 6.5 }]]);
+                    const commands = args.args[0][0].p;
+                    assert.deepEqual(commands, [
+                        [0, commands[0][1], { foo: "some value", qux: 6.5 }],
+                    ]);
                 }
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     return {
                         value: {
-                            p: [[5], [0, 1, { foo: "some value", int_field: 44, qux: 6.5 }]],
+                            p: [[0, false, { foo: "some value", int_field: 44, qux: 6.5 }]],
                         },
                     };
                 }
@@ -7452,7 +7438,7 @@ QUnit.module("Views", (hooks) => {
     QUnit.test("readonly set by modifier do not break many2many_tags", async function (assert) {
         serverData.models.partner.onchanges = {
             bar: function (obj) {
-                obj.timmy = [[6, false, [12]]];
+                obj.timmy = [[4, 12]];
             },
         };
         await makeView({
@@ -7488,7 +7474,7 @@ QUnit.module("Views", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (args.method === "onchange" && checkOnchange) {
+                if (args.method === "onchange2" && checkOnchange) {
                     assert.strictEqual(
                         args.kwargs.context.current_id,
                         false,
@@ -7596,12 +7582,13 @@ QUnit.module("Views", (hooks) => {
             arch: `<form><group><field name="foo"/></group></form>`,
             resId: 2,
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     return Promise.resolve({
                         warning: {
                             title: "Warning",
                             message: "Any warning.",
                         },
+                        value: {},
                     });
                 }
             },
@@ -7707,7 +7694,7 @@ QUnit.module("Views", (hooks) => {
             "the value of the fields should be fetched and displayed"
         );
         assert.verifySteps(
-            ["get_views", "read", "read", "get_views", "read", "read"],
+            ["get_views", "web_read", "get_views", "web_read"],
             "there should be 4 read rpcs"
         );
     });
@@ -7957,7 +7944,7 @@ QUnit.module("Views", (hooks) => {
                 bin_size: false,
             },
             mockRPC(route, args) {
-                if (args.method === "read") {
+                if (args.method === "web_read") {
                     assert.strictEqual(
                         args.kwargs.context.bin_size,
                         false,
@@ -7975,9 +7962,9 @@ QUnit.module("Views", (hooks) => {
             resModel: "partner",
             serverData,
             arch: `<form><field name="bar"/></form>`,
-            mockRPC(route, args) {
-                if (args.method === "create") {
-                    assert.strictEqual(args.args[0].bar, false);
+            mockRPC(route, { method, args }) {
+                if (method === "create") {
+                    assert.deepEqual(args[0][0].bar, false);
                 }
             },
         });
@@ -8022,7 +8009,7 @@ QUnit.module("Views", (hooks) => {
         });
 
         await click(target.querySelector(".o_data_cell"));
-        assert.verifySteps(["get_views", "read", "read", "read"]);
+        assert.verifySteps(["get_views", "web_read", "web_read"]);
     });
 
     QUnit.test("onchanges are applied before checking if it can be saved", async function (assert) {
@@ -8043,7 +8030,7 @@ QUnit.module("Views", (hooks) => {
             resId: 2,
             async mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     await def;
                 }
             },
@@ -8055,7 +8042,7 @@ QUnit.module("Views", (hooks) => {
         def.resolve();
         await nextTick();
 
-        assert.verifySteps(["get_views", "read", "onchange", "danger"]);
+        assert.verifySteps(["get_views", "web_read", "onchange2", "danger"]);
     });
 
     QUnit.test("display toolbar", async function (assert) {
@@ -8149,9 +8136,9 @@ QUnit.module("Views", (hooks) => {
 
         assert.verifySteps([
             "get_views",
-            "read",
+            "web_read",
             `{"action_id":29,"context":{"lang":"en","uid":7,"tz":"taht","active_id":1,"active_ids":[1],"active_model":"partner","active_domain":[]}}`,
-            "read",
+            "web_read",
         ]);
     });
 
@@ -8200,11 +8187,11 @@ QUnit.module("Views", (hooks) => {
 
         assert.verifySteps([
             "get_views",
-            "onchange",
+            "onchange2",
             "create",
-            "read",
+            "web_read",
             `{"action_id":29,"context":{"lang":"en","uid":7,"tz":"taht","active_id":6,"active_ids":[6],"active_model":"partner","active_domain":[]}}`,
-            "read",
+            "web_read",
         ]);
 
         assert.strictEqual(target.querySelector(".o_field_widget[name='foo'] input").value, "test");
@@ -8401,9 +8388,9 @@ QUnit.module("Views", (hooks) => {
     QUnit.test(
         "do not perform extra RPC to read invisible many2one fields",
         async function (assert) {
-            // This test isn't really meaningful anymore, since default_get and (first) onchange rpcs
-            // have been merged in a single onchange rpc, returning nameget for many2one fields. But it
-            // isn't really costly, and it still checks rpcs done when creating a new record with a m2o.
+            // WOWL TODO: use this test to check the unity spec:
+            // an invisible manyone should only requests the id, not the display_name
+            // -> invisible: { trululu: 1/{} }, visible: { trululu: { fields: { display_name }}}
             serverData.models.partner.fields.trululu.default = 2;
 
             await makeView({
@@ -8415,7 +8402,7 @@ QUnit.module("Views", (hooks) => {
                     assert.step(args.method);
                 },
             });
-            assert.verifySteps(["get_views", "onchange"]);
+            assert.verifySteps(["get_views", "onchange2"]);
         }
     );
 
@@ -8436,13 +8423,21 @@ QUnit.module("Views", (hooks) => {
                         </field>
                         <field name="timmy" invisible="1" widget="many2many_tags"/>
                     </form>`,
-            mockRPC(route, args) {
-                assert.step(args.method);
+            mockRPC(route, { method, kwargs }) {
+                assert.step(method);
+                if (method === "web_read") {
+                    assert.deepEqual(kwargs.specification, {
+                        p: {},
+                        product_ids: {},
+                        timmy: {},
+                        display_name: {},
+                    });
+                }
             },
             resId: 1,
         });
 
-        assert.verifySteps(["get_views", "read"]);
+        assert.verifySteps(["get_views", "web_read"]);
     });
 
     QUnit.test("default_order on x2many embedded view", async function (assert) {
@@ -8967,7 +8962,7 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "read"]);
+        assert.verifySteps(["get_views", "web_read"]);
         assert.containsOnce(target, ".o_form_editable");
         // o_field_translate is on the input and on the translate button
         assert.containsN(target, "div[name='foo'] > .o_field_translate", 2);
@@ -9066,10 +9061,10 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
         assert.containsOnce(target, ".o_form_editable");
         await click(target, ".o_field_translate.btn-link");
-        assert.verifySteps(["create", "read", "get_installed", "get_field_translations"]);
+        assert.verifySteps(["create", "web_read", "get_installed", "get_field_translations"]);
         assert.containsOnce(target, ".modal");
         assert.strictEqual(target.querySelector(".modal-title").textContent, "Translate: foo");
     });
@@ -9391,13 +9386,13 @@ QUnit.module("Views", (hooks) => {
                 "button should no longer be disabled"
             );
 
-            assert.verifySteps(["get_views", "onchange"]);
+            assert.verifySteps(["get_views", "onchange2"]);
 
             // click on button, and click on ok in confirm dialog
             await click(target.querySelector(".o_statusbar_buttons button"));
             assert.verifySteps([]);
             await click(target.querySelector(".modal-footer button.btn-primary"));
-            assert.verifySteps(["create", "read", "execute_action"]);
+            assert.verifySteps(["create", "web_read", "execute_action"]);
         }
     );
 
@@ -9435,7 +9430,7 @@ QUnit.module("Views", (hooks) => {
                 "confirmation dialog should have correct confirmation label"
             );
 
-            assert.verifySteps(["get_views", "onchange"]);
+            assert.verifySteps(["get_views", "onchange2"]);
         }
     );
 
@@ -9466,7 +9461,7 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
 
         await click(target.querySelector(".o_statusbar_buttons button"));
         assert.verifySteps([]);
@@ -9474,7 +9469,7 @@ QUnit.module("Views", (hooks) => {
         click(target.querySelector(".modal-footer button.btn-primary"));
         await Promise.resolve();
         await click(target.querySelector(".modal-footer button.btn-primary"));
-        assert.verifySteps(["create", "read", "execute_action"]);
+        assert.verifySteps(["create", "web_read", "execute_action"]);
     });
 
     QUnit.test(
@@ -9557,13 +9552,28 @@ QUnit.module("Views", (hooks) => {
         await nextTick();
         assert.verifySteps([
             "get_views",
-            "read", // initial read to render the view
+            "web_read", // initial read to render the view
             "write", // write on save
-            "read", // read on reload
+            "web_read", // read on reload
         ]);
     });
 
     QUnit.test("form view is not broken if save operation fails", async function (assert) {
+        registry.category("services").add("error", errorService);
+        const handler = (ev) => {
+            // need to preventDefault to remove error from console (so python test pass)
+            ev.preventDefault();
+        };
+        window.addEventListener("unhandledrejection", handler);
+        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
+        // remove the override in qunit.js that swallows unhandledrejection errors
+        // s.t. we let the error service handle them
+        const originalOnUnhandledRejection = window.onunhandledrejection;
+        window.onunhandledrejection = () => {};
+        registerCleanup(() => {
+            window.onunhandledrejection = originalOnUnhandledRejection;
+        });
+
         await makeView({
             type: "form",
             resModel: "partner",
@@ -9573,28 +9583,45 @@ QUnit.module("Views", (hooks) => {
             mockRPC(route, args) {
                 assert.step(args.method);
                 if (args.method === "write" && args.args[1].foo === "incorrect value") {
-                    return Promise.reject();
+                    return Promise.reject(new Error("Odoo Server Error"));
                 }
             },
         });
 
         await editInput(target, ".o_field_widget[name=foo] input", "incorrect value");
         await clickSave(target);
+        await nextTick();
+        assert.containsOnce(target, ".o_dialog", "should display an error dialog");
+        await click(target.querySelector(".o_dialog .modal-footer .btn-primary")); // close it
         await editInput(target, ".o_field_widget[name=foo] input", "correct value");
         await clickSave(target);
 
         assert.verifySteps([
             "get_views",
-            "read", // initial read to render the view
+            "web_read", // initial read to render the view
             "write", // write on save (it fails, does not trigger a read)
             "write", // write on save (it works)
-            "read", // read on reload
+            "web_read", // read on reload
         ]);
     });
 
     QUnit.test(
         "form view is not broken if save failed in readonly mode on field changed",
         async function (assert) {
+            registry.category("services").add("error", errorService);
+            const handler = (ev) => {
+                // need to preventDefault to remove error from console (so python test pass)
+                ev.preventDefault();
+            };
+            window.addEventListener("unhandledrejection", handler);
+            registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
+            // remove the override in qunit.js that swallows unhandledrejection errors
+            // s.t. we let the error service handle them
+            const originalOnUnhandledRejection = window.onunhandledrejection;
+            window.onunhandledrejection = () => {};
+            registerCleanup(() => {
+                window.onunhandledrejection = originalOnUnhandledRejection;
+            });
             let failFlag = false;
             await makeView({
                 type: "form",
@@ -9612,10 +9639,10 @@ QUnit.module("Views", (hooks) => {
                     if (args.method === "write") {
                         assert.step("write");
                         if (failFlag) {
-                            return Promise.reject();
+                            return Promise.reject(new Error("Odoo Server Error"));
                         }
-                    } else if (args.method === "read") {
-                        assert.step("read");
+                    } else if (args.method === "web_read") {
+                        assert.step("web_read");
                     }
                 },
             });
@@ -9643,11 +9670,11 @@ QUnit.module("Views", (hooks) => {
             );
 
             assert.verifySteps([
-                "read",
+                "web_read",
                 "write", // fails
-                "read", // must reload when saving fails
+                "web_read", // must reload when saving fails
                 "write", // works
-                "read", // must reload when saving works
+                "web_read", // must reload when saving works
             ]);
         }
     );
@@ -9715,8 +9742,8 @@ QUnit.module("Views", (hooks) => {
                     </field>
                 </form>`,
             mockRPC(route, args) {
-                if (checkOnchange && args.method === "onchange") {
-                    if (args.args[2] === "display_name") {
+                if (checkOnchange && args.method === "onchange2") {
+                    if (args.args[2][0] === "display_name") {
                         // onchange on field display_name
                         assert.strictEqual(
                             args.args[1].foo,
@@ -9740,9 +9767,9 @@ QUnit.module("Views", (hooks) => {
                 }
                 if (args.method === "create") {
                     assert.deepEqual(
-                        args.args[0],
+                        args.args[0][0],
                         {
-                            p: [[0, args.args[0].p[0][1], { display_name: "readonly" }]],
+                            p: [[0, args.args[0][0].p[0][1], { display_name: "readonly" }]],
                         },
                         "should not have sent the value of the readonly field"
                     );
@@ -9985,14 +10012,14 @@ QUnit.module("Views", (hooks) => {
         );
         assert.verifySteps([
             "get_views",
-            "read", // main record
+            "web_read", // main record
             "get_formview_id", // id of first form view opened in a dialog
             "get_views", // arch of first form view opened in a dialog
-            "read", // first dialog
+            "web_read", // first dialog
             "get_formview_id", // id of second form view opened in a dialog
-            "read", // second dialog
+            "web_read", // second dialog
             "write", // save second dialog
-            "read", // reload first dialog
+            "read", // reload the display_name (first dialog)
         ]);
     });
 
@@ -10141,7 +10168,7 @@ QUnit.module("Views", (hooks) => {
 
         assert.strictEqual(
             target.querySelector(".o_widget").textContent,
-            '{"foo":"My little Foo Value","bar":false}'
+            '{"foo":"My little Foo Value","bar":false,"display_name":""}'
         );
     });
 
@@ -10315,7 +10342,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("coming to a form view from a grouped and sorted list", async function (assert) {
-        assert.expect(22);
+        assert.expect(20);
         serverData.actions = {
             1: {
                 id: 1,
@@ -10346,21 +10373,13 @@ QUnit.module("Views", (hooks) => {
 
         const mockRPC = (route, args) => {
             assert.step(args.model ? args.model + ":" + args.method : route);
-            if (args.method === "read") {
-                if (args.model === "partner") {
-                    assert.deepEqual(args.kwargs.context, {
-                        bin_size: true,
-                        lang: "en",
-                        tz: "taht",
-                        uid: 7,
-                    });
-                } else if (args.model === "partner_type") {
-                    assert.deepEqual(args.kwargs.context, {
-                        lang: "en",
-                        tz: "taht",
-                        uid: 7,
-                    });
-                }
+            if (args.method === "web_read" && args.model === "partner") {
+                assert.deepEqual(args.kwargs.context, {
+                    bin_size: true,
+                    lang: "en",
+                    tz: "taht",
+                    uid: 7,
+                });
             }
         };
         const webClient = await createWebClient({ serverData, mockRPC });
@@ -10402,12 +10421,11 @@ QUnit.module("Views", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "partner:get_views",
-            "partner:web_search_read",
-            "partner:web_search_read",
+            "partner:unity_web_search_read",
+            "partner:unity_web_search_read",
             "partner:web_read_group",
-            "partner:web_search_read",
-            "partner:read",
-            "partner_type:read",
+            "partner:unity_web_search_read",
+            "partner:web_read",
         ]);
     });
 
@@ -10512,7 +10530,7 @@ QUnit.module("Views", (hooks) => {
             "some foo value",
             "foo field should have correct value"
         );
-        assert.verifySteps(["get_views", "onchange", "create", "read"]);
+        assert.verifySteps(["get_views", "onchange2", "create", "web_read"]);
     });
 
     QUnit.test("saving with invalid uncommitted changes", async function (assert) {
@@ -10540,7 +10558,7 @@ QUnit.module("Views", (hooks) => {
         assert.hasClass(target.querySelector("[name=qux]"), "o_field_invalid");
         assert.containsOnce(target, ".o_notification .text-danger");
         assert.containsOnce(target, ".o_form_editable .o_field_invalid[name=qux]");
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
     });
 
     QUnit.test(
@@ -10574,13 +10592,13 @@ QUnit.module("Views", (hooks) => {
                         </field>
                     </form>`,
                 async mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         await onchangeDef;
                     }
                     if (args.method === "create") {
                         assert.step("create");
                         assert.strictEqual(
-                            args.args[0].p[0][2].foo,
+                            args.args[0][0].p[0][2].foo,
                             "foo value",
                             "should have wait for the onchange to return before saving"
                         );
@@ -10651,7 +10669,7 @@ QUnit.module("Views", (hooks) => {
         const createDef = makeDeferred();
 
         const mockRPC = async (route, args) => {
-            if (args.method === "onchange") {
+            if (args.method === "onchange2") {
                 await onchangeDef;
             }
             if (args.method === "create") {
@@ -11170,7 +11188,7 @@ QUnit.module("Views", (hooks) => {
             await editInput(target, '.o_field_widget[name="name"] input', "Test Company");
             await clickSave(target);
 
-            assert.verifySteps(["get_views", "onchange", "create", "reload company", "read"]);
+            assert.verifySteps(["get_views", "onchange2", "create", "reload company", "web_read"]);
         }
     );
 
@@ -11216,7 +11234,7 @@ QUnit.module("Views", (hooks) => {
             await editInput(target, '.o_field_widget[name="name"] input', "Test Company2");
             await clickSave(target);
 
-            assert.verifySteps(["get_views", "read", "write", "reload company", "read"]);
+            assert.verifySteps(["get_views", "web_read", "write", "reload company", "web_read"]);
         }
     );
 
@@ -11442,6 +11460,12 @@ QUnit.module("Views", (hooks) => {
 
         registry.category("services").add("error", errorService);
 
+        const handler = (ev) => {
+            // need to preventDefault to remove error from console (so python test pass)
+            ev.preventDefault();
+        };
+        window.addEventListener("unhandledrejection", handler);
+        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
         // remove the override in qunit.js that swallows unhandledrejection errors
         // s.t. we let the error service handle them
         const originalOnUnhandledRejection = window.onunhandledrejection;
@@ -11675,9 +11699,7 @@ QUnit.module("Views", (hooks) => {
                 arch: `<form><field name="foo"/></form>`,
                 resId: 1,
                 mockRPC(route, { args, method, model }) {
-                    if (method === "write" && model === "partner") {
-                        throw new Error("no write should be done");
-                    }
+                    assert.step(method);
                 },
             });
 
@@ -11688,6 +11710,8 @@ QUnit.module("Views", (hooks) => {
 
             window.dispatchEvent(new Event("beforeunload"));
             await nextTick();
+
+            assert.verifySteps(["get_views", "web_read"]);
         }
     );
 
@@ -11810,7 +11834,7 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             resId: 1,
             mockRPC(route, { args, method, model }) {
-                if (method === "onchange" && model === "partner") {
+                if (method === "onchange2" && model === "partner") {
                     return def;
                 }
                 if (method === "write" && model === "partner") {
@@ -11846,7 +11870,7 @@ QUnit.module("Views", (hooks) => {
                 </form>`,
             resId: 1,
             mockRPC(route, { args, method }) {
-                if (method === "onchange") {
+                if (method === "onchange2") {
                     return def;
                 }
                 if (method === "write") {
@@ -11888,7 +11912,7 @@ QUnit.module("Views", (hooks) => {
         window.dispatchEvent(new Event("beforeunload"));
         await nextTick();
 
-        assert.verifySteps(["get_views", "read", "write"]);
+        assert.verifySteps(["get_views", "web_read", "write"]);
     });
 
     QUnit.test(
@@ -11916,7 +11940,7 @@ QUnit.module("Views", (hooks) => {
                 resId: 1,
                 mockRPC(route, { args, method }) {
                     assert.step(method);
-                    if (method === "onchange") {
+                    if (method === "onchange2") {
                         return def;
                     }
                     if (method === "write") {
@@ -11944,7 +11968,7 @@ QUnit.module("Views", (hooks) => {
             window.dispatchEvent(new Event("beforeunload"));
             await nextTick();
 
-            assert.verifySteps(["get_views", "read", "onchange", "write"]);
+            assert.verifySteps(["get_views", "web_read", "onchange2", "write"]);
         }
     );
 
@@ -11976,7 +12000,7 @@ QUnit.module("Views", (hooks) => {
             window.dispatchEvent(new Event("beforeunload"));
             await nextTick();
 
-            assert.verifySteps(["get_views", "read"]);
+            assert.verifySteps(["get_views", "web_read"]);
         }
     );
 
@@ -12004,12 +12028,9 @@ QUnit.module("Views", (hooks) => {
                 resId: 1,
                 mockRPC(route, { method }) {
                     assert.step(method);
-                    if (method === "onchange") {
+                    if (method === "onchange2") {
                         return def;
                     }
-                    if (method === "write") {
-                        throw new Error("Should not save the record");
-                    }
                 },
             });
 
@@ -12019,7 +12040,7 @@ QUnit.module("Views", (hooks) => {
             window.dispatchEvent(new Event("beforeunload"));
             await nextTick();
 
-            assert.verifySteps(["get_views", "read", "onchange"]);
+            assert.verifySteps(["get_views", "web_read", "onchange2"]);
         }
     );
 
@@ -12060,6 +12081,12 @@ QUnit.module("Views", (hooks) => {
 
         registry.category("services").add("error", errorService);
 
+        const handler = (ev) => {
+            // need to preventDefault to remove error from console (so python test pass)
+            ev.preventDefault();
+        };
+        window.addEventListener("unhandledrejection", handler);
+        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
         // remove the override in qunit.js that swallows unhandledrejection errors
         // s.t. we let the error service handle them
         const originalOnUnhandledRejection = window.onunhandledrejection;
@@ -12125,6 +12152,12 @@ QUnit.module("Views", (hooks) => {
 
         registry.category("services").add("error", errorService);
 
+        const handler = (ev) => {
+            // need to preventDefault to remove error from console (so python test pass)
+            ev.preventDefault();
+        };
+        window.addEventListener("unhandledrejection", handler);
+        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
         // remove the override in qunit.js that swallows unhandledrejection errors
         // s.t. we let the error service handle them
         const originalOnUnhandledRejection = window.onunhandledrejection;
@@ -12160,6 +12193,12 @@ QUnit.module("Views", (hooks) => {
 
         registry.category("services").add("error", errorService);
         registry.category("error_dialogs").add("odoo.exceptions.UserError", WarningDialog);
+        const handler = (ev) => {
+            // need to preventDefault to remove error from console (so python test pass)
+            ev.preventDefault();
+        };
+        window.addEventListener("unhandledrejection", handler);
+        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
         // remove the override in qunit.js that swallows unhandledrejection errors
         // s.t. we let the error service handle them
         const originalOnUnhandledRejection = window.onunhandledrejection;
@@ -12259,12 +12298,12 @@ QUnit.module("Views", (hooks) => {
                 mockRPC(route, args) {
                     if (args.method === "create") {
                         assert.deepEqual(
-                            args.args[0],
+                            args.args[0][0],
                             {
                                 p: [
                                     [
                                         0,
-                                        args.args[0].p[0][1],
+                                        args.args[0][0].p[0][1],
                                         { length: 0, display_name: "readonly" },
                                     ],
                                 ],
@@ -12349,7 +12388,7 @@ QUnit.module("Views", (hooks) => {
             });
 
             assert.strictEqual(target.querySelector("[name=foo] span").innerText, "xphone");
-            assert.verifySteps(["get_views", "read"]);
+            assert.verifySteps(["get_views", "web_read"]);
         }
     );
 
@@ -12446,7 +12485,7 @@ QUnit.module("Views", (hooks) => {
             mockRPC(route, args) {
                 assert.step(args.method);
                 if (args.method === "create") {
-                    assert.deepEqual(args.args, [
+                    assert.deepEqual(args.args[0], [
                         {
                             int_field: 0,
                             text: false,
@@ -12457,7 +12496,7 @@ QUnit.module("Views", (hooks) => {
         });
 
         await clickSave(target);
-        assert.verifySteps(["get_views", "onchange", "create", "read"]);
+        assert.verifySteps(["get_views", "onchange2", "create", "web_read"]);
     });
 
     QUnit.test(
@@ -12507,7 +12546,7 @@ QUnit.module("Views", (hooks) => {
                 mockRPC(route, args) {
                     assert.step(args.method);
                     if (args.method === "create") {
-                        assert.deepEqual(args.args[0].p[0][2], { int_field: 1, text: false });
+                        assert.deepEqual(args.args[0][0].p[0][2], { int_field: 1, text: false });
                     }
                 },
             });
@@ -12523,7 +12562,7 @@ QUnit.module("Views", (hooks) => {
                 target.querySelector(".o_list_renderer .o_data_row [name='int_field']").textContent,
                 "1"
             );
-            assert.verifySteps(["get_views", "onchange", "onchange", "create", "read", "read"]);
+            assert.verifySteps(["get_views", "onchange2", "onchange2", "create", "web_read"]);
         }
     );
 
@@ -12834,7 +12873,7 @@ QUnit.module("Views", (hooks) => {
                 arch: `<form js_class="custom_form"><field name="foo" required="1"/></form>`,
                 mockRPC(route, args) {
                     if (args.method === "write") {
-                        throw new Error("should not save the record");
+                        assert.step("write");
                     }
                 },
             });
@@ -13123,7 +13162,10 @@ QUnit.module("Views", (hooks) => {
             };
 
             const mockRPC = async (route, args) => {
-                if ((args.method === "read" || args.method === "write") && args.args[0][0] === 1) {
+                if (
+                    (args.method === "web_read" || args.method === "write") &&
+                    args.args[0][0] === 1
+                ) {
                     assert.step(args.method);
                 }
             };
@@ -13131,7 +13173,7 @@ QUnit.module("Views", (hooks) => {
             await doAction(webClient, 1);
             await addRow(target, "[name='p']");
             await editInput(target, "[name='p'] input", "new");
-            assert.verifySteps(["read"]);
+            assert.verifySteps(["web_read"]);
 
             await click(target, ".test_widget button");
             await nextTick();
@@ -13139,12 +13181,12 @@ QUnit.module("Views", (hooks) => {
             // Close ErrorDialog
             await click(target, ".o_dialog .btn-close");
             assert.deepEqual(target.querySelectorAll("[name='p'] .o_data_row").length, 1);
-            assert.verifySteps(["write", "read"]);
+            assert.verifySteps(["write", "web_read"]);
 
             await editInput(target, "[name=foo] input", "new value");
             await clickSave(target);
             assert.deepEqual(target.querySelectorAll("[name='p'] .o_data_row").length, 1);
-            assert.verifySteps(["write", "read"]);
+            assert.verifySteps(["write", "web_read"]);
         }
     );
 
@@ -13207,12 +13249,12 @@ QUnit.module("Views", (hooks) => {
             };
 
             const mockRPC = async (route, args) => {
-                if (args.method === "read") {
+                if (args.method === "web_read") {
                     assert.step(args.method);
                     assert.deepEqual(args.args[0], [6]);
                 } else if (args.method === "create") {
                     assert.step(args.method);
-                    assert.deepEqual(args.args[0], {
+                    assert.deepEqual(args.args[0][0], {
                         foo: "new value",
                     });
                 }
@@ -13228,7 +13270,134 @@ QUnit.module("Views", (hooks) => {
             // Close ErrorDialog
             await click(target, ".o_dialog .btn-close");
             assert.strictEqual(target.querySelector("[name=foo] input").value, "new value");
-            assert.verifySteps(["create", "read"]);
+            assert.verifySteps(["create", "web_read"]);
+        }
+    );
+
+    QUnit.test("only re-render necessary fields after change", async function (assert) {
+        function logLifeCycle(Component) {
+            patchWithCleanup(Component.prototype, {
+                setup() {
+                    this._super(...arguments);
+                    const prefix = `${this.constructor.name} ${this.props.name}`;
+                    owl.onMounted(() => assert.step(`[${prefix}] onMounted`));
+                    owl.onPatched(() => assert.step(`[${prefix}] onPatched`));
+                    owl.onWillStart(() => assert.step(`[${prefix}] onWillStart`));
+                    owl.onWillUpdateProps(() => assert.step(`[${prefix}] onWillUpdateProps`));
+                },
+            });
+        }
+        logLifeCycle(Field);
+        logLifeCycle(CharField);
+        logLifeCycle(IntegerField);
+        logLifeCycle(DateTimeField);
+
+        await makeView({
+            type: "form",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <form>
+                    <field name="foo"/>
+                    <field name="int_field"/>
+                    <field name="date"/>
+                </form>`,
+            resId: 2,
+        });
+
+        assert.verifySteps([
+            "[Field foo] onWillStart",
+            "[Field int_field] onWillStart",
+            "[Field date] onWillStart",
+            "[CharField foo] onWillStart",
+            "[IntegerField int_field] onWillStart",
+            "[DateTimeField date] onWillStart",
+            "[DateTimeField date] onMounted",
+            "[IntegerField int_field] onMounted",
+            "[CharField foo] onMounted",
+            "[Field date] onMounted",
+            "[Field int_field] onMounted",
+            "[Field foo] onMounted",
+        ]);
+
+        await editInput(target, ".o_field_widget[name=foo] input", "new value");
+
+        assert.verifySteps(["[Field foo] onPatched", "[CharField foo] onPatched"]);
+
+        await editInput(target, ".o_field_widget[name=int_field] input", "5846");
+
+        assert.verifySteps(["[Field int_field] onPatched", "[IntegerField int_field] onPatched"]);
+    });
+
+    QUnit.test(
+        "only re-render necessary fields after change (with onchange)",
+        async function (assert) {
+            function logLifeCycle(Component) {
+                patchWithCleanup(Component.prototype, {
+                    setup() {
+                        this._super(...arguments);
+                        const prefix = `${this.constructor.name} ${this.props.name}`;
+                        owl.onMounted(() => assert.step(`[${prefix}] onMounted`));
+                        owl.onPatched(() => assert.step(`[${prefix}] onPatched`));
+                        owl.onWillStart(() => assert.step(`[${prefix}] onWillStart`));
+                        owl.onWillUpdateProps(() => assert.step(`[${prefix}] onWillUpdateProps`));
+                    },
+                });
+            }
+            logLifeCycle(Field);
+            logLifeCycle(CharField);
+            logLifeCycle(IntegerField);
+            logLifeCycle(DateTimeField);
+
+            serverData.models.partner.onchanges = {
+                foo(obj) {
+                    obj.int_field = 23;
+                },
+            };
+
+            await makeView({
+                type: "form",
+                resModel: "partner",
+                serverData,
+                arch: `
+                <form>
+                    <field name="foo"/>
+                    <field name="int_field"/>
+                    <field name="date"/>
+                </form>`,
+                resId: 2,
+            });
+
+            assert.verifySteps([
+                "[Field foo] onWillStart",
+                "[Field int_field] onWillStart",
+                "[Field date] onWillStart",
+                "[CharField foo] onWillStart",
+                "[IntegerField int_field] onWillStart",
+                "[DateTimeField date] onWillStart",
+                "[DateTimeField date] onMounted",
+                "[IntegerField int_field] onMounted",
+                "[CharField foo] onMounted",
+                "[Field date] onMounted",
+                "[Field int_field] onMounted",
+                "[Field foo] onMounted",
+            ]);
+
+            await editInput(target, ".o_field_widget[name=foo] input", "new value");
+
+            assert.verifySteps([
+                "[Field foo] onPatched",
+                "[CharField foo] onPatched",
+                "[Field int_field] onPatched",
+                "[IntegerField int_field] onPatched",
+            ]);
+
+            await editInput(target, ".o_field_widget[name=int_field] input", "5846");
+
+            assert.verifySteps([
+                "[Field int_field] onPatched",
+                "[IntegerField int_field] onPatched",
+            ]);
         }
     );
 });
diff --git a/addons/web/static/tests/views/graph_view_tests.js b/addons/web/static/tests/views/graph_view_tests.js
index 810761f4be2..cc27d607280 100644
--- a/addons/web/static/tests/views/graph_view_tests.js
+++ b/addons/web/static/tests/views/graph_view_tests.js
@@ -31,7 +31,7 @@ import { onRendered } from "@odoo/owl";
 import { patchWithCleanup } from "../helpers/utils";
 import { fakeCookieService } from "@web/../tests/helpers/mock_services";
 import { Domain } from "@web/core/domain";
-import { SampleServer } from "@web/views/sample_server";
+import { SampleServer } from "@web/model/sample_server";
 
 const serviceRegistry = registry.category("services");
 
diff --git a/addons/web/static/tests/views/kanban/kanban_view_tests.js b/addons/web/static/tests/views/kanban/kanban_view_tests.js
index 58a09a3d760..41c11d094fd 100644
--- a/addons/web/static/tests/views/kanban/kanban_view_tests.js
+++ b/addons/web/static/tests/views/kanban/kanban_view_tests.js
@@ -40,14 +40,12 @@ import { getNextTabableElement } from "@web/core/utils/ui";
 import { session } from "@web/session";
 import { KanbanController } from "@web/views/kanban/kanban_controller";
 import { kanbanView } from "@web/views/kanban/kanban_view";
-import { DynamicRecordList } from "@web/views/relational_model";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 import { ViewButton } from "@web/views/view_button/view_button";
 import { AnimatedNumber } from "@web/views/view_components/animated_number";
 
 import { Component, onWillRender, xml } from "@odoo/owl";
-import { pick } from "@web/core/utils/objects";
-import { KanbanDynamicGroupList } from "@web/views/kanban/kanban_model";
-import { SampleServer } from "@web/views/sample_server";
+import { SampleServer } from "@web/model/sample_server";
 
 const serviceRegistry = registry.category("services");
 const viewWidgetRegistry = registry.category("view_widgets");
@@ -352,7 +350,7 @@ QUnit.module("Views", (hooks) => {
                     </t></templates>
                 </kanban>`,
             mockRPC(route, args) {
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.ok(
                         args.kwargs.context.bin_size,
                         "should not request direct binary payload"
@@ -448,9 +446,11 @@ QUnit.module("Views", (hooks) => {
             serverData,
             arch: `
                 <kanban>
-                    <templates><t t-name="kanban-box">
-                        <Div class="test">Hello</Div>
-                    </t></templates>
+                    <templates>
+                        <t t-name="kanban-box">
+                            <Div class="test">Hello</Div>
+                        </t>
+                    </templates>
                 </kanban>`,
         });
 
@@ -556,13 +556,18 @@ QUnit.module("Views", (hooks) => {
                 type: "kanban",
                 resModel: "partner",
                 serverData,
-                arch:
-                    "<kanban>" +
-                    '<field name="active"/>' +
-                    '<field name="bar"/>' +
-                    '<templates><t t-name="kanban-box">' +
-                    '<div><field name="foo"/></div>' +
-                    "</t></templates></kanban>",
+                arch: `
+                    <kanban>
+                        <field name="active"/>
+                        <field name="bar"/>
+                        <templates>
+                            <t t-name="kanban-box">
+                                <div>
+                                    <field name="foo"/>
+                                </div>
+                            </t>
+                        </templates>
+                    </kanban>`,
                 groupBy: ["bar"],
             });
 
@@ -1147,12 +1152,17 @@ QUnit.module("Views", (hooks) => {
             type: "kanban",
             resModel: "partner",
             serverData,
-            arch:
-                "<kanban>" +
-                '<field name="bar"/>' +
-                '<templates><t t-name="kanban-box">' +
-                '<div><field name="foo"/></div>' +
-                "</t></templates></kanban>",
+            arch: `
+                <kanban>
+                    <field name="bar"/>
+                    <templates>
+                        <t t-name="kanban-box">
+                            <div>
+                                <field name="foo"/>
+                            </div>
+                        </t>
+                    </templates>
+                </kanban>`,
             groupBy: ["bar"],
         });
 
@@ -1160,7 +1170,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("there should be no limit on the number of fetched groups", async (assert) => {
-        patchWithCleanup(KanbanDynamicGroupList, { DEFAULT_LIMIT: 1 });
+        patchWithCleanup(RelationalModel, { DEFAULT_GROUP_LIMIT: 1 });
 
         await makeView({
             type: "kanban",
@@ -1187,13 +1197,18 @@ QUnit.module("Views", (hooks) => {
             type: "kanban",
             resModel: "partner",
             serverData,
-            arch:
-                "<kanban>" +
-                '<templates><t t-name="kanban-box">' +
-                '<div><field name="foo"/></div>' +
-                "</t></templates></kanban>",
+            arch: `
+                <kanban>
+                    <templates>
+                        <t t-name="kanban-box">
+                            <div>
+                                <field name="foo"/>
+                            </div>
+                        </t>
+                    </templates>
+                </kanban>`,
             async mockRPC(route, { method, kwargs }) {
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.strictEqual(kwargs.limit, 40, "default limit should be 40 in Kanban");
                 }
             },
@@ -1216,7 +1231,7 @@ QUnit.module("Views", (hooks) => {
                 '<div><field name="foo"/></div>' +
                 "</t></templates></kanban>",
             async mockRPC(route, { method, kwargs }) {
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.strictEqual(kwargs.limit, 2);
                 }
             },
@@ -1241,7 +1256,7 @@ QUnit.module("Views", (hooks) => {
                 '<div><field name="foo"/></div>' +
                 "</t></templates></kanban>",
             async mockRPC(route, { method, kwargs }) {
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.strictEqual(kwargs.limit, 3);
                 }
             },
@@ -1253,7 +1268,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("pager, ungrouped, with count limit reached", async (assert) => {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
 
         await makeView({
             type: "kanban",
@@ -1275,7 +1290,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click(target.querySelector(".o_pager_limit"));
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
@@ -1285,7 +1300,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("pager, ungrouped, with count limit reached, click next", async (assert) => {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
 
         await makeView({
             type: "kanban",
@@ -1307,17 +1322,17 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click(target.querySelector(".o_pager_next"));
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "3-4");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "4");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
     });
 
     QUnit.test("pager, ungrouped, with count limit reached, click next (2)", async (assert) => {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
         serverData.models.partner.records.push({ id: 5, foo: "xxx" });
 
         await makeView({
@@ -1340,23 +1355,23 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click(target.querySelector(".o_pager_next"));
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "3-4");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "4+");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
 
         await click(target.querySelector(".o_pager_next"));
         assert.containsOnce(target, ".o_kanban_record:not(.o_kanban_ghost)");
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "5-5");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "5");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
     });
 
     QUnit.test("pager, ungrouped, with count limit reached, click previous", async (assert) => {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
         serverData.models.partner.records.push({ id: 5, foo: "xxx" });
 
         await makeView({
@@ -1379,17 +1394,17 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click(target.querySelector(".o_pager_previous"));
         assert.containsOnce(target, ".o_kanban_record:not(.o_kanban_ghost)");
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "5-5");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "5");
-        assert.verifySteps(["search_count", "web_search_read"]);
+        assert.verifySteps(["search_count", "unity_web_search_read"]);
     });
 
     QUnit.test("pager, ungrouped, with count limit reached, edit pager", async (assert) => {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
         serverData.models.partner.records.push({ id: 5, foo: "xxx" });
 
         await makeView({
@@ -1412,21 +1427,21 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click(target, ".o_pager_value");
         await editInput(target, "input.o_pager_value", "2-4");
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 3);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "2-4");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "4+");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
 
         await click(target, ".o_pager_value");
         await editInput(target, "input.o_pager_value", "2-14");
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 4);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "2-5");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "5");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
     });
 
     QUnit.test("count_limit attrs set in arch", async (assert) => {
@@ -1450,7 +1465,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click(target.querySelector(".o_pager_limit"));
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 2);
@@ -1500,7 +1515,7 @@ QUnit.module("Views", (hooks) => {
         }
     );
 
-    QUnit.test("pager, update calls onUpdatedPager before the render", async (assert) => {
+    QUnit.test("pager, update calls onUpdatedPager", async (assert) => {
         assert.expect(8);
 
         class TestKanbanController extends KanbanController {
@@ -1541,7 +1556,7 @@ QUnit.module("Views", (hooks) => {
         assert.step("next page");
         await click(target.querySelector(".o_pager_next"));
         assert.deepEqual(getPagerValue(target), [4, 4]);
-        assert.verifySteps(["render", "next page", "onUpdatedPager", "render"]);
+        assert.verifySteps(["render", "next page", "render", "onUpdatedPager"]);
     });
 
     QUnit.test("click on a button type='delete' to delete a record in a column", async (assert) => {
@@ -1612,9 +1627,9 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_record:not(.o_kanban_ghost)", 5);
         assert.verifySteps([
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
             "doAction some.action",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -1811,12 +1826,12 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
-            "onchange", // quick create
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
+            "onchange2", // quick create
             "name_create", // should perform a name_create to create the record
-            "read", // read the created record
-            "onchange", // reopen the quick create automatically
+            "web_read", // read the created record
+            "onchange2", // reopen the quick create automatically
         ]);
     });
 
@@ -1845,7 +1860,7 @@ QUnit.module("Views", (hooks) => {
                 assert.step(args.method || route);
                 if (args.method === "create") {
                     assert.deepEqual(
-                        args.args,
+                        args.args[0],
                         [
                             {
                                 foo: "new partner",
@@ -1889,14 +1904,14 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
             "get_views", // form view in quick create
-            "onchange", // quick create
+            "onchange2", // quick create
             "create", // should perform a create to create the record
-            "read",
-            "read", // read the created record
-            "onchange", // new quick create
+            "web_read",
+            "web_read", // read the created record
+            "onchange2", // new quick create
         ]);
     });
 
@@ -1928,7 +1943,7 @@ QUnit.module("Views", (hooks) => {
             async mockRPC(route, args) {
                 if (args.method === "create") {
                     assert.deepEqual(
-                        args.args,
+                        args.args[0],
                         [
                             {
                                 foo: "new partner",
@@ -1939,7 +1954,7 @@ QUnit.module("Views", (hooks) => {
                         "should send the correct values"
                     );
                 }
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     await def;
                 }
             },
@@ -2164,12 +2179,12 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
-            "onchange", // quick create
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
+            "onchange2", // quick create
             "name_create", // should perform a name_create to create the record
-            "read", // read the created record
-            "onchange", // reopen the quick create automatically
+            "web_read", // read the created record
+            "onchange2", // reopen the quick create automatically
         ]);
     });
 
@@ -2198,7 +2213,7 @@ QUnit.module("Views", (hooks) => {
                 assert.step(method || route);
                 if (method === "create") {
                     assert.deepEqual(
-                        args,
+                        args[0],
                         [
                             {
                                 foo: "new partner",
@@ -2233,14 +2248,14 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
             "get_views", // form view in quick create
-            "onchange", // quick create
+            "onchange2", // quick create
             "create", // should perform a create to create the record
-            "read",
-            "read", // read the created record
-            "onchange", // reopen the quick create automatically
+            "web_read",
+            "web_read", // read the created record
+            "onchange2", // reopen the quick create automatically
         ]);
     });
 
@@ -2290,14 +2305,12 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
-            "read", // read display_name of categories
-            "onchange", // quick create
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
+            "onchange2", // quick create
             "name_create", // should perform a name_create to create the record
-            "read",
-            "read", // read the created record
-            "onchange", // reopen the quick create automatically
+            "web_read", // read the created record
+            "onchange2", // reopen the quick create automatically
         ]);
     });
 
@@ -2349,14 +2362,13 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
-            "read", // read display_name of categories
-            "web_search_read", // read records when unfolding 'None'
-            "onchange", // quick create
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
+            "unity_web_search_read", // read records when unfolding 'None'
+            "onchange2", // quick create
             "name_create", // should perform a name_create to create the record
-            "read", // read the created record
-            "onchange", // reopen the quick create automatically
+            "web_read", // read the created record
+            "onchange2", // reopen the quick create automatically
         ]);
     });
 
@@ -2382,13 +2394,17 @@ QUnit.module("Views", (hooks) => {
             async mockRPC(route, { method, args, kwargs }) {
                 assert.step(method || route);
                 if (method === "create") {
-                    assert.deepEqual(args, [
+                    assert.deepEqual(args[0], [
                         {
                             foo: "new partner",
                         },
                     ]);
                     const { default_category_ids } = kwargs.context;
                     assert.deepEqual(default_category_ids, [6]);
+                    return [5];
+                }
+                if (method === "web_read" && args[0][0] === 5) {
+                    return [{ id: 5, foo: "new partner", category_ids: [6] }];
                 }
             },
         });
@@ -2414,13 +2430,13 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
             "get_views", // get form view
-            "onchange", // quick create
+            "onchange2", // quick create
             "create", // should perform a create to create the record
-            "read", // read the created record
-            "onchange", // reopen the quick create automatically
+            "web_read", // read the created record
+            "onchange2", // reopen the quick create automatically
         ]);
     });
 
@@ -2447,9 +2463,9 @@ QUnit.module("Views", (hooks) => {
             async mockRPC(route, { method, args, kwargs }) {
                 assert.step(method || route);
                 if (method === "create") {
-                    assert.deepEqual(args, [
+                    assert.deepEqual(args[0], [
                         {
-                            category_ids: [[6, false, [6]]],
+                            category_ids: [[4, 6]],
                             foo: "new partner",
                         },
                     ]);
@@ -2488,15 +2504,13 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
             "get_views", // get form view
-            "onchange", // quick create
-            "read",
+            "onchange2", // quick create
             "create", // should perform a create to create the record
-            "read",
-            "onchange",
-            "read",
+            "web_read",
+            "onchange2",
         ]);
     });
 
@@ -2518,10 +2532,15 @@ QUnit.module("Views", (hooks) => {
                 assert.step(method || route);
             },
         });
-        assert.verifySteps(["get_views", "web_read_group", "web_search_read", "web_search_read"]);
+        assert.verifySteps([
+            "get_views",
+            "web_read_group",
+            "unity_web_search_read",
+            "unity_web_search_read",
+        ]);
 
         await createRecord();
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
 
         // do not fill anything and validate
         await validateRecord();
@@ -2588,11 +2607,11 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
             "get_views", // form view in quick create
-            "onchange", // quick create
-            "onchange", // onchange due to 'foo' field change
+            "onchange2", // quick create
+            "onchange2", // onchange due to 'foo' field change
         ]);
     });
 
@@ -2679,19 +2698,19 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
         ]);
 
         // click on 'Create' -> should open the quick create in the first column
         await quickCreateRecord();
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
 
         // fill the 'foo' field -> should trigger the onchange
         await editQuickCreateInput("foo", "new partner");
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
         await validateRecord();
-        assert.verifySteps(["create", "read", "onchange"]);
+        assert.verifySteps(["create", "web_read", "onchange2"]);
     });
 
     QUnit.test("quick create record and change state in grouped mode", async (assert) => {
@@ -3135,7 +3154,7 @@ QUnit.module("Views", (hooks) => {
                 groupBy: ["bar"],
                 async mockRPC(route, { method, args }) {
                     switch (method) {
-                        case "onchange": {
+                        case "onchange2": {
                             assert.step(method);
                             if (shouldDelayOnchange) {
                                 await prom;
@@ -3144,7 +3163,7 @@ QUnit.module("Views", (hooks) => {
                         }
                         case "create": {
                             assert.step(method);
-                            const values = args[0];
+                            const values = args[0][0];
                             assert.strictEqual(values.foo, "new partner");
                             assert.strictEqual(values.int_field, 3);
                             break;
@@ -3208,10 +3227,10 @@ QUnit.module("Views", (hooks) => {
             );
 
             assert.verifySteps([
-                "onchange", // default_get
-                "onchange", // new partner
+                "onchange2", // default_get
+                "onchange2", // new partner
                 "create",
-                "onchange", // default_get
+                "onchange2", // default_get
             ]);
         }
     );
@@ -3243,15 +3262,15 @@ QUnit.module("Views", (hooks) => {
                     "</t></templates></kanban>",
                 groupBy: ["bar"],
                 async mockRPC(route, args) {
-                    if (args.method === "onchange") {
-                        assert.step("onchange");
+                    if (args.method === "onchange2") {
+                        assert.step("onchange2");
                         if (shouldDelayOnchange) {
                             await prom;
                         }
                     }
                     if (args.method === "create") {
                         assert.step("create");
-                        assert.deepEqual(pick(args.args[0], "foo", "int_field"), {
+                        assert.deepEqual(args.args[0][0], {
                             foo: "new partner",
                             int_field: 3,
                         });
@@ -3307,10 +3326,10 @@ QUnit.module("Views", (hooks) => {
             );
 
             assert.verifySteps([
-                "onchange", // default_get
-                "onchange", // new partner
+                "onchange2", // default_get
+                "onchange2", // new partner
                 "create",
-                "onchange", // default_get
+                "onchange2", // default_get
             ]);
         }
     );
@@ -3611,7 +3630,7 @@ QUnit.module("Views", (hooks) => {
                 '<div><field name="foo"/></div>' +
                 "</t></templates></kanban>",
             async mockRPC(route, { args, method }) {
-                if (method === "read") {
+                if (method === "web_read") {
                     newRecordID = args[0][0];
                 }
             },
@@ -3722,7 +3741,7 @@ QUnit.module("Views", (hooks) => {
                 "</t></templates></kanban>",
             groupBy: ["bar"],
             async mockRPC(route, { method }) {
-                if (method === "read") {
+                if (method === "web_read") {
                     await prom;
                 }
             },
@@ -3877,7 +3896,7 @@ QUnit.module("Views", (hooks) => {
                     throw makeServerError({ message: "This is a user error" });
                 }
                 if (args.method === "create") {
-                    assert.deepEqual(args.args[0], { foo: "blip" });
+                    assert.deepEqual(args.args[0][0], { foo: "blip" });
                     assert.deepEqual(args.kwargs.context, {
                         default_foo: "blip",
                         default_name: "test",
@@ -3927,7 +3946,7 @@ QUnit.module("Views", (hooks) => {
                     throw makeServerError({ message: "This is a user error" });
                 }
                 if (args.method === "create") {
-                    assert.deepEqual(args.args[0], { state: "abc" });
+                    assert.deepEqual(args.args[0][0], { state: "abc" });
                     assert.deepEqual(args.kwargs.context, {
                         default_state: "abc",
                         default_name: "test",
@@ -3977,8 +3996,16 @@ QUnit.module("Views", (hooks) => {
                     // by stage_id)
                     return {
                         groups: [
-                            { __domain: [["product_id", "=", 3]], product_id_count: 0 },
-                            { __domain: [["product_id", "=", 5]], product_id_count: 0 },
+                            {
+                                __domain: [["product_id", "=", 3]],
+                                product_id_count: 0,
+                                product_id: [3, "xplone"],
+                            },
+                            {
+                                __domain: [["product_id", "=", 5]],
+                                product_id_count: 0,
+                                product_id: [5, "xplan"],
+                            },
                         ],
                         length: 2,
                     };
@@ -4218,7 +4245,7 @@ QUnit.module("Views", (hooks) => {
                 groupBy: ["foo"],
                 async mockRPC(route, { method, args, kwargs }) {
                     if (method === "create") {
-                        assert.deepEqual(args, [{ foo: "blip" }]);
+                        assert.deepEqual(args[0], [{ foo: "blip" }]);
                         assert.strictEqual(kwargs.context.default_foo, "blip");
                     }
                 },
@@ -4260,7 +4287,7 @@ QUnit.module("Views", (hooks) => {
                 groupBy: ["bar"],
                 async mockRPC(route, { method, args, kwargs }) {
                     if (method === "create") {
-                        assert.deepEqual(args, [{ bar: true }]);
+                        assert.deepEqual(args[0], [{ bar: true }]);
                         assert.strictEqual(kwargs.context.default_bar, true);
                     }
                 },
@@ -4306,7 +4333,7 @@ QUnit.module("Views", (hooks) => {
                 groupBy: ["state"],
                 async mockRPC(route, { method, args, kwargs }) {
                     if (method === "create") {
-                        assert.deepEqual(args, [{ state: "abc" }]);
+                        assert.deepEqual(args[0], [{ state: "abc" }]);
                         assert.strictEqual(kwargs.context.default_state, "abc");
                     }
                 },
@@ -4536,14 +4563,10 @@ QUnit.module("Views", (hooks) => {
             "first record should contain 2 tags"
         );
         assert.containsOnce(getCard(0), ".o_tag.o_tag_color_2", "first tag should have color 2");
-        assert.verifySteps(
-            [
-                "/web/dataset/call_kw/partner/get_views",
-                "/web/dataset/call_kw/partner/web_search_read",
-                "/web/dataset/call_kw/category/read",
-            ],
-            "two RPC should have been done (one search read and one read for the m2m)"
-        );
+        assert.verifySteps([
+            "/web/dataset/call_kw/partner/get_views",
+            "/web/dataset/call_kw/partner/unity_web_search_read",
+        ]);
 
         // Checks that second records has only one tag as one should be hidden (color 0)
         assert.containsOnce(
@@ -4551,24 +4574,25 @@ QUnit.module("Views", (hooks) => {
             ".o_kanban_record:nth-child(2) .o_tag",
             "there should be only one tag in second record"
         );
+        const tag = target.querySelector(".o_kanban_record:nth-child(2) .o_tag");
+        assert.strictEqual(tag.innerText, "silver");
 
         // Write on the record using the priority widget to trigger a re-render in readonly
         await click(target, ".o_kanban_record:first-child .o_priority_star:first-child");
 
-        assert.verifySteps(
-            [
-                "/web/dataset/call_kw/partner/write",
-                "/web/dataset/call_kw/partner/read",
-                "/web/dataset/call_kw/category/read",
-            ],
-            "five RPCs should have been done (previous 2, 1 write (triggers a re-render), same 2 at re-render"
-        );
+        assert.verifySteps([
+            "/web/dataset/call_kw/partner/write",
+            "/web/dataset/call_kw/partner/web_read",
+        ]);
         assert.containsN(
             target,
             ".o_kanban_record:first-child .o_field_many2many_tags .o_tag",
             2,
             "first record should still contain only 2 tags"
         );
+        const tags = target.querySelectorAll(".o_kanban_record:first-child .o_tag");
+        assert.strictEqual(tags[0].innerText, "gold");
+        assert.strictEqual(tags[1].innerText, "silver");
 
         // click on a tag (should trigger switch_view)
         await click(target, ".o_kanban_record:first-child .o_tag:first-child");
@@ -4628,7 +4652,7 @@ QUnit.module("Views", (hooks) => {
             async switchView() {
                 // when clicking on a record in kanban view,
                 // it switches to form view.
-                throw new Error("should not switch view");
+                assert.step("switchView");
             },
         });
 
@@ -4658,6 +4682,7 @@ QUnit.module("Views", (hooks) => {
         });
 
         await click(testLink);
+        assert.verifySteps([]);
     });
 
     QUnit.test("Open record when clicking on widget field", async function (assert) {
@@ -4732,13 +4757,11 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -4766,13 +4789,11 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -4807,65 +4828,17 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
-    });
-
-    QUnit.test("wait x2manys batch fetches to re-render", async (assert) => {
-        let prom = Promise.resolve();
-        const kanban = await makeView({
-            type: "kanban",
-            resModel: "partner",
-            serverData,
-            arch:
-                "<kanban>" +
-                '<field name="product_id"/>' +
-                '<templates><t t-name="kanban-box">' +
-                "<div>" +
-                '<field name="category_ids" widget="many2many_tags"/>' +
-                "</div>" +
-                "</t></templates>" +
-                "</kanban>",
-            groupBy: ["product_id"],
-            async mockRPC(route, { method }) {
-                if (method === "read") {
-                    await prom;
-                }
-            },
-        });
-
-        assert.containsN(target, ".o_tag", 2);
-        assert.containsN(target, ".o_kanban_group", 2);
-
-        prom = makeDeferred();
-        reload(kanban, { groupBy: ["state"] });
-
-        await nextTick();
-
-        assert.containsN(target, ".o_tag", 2);
-        assert.containsN(target, ".o_kanban_group", 2);
-
-        prom.resolve();
-        await nextTick();
-
-        assert.containsN(target, ".o_kanban_group", 3);
-        assert.containsN(target, ".o_tag", 2, "Should display 2 tags after update");
-        assert.strictEqual(
-            target.querySelector(".o_kanban_group:nth-child(2) .o_tag").innerText,
-            "gold",
-            "First category should be 'gold'"
-        );
-        assert.strictEqual(
-            target.querySelector(".o_kanban_group:nth-child(3) .o_tag").innerText,
-            "silver",
-            "Second category should be 'silver'"
+        const allNames = Array.from(
+            target.querySelectorAll(".o_kanban_record span"),
+            (node) => node.textContent
         );
+        assert.deepEqual(allNames, ["hello", "", "xmo", ""]);
     });
 
     QUnit.test("can drag and drop a record from one column to the next", async (assert) => {
@@ -5036,7 +5009,7 @@ QUnit.module("Views", (hooks) => {
                     return true;
                 }
                 if (args.model === "partner" && args.method === "write") {
-                    throw new Error("should not be draggable");
+                    assert.step("should not be called");
                 }
             },
         });
@@ -5125,6 +5098,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_group:nth-child(3) .o_kanban_record", 0);
 
         assert.deepEqual(getCardTexts(0), ["yopABC", "gnapGHI"]);
+        assert.verifySteps([]);
     });
 
     QUnit.test("prevent drag and drop if grouped by date/datetime field", async (assert) => {
@@ -5308,18 +5282,18 @@ QUnit.module("Views", (hooks) => {
 
     QUnit.test("Ensuring each progress bar has some space", async (assert) => {
         serverData.models.partner.records = [
-            ({
+            {
                 id: 1,
                 foo: "blip",
                 state: "def",
-            }),
-            ({
+            },
+            {
                 id: 2,
                 foo: "blip",
                 state: "abc",
-            }),
+            },
         ];
-        
+
         for (let i = 0; i < 20; i++) {
             serverData.models.partner.records.push({
                 id: 3 + i,
@@ -5327,7 +5301,7 @@ QUnit.module("Views", (hooks) => {
                 state: "ghi",
             });
         }
-        
+
         await makeView({
             type: "kanban",
             resModel: "partner",
@@ -5434,8 +5408,8 @@ QUnit.module("Views", (hooks) => {
                 "</kanban>",
             groupBy: ["product_id"],
             async mockRPC(route, { model, method }) {
-                if (model === "partner" && method === "onchange") {
-                    throw {};
+                if (model === "partner" && method === "onchange2") {
+                    return Promise.reject({});
                 }
             },
         });
@@ -5523,7 +5497,7 @@ QUnit.module("Views", (hooks) => {
             `,
             async mockRPC(route, { method }) {
                 if (method === "web_read_group") {
-                    throw new Error("Should not do a read_group RPC");
+                    assert.step("web_read_group");
                 }
             },
             context: { search_default_itsName: 1 },
@@ -5536,6 +5510,7 @@ QUnit.module("Views", (hooks) => {
         // validate presence of the search arch info
         await toggleSearchBarMenu(target);
         assert.containsN(target, ".o_filter_menu .o_menu_item", 2);
+        assert.verifySteps([]);
     });
 
     QUnit.test("kanban view with create=False", async (assert) => {
@@ -5633,9 +5608,12 @@ QUnit.module("Views", (hooks) => {
                 "</t></templates>" +
                 "</kanban>",
             groupBy: ["product_id"],
-            async mockRPC(route, { method }) {
-                if (method === "create" || route === "/web/dataset/resequence") {
-                    assert.step(method || route);
+            async mockRPC(route, args) {
+                if (args.method === "create" || route === "/web/dataset/resequence") {
+                    assert.step(args.method || route);
+                    if (route === "/web/dataset/resequence") {
+                        assert.step(args.ids.toString());
+                    }
                 }
             },
         });
@@ -5682,7 +5660,7 @@ QUnit.module("Views", (hooks) => {
             "o_column_folded",
             "the created column should not be folded"
         );
-        assert.verifySteps(["create", "/web/dataset/resequence"]);
+        assert.verifySteps(["create", "/web/dataset/resequence", "3,5,6"]);
 
         // fold and unfold the created column, and check that no RPCs are done (as there are no records)
         const clickColumnAction = await toggleColumnActions(2);
@@ -5739,8 +5717,8 @@ QUnit.module("Views", (hooks) => {
                     result.groups[8].__fold = true;
                     return result;
                 }
-                if (args.method === "web_search_read") {
-                    assert.step(`web_search_read domain: ${args.kwargs.domain}`);
+                if (args.method === "unity_web_search_read") {
+                    assert.step(`unity_web_search_read domain: ${args.kwargs.domain}`);
                 }
             },
         });
@@ -5761,16 +5739,16 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_group.o_column_folded", 4);
 
         assert.verifySteps([
-            "web_search_read domain: product_id,=,3",
-            "web_search_read domain: product_id,=,5",
-            "web_search_read domain: product_id,=,9",
-            "web_search_read domain: product_id,=,10",
-            "web_search_read domain: product_id,=,11",
-            "web_search_read domain: product_id,=,12",
-            "web_search_read domain: product_id,=,13",
-            "web_search_read domain: product_id,=,15",
-            "web_search_read domain: product_id,=,16",
-            "web_search_read domain: product_id,=,17",
+            "unity_web_search_read domain: product_id,=,3",
+            "unity_web_search_read domain: product_id,=,5",
+            "unity_web_search_read domain: product_id,=,9",
+            "unity_web_search_read domain: product_id,=,10",
+            "unity_web_search_read domain: product_id,=,11",
+            "unity_web_search_read domain: product_id,=,12",
+            "unity_web_search_read domain: product_id,=,13",
+            "unity_web_search_read domain: product_id,=,15",
+            "unity_web_search_read domain: product_id,=,16",
+            "unity_web_search_read domain: product_id,=,17",
         ]);
     });
 
@@ -5812,8 +5790,8 @@ QUnit.module("Views", (hooks) => {
                     }
                     return result;
                 }
-                if (args.method === "web_search_read") {
-                    assert.step(`web_search_read domain: ${args.kwargs.domain}`);
+                if (args.method === "unity_web_search_read") {
+                    assert.step(`unity_web_search_read domain: ${args.kwargs.domain}`);
                 }
             },
         });
@@ -5834,16 +5812,16 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_group.o_column_folded", 4);
 
         assert.verifySteps([
-            "web_search_read domain: product_id,=,3",
-            "web_search_read domain: product_id,=,5",
-            "web_search_read domain: product_id,=,9",
-            "web_search_read domain: product_id,=,10",
-            "web_search_read domain: product_id,=,11",
-            "web_search_read domain: product_id,=,12",
-            "web_search_read domain: product_id,=,13",
-            "web_search_read domain: product_id,=,15",
-            "web_search_read domain: product_id,=,16",
-            "web_search_read domain: product_id,=,17",
+            "unity_web_search_read domain: product_id,=,3",
+            "unity_web_search_read domain: product_id,=,5",
+            "unity_web_search_read domain: product_id,=,9",
+            "unity_web_search_read domain: product_id,=,10",
+            "unity_web_search_read domain: product_id,=,11",
+            "unity_web_search_read domain: product_id,=,12",
+            "unity_web_search_read domain: product_id,=,13",
+            "unity_web_search_read domain: product_id,=,15",
+            "unity_web_search_read domain: product_id,=,16",
+            "unity_web_search_read domain: product_id,=,17",
         ]);
     });
 
@@ -6024,12 +6002,12 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "unlink",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
         assert.containsN(
             target,
@@ -6223,7 +6201,7 @@ QUnit.module("Views", (hooks) => {
                 "</kanban>",
             groupBy: ["product_id"],
             async mockRPC(_route, { method, model, kwargs }) {
-                if (model === "partner" && method === "web_search_read") {
+                if (model === "partner" && method === "unity_web_search_read") {
                     assert.strictEqual(
                         kwargs.context.lang,
                         "brol",
@@ -6766,12 +6744,12 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "onchange",
+                "onchange2",
                 "name_create",
-                "read",
+                "web_read",
                 "read_progress_bar",
                 "web_read_group",
-                "onchange",
+                "onchange2",
             ]);
         }
     );
@@ -8047,7 +8025,7 @@ QUnit.module("Views", (hooks) => {
         });
         assert.verifySteps([
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/web_search_read",
+            "/web/dataset/call_kw/partner/unity_web_search_read",
         ]);
 
         assert.ok(
@@ -8067,7 +8045,7 @@ QUnit.module("Views", (hooks) => {
 
         assert.strictEqual(count, 1, "should have triggered an execute action only once");
         assert.verifySteps(
-            ["/web/dataset/call_kw/partner/web_search_read"],
+            ["/web/dataset/call_kw/partner/unity_web_search_read"],
             "the records should be reloaded after executing a button action"
         );
     });
@@ -8564,19 +8542,21 @@ QUnit.module("Views", (hooks) => {
         assert.hasClass(getCard(0), "oe_kanban_color_9");
     });
 
-    QUnit.test("edit the kanban color with translated colors resulting in the same terms", async (assert) => {
-        serverData.models.category.records[0].color = 12;
+    QUnit.test(
+        "edit the kanban color with translated colors resulting in the same terms",
+        async (assert) => {
+            serverData.models.category.records[0].color = 12;
 
-        patchWithCleanup(translatedTerms, {
-            "Purple": "Violet",
-            "Violet": "Violet",
-        });
+            patchWithCleanup(translatedTerms, {
+                Purple: "Violet",
+                Violet: "Violet",
+            });
 
-        await makeView({
-            type: "kanban",
-            resModel: "category",
-            serverData,
-            arch: `
+            await makeView({
+                type: "kanban",
+                resModel: "category",
+                serverData,
+                arch: `
                 <kanban>
                     <field name="color"/>
                     <templates>
@@ -8590,12 +8570,13 @@ QUnit.module("Views", (hooks) => {
                         </t>
                     </templates>
                 </kanban>`,
-        });
+            });
 
-        await toggleRecordDropdown(0);
-        await click(target, ".oe_kanban_colorpicker a.oe_kanban_color_9");
-        assert.hasClass(getCard(0), "oe_kanban_color_9");
-    });
+            await toggleRecordDropdown(0);
+            await click(target, ".oe_kanban_colorpicker a.oe_kanban_color_9");
+            assert.hasClass(getCard(0), "oe_kanban_color_9");
+        }
+    );
 
     QUnit.test("colorpicker doesnt appear when missing access rights", async (assert) => {
         await makeView({
@@ -8641,7 +8622,7 @@ QUnit.module("Views", (hooks) => {
             groupBy: ["bar"],
             limit: 2,
             async mockRPC(_route, { method, kwargs }) {
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.step(`${kwargs.limit} - ${kwargs.offset}`);
                 }
             },
@@ -8702,24 +8683,29 @@ QUnit.module("Views", (hooks) => {
                 </kanban>`,
             groupBy: ["bar"],
             limit: 2,
-            async mockRPC(_route, { args, kwargs, model, method }) {
-                if (model === "category" && method === "read") {
-                    assert.step(`read ${String(args[0])}`);
-                } else if (method === "web_search_read") {
-                    assert.step(`web_search_read ${kwargs.limit}-${kwargs.offset}`);
+            async mockRPC(_route, { kwargs, method }) {
+                if (method === "unity_web_search_read") {
+                    assert.step(`unity_web_search_read ${kwargs.limit}-${kwargs.offset}`);
                 }
             },
         });
 
         assert.containsN(getColumn(1), ".o_kanban_record", 2);
-
-        assert.verifySteps(["web_search_read 2-0", "web_search_read 2-0", "read 7"]);
+        assert.deepEqual(
+            [...getColumn(1).querySelectorAll("[name='category_ids']")].map((el) => el.textContent),
+            ["silver", ""]
+        );
+        assert.verifySteps(["unity_web_search_read 2-0", "unity_web_search_read 2-0"]);
 
         // load more
         await loadMore(1);
 
         assert.containsN(getColumn(1), ".o_kanban_record", 3);
-        assert.verifySteps(["web_search_read 4-0", "read 7,6"]);
+        assert.deepEqual(
+            [...getColumn(1).querySelectorAll("[name='category_ids']")].map((el) => el.textContent),
+            ["silver", "", "gold"]
+        );
+        assert.verifySteps(["unity_web_search_read 4-0"]);
     });
 
     QUnit.test("update buttons after column creation", async (assert) => {
@@ -8790,6 +8776,19 @@ QUnit.module("Views", (hooks) => {
         await reload(kanban, { groupBy: ["product_id"] });
 
         assert.containsN(target, ".o_kanban_group", 3, "should have 3 columns");
+        assert.hasClass(
+            target.querySelector(".o_kanban_group"),
+            "o_column_folded",
+            "first column should be folded"
+        );
+
+        await click(target.querySelector(".o_kanban_group"));
+        assert.containsN(target, ".o_kanban_group", 3, "should have 3 columns");
+        assert.doesNotHaveClass(
+            target.querySelector(".o_kanban_group"),
+            "o_column_folded",
+            "first column should not be folded"
+        );
         assert.strictEqual(
             target.querySelectorAll(".o_kanban_group:nth-child(1) .o_kanban_record").length,
             1,
@@ -8811,7 +8810,9 @@ QUnit.module("Views", (hooks) => {
             "first column should have a default title for when no value is provided"
         );
 
-        const groupsTitle = [...target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title")];
+        const groupsTitle = [
+            ...target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title"),
+        ];
         await mouseEnter(groupsTitle[0]);
         assert.containsNone(
             target,
@@ -8868,7 +8869,9 @@ QUnit.module("Views", (hooks) => {
         assert.hasClass(target.querySelector(".o_kanban_renderer"), "o_kanban_grouped");
         assert.containsN(target, ".o_column_title", 2);
 
-        await mouseEnter(target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title")[0]);
+        await mouseEnter(
+            target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title")[0]
+        );
         assert.containsNone(target, ".o-tooltip");
 
         await triggerEvent(
@@ -8878,7 +8881,9 @@ QUnit.module("Views", (hooks) => {
         );
         assert.containsNone(target, ".o-tooltip");
 
-        await mouseEnter(target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title")[0]);
+        await mouseEnter(
+            target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title")[0]
+        );
         assert.containsNone(target, ".o-tooltip");
 
         prom.resolve();
@@ -8914,7 +8919,9 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        await mouseEnter(target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title")[0]);
+        await mouseEnter(
+            target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title")[0]
+        );
         assert.containsOnce(target, ".o-tooltip");
         assert.strictEqual(target.querySelector(".o-tooltip").textContent.trim(), "Namehello");
         assert.verifySteps(["read: product"]);
@@ -8926,7 +8933,9 @@ QUnit.module("Views", (hooks) => {
         );
         assert.containsNone(target, ".o-tooltip", "tooltip should be closed");
 
-        await mouseEnter(target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title")[0]);
+        await mouseEnter(
+            target.querySelectorAll(".o_kanban_group .o_kanban_header_title .o_column_title")[0]
+        );
         assert.containsOnce(target, ".o-tooltip");
         assert.strictEqual(target.querySelector(".o-tooltip").textContent.trim(), "Namehello");
         assert.verifySteps([]);
@@ -9109,8 +9118,8 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -9175,9 +9184,9 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -9228,10 +9237,10 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "web_read_group",
+            "unity_web_search_read",
         ]);
     });
 
@@ -9258,7 +9267,7 @@ QUnit.module("Views", (hooks) => {
 
         assert.deepEqual(getCardTexts(), ["name", "name", "name", "name"]);
         assert.verifySteps(
-            ["get_views", "web_search_read"],
+            ["get_views", "unity_web_search_read"],
             "no read on progress bar data is done"
         );
     });
@@ -9303,8 +9312,8 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
                 "create",
                 "/web/dataset/resequence",
             ]);
@@ -9349,13 +9358,13 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
-            "onchange",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "onchange2",
             "name_create",
-            "read",
+            "web_read",
             "read_progress_bar",
-            "onchange",
+            "onchange2",
         ]);
     });
 
@@ -9390,9 +9399,9 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -9435,10 +9444,10 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
             ]);
         }
     );
@@ -9492,11 +9501,11 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "action_archive",
             "web_read_group",
-            "web_search_read",
+            "unity_web_search_read",
             "read_progress_bar",
             "web_read_group",
         ]);
@@ -9547,11 +9556,11 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
                 "action_archive",
                 "web_read_group",
-                "web_search_read",
+                "unity_web_search_read",
                 "read_progress_bar",
                 "web_read_group",
             ]);
@@ -9587,13 +9596,13 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             // reload
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -9630,15 +9639,15 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "web_read_group", // recomputes aggregates
+            "unity_web_search_read",
             // activate filter
             "web_read_group", // recomputes aggregates
-            "web_search_read",
+            "unity_web_search_read",
             // activate another filter (switching)
-            "web_read_group", // recomputes aggregates
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -9693,22 +9702,19 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "write",
             "read_progress_bar",
-            "read",
             "/web/dataset/resequence",
             "read",
             "write",
             "read_progress_bar",
-            "read",
             "/web/dataset/resequence",
             "read",
             "write",
             "read_progress_bar",
-            "read",
             "/web/dataset/resequence",
             "read",
         ]);
@@ -9742,9 +9748,9 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -9784,11 +9790,10 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
                 "write",
                 "read_progress_bar",
-                "read",
                 "/web/dataset/resequence",
                 "read",
             ]);
@@ -9878,15 +9883,15 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
                 "get_views",
-                "onchange",
+                "onchange2",
                 "create",
-                "read",
+                "web_read",
                 "read_progress_bar",
                 "web_read_group",
-                "onchange",
+                "onchange2",
             ]);
         }
     );
@@ -9951,25 +9956,24 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
                 "web_read_group",
+                "unity_web_search_read",
                 "get_views",
-                "onchange",
+                "onchange2",
                 "create",
-                "read",
+                "web_read",
                 "read_progress_bar",
                 "web_read_group",
                 "web_read_group",
-                "onchange",
-                "onchange",
+                "onchange2",
                 "create",
-                "read",
+                "web_read",
                 "read_progress_bar",
                 "web_read_group",
                 "web_read_group",
-                "onchange",
+                "onchange2",
             ]);
         }
     );
@@ -10056,8 +10060,8 @@ QUnit.module("Views", (hooks) => {
                     </div></t></templates>
                 </kanban>`,
             mockRPC(route, { method, kwargs }) {
-                if (method === "web_search_read") {
-                    assert.deepEqual(kwargs.fields, ["id", "write_date"]);
+                if (method === "unity_web_search_read") {
+                    assert.deepEqual(kwargs.specification, { id: {}, write_date: {} });
                 }
             },
             domain: [["id", "in", [1]]],
@@ -10649,7 +10653,7 @@ QUnit.module("Views", (hooks) => {
                 "</t></templates></kanban>",
             async mockRPC(route, args) {
                 if (route === "/web/dataset/resequence") {
-                    throw new Error("should not trigger a resequencing");
+                    assert.step("resequence");
                 }
             },
         });
@@ -10659,6 +10663,7 @@ QUnit.module("Views", (hooks) => {
         await dragAndDrop(".o_kanban_record", ".o_kanban_record:nth-child(4)");
 
         assert.deepEqual(getCardTexts(), ["yop", "blip", "gnap", "blip"]);
+        assert.verifySteps([]);
     });
 
     QUnit.test("click on image field in kanban with oe_kanban_global_click", async (assert) => {
@@ -10941,16 +10946,16 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
+                "unity_web_search_read",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
             ]);
         }
     );
@@ -11037,18 +11042,18 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
             ]);
         }
     );
@@ -11129,12 +11134,11 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
                 "write",
                 "read_progress_bar",
-                "read",
                 "/web/dataset/resequence",
                 "read",
             ]);
@@ -11180,8 +11184,8 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
 
         // Apply an active filter
@@ -11198,7 +11202,7 @@ QUnit.module("Views", (hooks) => {
         );
         assert.containsOnce(target, ".o_kanban_group.o_kanban_group_show .o_kanban_record");
         assert.deepEqual(getCardTexts(1), ["1yop"]);
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
 
         // Drag out its only record onto the first column
         await dragAndDrop(
@@ -11220,8 +11224,7 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "write",
             "read_progress_bar",
-            "web_search_read",
-            "read", // read happens is delayed by the ORM batcher
+            "unity_web_search_read",
             "/web/dataset/resequence",
             "read",
         ]);
@@ -11288,9 +11291,9 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
         await click(target.querySelector(".o_kanban_record p"));
-        assert.verifySteps(["doActionButton type object name a1", "web_search_read"]);
+        assert.verifySteps(["doActionButton type object name a1", "unity_web_search_read"]);
     });
 
     QUnit.test("action/type attributes on kanban arch, type='action'", async (assert) => {
@@ -11317,9 +11320,9 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
         await click(target.querySelector(".o_kanban_record p"));
-        assert.verifySteps(["doActionButton type action name a1", "web_search_read"]);
+        assert.verifySteps(["doActionButton type action name a1", "unity_web_search_read"]);
     });
 
     QUnit.test("Missing t-key is automatically filled with a warning", async (assert) => {
@@ -11365,29 +11368,30 @@ QUnit.module("Views", (hooks) => {
                 </kanban>`,
             groupBy: ["product_id"],
             async mockRPC(_route, { method }) {
-                if (method === "read") {
+                if (method === "web_read") {
                     await def;
                 }
-                if (["name_create", "read"].includes(method)) {
+                if (["name_create", "web_read"].includes(method)) {
                     assert.step(method);
                 }
             },
         });
 
         assert.deepEqual(getCardTexts(0), ["0", "1"]);
-        assert.verifySteps(["read"]);
+        assert.verifySteps([]);
 
         def = makeDeferred();
 
         await quickCreateRecord(0);
         await editQuickCreateInput("display_name", "Test");
         await validateRecord();
+        assert.deepEqual(getCardTexts(0), ["0", "1"]);
 
         def.resolve();
         await nextTick();
 
         assert.deepEqual(getCardTexts(0), ["0", "0", "1"]);
-        assert.verifySteps(["name_create", "read"]);
+        assert.verifySteps(["name_create", "web_read"]);
     });
 
     QUnit.test("Allow use of 'editable'/'deletable' in ungrouped kanban", async (assert) => {
@@ -11644,7 +11648,12 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_group", 2);
         assert.containsOnce(target, ".o_kanban_group:first-child .o_kanban_record");
         assert.containsN(target, ".o_kanban_group:nth-child(2) .o_kanban_record", 3);
-        assert.verifySteps(["get_views", "web_read_group", "web_search_read", "web_search_read"]);
+        assert.verifySteps([
+            "get_views",
+            "web_read_group",
+            "unity_web_search_read",
+            "unity_web_search_read",
+        ]);
     });
 
     QUnit.test("basic rendering with a date groupby with a granularity", async (assert) => {
@@ -11677,7 +11686,12 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_kanban_group", 2);
         assert.containsN(target, ".o_kanban_group:first-child .o_kanban_record", 3);
         assert.containsOnce(target, ".o_kanban_group:nth-child(2) .o_kanban_record");
-        assert.verifySteps(["get_views", "web_read_group", "web_search_read", "web_search_read"]);
+        assert.verifySteps([
+            "get_views",
+            "web_read_group",
+            "unity_web_search_read",
+            "unity_web_search_read",
+        ]);
     });
 
     QUnit.test("quick create record and click outside (no dirty input)", async (assert) => {
@@ -11987,11 +12001,11 @@ QUnit.module("Views", (hooks) => {
                 "get_views",
                 "web_read_group",
                 "read_progress_bar",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
             ]);
         }
     );
@@ -12071,14 +12085,14 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "write",
-            "read",
+            "web_read",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -12104,7 +12118,7 @@ QUnit.module("Views", (hooks) => {
             groupBy: ["bar"],
             mockRPC: async (route, args) => {
                 const { method } = args;
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     await def;
                 }
             },
@@ -12159,7 +12173,7 @@ QUnit.module("Views", (hooks) => {
             domain: [["id", ">", 0]],
             mockRPC: (route, args) => {
                 const { method, kwargs } = args;
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.step(method);
                     assert.deepEqual(kwargs.domain, [
                         "&",
@@ -12187,7 +12201,7 @@ QUnit.module("Views", (hooks) => {
         await click(getProgressBars(0)[0]);
         assert.containsOnce(target, ".o_kanban_record");
 
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
     });
 
     QUnit.test(
@@ -12450,8 +12464,8 @@ QUnit.module("Views", (hooks) => {
             `,
             groupBy: ["bar"],
             async mockRPC(route, args) {
-                if (args.method === "onchange") {
-                    assert.step("onchange");
+                if (args.method === "onchange2") {
+                    assert.step("onchange2");
                     await Promise.resolve(def);
                 }
             },
@@ -12494,7 +12508,7 @@ QUnit.module("Views", (hooks) => {
             ),
             ["blipDEF", "ABC"]
         );
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
 
         def.resolve();
         await nextTick();
@@ -12600,7 +12614,7 @@ QUnit.module("Views", (hooks) => {
             });
 
             assert.strictEqual(target.querySelector("[name=foo] span").innerText, "hello");
-            assert.verifySteps(["get_views", "web_search_read"]);
+            assert.verifySteps(["get_views", "unity_web_search_read"]);
         }
     );
 
@@ -12767,8 +12781,8 @@ QUnit.module("Views", (hooks) => {
             "get_views",
             "web_read_group",
             "read_progress_bar",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "write",
             "read_progress_bar",
             "web_read_group",
@@ -12852,15 +12866,15 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group", // initial read_group
-            "web_search_read", // initial search_read (first column)
-            "web_search_read", // initial search_read (second column)
-            "onchange", // quick create
+            "unity_web_search_read", // initial search_read (first column)
+            "unity_web_search_read", // initial search_read (second column)
+            "onchange2", // quick create
             "name_create", // should perform a name_create to create the record
             "get_views", // load views for form view dialog
-            "onchange", // load of a virtual record in form view dialog
+            "onchange2", // load of a virtual record in form view dialog
             "create", // save virtual record
-            "read", // read the created record to get foo value
-            "onchange", // reopen the quick create automatically
+            "web_read", // read the created record to get foo value
+            "onchange2", // reopen the quick create automatically
         ]);
     });
 
@@ -13029,61 +13043,6 @@ QUnit.module("Views", (hooks) => {
         assert.deepEqual(getCardTexts(), ["1", "3", "4", "2"]);
     });
 
-    QUnit.test("group key in foreach cannot be a duplicate", async function (assert) {
-        serverData.models.product.records = [
-            {
-                id: 1,
-                name: "Product with id 1",
-            },
-        ];
-
-        serverData.models.partner.records = [
-            {
-                id: 1,
-                name: "Partner 1",
-                product_id: 1,
-            },
-        ];
-
-        await makeView({
-            type: "kanban",
-            resModel: "partner",
-            serverData,
-            arch: /* xml */ `
-                <kanban>
-                    <templates>
-                        <div t-name="kanban-box">
-                            <field name="name" />
-                        </div>
-                    </templates>
-                </kanban>
-            `,
-            groupBy: ["product_id"],
-            async mockRPC(route, args, performRPC) {
-                if (args.method === "web_read_group") {
-                    const result = await performRPC(route, args);
-                    result.groups = [
-                        ...result.groups,
-                        {
-                            // Add an empty and valueless group, will result in foreach key group_key_0
-                            __domain: [["product_id", "=", null]],
-                            __fold: false,
-                        },
-                        {
-                            // Add an empty and valueless group, will result in foreach key group_key_1
-                            __domain: [["product_id", "=", null]],
-                            __fold: false,
-                        },
-                    ];
-                    result.length = 2;
-                    return result;
-                }
-            },
-        });
-        assert.strictEqual(target.querySelectorAll(".o_kanban_group").length, 3);
-        assert.strictEqual(target.querySelectorAll(".o_kanban_record").length, 1);
-    });
-
     QUnit.test("drag & drop: content scrolls when reaching the edges", async (assert) => {
         const { advanceFrame } = mockAnimationFrame();
         await makeView({
@@ -13212,7 +13171,7 @@ QUnit.module("Views", (hooks) => {
                 mockRPC: async (route, args) => {
                     assert.step(args.method || route);
                     if (args.method === "read") {
-                        assert.deepEqual(args.args[0], readIds.shift());
+                        assert.deepEqual(args.args[0], readIds[1]);
                         await prom;
                     }
                 },
@@ -13221,8 +13180,8 @@ QUnit.module("Views", (hooks) => {
             assert.verifySteps([
                 "get_views",
                 "web_read_group",
-                "web_search_read",
-                "web_search_read",
+                "unity_web_search_read",
+                "unity_web_search_read",
             ]);
             assert.deepEqual(
                 [...target.querySelectorAll(".o_kanban_record")].map((el) => el.innerText),
@@ -13241,7 +13200,7 @@ QUnit.module("Views", (hooks) => {
             prom.resolve();
             await nextTick();
 
-            assert.verifySteps(["write", "read", "/web/dataset/resequence", "read"]);
+            assert.verifySteps(["write", "/web/dataset/resequence", "read"]);
             assert.deepEqual(
                 [...target.querySelectorAll(".o_kanban_record")].map((el) => el.innerText),
                 ["hello", "hello", "hello", "xmo"]
@@ -13272,18 +13231,23 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("rerenders only once after resequencing records", async (assert) => {
-        // actually it's not once, but twice, because we must render directly after
-        // the drag&drop s.t. the dropped record remains where it has been dropped,
-        // and once again after the reload
+        let renderCount = 0;
+        let def;
         class MyField extends Component {
             setup() {
-                this.renderCount = 0;
-                owl.onWillRender(() => this.renderCount++);
+                owl.onWillRender(() => {
+                    renderCount++;
+                });
+            }
+            get renderCount() {
+                return renderCount;
             }
         }
         MyField.template = xml`<span t-esc="renderCount"/>`;
         registry.category("fields").add("my_field", { component: MyField });
 
+        serverData.models.partner.onchanges = { product_id: () => {} };
+
         await makeView({
             type: "kanban",
             resModel: "partner",
@@ -13291,6 +13255,7 @@ QUnit.module("Views", (hooks) => {
             arch: `
                 <kanban>
                     <templates>
+                        <field name="product_id"/>
                         <t t-name="kanban-box">
                             <div>
                                 <field name="foo"/>
@@ -13300,37 +13265,63 @@ QUnit.module("Views", (hooks) => {
                     </templates>
                 </kanban>`,
             groupBy: ["product_id"],
+            mockRPC: async (route, { method }) => {
+                if (method === "onchange2") {
+                    await def;
+                }
+            },
         });
 
         assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_kanban_record")), [
             "yop1",
-            "gnap1",
-            "blip1",
-            "blip1",
+            "gnap2",
+            "blip3",
+            "blip4",
         ]);
 
+        def = makeDeferred();
+        await dragAndDrop(
+            ".o_kanban_group:first-child .o_kanban_record",
+            ".o_kanban_group:nth-child(2)"
+        );
+
+        assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_kanban_record")), [
+            "gnap2",
+            "blip3",
+            "blip4",
+            "yop5",
+        ]);
+
+        def.resolve();
+
+        assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_kanban_record")), [
+            "gnap2",
+            "blip3",
+            "blip4",
+            "yop5",
+        ]);
+
+        def = makeDeferred();
+
         await dragAndDrop(
             ".o_kanban_group:first-child .o_kanban_record",
             ".o_kanban_group:nth-child(2)"
         );
 
         assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_kanban_record")), [
-            "gnap3",
             "blip3",
-            "blip3",
-            "yop1", // new instance
+            "blip4",
+            "yop5",
+            "gnap6",
         ]);
 
-        await dragAndDrop(
-            ".o_kanban_group:first-child .o_kanban_record",
-            ".o_kanban_group:nth-child(2)"
-        );
+        def.resolve();
 
         assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_kanban_record")), [
-            "blip5",
-            "blip5",
-            "yop3",
-            "gnap1", // new instance
+            "blip3",
+            "blip4",
+            "yop5",
+            "gnap6",
         ]);
     });
 
diff --git a/addons/web/static/tests/views/list_view_tests.js b/addons/web/static/tests/views/list_view_tests.js
index 7d43d910ad5..c090a0b5357 100644
--- a/addons/web/static/tests/views/list_view_tests.js
+++ b/addons/web/static/tests/views/list_view_tests.js
@@ -16,7 +16,7 @@ import { AutoComplete } from "@web/core/autocomplete/autocomplete";
 import { Many2XAutocomplete } from "@web/views/fields/relational_utils";
 import { textField } from "@web/views/fields/text/text_field";
 import { ListController } from "@web/views/list/list_controller";
-import { DynamicGroupList, DynamicRecordList } from "@web/views/relational_model";
+import { RelationalModel } from "@web/model/relational_model/relational_model";
 import { actionService } from "@web/webclient/actions/action_service";
 import { getPickerApplyButton, getPickerCell } from "../core/datetime/datetime_test_helpers";
 import { makeFakeLocalizationService, makeFakeUserService } from "../helpers/mock_services";
@@ -65,7 +65,6 @@ import {
 } from "../search/helpers";
 import { createWebClient, doAction, loadState } from "../webclient/helpers";
 import { makeView, makeViewInDialog, setupViewRegistries } from "./helpers";
-import { x2ManyCommands } from "@web/core/orm_service";
 
 const fieldRegistry = registry.category("fields");
 const serviceRegistry = registry.category("services");
@@ -1138,11 +1137,11 @@ QUnit.module("Views", (hooks) => {
 
             assert.verifySteps([
                 "get_views",
-                "web_search_read",
+                "unity_web_search_read",
                 "write",
-                "read",
+                "web_read",
                 "toDo",
-                "web_search_read",
+                "unity_web_search_read",
             ]);
         }
     );
@@ -1438,7 +1437,7 @@ QUnit.module("Views", (hooks) => {
         }
     );
 
-    QUnit.test("save a record with an invisible required field ", async function (assert) {
+    QUnit.test("save a record with an invisible required field", async function (assert) {
         serverData.models.foo.fields.foo.required = true;
 
         await makeView({
@@ -1458,14 +1457,14 @@ QUnit.module("Views", (hooks) => {
             },
         });
         assert.containsN(target, ".o_data_row", 4);
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click($(".o_list_button_add:visible").get(0));
         await editInput(target, "[name='int_field'] input", 1);
         await click(target, ".o_list_view");
         assert.containsN(target, ".o_data_row", 5);
         assert.strictEqual(target.querySelector(".o_data_row [name='int_field']").textContent, "1");
-        assert.verifySteps(["onchange", "create", "read"]);
+        assert.verifySteps(["onchange2", "create", "web_read"]);
     });
 
     QUnit.test("multi_edit: edit a required field with an invalid value", async function (assert) {
@@ -1485,7 +1484,7 @@ QUnit.module("Views", (hooks) => {
             },
         });
         assert.containsN(target, ".o_data_row", 4);
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         const rows = target.querySelectorAll(".o_data_row");
         await click(rows[0], ".o_list_record_selector input");
@@ -1672,7 +1671,7 @@ QUnit.module("Views", (hooks) => {
 
             await click($(".o_list_button_add:visible").get(0));
             assert.verifySteps(
-                ["get_views", "web_search_read", "onchange"],
+                ["get_views", "unity_web_search_read", "onchange2"],
                 "no nameget should be done"
             );
         }
@@ -2281,7 +2280,7 @@ QUnit.module("Views", (hooks) => {
                     <field name="date"/>
                 </tree>`,
             mockRPC(route, args) {
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     if (searchReads === 0) {
                         assert.strictEqual(
                             args.kwargs.order,
@@ -2552,9 +2551,9 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
         await click(target.querySelector(".o_data_cell"));
-        assert.verifySteps(["doActionButton type object name a1", "web_search_read"]);
+        assert.verifySteps(["doActionButton type object name a1", "unity_web_search_read"]);
     });
 
     QUnit.test("action/type attributes on tree arch, type='action'", async (assert) => {
@@ -2575,9 +2574,9 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
         await click(target.querySelector(".o_data_cell"));
-        assert.verifySteps(["doActionButton type action name a1", "web_search_read"]);
+        assert.verifySteps(["doActionButton type action name a1", "unity_web_search_read"]);
     });
 
     QUnit.test("editable list view: readonly fields cannot be edited", async function (assert) {
@@ -4212,7 +4211,7 @@ QUnit.module("Views", (hooks) => {
                             }`
                         );
                     }
-                    if (method === "web_search_read") {
+                    if (method === "unity_web_search_read") {
                         assert.step(
                             `web_search_read.order: ${args.kwargs.order || "default order"}`
                         );
@@ -4262,10 +4261,10 @@ QUnit.module("Views", (hooks) => {
                         assert.step(
                             `web_read_group.orderby: ${args.kwargs.orderby || "default order"}`
                         );
+                    }
+                    if (method === "unity_web_search_read") {
                         assert.step(
-                            `web_read_group.expand_orderby: ${
-                                args.kwargs.expand_orderby || "default order"
-                            }`
+                            `web_search_read.orderby: ${args.kwargs.order || "default order"}`
                         );
                     }
                 },
@@ -4276,7 +4275,8 @@ QUnit.module("Views", (hooks) => {
             );
             assert.verifySteps([
                 "web_read_group.orderby: default order",
-                "web_read_group.expand_orderby: default order",
+                "web_search_read.orderby: default order",
+                "web_search_read.orderby: default order",
             ]);
 
             await click(target.querySelector(".o_column_sortable[data-name='foo']"));
@@ -4286,7 +4286,8 @@ QUnit.module("Views", (hooks) => {
             );
             assert.verifySteps([
                 "web_read_group.orderby: default order",
-                "web_read_group.expand_orderby: foo ASC",
+                "web_search_read.orderby: foo ASC",
+                "web_search_read.orderby: foo ASC",
             ]);
         }
     );
@@ -5556,7 +5557,9 @@ QUnit.module("Views", (hooks) => {
         class CautiousController extends listView.Controller {
             get deleteConfirmationDialogProps() {
                 const props = super.deleteConfirmationDialogProps;
-                props.body = markup(`<span class="text-danger">These are the consequences</span><br/>${props.body}`);
+                props.body = markup(
+                    `<span class="text-danger">These are the consequences</span><br/>${props.body}`
+                );
                 return props;
             }
         }
@@ -5680,6 +5683,9 @@ QUnit.module("Views", (hooks) => {
         serverData.models.foo.records.push({ id: 5, bar: true, foo: "xxx" });
         serverData.models.foo.records.push({ id: 6, bar: true, foo: "yyy" });
 
+        patchWithCleanup(session, {
+            active_ids_limit: 4,
+        });
         const list = await makeView({
             type: "list",
             resModel: "foo",
@@ -5693,9 +5699,6 @@ QUnit.module("Views", (hooks) => {
             },
             actionMenus: {},
         });
-        patchWithCleanup(session, {
-            active_ids_limit: 4,
-        });
         patchWithCleanup(list.env.services.notification, {
             add: () => {
                 assert.step("notify");
@@ -5748,7 +5751,7 @@ QUnit.module("Views", (hooks) => {
 
         assert.verifySteps([
             "/web/dataset/call_kw/foo/get_views",
-            "/web/dataset/call_kw/foo/web_search_read",
+            "/web/dataset/call_kw/foo/unity_web_search_read",
         ]);
         await toggleActionMenu(target);
         await toggleMenuItem(target, "Archive");
@@ -5777,7 +5780,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, "tbody td.o_list_record_selector", 3, "should have 3 records");
         assert.verifySteps([
             "/web/dataset/call_kw/foo/action_archive",
-            "/web/dataset/call_kw/foo/web_search_read",
+            "/web/dataset/call_kw/foo/unity_web_search_read",
         ]);
     });
 
@@ -5835,6 +5838,9 @@ QUnit.module("Views", (hooks) => {
         serverData.models.foo.records.push({ id: 5, bar: true, foo: "xxx" });
         serverData.models.foo.records.push({ id: 6, bar: true, foo: "yyy" });
 
+        patchWithCleanup(session, {
+            active_ids_limit: 4,
+        });
         const list = await makeView({
             type: "list",
             resModel: "foo",
@@ -5849,9 +5855,6 @@ QUnit.module("Views", (hooks) => {
             actionMenus: {},
         });
 
-        patchWithCleanup(session, {
-            active_ids_limit: 4,
-        });
         patchWithCleanup(list.env.services.notification, {
             add: () => {
                 assert.step("notify");
@@ -6110,7 +6113,7 @@ QUnit.module("Views", (hooks) => {
                     <filter name="bar" string="bar" context="{'group_by': 'bar'}"/>
                 </search>`,
             mockRPC(route, args) {
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(args.kwargs.limit, 80, "default limit should be 80 in List");
                 }
             },
@@ -6124,7 +6127,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("pager, ungrouped, with count limit reached", async function (assert) {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
 
         let expectedCountLimit = 4;
         await makeView({
@@ -6134,7 +6137,7 @@ QUnit.module("Views", (hooks) => {
             arch: '<tree limit="2"><field name="foo"/><field name="bar"/></tree>',
             mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(args.kwargs.count_limit, expectedCountLimit);
                 }
             },
@@ -6143,7 +6146,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click(target.querySelector(".o_pager_limit"));
         assert.containsN(target, ".o_data_row", 2);
@@ -6153,11 +6156,11 @@ QUnit.module("Views", (hooks) => {
 
         expectedCountLimit = undefined;
         await click(target.querySelector(".o_pager_next"));
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
     });
 
     QUnit.test("pager, ungrouped, with count limit reached, click next", async function (assert) {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
 
         let expectedCountLimit = 4;
         await makeView({
@@ -6167,7 +6170,7 @@ QUnit.module("Views", (hooks) => {
             arch: '<tree limit="2"><field name="foo"/><field name="bar"/></tree>',
             mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(args.kwargs.count_limit, expectedCountLimit);
                 }
             },
@@ -6176,18 +6179,18 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         expectedCountLimit = 5;
         await click(target.querySelector(".o_pager_next"));
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "3-4");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "4");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
     });
 
     QUnit.test("pager, ungrouped, with count limit reached, click next (2)", async (assert) => {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
         serverData.models.foo.records.push({ id: 5, bar: true, foo: "xxx" });
 
         let expectedCountLimit = 4;
@@ -6198,7 +6201,7 @@ QUnit.module("Views", (hooks) => {
             arch: '<tree limit="2"><field name="foo"/><field name="bar"/></tree>',
             mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(args.kwargs.count_limit, expectedCountLimit);
                 }
             },
@@ -6207,25 +6210,25 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         expectedCountLimit = 5;
         await click(target.querySelector(".o_pager_next"));
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "3-4");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "4+");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
 
         expectedCountLimit = 7;
         await click(target.querySelector(".o_pager_next"));
         assert.containsOnce(target, ".o_data_row");
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "5-5");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "5");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
     });
 
     QUnit.test("pager, ungrouped, with count limit reached, click previous", async (assert) => {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
         serverData.models.foo.records.push({ id: 5, bar: true, foo: "xxx" });
 
         let expectedCountLimit = 4;
@@ -6236,7 +6239,7 @@ QUnit.module("Views", (hooks) => {
             arch: '<tree limit="2"><field name="foo"/><field name="bar"/></tree>',
             mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(args.kwargs.count_limit, expectedCountLimit);
                 }
             },
@@ -6245,18 +6248,18 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         expectedCountLimit = undefined;
         await click(target.querySelector(".o_pager_previous"));
         assert.containsOnce(target, ".o_data_row");
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "5-5");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "5");
-        assert.verifySteps(["search_count", "web_search_read"]);
+        assert.verifySteps(["search_count", "unity_web_search_read"]);
     });
 
     QUnit.test("pager, ungrouped, with count limit reached, edit pager", async (assert) => {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
         serverData.models.foo.records.push({ id: 5, bar: true, foo: "xxx" });
 
         let expectedCountLimit = 4;
@@ -6267,7 +6270,7 @@ QUnit.module("Views", (hooks) => {
             arch: '<tree limit="2"><field name="foo"/><field name="bar"/></tree>',
             mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(args.kwargs.count_limit, expectedCountLimit);
                 }
             },
@@ -6276,7 +6279,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         expectedCountLimit = 5;
         await click(target, ".o_pager_value");
@@ -6284,7 +6287,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 3);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "2-4");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "4+");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
 
         expectedCountLimit = 15;
         await click(target, ".o_pager_value");
@@ -6292,11 +6295,11 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 4);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "2-5");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "5");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
     });
 
     QUnit.test("pager, ungrouped, with count equals count limit", async function (assert) {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 4 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 4 });
 
         await makeView({
             type: "list",
@@ -6311,11 +6314,11 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "4");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
     });
 
     QUnit.test("pager, ungrouped, reload while fetching count", async function (assert) {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
 
         const def = makeDeferred();
         await makeView({
@@ -6334,7 +6337,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click(target.querySelector(".o_pager_limit"));
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
@@ -6344,7 +6347,7 @@ QUnit.module("Views", (hooks) => {
         await reloadListView(target);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
 
         def.resolve();
         await nextTick();
@@ -6354,7 +6357,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("pager, ungrouped, next and fetch count simultaneously", async function (assert) {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 5 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 5 });
         serverData.models.foo.records.push({ id: 11, foo: "r11", bar: true });
         serverData.models.foo.records.push({ id: 12, foo: "r12", bar: true });
         serverData.models.foo.records.push({ id: 13, foo: "r13", bar: true });
@@ -6367,7 +6370,7 @@ QUnit.module("Views", (hooks) => {
             arch: '<tree limit="2"><field name="foo"/><field name="bar"/></tree>',
             async mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     await def;
                 }
             },
@@ -6376,7 +6379,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "5+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         def = makeDeferred();
         await click(target.querySelector(".o_pager_next")); // this request will be pending
@@ -6384,7 +6387,7 @@ QUnit.module("Views", (hooks) => {
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "5+");
         // can't fetch count simultaneously as it is temporarily disabled while updating
         assert.hasClass(target.querySelector(".o_pager_limit"), "disabled");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
 
         def.resolve();
         await nextTick();
@@ -6392,7 +6395,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("pager, grouped, with groups count limit reached", async function (assert) {
-        patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+        patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
         serverData.models.foo.records.push({ id: 398, foo: "ozfijz" }); // to have 4 groups
 
         await makeView({
@@ -6454,7 +6457,7 @@ QUnit.module("Views", (hooks) => {
             arch: '<tree limit="2" count_limit="3"><field name="foo"/><field name="bar"/></tree>',
             mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(args.kwargs.count_limit, expectedCountLimit);
                 }
             },
@@ -6463,7 +6466,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, ".o_data_row", 2);
         assert.strictEqual(target.querySelector(".o_pager_value").innerText, "1-2");
         assert.strictEqual(target.querySelector(".o_pager_limit").innerText, "3+");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         await click(target.querySelector(".o_pager_limit"));
         assert.containsN(target, ".o_data_row", 2);
@@ -6473,13 +6476,13 @@ QUnit.module("Views", (hooks) => {
 
         expectedCountLimit = undefined;
         await click(target.querySelector(".o_pager_next"));
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
     });
 
     QUnit.test(
         "pager, grouped, pager limit should be based on the group's count",
         async function (assert) {
-            patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+            patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
             serverData.models.foo.records = [
                 { id: 121, foo: "blip" },
                 { id: 122, foo: "blip" },
@@ -6508,7 +6511,7 @@ QUnit.module("Views", (hooks) => {
     QUnit.test(
         "pager, grouped, group pager should update after removing a filter",
         async function (assert) {
-            patchWithCleanup(DynamicRecordList, { WEB_SEARCH_READ_COUNT_LIMIT: 3 });
+            patchWithCleanup(RelationalModel, { DEFAULT_COUNT_LIMIT: 3 });
             serverData.models.foo.records = [
                 { id: 121, foo: "aaa" },
                 { id: 122, foo: "blip" },
@@ -6552,7 +6555,7 @@ QUnit.module("Views", (hooks) => {
         "grouped, show only limited records when the list view is initially expanded",
         async function (assert) {
             const forcedDefaultLimit = 3;
-            patchWithCleanup(DynamicGroupList, { DEFAULT_LIMIT: forcedDefaultLimit });
+            patchWithCleanup(RelationalModel, { DEFAULT_LIMIT: forcedDefaultLimit });
 
             serverData.models.foo.records = [
                 { id: 121, foo: "blip" },
@@ -6587,7 +6590,7 @@ QUnit.module("Views", (hooks) => {
 
         const offsets = [0, 1, 1];
         const mockRPC = async (route, args) => {
-            if (args.method === "web_search_read") {
+            if (args.method === "unity_web_search_read") {
                 assert.strictEqual(args.kwargs.offset, offsets.shift());
             }
         };
@@ -6668,8 +6671,8 @@ QUnit.module("Views", (hooks) => {
             resModel: "foo",
             serverData,
             arch: '<tree><field name="foo"/><field name="bar"/></tree>',
-            mockRPC(route) {
-                if (route === "/web/dataset/call_kw/foo/web_search_read") {
+            mockRPC(route, args) {
+                if (args.method === "unity_web_search_read") {
                     nbSearchRead++;
                 }
             },
@@ -6719,8 +6722,8 @@ QUnit.module("Views", (hooks) => {
             resModel: "foo",
             serverData,
             arch: '<tree><field name="foo" nolabel="1"/><field name="int_field"/></tree>',
-            mockRPC(route) {
-                if (route === "/web/dataset/call_kw/foo/web_search_read") {
+            mockRPC(route, args) {
+                if (args.method === "unity_web_search_read") {
                     nbSearchRead++;
                 }
             },
@@ -6747,7 +6750,7 @@ QUnit.module("Views", (hooks) => {
             serverData,
             arch: '<tree default_order="foo"><field name="foo"/><field name="bar"/></tree>',
             mockRPC(route, args) {
-                if (route === "/web/dataset/call_kw/foo/web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(
                         args.kwargs.order,
                         "foo ASC",
@@ -6779,7 +6782,7 @@ QUnit.module("Views", (hooks) => {
                 '<field name="foo"/><field name="bar"/>' +
                 "</tree>",
             mockRPC(route, args) {
-                if (route === "/web/dataset/call_kw/foo/web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(
                         args.kwargs.order,
                         "foo ASC, bar DESC, int_field ASC",
@@ -7000,7 +7003,7 @@ QUnit.module("Views", (hooks) => {
                 assert.step(args.method);
             },
         });
-        assert.verifySteps(["get_views", "web_search_read"], "should have done 1 web_search_read");
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
         assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_data_cell")), [
             "2 records",
             "3 records",
@@ -7787,7 +7790,7 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
         assert.containsOnce(
             target,
             "thead th:not(.o_list_record_selector)",
@@ -7805,7 +7808,7 @@ QUnit.module("Views", (hooks) => {
             "there should be no button in the header"
         );
         await click(target, ".o_group_header:first-child");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
         assert.containsOnce(target, ".o_group_header button");
 
         await click(target, ".o_group_header:first-child button");
@@ -7838,7 +7841,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("groupby node with a button with modifiers", async function (assert) {
-        assert.expect(15);
+        assert.expect(16);
         await makeView({
             type: "list",
             resModel: "foo",
@@ -7853,24 +7856,25 @@ QUnit.module("Views", (hooks) => {
                 </tree>`,
             mockRPC(route, args) {
                 assert.step(args.method || route);
-                if (args.method === "read" && args.model === "res_currency") {
-                    assert.deepEqual(args.args, [[1, 2], ["position"]]);
+                if (args.method === "web_read" && args.model === "res_currency") {
+                    assert.deepEqual(args.args, [[1, 2]]);
+                    assert.deepEqual(args.kwargs.specification, { position: {} });
                 }
             },
             groupBy: ["currency_id"],
         });
 
-        assert.verifySteps(["get_views", "web_read_group", "read"]);
+        assert.verifySteps(["get_views", "web_read_group", "web_read"]);
         assert.containsNone(target, ".o_group_header button");
         assert.containsNone(target, ".o_data_row");
 
         await click(target, ".o_group_header:nth-child(2)");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
         assert.containsNone(target, ".o_group_header button");
         assert.containsN(target, ".o_data_row", 1);
 
         await click(target, ".o_group_header:first-child");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
         assert.containsOnce(target, ".o_group_header button");
         assert.containsN(target, ".o_data_row", 4);
     });
@@ -7906,7 +7910,13 @@ QUnit.module("Views", (hooks) => {
             assert.containsOnce(groupHeaders[0], "button");
             assert.containsNone(groupHeaders[1], "button");
 
-            assert.verifySteps(["get_views", "web_read_group", "read"]);
+            assert.verifySteps([
+                "get_views",
+                "web_read_group",
+                "unity_web_search_read",
+                "unity_web_search_read",
+                "web_read",
+            ]);
         }
     );
 
@@ -8011,7 +8021,8 @@ QUnit.module("Views", (hooks) => {
             type: "list",
             resModel: "foo",
             serverData,
-            arch: `<tree editable="bottom" expand="1">
+            arch: `
+                <tree editable="bottom" expand="1">
                     <field name="foo"/>
                     <field name="currency_id"/>
                     <groupby name="currency_id">
@@ -8020,12 +8031,16 @@ QUnit.module("Views", (hooks) => {
                 </tree>`,
             groupBy: ["currency_id"],
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.deepEqual(
                         args.args[3],
                         {
-                            foo: "1",
-                            currency_id: "",
+                            currency_id: {
+                                fields: {
+                                    display_name: {},
+                                },
+                            },
+                            foo: {},
                         },
                         "onchange spec should not follow relation of many2one fields"
                     );
@@ -8373,8 +8388,8 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps(
             [
                 "/web/dataset/call_kw/foo/get_views",
-                "/web/dataset/call_kw/foo/web_search_read",
-                "/web/dataset/call_kw/foo/web_search_read",
+                "/web/dataset/call_kw/foo/unity_web_search_read",
+                "/web/dataset/call_kw/foo/unity_web_search_read",
             ],
             "should have reloaded the view (after the action is complete)"
         );
@@ -8541,7 +8556,7 @@ QUnit.module("Views", (hooks) => {
                         );
                     }
                     nbRPCs.readGroup++;
-                } else if (args.method === "web_search_read") {
+                } else if (args.method === "unity_web_search_read") {
                     // called twice (once when opening the group, once when sorting)
                     assert.deepEqual(
                         args.kwargs.domain,
@@ -8997,7 +9012,6 @@ QUnit.module("Views", (hooks) => {
             serverData.models.foo.onchanges = {
                 o2m: function (obj) {
                     obj.o2m = [
-                        [5],
                         [1, 1, { display_name: "Value 1", stage: "open" }],
                         [1, 2, { display_name: "Value 2", stage: "draft" }],
                     ];
@@ -9135,7 +9149,7 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
         assert.containsN(target, "tr.o_data_row", 4);
 
         // click on 3rd line
@@ -9161,7 +9175,7 @@ QUnit.module("Views", (hooks) => {
         assert.containsN(target, "tr.o_data_row", 5);
         assert.hasClass(target.querySelector("tr.o_data_row:nth-child(5)"), "o_selected_row");
 
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
     });
 
     QUnit.test("pressing tab on last cell of editable list view", async function (assert) {
@@ -9207,10 +9221,10 @@ QUnit.module("Views", (hooks) => {
 
         assert.verifySteps([
             "/web/dataset/call_kw/foo/get_views",
-            "/web/dataset/call_kw/foo/web_search_read",
+            "/web/dataset/call_kw/foo/unity_web_search_read",
             "/web/dataset/call_kw/foo/write",
-            "/web/dataset/call_kw/foo/read",
-            "/web/dataset/call_kw/foo/onchange",
+            "/web/dataset/call_kw/foo/web_read",
+            "/web/dataset/call_kw/foo/onchange2",
         ]);
     });
 
@@ -9226,12 +9240,12 @@ QUnit.module("Views", (hooks) => {
             mockRPC(route, args, performRPC) {
                 assert.step(args.method);
                 const result = performRPC(route, args);
-                if (args.method === "read") {
+                if (args.method === "web_read") {
                     return readPromise.then(function () {
                         return result;
                     });
                 }
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     return onchangeGetPromise.then(function () {
                         return result;
                     });
@@ -9270,7 +9284,13 @@ QUnit.module("Views", (hooks) => {
             "5th row should be selected"
         );
 
-        assert.verifySteps(["get_views", "web_search_read", "write", "read", "onchange"]);
+        assert.verifySteps([
+            "get_views",
+            "unity_web_search_read",
+            "write",
+            "web_read",
+            "onchange2",
+        ]);
     });
 
     QUnit.test("display toolbar", async function (assert) {
@@ -9349,9 +9369,9 @@ QUnit.module("Views", (hooks) => {
 
         assert.verifySteps([
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
             `{"action_id":44,"context":{"lang":"en","uid":7,"tz":"taht","active_id":1,"active_ids":[1,2,3,4],"active_model":"foo","active_domain":[]}}`,
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -9881,7 +9901,7 @@ QUnit.module("Views", (hooks) => {
                 1,
                 "should have the new value visible in dom"
             );
-            assert.verifySteps(["get_views", "web_search_read", "write", "read"]);
+            assert.verifySteps(["get_views", "unity_web_search_read", "write", "web_read"]);
         }
     );
 
@@ -9921,7 +9941,7 @@ QUnit.module("Views", (hooks) => {
                         </group>
                     </form>`,
                 mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         assert.step(`onchange:${args.model}`);
                     }
                 },
@@ -10865,7 +10885,7 @@ QUnit.module("Views", (hooks) => {
             arch: '<tree editable="top"><field name="m2o" required="1"/></tree>',
             mockRPC: async function (route, args, performRPC) {
                 const result = await performRPC(route, args);
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     await prom;
                 }
                 return result;
@@ -10895,17 +10915,8 @@ QUnit.module("Views", (hooks) => {
             resModel: "foo",
             serverData,
             arch: '<tree><field name="reference"/></tree>',
-            mockRPC(route, args) {
-                if (args.method === "read") {
-                    assert.step(args.model);
-                }
-            },
         });
 
-        assert.verifySteps(
-            ["bar", "res_currency"],
-            "should have done 1 read by model in reference values"
-        );
         assert.strictEqual(
             $(target).find("tbody td:not(.o_list_record_selector)").text(),
             "Value 1USDEUREUR",
@@ -10914,7 +10925,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("reference field batched in grouped list", async function (assert) {
-        assert.expect(9);
+        assert.expect(7);
 
         serverData.models.foo.records = [
             // group 1
@@ -10937,21 +10948,14 @@ QUnit.module("Views", (hooks) => {
             groupBy: ["foo"],
             mockRPC(route, args) {
                 assert.step(args.method || route);
-                if (
-                    args.method === "read" &&
-                    args.args[1].length === 1 &&
-                    args.args[1][0] === "display_name"
-                ) {
-                    if (args.model === "bar") {
-                        assert.deepEqual(args.args[0], [1, 2, 3]);
-                    }
-                    if (args.model === "res_currency") {
-                        assert.deepEqual(args.args[0], [1]);
-                    }
-                }
             },
         });
-        assert.verifySteps(["get_views", "web_read_group", "read", "read"]);
+        assert.verifySteps([
+            "get_views",
+            "web_read_group",
+            "unity_web_search_read",
+            "unity_web_search_read",
+        ]);
         assert.containsN(target, ".o_group_header", 2);
         const allNames = Array.from(
             target.querySelectorAll(".o_data_cell"),
@@ -10997,7 +11001,7 @@ QUnit.module("Views", (hooks) => {
     });
 
     QUnit.test("multi edit reference field batched in grouped list", async function (assert) {
-        assert.expect(19);
+        assert.expect(13);
 
         serverData.models.foo.records = [
             // group 1
@@ -11009,7 +11013,6 @@ QUnit.module("Views", (hooks) => {
             { id: 5, foo: "2", reference: "bar,3" },
         ];
         // Field boolean_toggle just to simplify the test flow
-        let nameGetCount = 0;
         await makeView({
             type: "list",
             resModel: "foo",
@@ -11026,25 +11029,15 @@ QUnit.module("Views", (hooks) => {
                 if (args.method === "write") {
                     assert.deepEqual(args.args, [[1, 2, 3], { bar: true }]);
                 }
-                if (
-                    args.method === "read" &&
-                    args.args[1].length === 1 &&
-                    args.args[1][0] === "display_name"
-                ) {
-                    if (nameGetCount === 2) {
-                        assert.strictEqual(args.model, "bar");
-                        assert.deepEqual(args.args[0], [1, 2]);
-                    }
-                    if (nameGetCount === 3) {
-                        assert.strictEqual(args.model, "res_currency");
-                        assert.deepEqual(args.args[0], [1]);
-                    }
-                    nameGetCount++;
-                }
             },
         });
 
-        assert.verifySteps(["get_views", "web_read_group", "read", "read"]);
+        assert.verifySteps([
+            "get_views",
+            "web_read_group",
+            "unity_web_search_read",
+            "unity_web_search_read",
+        ]);
         await click(target.querySelectorAll(".o_data_row .o_list_record_selector input")[0]);
         await click(target.querySelectorAll(".o_data_row .o_list_record_selector input")[1]);
         await click(target.querySelectorAll(".o_data_row .o_list_record_selector input")[2]);
@@ -11053,7 +11046,7 @@ QUnit.module("Views", (hooks) => {
 
         await click(target, ".modal .modal-footer .btn-primary");
         assert.containsNone(target, ".modal");
-        assert.verifySteps(["write", "read", "read", "read"]);
+        assert.verifySteps(["write", "web_read"]);
         assert.containsN(target, ".o_group_header", 2);
 
         const allNames = Array.from(target.querySelectorAll(".o_data_cell"))
@@ -11122,7 +11115,7 @@ QUnit.module("Views", (hooks) => {
         const changesTable = document.querySelector(".modal-body .o_modal_changes");
         assert.strictEqual(
             changesTable.innerText.replaceAll("\n", "").replaceAll("\t", ""),
-            "Field:Date StartUpdate to:01/16/2017Field:Date EndUpdate to:02/12/2017"
+            "Field:Date StartUpdate to:01/16/201702/12/2017Field:Date EndUpdate to:02/12/2017"
         );
 
         // Valid the confirm dialog
@@ -11191,7 +11184,7 @@ QUnit.module("Views", (hooks) => {
             const changesTable = target.querySelector(".modal-body .o_modal_changes");
             assert.strictEqual(
                 changesTable.innerText.replaceAll("\n", "").replaceAll("\t", ""),
-                "Field:Date StartUpdate to:04/01/2021"
+                "Field:Date StartUpdate to:04/01/202101/26/2017"
             );
 
             // Valid the confirm dialog
@@ -11293,7 +11286,7 @@ QUnit.module("Views", (hooks) => {
             mockRPC(route, args) {
                 if (
                     route === "/web/dataset/call_kw/foo/write" ||
-                    route === "/web/dataset/call_kw/foo/read"
+                    route === "/web/dataset/call_kw/foo/web_read"
                 ) {
                     const context = args.kwargs.context;
                     assert.strictEqual(context.active_field, 2, "context should be correct");
@@ -11399,8 +11392,6 @@ QUnit.module("Views", (hooks) => {
     );
 
     QUnit.test("editable list view: multi edition", async function (assert) {
-        assert.expect(26);
-
         await makeView({
             type: "list",
             resModel: "foo",
@@ -11418,22 +11409,16 @@ QUnit.module("Views", (hooks) => {
                         [[1, 2], { int_field: 666 }],
                         "should write on multi records"
                     );
-                } else if (args.method === "read") {
+                } else if (args.method === "web_read") {
                     if (args.args[0].length !== 1) {
-                        assert.deepEqual(
-                            args.args,
-                            [
-                                [1, 2],
-                                ["foo", "int_field"],
-                            ],
-                            "should batch the read"
-                        );
+                        assert.deepEqual(args.args, [[1, 2]], "should batch the read");
+                        assert.deepEqual(args.kwargs.specification, { foo: {}, int_field: {} });
                     }
                 }
             },
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         // select two records
         const rows = target.querySelectorAll(".o_data_row");
@@ -11449,13 +11434,13 @@ QUnit.module("Views", (hooks) => {
 
         // create a record and edit its value
         await click($(".o_list_button_add:visible").get(0));
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
 
         await editInput(target, ".o_selected_row [name=int_field] input", 123);
         assert.containsNone(document.body, ".modal");
 
         await clickSave(target);
-        assert.verifySteps(["create", "read"]);
+        assert.verifySteps(["create", "web_read"]);
 
         // edit a field
         await click(rows[0].querySelector("[name=int_field]"));
@@ -11491,7 +11476,7 @@ QUnit.module("Views", (hooks) => {
             ".o_list_record_selector input:checked",
             "no record should be selected anymore"
         );
-        assert.verifySteps(["write", "read"]);
+        assert.verifySteps(["write", "web_read"]);
         assert.strictEqual(
             $(target).find(".o_data_row:eq(0) .o_data_cell").text(),
             "yop666",
@@ -11581,7 +11566,7 @@ QUnit.module("Views", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         // select and edit a single record
         const rows = target.querySelectorAll(".o_data_row");
@@ -11598,8 +11583,7 @@ QUnit.module("Views", (hooks) => {
             ["blip", "9"]
         );
 
-        assert.verifySteps(["write", "read"]);
-
+        assert.verifySteps(["write", "web_read"]);
         // select the second record (the first one is still selected)
         assert.containsNone(target, ".o_list_record_selector input:checked");
         await click(rows[0], ".o_list_record_selector input");
@@ -11620,7 +11604,10 @@ QUnit.module("Views", (hooks) => {
             ["hello", "5"]
         );
 
-        assert.verifySteps(["write", "read"], "should not perform the onchange in multi edition");
+        assert.verifySteps(
+            ["write", "web_read"],
+            "should not perform the onchange in multi edition"
+        );
     });
 
     QUnit.test(
@@ -11780,7 +11767,7 @@ QUnit.module("Views", (hooks) => {
                     if (args.method === "write") {
                         assert.deepEqual(
                             args.args,
-                            [[1, 2, 3, 4], { m2o: 1 }],
+                            [[1, 2, 3, 4], { m2o: 2 }],
                             "should force write value on all selected records"
                         );
                     }
@@ -11797,14 +11784,14 @@ QUnit.module("Views", (hooks) => {
 
             // set m2o to 1 in first record
             await click(target.querySelector(".o_data_row .o_data_cell"));
-            await editInput(target, ".o_data_row [name=m2o] input", "Value 1");
+            await editInput(target, ".o_data_row [name=m2o] input", "Value 2");
             await click(target.querySelector(".o-autocomplete--dropdown-item"));
             assert.containsOnce(target, ".modal");
 
             await click(target, ".modal .modal-footer .btn-primary");
             assert.strictEqual(
                 $(target).find(".o_list_many2one").text(),
-                "Value 1Value 1Value 1Value 1"
+                "Value 2Value 2Value 2Value 2"
             );
         }
     );
@@ -11890,7 +11877,7 @@ QUnit.module("Views", (hooks) => {
                 "gnap",
                 "blip",
             ]);
-            assert.verifySteps(["get_views", "web_search_read", "write", "read"]);
+            assert.verifySteps(["get_views", "unity_web_search_read", "write", "web_read"]);
         }
     );
 
@@ -12017,7 +12004,7 @@ QUnit.module("Views", (hooks) => {
                 },
             });
 
-            assert.verifySteps(["get_views", "web_search_read"]);
+            assert.verifySteps(["get_views", "unity_web_search_read"]);
             // select two records
             const rows = target.querySelectorAll(".o_data_row");
             await click(rows[0], ".o_list_record_selector input");
@@ -12029,7 +12016,7 @@ QUnit.module("Views", (hooks) => {
                 "Modal should ask to save changes"
             );
             await click(target, ".modal .btn-primary");
-            assert.verifySteps(["write", "read"]);
+            assert.verifySteps(["write", "web_read"]);
         }
     );
 
@@ -12461,7 +12448,7 @@ QUnit.module("Views", (hooks) => {
         }
     );
 
-    QUnit.test("editable readonly list view: multi edition", async function (assert) {
+    QUnit.test("non editable list view: multi edition", async function (assert) {
         await makeView({
             type: "list",
             arch: `
@@ -12478,23 +12465,17 @@ QUnit.module("Views", (hooks) => {
                         [[1, 2], { int_field: 666 }],
                         "should write on multi records"
                     );
-                } else if (args.method === "read") {
+                } else if (args.method === "web_read") {
                     if (args.args[0].length !== 1) {
-                        assert.deepEqual(
-                            args.args,
-                            [
-                                [1, 2],
-                                ["foo", "int_field"],
-                            ],
-                            "should batch the read"
-                        );
+                        assert.deepEqual(args.args, [[1, 2]], "should batch the read");
+                        assert.deepEqual(args.kwargs.specification, { foo: {}, int_field: {} });
                     }
                 }
             },
             resModel: "foo",
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         // select two records
         const rows = target.querySelectorAll(".o_data_row");
@@ -12523,7 +12504,7 @@ QUnit.module("Views", (hooks) => {
         );
 
         await click(target, ".modal .btn-primary");
-        assert.verifySteps(["write", "read"]);
+        assert.verifySteps(["write", "web_read"]);
         assert.strictEqual(
             $(target).find(".o_data_row:eq(0) .o_data_cell").text(),
             "yop666",
@@ -12882,7 +12863,7 @@ QUnit.module("Views", (hooks) => {
             serverData,
             arch: '<tree limit="2"><field name="foo"/></tree>',
             mockRPC(route, args) {
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     assert.strictEqual(args.kwargs.limit, 2, "should use the correct limit value");
                 }
             },
@@ -12901,7 +12882,7 @@ QUnit.module("Views", (hooks) => {
             serverData,
             arch: '<tree><field name="foo"/></tree>',
             mockRPC: async function (route, args) {
-                if (args.method === "web_search_read" && blockSearchRead) {
+                if (args.method === "unity_web_search_read" && blockSearchRead) {
                     await def;
                 }
             },
@@ -12965,7 +12946,7 @@ QUnit.module("Views", (hooks) => {
                 serverData,
                 arch: '<tree limit="3"><field name="display_name"/></tree>',
                 mockRPC(route, args) {
-                    if (checkSearchRead && args.method === "web_search_read") {
+                    if (checkSearchRead && args.method === "unity_web_search_read") {
                         assert.strictEqual(args.kwargs.limit, 3, "limit should 3");
                         assert.notOk(
                             args.kwargs.offset,
@@ -13010,7 +12991,7 @@ QUnit.module("Views", (hooks) => {
                 serverData,
                 arch: '<tree limit="2"><field name="display_name"/></tree>',
                 mockRPC(route, args) {
-                    if (checkSearchRead && args.method === "web_search_read") {
+                    if (checkSearchRead && args.method === "unity_web_search_read") {
                         assert.strictEqual(args.kwargs.limit, 2, "limit should 2");
                         assert.notOk(
                             args.kwargs.offset,
@@ -13409,7 +13390,9 @@ QUnit.module("Views", (hooks) => {
 
         assert.verifySteps([
             "get_views",
-            "web_read_group", // records are fetched alongside groups
+            "web_read_group",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -14115,14 +14098,14 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
             "write",
-            "read",
-            "onchange",
+            "web_read",
+            "onchange2",
             "create",
-            "read",
-            "onchange",
+            "web_read",
+            "onchange2",
         ]);
     });
 
@@ -14164,7 +14147,13 @@ QUnit.module("Views", (hooks) => {
                 secondDataRow.querySelector(".o_selected_row [name=foo] input")
             );
 
-            assert.verifySteps(["get_views", "web_read_group", "web_search_read", "write", "read"]);
+            assert.verifySteps([
+                "get_views",
+                "web_read_group",
+                "unity_web_search_read",
+                "write",
+                "web_read",
+            ]);
         }
     );
 
@@ -14205,9 +14194,9 @@ QUnit.module("Views", (hooks) => {
         assert.verifySteps([
             "get_views",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
-            "onchange",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "onchange2",
         ]);
     });
 
@@ -14244,7 +14233,12 @@ QUnit.module("Views", (hooks) => {
 
         assert.hasClass(target.querySelectorAll(".o_data_row")[2], "o_selected_row");
 
-        assert.verifySteps(["get_views", "web_read_group", "web_search_read", "web_search_read"]);
+        assert.verifySteps([
+            "get_views",
+            "web_read_group",
+            "unity_web_search_read",
+            "unity_web_search_read",
+        ]);
     });
 
     QUnit.test(
@@ -14272,7 +14266,7 @@ QUnit.module("Views", (hooks) => {
             await click(secondGroupHeader);
             assert.containsN(target, ".o_data_row", 4);
             assert.containsNone(target, ".o_selected_row");
-            assert.verifySteps(["web_search_read", "web_search_read"]);
+            assert.verifySteps(["unity_web_search_read", "unity_web_search_read"]);
 
             // Click on first data row
             const dataRows = [...target.querySelectorAll(".o_data_row")];
@@ -15558,7 +15552,7 @@ QUnit.module("Views", (hooks) => {
                 </tree>`,
             groupBy: ["priority"],
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.step(args.kwargs.context.default_priority.toString());
                 }
             },
@@ -15598,7 +15592,7 @@ QUnit.module("Views", (hooks) => {
                 </tree>`,
             groupBy: ["m2o"],
             mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.step(args.kwargs.context.default_m2o.toString());
                 }
             },
@@ -16985,7 +16979,7 @@ QUnit.module("Views", (hooks) => {
                         <field name="int_field"/>
                     </tree>`,
                 mockRPC(route, { args, method, model }) {
-                    if (model === "foo" && method === "onchange") {
+                    if (model === "foo" && method === "onchange2") {
                         return def;
                     }
                     if (model === "foo" && method === "write") {
@@ -17021,7 +17015,7 @@ QUnit.module("Views", (hooks) => {
                     <field name="int_field"/>
                 </tree>`,
             mockRPC(route, { args, method, model }) {
-                if (model === "foo" && method === "onchange") {
+                if (model === "foo" && method === "onchange2") {
                     return def;
                 }
                 if (model === "foo" && method === "write") {
@@ -17076,7 +17070,7 @@ QUnit.module("Views", (hooks) => {
                         </group>
                     </form>`,
                 mockRPC(route, args) {
-                    if (args.method === "onchange") {
+                    if (args.method === "onchange2") {
                         assert.step(`onchange:${args.model}`);
                     }
                 },
@@ -17447,7 +17441,7 @@ QUnit.module("Views", (hooks) => {
             });
 
             assert.strictEqual(target.querySelector("[name=foo] span").innerText, "1");
-            assert.verifySteps(["get_views", "web_search_read"]);
+            assert.verifySteps(["get_views", "unity_web_search_read"]);
         }
     );
 
@@ -17496,19 +17490,19 @@ QUnit.module("Views", (hooks) => {
                 </tree>`,
             async mockRPC(route, args) {
                 assert.step(args.method);
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     await Promise.resolve(def);
                 }
             },
         });
 
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
 
         const value = "14";
         // add a new line
         await click($(".o_list_button_add:visible").get(0));
 
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
 
         // we want to add a delay to simulate an onchange
         def = makeDeferred();
@@ -17521,7 +17515,7 @@ QUnit.module("Views", (hooks) => {
 
         // check that nothing changed before the onchange finished
         assert.strictEqual(target.querySelector("[name=int_field] input").value, value);
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
 
         // unlock onchange
         def.resolve();
@@ -17529,7 +17523,7 @@ QUnit.module("Views", (hooks) => {
 
         // check the current line is added with the correct content
         assert.strictEqual(target.querySelector(".o_data_row [name=int_field]").innerText, value);
-        assert.verifySteps(["create", "read"]);
+        assert.verifySteps(["create", "web_read"]);
     });
 
     QUnit.test("create a record with the correct context", async (assert) => {
@@ -18050,13 +18044,8 @@ QUnit.module("Views", (hooks) => {
                 </tree>
             `,
             mockRPC(_, args) {
-                if (
-                    args.method === "read" &&
-                    args.args[1].length === 1 &&
-                    args.args[1][0] === "display_name"
-                ) {
-                    assert.step("readDisplayName");
-                    assert.deepEqual(args.args[0], [3]);
+                if (args.method === "web_read") {
+                    assert.step(`web_read ${args.args[0]}`);
                 }
             },
         });
@@ -18074,13 +18063,14 @@ QUnit.module("Views", (hooks) => {
 
         await click(target, ".modal .o_data_row:nth-child(3) td[name=display_name]");
 
-        assert.verifySteps(["readDisplayName"]);
+        assert.verifySteps(["web_read 3"]);
 
         await clickSave(target);
         assert.deepEqual(
             [...target.querySelectorAll(".o_data_row td[name=m2o]")].map((el) => el.innerText),
             ["Value 3", "Value 2", "Value 1", "Value 1"]
         );
+        assert.verifySteps(["web_read 1"]);
     });
 
     QUnit.test("view's context is passed down as evalContext", async (assert) => {
@@ -18624,7 +18614,7 @@ QUnit.module("Views", (hooks) => {
             name: "property_many2one",
             string: "Property many2one",
             comodel: "res_currency",
-            domain: [],
+            domain: "[]",
         };
         serverData.models.bar.records[0].definitions = [definition];
         for (const record of serverData.models.foo.records) {
@@ -18683,7 +18673,7 @@ QUnit.module("Views", (hooks) => {
             name: "property_many2many",
             string: "Property many2many",
             comodel: "res_currency",
-            domain: [],
+            domain: "[]",
         };
         serverData.models.bar.records[0].definitions = [definition];
         for (const record of serverData.models.foo.records) {
@@ -18872,13 +18862,13 @@ QUnit.module("Views", (hooks) => {
 
         assert.verifySteps([
             "/web/dataset/call_kw/foo/get_views",
-            "/web/dataset/call_kw/foo/web_search_read",
+            "/web/dataset/call_kw/foo/unity_web_search_read",
         ]);
 
         await toggleSearchBarMenu(target);
         await toggleMenuItem(target, "only one");
 
-        assert.verifySteps(["/web/dataset/call_kw/foo/web_search_read"]);
+        assert.verifySteps(["/web/dataset/call_kw/foo/unity_web_search_read"]);
     });
 
     QUnit.test("do not reload properties definitions when page change", async (assert) => {
@@ -18911,12 +18901,12 @@ QUnit.module("Views", (hooks) => {
 
         assert.verifySteps([
             "/web/dataset/call_kw/foo/get_views",
-            "/web/dataset/call_kw/foo/web_search_read",
+            "/web/dataset/call_kw/foo/unity_web_search_read",
         ]);
 
         await pagerNext(target);
 
-        assert.verifySteps(["/web/dataset/call_kw/foo/web_search_read"]);
+        assert.verifySteps(["/web/dataset/call_kw/foo/unity_web_search_read"]);
     });
 
     QUnit.test("load properties definitions only once when grouped", async (assert) => {
@@ -18954,7 +18944,7 @@ QUnit.module("Views", (hooks) => {
         ]);
 
         await click(target.querySelector(".o_group_header"));
-        assert.verifySteps(["/web/dataset/call_kw/foo/web_search_read"]);
+        assert.verifySteps(["/web/dataset/call_kw/foo/unity_web_search_read"]);
     });
 
     QUnit.test("Invisible Properties", async (assert) => {
@@ -18986,7 +18976,7 @@ QUnit.module("Views", (hooks) => {
         });
 
         assert.containsNone(target, ".o_optional_columns_dropdown_toggle");
-        assert.verifySteps(["get_views", "web_search_read"]);
+        assert.verifySteps(["get_views", "unity_web_search_read"]);
     });
 
     QUnit.test("header buttons in list view", async function (assert) {
@@ -19050,7 +19040,7 @@ QUnit.module("Views", (hooks) => {
         const webclient = await createWebClient({
             serverData,
             async mockRPC(route, { kwargs, method }) {
-                if (method === "web_search_read") {
+                if (method === "unity_web_search_read") {
                     assert.step("order:" + kwargs.order);
                 }
             },
@@ -19083,7 +19073,7 @@ QUnit.module("Views", (hooks) => {
                     <field name="m2o"/>
                 </tree>`,
             async mockRPC(route, args) {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     assert.step("onchange");
                     await def;
                     return { value: { m2o: [3, "Value 3"] } };
@@ -19118,32 +19108,40 @@ QUnit.module("Views", (hooks) => {
         );
     });
 
-    QUnit.test("list view: prevent record selection when editable list in edit mode", async function (assert) {
-        await makeView({
-            type: "list",
-            resModel: "foo",
-            serverData,
-            arch: `
+    QUnit.test(
+        "list view: prevent record selection when editable list in edit mode",
+        async function (assert) {
+            await makeView({
+                type: "list",
+                resModel: "foo",
+                serverData,
+                arch: `
                 <tree editable="top">
                     <field name="foo" />
                 </tree>`,
-        });
+            });
 
-        //  When we try to select new record in edit mode
-        await click(target.querySelector(".o_control_panel_main_buttons .d-none.d-xl-inline-flex .o_list_button_add"));
-        await click(target.querySelector('.o_data_row .o_list_record_selector'));
-        assert.strictEqual(
-            target.querySelector('.o_data_row .o_list_record_selector input[type="checkbox"]').checked,
-            false
-        );
+            //  When we try to select new record in edit mode
+            await click(
+                target.querySelector(
+                    ".o_control_panel_main_buttons .d-none.d-xl-inline-flex .o_list_button_add"
+                )
+            );
+            await click(target.querySelector(".o_data_row .o_list_record_selector"));
+            assert.strictEqual(
+                target.querySelector('.o_data_row .o_list_record_selector input[type="checkbox"]')
+                    .checked,
+                false
+            );
 
-        //  When we try to select all records in edit mode
-        await click(target.querySelector('th.o_list_record_selector.o_list_controller'));
-        assert.strictEqual(
-            target.querySelector('.o_list_controller input[type="checkbox"]').checked,
-            false
-        );
-    });
+            //  When we try to select all records in edit mode
+            await click(target.querySelector("th.o_list_record_selector.o_list_controller"));
+            assert.strictEqual(
+                target.querySelector('.o_list_controller input[type="checkbox"]').checked,
+                false
+            );
+        }
+    );
 
     QUnit.test("context keys not passed down the stack and not to fields", async (assert) => {
         patchWithCleanup(AutoComplete, {
@@ -19192,8 +19190,7 @@ QUnit.module("Views", (hooks) => {
         await doAction(wc, 1);
         assert.verifySteps([
             `foo: get_views: {"lang":"en","uid":7,"tz":"taht","tree_view_ref":"foo_view_ref","search_default_bar":true}`,
-            `foo: web_search_read: {"lang":"en","uid":7,"tz":"taht","bin_size":true}`,
-            `bar: read: {"lang":"en","uid":7,"tz":"taht","bin_size":true}`,
+            `foo: unity_web_search_read: {"lang":"en","uid":7,"tz":"taht","bin_size":true,"tree_view_ref":"foo_view_ref"}`,
         ]);
 
         await click(target.querySelectorAll(".o_data_row .o_data_cell")[1]);
@@ -19210,7 +19207,7 @@ QUnit.module("Views", (hooks) => {
         await click(items.find((el) => el.textContent.trim() === "View all"));
         assert.verifySteps([
             `bar: get_views: {"lang":"en","uid":7,"tz":"taht"}`,
-            `bar: web_search_read: {"lang":"en","uid":7,"tz":"taht","bin_size":true}`,
+            `bar: unity_web_search_read: {"lang":"en","uid":7,"tz":"taht","bin_size":true}`,
         ]);
         assert.containsOnce(target, ".modal");
         assert.strictEqual(
@@ -19297,38 +19294,4 @@ QUnit.module("Views", (hooks) => {
             "Monetary cells should have ltr direction"
         );
     });
-
-    QUnit.test("multisave take changes into account when there is only one record selected", async function (assert) {
-        const listView = registry.category("views").get("list");
-
-        class CustomListRenderer extends listView.Renderer {
-            onGlobalClick(ev) {
-                const record = this.props.list.selection[0];
-                record.model.root._multiSave(record, {
-                    m2m: [x2ManyCommands.linkTo(1)],
-                });
-            }
-        }
-
-        registry.category("views").add("custom_list", {
-            ...listView,
-            Renderer: CustomListRenderer,
-        }, { force: true });
-
-        await makeView({
-            type: "list",
-            resModel: "foo",
-            serverData,
-            resId: 3,
-            arch: '<tree js_class="custom_list"><field name="foo"/></tree>',
-            mockRPC: (route, { method, args }) => {
-                if (method === "write") {
-                    assert.deepEqual(args[1], { m2m: [[x2ManyCommands.LINK_TO, 1, false]] });
-                }
-            },
-        });
-
-        await click(target.querySelectorAll(".o_data_row .o_list_record_selector input")[0]);
-        await click(target.querySelectorAll(".o_data_row [name=foo]")[0]);
-    });
 });
diff --git a/addons/web/static/tests/views/pivot_view_tests.js b/addons/web/static/tests/views/pivot_view_tests.js
index a0dcea236ae..6bfe6ea4c88 100644
--- a/addons/web/static/tests/views/pivot_view_tests.js
+++ b/addons/web/static/tests/views/pivot_view_tests.js
@@ -4072,8 +4072,8 @@ QUnit.module("Views", (hooks) => {
                     }
                     readGroupCount++;
                 }
-                if (args.method === "web_search_read") {
-                    assert.step("search_read");
+                if (args.method === "unity_web_search_read") {
+                    assert.step("unity_web_search_read");
                     const domain = args.kwargs.domain;
                     assert.deepEqual(
                         domain,
@@ -4107,7 +4107,7 @@ QUnit.module("Views", (hooks) => {
                 "read_group",
                 "read_group",
                 "read_group",
-                "search_read",
+                "unity_web_search_read",
                 "read_group",
                 "read_group",
             ]);
@@ -4742,7 +4742,7 @@ QUnit.module("Views", (hooks) => {
         await legacyExtraNextTick();
 
         assert.containsOnce(target, ".o_list_view");
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
 
         // switch back to pivot
         await click(target.querySelector(".o_control_panel .o_switch_view.o_pivot"));
diff --git a/addons/web/static/tests/views/record_tests.js b/addons/web/static/tests/views/record_tests.js
index aad8b33ec9d..fa5450ef2ce 100644
--- a/addons/web/static/tests/views/record_tests.js
+++ b/addons/web/static/tests/views/record_tests.js
@@ -3,6 +3,7 @@
 import { browser } from "@web/core/browser/browser";
 import { Field } from "@web/views/fields/field";
 import { Many2OneField } from "@web/views/fields/many2one/many2one_field";
+import { Many2ManyTagsField } from "@web/views/fields/many2many_tags/many2many_tags_field";
 import { Record } from "@web/views/record";
 
 import { makeTestEnv } from "@web/../tests/helpers/mock_env";
@@ -10,6 +11,7 @@ import {
     click,
     editInput,
     getFixture,
+    getNodesTextContent,
     mount,
     nextTick,
     patchWithCleanup,
@@ -121,7 +123,7 @@ QUnit.module("Record Component", (hooks) => {
         );
         assert.verifySteps([
             "/web/dataset/call_kw/partner/fields_get",
-            "/web/dataset/call_kw/partner/read",
+            "/web/dataset/call_kw/partner/web_read",
         ]);
     });
 
@@ -137,7 +139,7 @@ QUnit.module("Record Component", (hooks) => {
         Parent.template = xml`
             <Record resModel="'partner'" resId="state.resId" fieldNames="['foo']" t-slot-scope="data">
                 <Field name="'foo'" record="data.record"/>
-                <button t-on-click="() => this.state.resId++">Next</button>
+                <button class="my-btn" t-on-click="() => this.state.resId++">Next</button>
             </Record>`;
         const env = await makeTestEnv({
             serverData,
@@ -148,12 +150,12 @@ QUnit.module("Record Component", (hooks) => {
         await mount(Parent, target, { env, dev: true });
         assert.verifySteps([
             "/web/dataset/call_kw/partner/fields_get",
-            "/web/dataset/call_kw/partner/read",
+            "/web/dataset/call_kw/partner/web_read",
         ]);
         assert.containsOnce(target, ".o_field_char:contains(yop)");
-        await click(target.querySelector("button"));
+        await click(target.querySelector("button.my-btn"));
         assert.containsOnce(target, ".o_field_char:contains(blip)");
-        assert.verifySteps(["/web/dataset/call_kw/partner/read"]);
+        assert.verifySteps(["/web/dataset/call_kw/partner/web_read"]);
     });
 
     QUnit.test("predefined fields and values", async function (assert) {
@@ -215,7 +217,7 @@ QUnit.module("Record Component", (hooks) => {
 
             onRecordChanged(record, changes) {
                 assert.step("record changed");
-                assert.strictEqual(record.model.constructor.name, "RelationalModel");
+                assert.strictEqual(record.model.constructor.name, "StandaloneRelationalModel");
                 assert.deepEqual(changes, { foo: "753" });
             }
         }
@@ -269,10 +271,10 @@ QUnit.module("Record Component", (hooks) => {
         await click(target, "button.save");
         assert.verifySteps([
             "fields_get",
-            "read",
+            "web_read",
             "onWillSaveRecord",
             "write",
-            "read",
+            "web_read",
             "onRecordSaved",
         ]);
     });
@@ -301,7 +303,7 @@ QUnit.module("Record Component", (hooks) => {
                     },
                 };
                 this.values = {
-                    foo: [1, undefined],
+                    foo: [1, "bar1"],
                 };
             }
 
@@ -326,7 +328,7 @@ QUnit.module("Record Component", (hooks) => {
                 },
             }),
         });
-        assert.verifySteps(["/web/dataset/call_kw/bar/read"]);
+        assert.verifySteps([]);
         assert.strictEqual(target.querySelector(".o_field_many2one_selection input").value, "bar1");
         await editInput(target, ".o_field_many2one_selection input", "abc");
         assert.verifySteps(["/web/dataset/call_kw/bar/name_search"]);
@@ -335,6 +337,167 @@ QUnit.module("Record Component", (hooks) => {
         assert.strictEqual(target.querySelector(".o_field_many2one_selection input").value, "abc");
     });
 
+    QUnit.test("handles many2one fields (2)", async function (assert) {
+        patchWithCleanup(browser, {
+            setTimeout: (fn) => fn(),
+        });
+
+        serverData.models = {
+            bar: {
+                records: [
+                    { id: 1, display_name: "bar1" },
+                    { id: 3, display_name: "abc" },
+                ],
+            },
+        };
+
+        class Parent extends Component {
+            setup() {
+                this.fields = {
+                    foo: {
+                        name: "foo",
+                        type: "many2one",
+                        relation: "bar",
+                    },
+                };
+                this.values = {
+                    foo: 1,
+                };
+            }
+
+            onRecordChanged(record, changes) {
+                assert.step("record changed");
+                assert.deepEqual(changes, { foo: 3 });
+                assert.deepEqual(record.data, { foo: [3, "abc"] });
+            }
+        }
+        Parent.components = { Record, Many2OneField };
+        Parent.template = xml`
+            <Record resModel="'partner'" fieldNames="['foo']" fields="fields" values="values" t-slot-scope="data">
+                <Many2OneField name="'foo'" record="data.record" relation="'bar'" value="data.record.data.foo"/>
+            </Record>
+        `;
+
+        await mount(Parent, target, {
+            env: await makeTestEnv({
+                serverData,
+                mockRPC(route, args) {
+                    assert.step(route);
+                },
+            }),
+        });
+        assert.verifySteps(["/web/dataset/call_kw/bar/web_read"]);
+        assert.strictEqual(target.querySelector(".o_field_many2one_selection input").value, "bar1");
+    });
+
+    QUnit.test("handles many2one fields (3)", async function (assert) {
+        patchWithCleanup(browser, {
+            setTimeout: (fn) => fn(),
+        });
+
+        serverData.models = {
+            bar: {
+                records: [
+                    { id: 1, display_name: "bar1" },
+                    { id: 3, display_name: "abc" },
+                ],
+            },
+        };
+
+        class Parent extends Component {
+            setup() {
+                this.fields = {
+                    foo: {
+                        name: "foo",
+                        type: "many2one",
+                        relation: "bar",
+                    },
+                };
+                this.values = {
+                    foo: [1],
+                };
+            }
+
+            onRecordChanged(record, changes) {
+                assert.step("record changed");
+                assert.deepEqual(changes, { foo: 3 });
+                assert.deepEqual(record.data, { foo: [3, "abc"] });
+            }
+        }
+        Parent.components = { Record, Many2OneField };
+        Parent.template = xml`
+            <Record resModel="'partner'" fieldNames="['foo']" fields="fields" values="values" t-slot-scope="data">
+                <Many2OneField name="'foo'" record="data.record" relation="'bar'" value="data.record.data.foo"/>
+            </Record>
+        `;
+
+        await mount(Parent, target, {
+            env: await makeTestEnv({
+                serverData,
+                mockRPC(route, args) {
+                    assert.step(route);
+                },
+            }),
+        });
+        assert.verifySteps(["/web/dataset/call_kw/bar/web_read"]);
+        assert.strictEqual(target.querySelector(".o_field_many2one_selection input").value, "bar1");
+    });
+
+    QUnit.test("handles x2many fields", async function (assert) {
+        serverData.models = {
+            tag: {
+                records: [
+                    { id: 1, display_name: "bug" },
+                    { id: 3, display_name: "ref" },
+                ],
+            },
+        };
+
+        class Parent extends Component {
+            setup() {
+                this.activeFields = {
+                    tags: {
+                        related: {
+                            activeFields: {
+                                display_name: {},
+                            },
+                            fields: {
+                                display_name: { name: "display_name", type: "string" },
+                            },
+                        },
+                    },
+                };
+                this.fields = {
+                    tags: {
+                        name: "Tags",
+                        type: "many2many",
+                        relation: "tag",
+                    },
+                };
+                this.values = {
+                    tags: [1, 3],
+                };
+            }
+        }
+        Parent.components = { Record, Many2ManyTagsField };
+        Parent.template = xml`
+            <Record resModel="'partner'" fieldNames="['tags']" activeFields="activeFields" fields="fields" values="values" t-slot-scope="data">
+                <Many2ManyTagsField name="'tags'" record="data.record"/>
+            </Record>
+        `;
+
+        await mount(Parent, target, {
+            env: await makeTestEnv({
+                serverData,
+                mockRPC(route, args) {
+                    assert.step(route);
+                },
+            }),
+        });
+        assert.verifySteps(["/web/dataset/call_kw/tag/web_read"]);
+        assert.deepEqual(getNodesTextContent(target.querySelectorAll(".o_tag")), ["bug", "ref"]);
+    });
+
     QUnit.test(
         "supports passing dynamic values -- full control to the user of Record",
         async (assert) => {
@@ -358,7 +521,7 @@ QUnit.module("Record Component", (hooks) => {
 
                 onRecordChanged(record, changes) {
                     assert.step("record changed");
-                    assert.strictEqual(record.model.constructor.name, "RelationalModel");
+                    assert.strictEqual(record.model.constructor.name, "StandaloneRelationalModel");
                     assert.deepEqual(changes, { foo: "753" });
                     this.values.foo = "357";
                 }
@@ -374,7 +537,7 @@ QUnit.module("Record Component", (hooks) => {
                 env: await makeTestEnv({
                     serverData,
                     mockRPC(route) {
-                        assert.step(route);
+                        throw new Error("should not do any rpc");
                     },
                 }),
             });
@@ -419,13 +582,17 @@ QUnit.module("Record Component", (hooks) => {
         await mount(Parent, target, {
             env: await makeTestEnv({
                 serverData,
-                mockRPC(route, args) {
-                    assert.step(`${args.method} : ${JSON.stringify(args.args)}`);
+                mockRPC(route, { method, args, kwargs }) {
+                    assert.step(
+                        `${method} : ${JSON.stringify(args[0])} - ${JSON.stringify(
+                            kwargs.specification
+                        )}`
+                    );
                 },
             }),
         });
 
-        assert.verifySteps([`read : [[1],["foo"]]`]);
+        assert.verifySteps([`web_read : [1] - {"foo":{}}`]);
         const increment = target.querySelector("#increment");
         const field = target.querySelector("div[name='foo']");
         assert.strictEqual(increment.textContent, "0");
@@ -438,7 +605,7 @@ QUnit.module("Record Component", (hooks) => {
         assert.strictEqual(field.textContent, "yop");
 
         await click(target.querySelector("#next"));
-        assert.verifySteps([`read : [[5],["foo"]]`]);
+        assert.verifySteps([`web_read : [5] - {"foo":{}}`]);
         assert.strictEqual(increment.textContent, "2");
         assert.strictEqual(field.textContent, "blop");
     });
diff --git a/addons/web/static/tests/views/view_dialogs/form_view_dialog_tests.js b/addons/web/static/tests/views/view_dialogs/form_view_dialog_tests.js
index 4a17446afc7..b2494e24ef2 100644
--- a/addons/web/static/tests/views/view_dialogs/form_view_dialog_tests.js
+++ b/addons/web/static/tests/views/view_dialogs/form_view_dialog_tests.js
@@ -9,10 +9,9 @@ import {
     triggerHotkey,
     makeDeferred,
 } from "@web/../tests/helpers/utils";
-import { makeViewInDialog } from "@web/../tests/views/helpers";
+import { makeViewInDialog, setupViewRegistries } from "@web/../tests/views/helpers";
 import { createWebClient } from "@web/../tests/webclient/helpers";
 import { FormViewDialog } from "@web/views/view_dialogs/form_view_dialog";
-import { setupControlPanelServiceRegistry } from "@web/../tests/search/helpers";
 
 QUnit.module("ViewDialogs", (hooks) => {
     let serverData;
@@ -67,7 +66,7 @@ QUnit.module("ViewDialogs", (hooks) => {
             },
         };
         target = getFixture();
-        setupControlPanelServiceRegistry();
+        setupViewRegistries();
     });
 
     QUnit.module("FormViewDialog");
@@ -277,10 +276,10 @@ QUnit.module("ViewDialogs", (hooks) => {
 
         assert.containsOnce(target, ".o_dialog .o_form_view");
         assert.containsN(target, ".o_dialog .o_form_view button", 2);
-        assert.verifySteps(["/web/webclient/load_menus", "get_views", "read"]);
+        assert.verifySteps(["/web/webclient/load_menus", "get_views", "web_read"]);
         await click(target.querySelector(".o_dialog .o_form_view .btn1"));
         assert.containsOnce(target, ".o_dialog .o_form_view");
-        assert.verifySteps(["method1", "read"]); // should re-read the record
+        assert.verifySteps(["method1", "web_read"]); // should re-read the record
         await click(target.querySelector(".o_dialog .o_form_view .btn2"));
         assert.containsNone(target, ".o_dialog .o_form_view");
         assert.verifySteps(["method2"]); // should not read as we closed
diff --git a/addons/web/static/tests/views/view_dialogs/select_create_dialog_tests.js b/addons/web/static/tests/views/view_dialogs/select_create_dialog_tests.js
index c7a7da43997..9d0c67a974e 100644
--- a/addons/web/static/tests/views/view_dialogs/select_create_dialog_tests.js
+++ b/addons/web/static/tests/views/view_dialogs/select_create_dialog_tests.js
@@ -124,16 +124,13 @@ QUnit.module("ViewDialogs", (hooks) => {
                             fields: ["display_name", "foo", "bar"],
                             groupby: ["bar"],
                             orderby: "",
-                            expand: false,
-                            expand_orderby: null,
-                            expand_limit: null,
                             lazy: true,
                             limit: 80,
                             offset: 0,
                         },
                         "should search with the complete domain (domain + search), and group by 'bar'"
                     );
-                } else if (args.method === "web_search_read") {
+                } else if (args.method === "unity_web_search_read") {
                     if (search === 0) {
                         assert.deepEqual(
                             args.kwargs,
@@ -151,7 +148,7 @@ QUnit.module("ViewDialogs", (hooks) => {
                                     ["display_name", "ilike", "piou"],
                                     ["foo", "ilike", "piou"],
                                 ],
-                                fields: ["display_name", "foo"],
+                                specification: { display_name: {}, foo: {} },
                                 limit: 80,
                                 offset: 0,
                                 order: "",
@@ -170,7 +167,7 @@ QUnit.module("ViewDialogs", (hooks) => {
                                     uid: 7,
                                 }, // not part of the test, may change
                                 domain: [["display_name", "like", "a"]],
-                                fields: ["display_name", "foo"],
+                                specification: { display_name: {}, foo: {} },
                                 limit: 80,
                                 offset: 0,
                                 order: "",
@@ -215,7 +212,7 @@ QUnit.module("ViewDialogs", (hooks) => {
                 `,
         };
         const mockRPC = async (route, args) => {
-            if (args.method === "web_search_read") {
+            if (args.method === "unity_web_search_read") {
                 assert.deepEqual(
                     args.kwargs.domain,
                     [["id", "=", 2]],
@@ -310,11 +307,11 @@ QUnit.module("ViewDialogs", (hooks) => {
                 }
                 if (route === "/web/dataset/call_kw/instrument/create") {
                     assert.deepEqual(
-                        args.args,
+                        args.args[0],
                         [{ badassery: [[6, false, [1]]], name: "ABC" }],
                         "The method create should have been called with the right arguments"
                     );
-                    return Promise.resolve(false);
+                    return Promise.resolve([90]);
                 }
             },
         });
diff --git a/addons/web/static/tests/views/widgets/attach_document_tests.js b/addons/web/static/tests/views/widgets/attach_document_tests.js
index 94846f4f0fa..7244f3fcfe1 100644
--- a/addons/web/static/tests/views/widgets/attach_document_tests.js
+++ b/addons/web/static/tests/views/widgets/attach_document_tests.js
@@ -78,7 +78,7 @@ QUnit.module("Widgets", (hooks) => {
                 if (args.method === "write") {
                     assert.deepEqual(args.args[1], { display_name: "yop" });
                 }
-                if (args.method === "read") {
+                if (args.method === "web_read") {
                     assert.deepEqual(args.args[0], [1]);
                 }
             },
@@ -88,13 +88,13 @@ QUnit.module("Widgets", (hooks) => {
                     <field name="display_name" required="1"/>
                 </form>`,
         });
-        assert.verifySteps(["get_views", "read"]);
+        assert.verifySteps(["get_views", "web_read"]);
 
         await editInput(target, "[name='display_name'] input", "yop");
         await click(target, ".o_attach_document");
         fileInput.dispatchEvent(new Event("change"));
         await nextTick();
-        assert.verifySteps(["write", "read", "post", "my_action", "read"]);
+        assert.verifySteps(["write", "web_read", "post", "my_action", "web_read"]);
     });
 
     QUnit.test(
@@ -133,9 +133,9 @@ QUnit.module("Widgets", (hooks) => {
                         return true;
                     }
                     if (args.method === "create") {
-                        assert.deepEqual(args.args[0], { display_name: "yop" });
+                        assert.deepEqual(args.args[0], [{ display_name: "yop" }]);
                     }
-                    if (args.method === "read") {
+                    if (args.method === "web_read") {
                         assert.deepEqual(args.args[0], [2]);
                     }
                 },
@@ -145,13 +145,13 @@ QUnit.module("Widgets", (hooks) => {
                     <field name="display_name" required="1"/>
                 </form>`,
             });
-            assert.verifySteps(["get_views", "onchange"]);
+            assert.verifySteps(["get_views", "onchange2"]);
 
             await editInput(target, "[name='display_name'] input", "yop");
             await click(target, ".o_attach_document");
             fileInput.dispatchEvent(new Event("change"));
             await nextTick();
-            assert.verifySteps(["create", "read", "post", "my_action", "read"]);
+            assert.verifySteps(["create", "web_read", "post", "my_action", "web_read"]);
         }
     );
 });
diff --git a/addons/web/static/tests/webclient/actions/close_action_tests.js b/addons/web/static/tests/webclient/actions/close_action_tests.js
index f246ee4cde9..e8bb721ad4a 100644
--- a/addons/web/static/tests/webclient/actions/close_action_tests.js
+++ b/addons/web/static/tests/webclient/actions/close_action_tests.js
@@ -203,8 +203,8 @@ QUnit.module("ActionManager", (hooks) => {
         });
 
         const readOnFirstRecordDef = testUtils.makeTestPromise();
-        const mockRPC = (route, args) => {
-            if (args.method === "read" && args.args[0][0] === 1) {
+        const mockRPC = (route, { method, args, kwargs }) => {
+            if (method === "web_read" && args[0][0] === 1) {
                 return readOnFirstRecordDef;
             }
         };
diff --git a/addons/web/static/tests/webclient/actions/concurrency_tests.js b/addons/web/static/tests/webclient/actions/concurrency_tests.js
index 52b9b8aba2a..9e55a1ce7a6 100644
--- a/addons/web/static/tests/webclient/actions/concurrency_tests.js
+++ b/addons/web/static/tests/webclient/actions/concurrency_tests.js
@@ -64,7 +64,7 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/action/load",
             "/web/action/load",
             "/web/dataset/call_kw/pony/get_views",
-            "/web/dataset/call_kw/pony/web_search_read",
+            "/web/dataset/call_kw/pony/unity_web_search_read",
         ]);
     });
 
@@ -74,7 +74,7 @@ QUnit.module("ActionManager", (hooks) => {
         const defs = [Promise.resolve(), def, Promise.resolve()];
         const mockRPC = async function (route, { method }) {
             assert.step(route);
-            if (method === "web_search_read") {
+            if (method === "unity_web_search_read") {
                 await defs.shift();
             }
         };
@@ -90,9 +90,9 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/web_search_read",
-            "/web/dataset/call_kw/partner/web_search_read",
-            "/web/dataset/call_kw/partner/web_search_read",
+            "/web/dataset/call_kw/partner/unity_web_search_read",
+            "/web/dataset/call_kw/partner/unity_web_search_read",
+            "/web/dataset/call_kw/partner/unity_web_search_read",
         ]);
         // we resolve def => list view is now ready (but we want to ignore it)
         def.resolve();
@@ -122,7 +122,7 @@ QUnit.module("ActionManager", (hooks) => {
         assert.expect(1);
         let def;
         const mockRPC = async function (route, args) {
-            if (args && args.method === "read") {
+            if (args && args.method === "web_read") {
                 await def;
             }
         };
@@ -151,7 +151,7 @@ QUnit.module("ActionManager", (hooks) => {
             let def;
             const mockRPC = async function (route, { method, model }) {
                 assert.step(method || route);
-                if (method === "web_search_read" && model === "partner") {
+                if (method === "unity_web_search_read" && model === "partner") {
                     await def;
                 }
             };
@@ -178,11 +178,11 @@ QUnit.module("ActionManager", (hooks) => {
                 "/web/webclient/load_menus",
                 "/web/action/load",
                 "get_views",
-                "read",
-                "web_search_read",
+                "web_read",
+                "unity_web_search_read",
                 "/web/action/load",
                 "get_views",
-                "web_search_read",
+                "unity_web_search_read",
             ]);
             // unblock the switch to Kanban in action 4
             def.resolve();
@@ -227,12 +227,12 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "web_read",
             "object",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
         // unblock the call_button request
         def.resolve();
@@ -261,7 +261,7 @@ QUnit.module("ActionManager", (hooks) => {
             let def;
             const mockRPC = async function (route, args) {
                 assert.step((args && args.method) || route);
-                if (args && args.method === "read") {
+                if (args && args.method === "web_read") {
                     await def;
                 }
             };
@@ -288,11 +288,11 @@ QUnit.module("ActionManager", (hooks) => {
                 "/web/webclient/load_menus",
                 "/web/action/load",
                 "get_views",
-                "web_search_read",
-                "read",
+                "unity_web_search_read",
+                "web_read",
                 "/web/action/load",
                 "get_views",
-                "web_search_read",
+                "unity_web_search_read",
             ]);
             // unblock the switch to the form view in action 3
             def.resolve();
@@ -339,7 +339,7 @@ QUnit.module("ActionManager", (hooks) => {
             "get_views",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -348,7 +348,7 @@ QUnit.module("ActionManager", (hooks) => {
         const def = makeDeferred();
         const mockRPC = async function (route, { method }) {
             assert.step(method || route);
-            if (method === "web_search_read") {
+            if (method === "unity_web_search_read") {
                 await def;
             }
         };
@@ -368,10 +368,10 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -463,10 +463,10 @@ QUnit.module("ActionManager", (hooks) => {
                 "/web/webclient/load_menus",
                 "/web/action/load",
                 "get_views",
-                "web_search_read",
-                "read",
+                "unity_web_search_read",
+                "web_read",
                 "/web/action/load",
-                "web_search_read",
+                "unity_web_search_read",
             ]);
         }
     );
@@ -497,9 +497,9 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
             "/web/action/load",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -529,10 +529,10 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -542,7 +542,7 @@ QUnit.module("ActionManager", (hooks) => {
         const defs = [null, def, null];
         const mockRPC = async (route, { method }) => {
             assert.step(method || route);
-            if (method === "web_search_read") {
+            if (method === "unity_web_search_read") {
                 await Promise.resolve(defs.shift());
             }
         };
@@ -561,11 +561,11 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -573,7 +573,7 @@ QUnit.module("ActionManager", (hooks) => {
         const def = makeDeferred();
         const defs = [null, def];
         const mockRPC = async (route, args) => {
-            if (args.method === "read") {
+            if (args.method === "web_read") {
                 await Promise.resolve(defs.shift());
             }
         };
diff --git a/addons/web/static/tests/webclient/actions/error_handling_tests.js b/addons/web/static/tests/webclient/actions/error_handling_tests.js
index 243ac1bf5e6..73ae88188eb 100644
--- a/addons/web/static/tests/webclient/actions/error_handling_tests.js
+++ b/addons/web/static/tests/webclient/actions/error_handling_tests.js
@@ -26,7 +26,7 @@ QUnit.module("ActionManager", (hooks) => {
         Boom.template = xml`<div><t t-esc="a.b.c"/></div>`;
         actionRegistry.add("Boom", Boom);
         const mockRPC = (route, args) => {
-            if (args.method === "web_search_read") {
+            if (args.method === "unity_web_search_read") {
                 assert.step("web_search_read");
             }
         };
diff --git a/addons/web/static/tests/webclient/actions/load_state_tests.js b/addons/web/static/tests/webclient/actions/load_state_tests.js
index 8c80b501856..723f4852c17 100644
--- a/addons/web/static/tests/webclient/actions/load_state_tests.js
+++ b/addons/web/static/tests/webclient/actions/load_state_tests.js
@@ -175,8 +175,8 @@ QUnit.module("ActionManager", (hooks) => {
 
     QUnit.test("should not crash on invalid state", async function (assert) {
         assert.expect(3);
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await loadState(webClient, {
@@ -191,8 +191,8 @@ QUnit.module("ActionManager", (hooks) => {
         class ClientAction extends Component {}
         ClientAction.template = xml`<div class="o_client_action_test">Hello World</div>`;
         actionRegistry.add("HelloWorldTest", ClientAction);
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         webClient.env.bus.trigger("test:hashchange", {
@@ -210,8 +210,8 @@ QUnit.module("ActionManager", (hooks) => {
 
     QUnit.test("properly load act window actions", async function (assert) {
         assert.expect(7);
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         webClient.env.bus.trigger("test:hashchange", {
@@ -225,14 +225,14 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
     QUnit.test("properly load records", async function (assert) {
         assert.expect(6);
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         webClient.env.bus.trigger("test:hashchange", {
@@ -243,13 +243,13 @@ QUnit.module("ActionManager", (hooks) => {
         await testUtils.nextTick();
         assert.containsOnce(target, ".o_form_view");
         assert.deepEqual(getBreadCrumbTexts(target), ["Second record"]);
-        assert.verifySteps(["/web/webclient/load_menus", "get_views", "read"]);
+        assert.verifySteps(["/web/webclient/load_menus", "get_views", "web_read"]);
     });
 
     QUnit.test("properly load records with existing first APP", async function (assert) {
         assert.expect(7);
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         // simulate a real scenario with a first app (e.g. Discuss), to ensure that we don't
         // fallback on that first app when only a model and res_id are given in the url
@@ -266,13 +266,13 @@ QUnit.module("ActionManager", (hooks) => {
         assert.containsOnce(target, ".o_form_view");
         assert.deepEqual(getBreadCrumbTexts(target), ["Second record"]);
         assert.containsNone(target, ".o_menu_brand");
-        assert.verifySteps(["/web/webclient/load_menus", "get_views", "read"]);
+        assert.verifySteps(["/web/webclient/load_menus", "get_views", "web_read"]);
     });
 
     QUnit.test("properly load default record", async function (assert) {
         assert.expect(6);
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         webClient.env.bus.trigger("test:hashchange", {
@@ -288,14 +288,14 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "onchange",
+            "onchange2",
         ]);
     });
 
     QUnit.test("load requested view for act window actions", async function (assert) {
         assert.expect(7);
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         webClient.env.bus.trigger("test:hashchange", {
@@ -310,7 +310,7 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -318,8 +318,12 @@ QUnit.module("ActionManager", (hooks) => {
         "lazy load multi record view if mono record one is requested",
         async function (assert) {
             assert.expect(11);
-            const mockRPC = async function (route, args) {
-                assert.step((args && args.method) || route);
+            const mockRPC = async function (route, { method, kwargs }) {
+                if (method === "unity_read") {
+                    assert.step(`unity_read ${kwargs.method}`);
+                } else {
+                    assert.step(method || route);
+                }
             };
             const webClient = await createWebClient({ serverData, mockRPC });
             webClient.env.bus.trigger("test:hashchange", {
@@ -340,8 +344,8 @@ QUnit.module("ActionManager", (hooks) => {
                 "/web/webclient/load_menus",
                 "/web/action/load",
                 "get_views",
-                "read",
-                "web_search_read",
+                "web_read",
+                "unity_web_search_read",
             ]);
         }
     );
@@ -368,8 +372,8 @@ QUnit.module("ActionManager", (hooks) => {
         "lazy loaded multi record view with failing mono record one",
         async function (assert) {
             assert.expect(3);
-            const mockRPC = async function (route, args) {
-                if (args && args.method === "read") {
+            const mockRPC = async function (route, { method, kwargs }) {
+                if (method === "web_read") {
                     return Promise.reject();
                 }
             };
@@ -388,8 +392,8 @@ QUnit.module("ActionManager", (hooks) => {
 
     QUnit.test("change the viewType of the current action", async function (assert) {
         assert.expect(13);
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 3);
@@ -421,16 +425,16 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "web_read",
         ]);
     });
 
     QUnit.test("change the id of the current action", async function (assert) {
         assert.expect(11);
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         // execute action 3 and open the first record in a form view
@@ -454,9 +458,9 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "read",
-            "read",
+            "unity_web_search_read",
+            "web_read",
+            "web_read",
         ]);
     });
 
@@ -633,8 +637,8 @@ QUnit.module("ActionManager", (hooks) => {
                 return this._super(k, v);
             },
         });
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+        const mockRPC = async (route, { method, kwargs }) => {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 4);
@@ -651,10 +655,10 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
             "setItem session current_action",
             "getItem session current_action",
-            "web_search_read",
+            "unity_web_search_read",
             "setItem session current_action",
         ]);
     });
@@ -679,7 +683,7 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/web_search_read",
+            "/web/dataset/call_kw/partner/unity_web_search_read",
         ]);
     });
 
@@ -720,7 +724,7 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/web_search_read",
+            "/web/dataset/call_kw/partner/unity_web_search_read",
         ]);
     });
 
@@ -747,14 +751,14 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/read",
+            "/web/dataset/call_kw/partner/web_read",
         ]);
         await loadState(webClient, {
             action: 999,
             view_type: "form",
             id: "",
         });
-        assert.verifySteps(["/web/dataset/call_kw/partner/onchange"]);
+        assert.verifySteps(["/web/dataset/call_kw/partner/onchange2"]);
         assert.containsOnce(target, ".o_form_view .o_form_editable");
         assert.deepEqual(getBreadCrumbTexts(target), ["Partner", "New"]);
     });
diff --git a/addons/web/static/tests/webclient/actions/push_state_tests.js b/addons/web/static/tests/webclient/actions/push_state_tests.js
index 8f5149cbeca..4a259481562 100644
--- a/addons/web/static/tests/webclient/actions/push_state_tests.js
+++ b/addons/web/static/tests/webclient/actions/push_state_tests.js
@@ -202,10 +202,9 @@ QUnit.module("ActionManager", (hooks) => {
     });
 
     QUnit.test("push state after action is loaded, not before", async function (assert) {
-        assert.expect(2);
         const def = makeDeferred();
         const mockRPC = async function (route, args) {
-            if (args.method === "web_search_read") {
+            if (args.method === "unity_web_search_read") {
                 await def;
             }
         };
diff --git a/addons/web/static/tests/webclient/actions/server_action_tests.js b/addons/web/static/tests/webclient/actions/server_action_tests.js
index f4aeb7c936e..bbfc6040342 100644
--- a/addons/web/static/tests/webclient/actions/server_action_tests.js
+++ b/addons/web/static/tests/webclient/actions/server_action_tests.js
@@ -33,7 +33,7 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/action/run",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -63,7 +63,7 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "onchange",
+            "onchange2",
             "/web/action/load",
             "/web/action/run",
             "close handler",
diff --git a/addons/web/static/tests/webclient/actions/target_tests.js b/addons/web/static/tests/webclient/actions/target_tests.js
index 17efedb2e55..a91cbba6a1c 100644
--- a/addons/web/static/tests/webclient/actions/target_tests.js
+++ b/addons/web/static/tests/webclient/actions/target_tests.js
@@ -50,7 +50,7 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "onchange",
+            "onchange2",
         ]);
     });
 
@@ -145,22 +145,22 @@ QUnit.module("ActionManager", (hooks) => {
         assert.verifySteps([
             "/web/action/load",
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/onchange",
+            "/web/dataset/call_kw/partner/onchange2",
         ]);
         await testUtils.dom.click(`button[name="5"]`);
         assert.verifySteps([
             "/web/dataset/call_kw/partner/create",
-            "/web/dataset/call_kw/partner/read",
+            "/web/dataset/call_kw/partner/web_read",
             "/web/action/load",
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/onchange",
+            "/web/dataset/call_kw/partner/onchange2",
         ]);
         assert.containsOnce(document.body, ".modal");
         await testUtils.dom.click(`button[name="some_method"]`);
         assert.verifySteps([
             "/web/dataset/call_kw/partner/create",
             "/web/dataset/call_button",
-            "/web/dataset/call_kw/partner/read",
+            "/web/dataset/call_kw/partner/web_read",
         ]);
         assert.containsNone(document.body, ".modal");
     });
diff --git a/addons/web/static/tests/webclient/actions/window_action_tests.js b/addons/web/static/tests/webclient/actions/window_action_tests.js
index 22f338e71db..00a2505c309 100644
--- a/addons/web/static/tests/webclient/actions/window_action_tests.js
+++ b/addons/web/static/tests/webclient/actions/window_action_tests.js
@@ -54,8 +54,8 @@ QUnit.module("ActionManager", (hooks) => {
 
     QUnit.test("can execute act_window actions from db ID", async function (assert) {
         assert.expect(7);
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 1);
@@ -69,7 +69,7 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -103,8 +103,8 @@ QUnit.module("ActionManager", (hooks) => {
 
     QUnit.test("can switch between views", async function (assert) {
         assert.expect(19);
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 3);
@@ -138,11 +138,11 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "web_search_read",
-            "web_search_read",
-            "read",
-            "web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "web_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -166,8 +166,8 @@ QUnit.module("ActionManager", (hooks) => {
                 [false, "form"],
             ],
         };
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 1);
@@ -188,12 +188,12 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/action/load",
             "get_views",
             "web_read_group",
-            "web_search_read",
-            "web_search_read",
-            "onchange",
+            "unity_web_search_read",
+            "unity_web_search_read",
+            "onchange2",
             "name_create",
-            "read",
-            "read",
+            "web_read",
+            "web_read",
         ]);
     });
 
@@ -220,7 +220,7 @@ QUnit.module("ActionManager", (hooks) => {
             ];
             let searchReadCount = 1;
             const mockRPC = async (route, args) => {
-                if (args.method === "web_search_read") {
+                if (args.method === "unity_web_search_read") {
                     args = args || {};
                     if (searchReadCount === 1) {
                         assert.strictEqual(args.model, "partner");
@@ -538,7 +538,32 @@ QUnit.module("ActionManager", (hooks) => {
 
     QUnit.test("A new form view can be reloaded after a failed one", async function (assert) {
         assert.expect(5);
+
+        /*
+         * By-pass QUnit's and test's error handling because the error service needs to be active
+         */
+        const handler = (ev) => {
+            // need to preventDefault to remove error from console (so python test pass)
+            ev.preventDefault();
+        };
+        window.addEventListener("unhandledrejection", handler);
+        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
+
+        patchWithCleanup(QUnit, {
+            onUnhandledRejection: () => {},
+        });
+
+        const originOnunhandledrejection = window.onunhandledrejection;
+        window.onunhandledrejection = () => {};
+        registerCleanup(() => {
+            window.onunhandledrejection = originOnunhandledrejection;
+        });
+        /*
+         * End By pass error handling
+         */
+
         const webClient = await createWebClient({ serverData });
+        serviceRegistry.add("error", errorService);
 
         await doAction(webClient, 3);
         await cpHelpers.switchView(target, "list");
@@ -688,8 +713,8 @@ QUnit.module("ActionManager", (hooks) => {
 
     QUnit.test("reload previous controller when discarding a new record", async function (assert) {
         assert.expect(9);
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 3);
@@ -707,9 +732,9 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "onchange",
-            "web_search_read",
+            "unity_web_search_read",
+            "onchange2",
+            "unity_web_search_read",
         ]);
     });
 
@@ -717,7 +742,7 @@ QUnit.module("ActionManager", (hooks) => {
         assert.expect(11);
         patchWithCleanup(session.user_context, { some_key: 2 });
         const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+            assert.step(args.method || route);
             if (route === "/web/dataset/call_button") {
                 assert.deepEqual(
                     args,
@@ -765,10 +790,10 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "web_read",
             "object",
-            "read",
+            "web_read",
         ]);
     });
 
@@ -791,7 +816,7 @@ QUnit.module("ActionManager", (hooks) => {
             };
             const def = testUtils.makeTestPromise();
             const mockRPC = async (route, args) => {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     // delay the opening of the dialog
                     await def;
                 }
@@ -841,7 +866,7 @@ QUnit.module("ActionManager", (hooks) => {
             assert.containsOnce(target, ".o_form_view");
             // save to ensure the presence of the create button
             await click(target.querySelector(".o_form_button_save"));
-            // click on 'Execute action', to execute action 4 in a dialogdebugger
+            // click on 'Execute action', to execute action 4 in a dialog
             click(target.querySelector('.o_form_view button[name="object"]'));
             assert.ok(target.querySelector(".o_form_button_create").disabled);
             await nextTick();
@@ -882,8 +907,8 @@ QUnit.module("ActionManager", (hooks) => {
 
     QUnit.test("requests for execute_action of type action are handled", async function (assert) {
         assert.expect(12);
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 3);
@@ -906,23 +931,23 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "web_read",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
     QUnit.test("execute smart button and back", async function (assert) {
-        const mockRPC = async (route, args) => {
-            if (args.method === "read") {
-                assert.step("read");
-                assert.notOk("default_partner" in args.kwargs.context);
+        const mockRPC = async (route, { method, kwargs }) => {
+            if (method === "web_read") {
+                assert.step("web_read");
+                assert.notOk("default_partner" in kwargs.context);
             }
-            if (args.method === "web_search_read") {
-                assert.step("web_search_read");
-                assert.strictEqual(args.kwargs.context.default_partner, 2);
+            if (method === "unity_web_search_read") {
+                assert.step("unity_web_search_read");
+                assert.strictEqual(kwargs.context.default_partner, 2);
             }
         };
         const webClient = await createWebClient({ serverData, mockRPC });
@@ -936,14 +961,14 @@ QUnit.module("ActionManager", (hooks) => {
         await legacyExtraNextTick();
         assert.containsOnce(target, ".o_form_view");
         assert.containsOnce(target, ".o_form_button_create:not([disabled]):visible");
-        assert.verifySteps(["read", "web_search_read", "read"]);
+        assert.verifySteps(["web_read", "unity_web_search_read", "web_read"]);
     });
 
     QUnit.test("execute smart button and fails", async function (assert) {
         assert.expect(13);
-        const mockRPC = async (route, args) => {
-            assert.step(route);
-            if (args.method === "web_search_read") {
+        const mockRPC = async (route, { method }) => {
+            assert.step(method || route);
+            if (method === "unity_web_search_read") {
                 return Promise.reject();
             }
         };
@@ -958,12 +983,12 @@ QUnit.module("ActionManager", (hooks) => {
         assert.verifySteps([
             "/web/webclient/load_menus",
             "/web/action/load",
-            "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/read",
+            "get_views",
+            "web_read",
             "/web/action/load",
-            "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/web_search_read",
-            "/web/dataset/call_kw/partner/read",
+            "get_views",
+            "unity_web_search_read",
+            "web_read",
         ]);
     });
 
@@ -975,7 +1000,7 @@ QUnit.module("ActionManager", (hooks) => {
             const mockRPC = async (route, args) => {
                 if (route === "/web/dataset/call_button") {
                     return Promise.resolve(false);
-                } else if (args && args.method === "read") {
+                } else if (args.method === "web_read") {
                     await def; // block the 'read' call
                 }
             };
@@ -1034,8 +1059,8 @@ QUnit.module("ActionManager", (hooks) => {
 
     QUnit.test("can open different records from a multi record view", async function (assert) {
         assert.expect(12);
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 3);
@@ -1071,10 +1096,10 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "read",
-            "web_search_read",
-            "read",
+            "unity_web_search_read",
+            "web_read",
+            "unity_web_search_read",
+            "web_read",
         ]);
     });
 
@@ -1206,11 +1231,11 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/web_search_read",
-            "/web/dataset/call_kw/partner/read",
+            "/web/dataset/call_kw/partner/unity_web_search_read",
+            "/web/dataset/call_kw/partner/web_read",
             "/web/dataset/call_kw/partner/get_formview_action",
             "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/read",
+            "/web/dataset/call_kw/partner/web_read",
         ]);
     });
 
@@ -1359,8 +1384,8 @@ QUnit.module("ActionManager", (hooks) => {
                 [1, "kanban"],
             ],
         };
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 33);
@@ -1374,7 +1399,7 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
+            "unity_web_search_read",
         ]);
     });
 
@@ -1412,8 +1437,8 @@ QUnit.module("ActionManager", (hooks) => {
             },
             views: [[false, "form"]],
         };
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
+        const mockRPC = async function (route, { method }) {
+            assert.step(method || route);
         };
         const webClient = await createWebClient({ serverData, mockRPC });
         await doAction(webClient, 44);
@@ -1423,7 +1448,12 @@ QUnit.module("ActionManager", (hooks) => {
             "should display the form view in edit mode"
         ); // provided that the default mode is readonly
 
-        assert.verifySteps(["/web/webclient/load_menus", "/web/action/load", "get_views", "read"]);
+        assert.verifySteps([
+            "/web/webclient/load_menus",
+            "/web/action/load",
+            "get_views",
+            "web_read",
+        ]);
     });
 
     QUnit.test("save current search", async function (assert) {
@@ -1554,7 +1584,7 @@ QUnit.module("ActionManager", (hooks) => {
             },
         ];
         const mockRPC = (route, args) => {
-            if (args.method === "web_search_read") {
+            if (args.method === "unity_web_search_read") {
                 assert.deepEqual(args.kwargs.domain, [["bar", "=", 1]]);
             }
         };
@@ -1640,9 +1670,9 @@ QUnit.module("ActionManager", (hooks) => {
                 <field name="foo"/>
                 <field name="bar" readonly="1"/>
             </form>`;
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
-            if (args && args.method === "get_formview_action") {
+        const mockRPC = async (route, { method }) => {
+            assert.step(method || route);
+            if (method === "get_formview_action") {
                 return Promise.resolve({
                     res_id: 1,
                     res_model: "partner",
@@ -1676,13 +1706,13 @@ QUnit.module("ActionManager", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "web_search_read",
-            "onchange",
+            "unity_web_search_read",
+            "onchange2",
             "get_formview_action",
             "create", // FIXME: to check with mcm
             "get_views",
-            "read",
-            "read",
+            "web_read",
+            "web_read",
         ]);
     });
 
@@ -1909,7 +1939,7 @@ QUnit.module("ActionManager", (hooks) => {
         // because of how native events are handled in tests
         const searchPromise = testUtils.makeTestPromise();
         const mockRPC = async (route, args) => {
-            if (args.method === "web_search_read") {
+            if (args.method === "unity_web_search_read") {
                 assert.step("search_read " + args.kwargs.domain);
                 if (JSON.stringify(args.domain) === JSON.stringify([["foo", "ilike", "m"]])) {
                     await searchPromise;
@@ -1962,7 +1992,7 @@ QUnit.module("ActionManager", (hooks) => {
         async function (assert) {
             serverData.views["partner,false,form"] = `<form><field name="foo"/></form>`;
             const mockRPC = (route, args) => {
-                if (args.method === "onchange") {
+                if (args.method === "onchange2") {
                     return Promise.resolve({
                         value: {},
                         warning: {
@@ -2129,7 +2159,7 @@ QUnit.module("ActionManager", (hooks) => {
             sections: [],
         });
         const mockRPC = async (route, args) => {
-            if (args.method === "web_search_read") {
+            if (args.method === "unity_web_search_read") {
                 assert.deepEqual(args.kwargs.domain, [["id", "=", 99]]);
             }
         };
@@ -2180,7 +2210,7 @@ QUnit.module("ActionManager", (hooks) => {
             .add("odoo.exceptions.ValidationError", WarningDialogWait);
 
         const mockRPC = (route, args) => {
-            if (args.method === "onchange" && args.model === "partner") {
+            if (args.method === "onchange2" && args.model === "partner") {
                 throw makeServerError({ type: "ValidationError" });
             }
         };
@@ -2216,18 +2246,18 @@ QUnit.module("ActionManager", (hooks) => {
 
         await doAction(webClient, 1);
         assert.containsOnce(target, ".o_kanban_view");
-        assert.verifySteps(["/web/action/load", "get_views", "web_search_read"]);
+        assert.verifySteps(["/web/action/load", "get_views", "unity_web_search_read"]);
 
         await doAction(webClient, 1);
         assert.containsOnce(target, ".o_kanban_view");
 
-        assert.verifySteps(["web_search_read"]);
+        assert.verifySteps(["unity_web_search_read"]);
 
         await webClient.env.services.orm.unlink("ir.actions.act_window", [333]);
         assert.verifySteps(["unlink"]);
         await doAction(webClient, 1);
         // cache was cleared => reload the action
-        assert.verifySteps(["/web/action/load", "web_search_read"]);
+        assert.verifySteps(["/web/action/load", "unity_web_search_read"]);
     });
 
     QUnit.test("pushState also changes the title of the tab", async (assert) => {
@@ -2493,7 +2523,7 @@ QUnit.module("ActionManager", (hooks) => {
             .add("odoo.exceptions.ValidationError", WarningDialogWait);
 
         const mockRPC = (route, args) => {
-            if (args.method === "web_search_read" && args.model === "partner") {
+            if (args.method === "unity_web_search_read" && args.model === "partner") {
                 throw makeServerError({ type: "ValidationError" });
             }
         };
diff --git a/addons/web/static/tests/webclient/settings_form_view/settings_form_view_tests.js b/addons/web/static/tests/webclient/settings_form_view/settings_form_view_tests.js
index e4c3b77568f..8f2214d1f80 100644
--- a/addons/web/static/tests/webclient/settings_form_view/settings_form_view_tests.js
+++ b/addons/web/static/tests/webclient/settings_form_view/settings_form_view_tests.js
@@ -412,12 +412,12 @@ QUnit.module("SettingsFormView", (hooks) => {
             assert.notOk(target.querySelector(".o_field_boolean input").disabled);
             assert.verifySteps([
                 "get_views", // initial setting action
-                "onchange", // this is a setting view => new record transient record
+                "onchange2", // this is a setting view => new record transient record
                 "create", // create the record before doing the action
-                "read", // read the created record
+                "web_read", // read the created record
                 "get_views", // for other action in breadcrumb,
-                "web_search_read", // with a searchread
-                "onchange", // when we come back, we want to restart from scratch
+                "unity_web_search_read", // with a searchread
+                "onchange2", // when we come back, we want to restart from scratch
             ]);
         }
     );
@@ -488,7 +488,7 @@ QUnit.module("SettingsFormView", (hooks) => {
                     ]);
                 }
                 if (route === "/web/dataset/call_button" && method === "execute") {
-                    assert.deepEqual(args, [[2]]);
+                    assert.deepEqual(args[0].length, 1);
                     return true;
                 }
             },
@@ -550,23 +550,23 @@ QUnit.module("SettingsFormView", (hooks) => {
 
         assert.verifySteps([
             "get_views", // initial setting action
-            "onchange", // this is a setting view => new record transient record
+            "onchange2", // this is a setting view => new record transient record
         ]);
 
         await click(target.querySelector("button[name='4']"));
 
         assert.verifySteps([
             "create", // settings: create the record before doing the action
-            "read", // settings: read the created record
+            "web_read", // settings: read the created record
             "get_views", // dialog: get views
-            "onchange", // dialog: onchange
+            "onchange2", // dialog: onchange
         ]);
 
         await click(target, ".modal button.btn.btn-primary.o_form_button_save");
         assert.verifySteps([
             "create", // dialog: create the record before doing back to the settings
-            "read", // dialog: read the created record
-            "onchange", // settings: when we come back, we want to restart from scratch
+            "web_read", // dialog: read the created record
+            "onchange2", // settings: when we come back, we want to restart from scratch
         ]);
     });
 
@@ -972,7 +972,7 @@ QUnit.module("SettingsFormView", (hooks) => {
         const mockRPC = (route, args) => {
             if (args.method === "create") {
                 assert.deepEqual(
-                    args.args[0],
+                    args.args[0][0],
                     { foo: true },
                     "should create a record with foo=true"
                 );
@@ -1034,13 +1034,13 @@ QUnit.module("SettingsFormView", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
         await click(target, ".o_field_boolean input[type='checkbox']");
         await click(target, ".myBtn");
         await click(target, ".modal .btn-primary");
         assert.verifySteps([
             "create",
-            "read",
+            "web_read",
             'action executed {"name":"execute","type":"object","resModel":"res.config.settings","resId":1,"resIds":[1],"context":{"lang":"en","uid":7,"tz":"taht"},"buttonContext":{}}',
         ]);
     });
@@ -1075,13 +1075,13 @@ QUnit.module("SettingsFormView", (hooks) => {
             },
         });
 
-        assert.verifySteps(["get_views", "onchange"]);
+        assert.verifySteps(["get_views", "onchange2"]);
         await click(target, ".o_field_boolean input[type='checkbox']");
         await click(target, ".myBtn");
         await click(target.querySelectorAll(".modal .btn-secondary")[1]);
         assert.verifySteps([
             "create",
-            "read",
+            "web_read",
             'action executed {"context":{"lang":"en","uid":7,"tz":"taht"},"type":"object","name":"mymethod","resModel":"res.config.settings","resId":1,"resIds":[1],"buttonContext":{}}',
         ]);
     });
@@ -1308,7 +1308,7 @@ QUnit.module("SettingsFormView", (hooks) => {
 
             let def;
             const mockRPC = async (route, args) => {
-                if (args.method === "web_search_read") {
+                if (args.method === "web_read") {
                     await def; // slow down reload of settings view
                 }
             };
@@ -1437,6 +1437,7 @@ QUnit.module("SettingsFormView", (hooks) => {
             ]);
         }
     );
+
     QUnit.test("Discard button clean the settings view", async function (assert) {
         assert.expect(10);
 
@@ -1478,7 +1479,7 @@ QUnit.module("SettingsFormView", (hooks) => {
             "/web/webclient/load_menus",
             "/web/action/load",
             "get_views",
-            "onchange",
+            "onchange2",
         ]);
         assert.containsNone(
             target,
@@ -1496,7 +1497,7 @@ QUnit.module("SettingsFormView", (hooks) => {
             ".o_field_boolean input:checked",
             "checkbox should not be checked"
         );
-        assert.verifySteps(["onchange"]);
+        assert.verifySteps(["onchange2"]);
     });
 
     QUnit.test("Settings Radio widget: show and search", async function (assert) {
diff --git a/addons/web_editor/static/src/js/backend/html_field.js b/addons/web_editor/static/src/js/backend/html_field.js
index 07654d0d200..1d730f198c6 100644
--- a/addons/web_editor/static/src/js/backend/html_field.js
+++ b/addons/web_editor/static/src/js/backend/html_field.js
@@ -541,12 +541,7 @@ export class HtmlField extends Component {
         if (!(this.props.record.fieldNames.includes('attachment_ids') && this.props.record.resModel === 'mail.compose.message')) {
             return;
         }
-        this.props.record.update({
-            attachment_ids: {
-                operation: "ADD_M2M",
-                ids: attachment,
-            },
-        });
+        this.props.record.data.attachment_ids.linkTo(attachment.res_id, attachment);
     }
     _onDblClickEditableMedia(ev) {
         const el = ev.target;
diff --git a/addons/website_forum/static/src/js/systray_items/forum_forum_add_form.js b/addons/website_forum/static/src/js/systray_items/forum_forum_add_form.js
index 5c362badc6f..cac846309e1 100644
--- a/addons/website_forum/static/src/js/systray_items/forum_forum_add_form.js
+++ b/addons/website_forum/static/src/js/systray_items/forum_forum_add_form.js
@@ -8,7 +8,7 @@ export class AddForumFormController extends NewContentFormController {
      * @override
      */
     computePath() {
-        return `/forum/${encodeURIComponent(this.model.root.data.id)}`;
+        return `/forum/${encodeURIComponent(this.model.root.resId)}`;
     }
 }
 
diff --git a/addons/website_slides/static/src/slide_category_list_renderer.js b/addons/website_slides/static/src/slide_category_list_renderer.js
index 7a3ad428396..61f0bf5972e 100644
--- a/addons/website_slides/static/src/slide_category_list_renderer.js
+++ b/addons/website_slides/static/src/slide_category_list_renderer.js
@@ -72,7 +72,7 @@ export class SlideCategoryListRenderer extends ListRenderer {
             case "enter":
             case "tab":
             case "shift+tab": {
-                this.props.list.unselectRecord(true);
+                this.props.list.leaveEditMode();
                 return true;
             }
         }
diff --git a/addons/website_slides/static/tests/slide_category_one2many_field_tests.js b/addons/website_slides/static/tests/slide_category_one2many_field_tests.js
index 20e5e40111f..c19bae18a17 100644
--- a/addons/website_slides/static/tests/slide_category_one2many_field_tests.js
+++ b/addons/website_slides/static/tests/slide_category_one2many_field_tests.js
@@ -139,7 +139,6 @@ QUnit.test("click on real line opens a dialog", async (assert) => {
             </form>`,
     });
     await click($(".o_data_row:nth-child(2) .o_data_cell")[0]);
-    assert.containsNone($, ".o_selected_row");
     assert.containsOnce($, ".modal .o_form_view");
 });
 
diff --git a/odoo/addons/test_new_api/tests/test_unity_read.py b/odoo/addons/test_new_api/tests/test_unity_read.py
index 3fe3f3c67a2..b9c97d495b0 100644
--- a/odoo/addons/test_new_api/tests/test_unity_read.py
+++ b/odoo/addons/test_new_api/tests/test_unity_read.py
@@ -152,6 +152,41 @@ class TestUnityRead(TransactionCase):
                 }
             }])
 
+    def test_read_many2one_with_new_record(self):
+        values = {'author_id': {'id': self.author.id}}
+        new_course = self.course.new(values, origin=self.course)
+
+        # new_course.author_id is a new record
+        self.assertTrue(new_course.author_id)
+        self.assertFalse(new_course.author_id.id)
+
+        result = new_course.web_read({
+            'display_name': {},
+            'author_id': {},
+        })
+        self.assertEqual(result, [
+            {
+                'id': new_course.id,
+                'display_name': 'introduction to OWL',
+                'author_id': self.author.id,
+            }
+        ])
+
+        result = new_course.web_read({
+            'display_name': {},
+            'author_id': {'fields': {'display_name': {}}},
+        })
+        self.assertEqual(result, [
+            {
+                'id': new_course.id,
+                'display_name': 'introduction to OWL',
+                'author_id': {
+                    'id': self.author.id,
+                    'display_name': 'ged'
+                }
+            }
+        ])
+
     def test_new_record_with_inherits(self):
         # virtualize a record
         new_account = self.account.new(origin=self.account)
diff --git a/odoo/fields.py b/odoo/fields.py
index 53a361e93f5..8b7b110a0f4 100644
--- a/odoo/fields.py
+++ b/odoo/fields.py
@@ -3032,10 +3032,8 @@ class Many2one(_Relational):
             except MissingError:
                 # Should not happen, unless the foreign key is missing.
                 return False
-        elif self.delegate:
-            return value.id
         else:
-            return value._origin.id
+            return value.id
 
     def convert_to_write(self, value, record):
         if type(value) in IdType: