From 11b43124826afa077254cf30802fda15d0d60b3d Mon Sep 17 00:00:00 2001
From: Jan Willem Rigters <janwillem@steets.nl>
Date: Wed, 22 Jul 2026 23:25:54 +0200
Subject: [PATCH 1/2] Improve Bard/Replicator performance on large documents

---
 .../js/components/entries/PublishForm.vue     |  10 +-
 .../js/components/fieldtypes/Fieldtype.vue    |  39 ++-
 .../fieldtypes/bard/BardFieldtype.vue         |  50 ++--
 .../js/components/fieldtypes/bard/Set.vue     | 119 ++++++--
 .../js/tests/createMountScheduler.test.js     | 282 ++++++++++++++++++
 resources/js/util/createMountScheduler.js     |  49 +++
 6 files changed, 488 insertions(+), 61 deletions(-)
 create mode 100644 resources/js/tests/createMountScheduler.test.js
 create mode 100644 resources/js/util/createMountScheduler.js

diff --git a/resources/js/components/entries/PublishForm.vue b/resources/js/components/entries/PublishForm.vue
index 2c888064b35..a0d84d07896 100644
--- a/resources/js/components/entries/PublishForm.vue
+++ b/resources/js/components/entries/PublishForm.vue
@@ -582,7 +582,7 @@ export default {
                         this.trackDirtyState = false;
                         this.values = resetValuesFromResponse(response.data.data.values, this.$refs.container);
                         this.extraValues = response.data.data.extraValues;
-                        this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 500);
+                        this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 3000);
                         this.$nextTick(() => this.$emit('saved', response));
                         return;
                     }
@@ -605,7 +605,7 @@ export default {
                     else {
                         clearTimeout(this.trackDirtyStateTimeout);
                         this.trackDirtyState = false;
-                        this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 500);
+                        this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 3000);
                         this.initialPublished = response.data.data.published;
                         this.activeLocalization.published = response.data.data.published;
                         this.activeLocalization.status = response.data.data.status;
@@ -694,7 +694,7 @@ export default {
                 this.initialPublished = data.values.published;
                 this.readOnly = data.readOnly;
 
-                this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 500); // after any fieldtypes do a debounced update
+                this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 3000); // after any fieldtypes do a debounced update
             });
         },
 
@@ -777,7 +777,7 @@ export default {
                 clearTimeout(this.trackDirtyStateTimeout);
                 this.trackDirtyState = false;
                 this.values = resetValuesFromResponse(response.data.data.values, this.$refs.container);
-                this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 500);
+                this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 3000);
                 this.activeLocalization.title = response.data.data.title;
                 this.activeLocalization.published = response.data.data.published;
                 this.activeLocalization.status = response.data.data.status;
@@ -813,7 +813,7 @@ export default {
                 clearTimeout(this.trackDirtyStateTimeout);
                 this.trackDirtyState = false;
                 this.values = resetValuesFromResponse(response.data.values, this.$refs.container);
-                this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 500);
+                this.trackDirtyStateTimeout = setTimeout(() => (this.trackDirtyState = true), 3000);
                 this.initialPublished = response.data.published;
                 this.activeLocalization.published = response.data.published;
                 this.activeLocalization.status = response.data.status;
diff --git a/resources/js/components/fieldtypes/Fieldtype.vue b/resources/js/components/fieldtypes/Fieldtype.vue
index c6ee19b8aa3..249115f7b07 100644
--- a/resources/js/components/fieldtypes/Fieldtype.vue
+++ b/resources/js/components/fieldtypes/Fieldtype.vue
@@ -43,12 +43,39 @@ export default {
             // When using the Options API, this feels more natural. However since this is a
             // computed, it won't be avaialble within data(). In those cases you will
             // need to use this.injectedPublishContainer.someValue.value directly.
-            return Object.fromEntries(
-               Object.entries(this.injectedPublishContainer).map(([key, value]) => [
-                   key,
-                   isRef(value) ? value.value : value,
-               ])
-           );
+            //
+            // We build the cache once with lazy getters, so this computed has zero reactive
+            // deps and is never invalidated/recomputed itself — reading a specific key still
+            // goes through to the live ref, so dependency tracking happens correctly in
+            // whichever consumer's reactive scope reads it (e.g. a field's own condition
+            // computed), rather than recomputing this whole object for every field on the
+            // page whenever any one of the injected refs changes.
+            if (this._publishContainerCache) return this._publishContainerCache;
+
+            const cache = {};
+            const src = this.injectedPublishContainer;
+
+            for (const key in src) {
+                const val = src[key];
+
+                if (isRef(val)) {
+                    Object.defineProperty(cache, key, {
+                        enumerable: true,
+                        configurable: true,
+                        get: () => val.value,
+                    });
+                } else {
+                    Object.defineProperty(cache, key, {
+                        enumerable: true,
+                        configurable: true,
+                        writable: false,
+                        value: val,
+                    });
+                }
+            }
+
+            this._publishContainerCache = cache;
+            return cache;
         },
 
         name() {
diff --git a/resources/js/components/fieldtypes/bard/BardFieldtype.vue b/resources/js/components/fieldtypes/bard/BardFieldtype.vue
index e682303b6f1..794da78f86d 100644
--- a/resources/js/components/fieldtypes/bard/BardFieldtype.vue
+++ b/resources/js/components/fieldtypes/bard/BardFieldtype.vue
@@ -175,8 +175,9 @@ import readTimeEstimate from 'read-time-estimate';
 import { common, createLowlight } from 'lowlight';
 import 'highlight.js/styles/github.css';
 import importTiptap from '@/util/tiptap.js';
-import { computed } from 'vue';
+import { computed, markRaw } from 'vue';
 import { data_get } from "@/bootstrap/globals.js";
+import { createMountScheduler } from '@/util/createMountScheduler.js';
 import { useContentDirection } from '@/composables/content-direction';
 
 const lowlight = createLowlight(common);
@@ -224,6 +225,7 @@ export default {
                 bard: this.makeBardProvide(),
                 bardSets: this.config.sets,
                 showReplicatorFieldPreviews: this.config.previews,
+                mountScheduler: createMountScheduler(),
             },
             errorsById: {},
             debounceNextUpdate: true,
@@ -396,8 +398,9 @@ export default {
         this.initToolbarButtons();
         this.initEditor();
 
-        this.json = this.editor.getJSON().content;
+        this.json = markRaw(this.editor.getJSON().content);
         this.html = this.editor.getHTML();
+        this._lastDocSize = this.editor.state.doc.content.size;
 
 		this.$nextTick(() => this.mounted = true);
 
@@ -877,24 +880,31 @@ export default {
                         }
                     }, 1);
                 },
-                onUpdate: () => {
-                    const oldJson = this.json;
-                    const newJson = clone(this.editor.getJSON().content);
-
-                    const countNodes = (nodes) => {
-                        if (!nodes || !Array.isArray(nodes)) return 0;
-                        let count = nodes.length;
-                        nodes.forEach(node => {
-                            if (node.content) {
-                                count += countNodes(node.content);
-                            }
-                        });
-                        return count;
-                    };
-
-                    if (countNodes(oldJson) !== countNodes(newJson)) this.debounceNextUpdate = false;
-
-                    this.json = newJson;
+                onUpdate: ({ transaction }) => {
+                    // Selection-only transactions (cursor moves, etc.) don't change the
+                    // document at all — skip all of the work below entirely for those.
+                    if (!transaction.docChanged) return;
+
+                    const newDocSize = this.editor.state.doc.content.size;
+                    const oldDocSize = this._lastDocSize ?? newDocSize;
+
+                    // doc.content.size changes on every keystroke, not just structural
+                    // edits (block add/remove). That's intentional here — debounceNextUpdate
+                    // previously used a recursive node-count comparison to approximate this,
+                    // but that required a full clone() + tree walk on every transaction just
+                    // to produce a coarser signal. If a debounce-suppression distinction
+                    // between "typed a character" and "added/removed a node" turns out to be
+                    // load-bearing elsewhere, this may need revisiting.
+                    if (oldDocSize !== newDocSize) this.debounceNextUpdate = false;
+                    this._lastDocSize = newDocSize;
+
+                    // markRaw prevents Vue from deep-reactive-proxying the full document
+                    // tree. Every node in a large Bard document would otherwise get its own
+                    // Proxy plus a dependency-tracking map, regenerated on every update — this
+                    // is the dominant cost (both CPU and memory) on large documents. json/html
+                    // are only used here for display/emit purposes and don't rely on deep
+                    // reactivity elsewhere in this component.
+                    this.json = markRaw(this.editor.getJSON().content);
                     this.html = this.editor.getHTML();
                 },
                 onCreate: ({ editor }) => {
diff --git a/resources/js/components/fieldtypes/bard/Set.vue b/resources/js/components/fieldtypes/bard/Set.vue
index 1c99d83d775..9116763adc2 100644
--- a/resources/js/components/fieldtypes/bard/Set.vue
+++ b/resources/js/components/fieldtypes/bard/Set.vue
@@ -56,14 +56,16 @@
                             <Button icon="dots" variant="ghost" size="xs" :aria-label="__('Open dropdown menu')" @mousedown.prevent />
                         </template>
                         <DropdownMenu>
-                            <DropdownItem
-                                v-if="fieldActions.length"
-                                v-for="action in fieldActions"
-                                :text="action.title"
-                                :variant="action.dangerous ? 'destructive' : 'default'"
-                                @click="action.run(action)"
-                            />
-                            <DropdownSeparator v-if="fieldActions.length" />
+                            <template v-if="fieldActions.length">
+                                <DropdownItem
+                                    v-for="action in fieldActions"
+                                    :key="action.title"
+                                    :text="action.title"
+                                    :variant="action.dangerous ? 'destructive' : 'default'"
+                                    @click="action.run(action)"
+                                />
+                                <DropdownSeparator />
+                            </template>
                             <DropdownItem
                                 :text="__(collapsed ? __('Expand Set') : __('Collapse Set'))"
                                 @click="toggleCollapsedState"
@@ -80,20 +82,22 @@
             </header>
 
             <div
-                v-if="index !== undefined && hasFields"
+                v-if="index !== undefined && hasFields && hasBeenExpanded"
                 v-show="!collapsed"
                 :class="{ 'contain-paint': collapsed, 'isolate': !collapsed }"
                 class="border-t border-t-gray-300! dark:border-t-white/10!"
             >
-                <FieldsProvider
-                    :fields="fields"
-                    :as-config="false"
-                    :read-only="isReadOnly"
-                    :field-path-prefix="fieldPathPrefix"
-                    :meta-path-prefix="metaPathPrefix"
-                >
-                    <Fields class="p-4" />
-                </FieldsProvider>
+                <template v-if="fieldsReady">
+                    <FieldsProvider
+                        :fields="fields"
+                        :as-config="false"
+                        :read-only="isReadOnly"
+                        :field-path-prefix="fieldPathPrefix"
+                        :meta-path-prefix="metaPathPrefix"
+                    >
+                        <Fields class="p-4" />
+                    </FieldsProvider>
+                </template>
             </div>
         </div>
     </node-view-wrapper>
@@ -120,6 +124,7 @@ import { containerContextKey } from '@/components/ui/Publish/Container.vue';
 import { watch } from 'vue';
 import { reveal } from '@api';
 import { useUiDirection } from '@/composables/ui-direction';
+import { createMountScheduler } from '@/util/createMountScheduler.js';
 
 export default {
     props: nodeViewProps,
@@ -147,9 +152,32 @@ export default {
 
     mixins: [ManagesPreviewText, HasFieldActions],
 
+    data() {
+        return {
+            hasBeenExpanded: false,
+            fieldsReady: false,
+        };
+    },
+
+    watch: {
+        collapsed(collapsed) {
+            if (!collapsed && !this.hasBeenExpanded) {
+                this.hasBeenExpanded = true;
+                this.mountScheduler.schedule(() => {
+                    if (!this._unmounted) {
+                        this.fieldsReady = true;
+                    }
+                });
+            } else if (!collapsed) {
+                this.fieldsReady = true;
+            }
+        },
+    },
+
     inject: {
         bard: {},
         bardSets: {},
+        mountScheduler: { default: createMountScheduler() },
         publishContainer: { from: containerContextKey },
     },
 
@@ -368,16 +396,38 @@ export default {
     },
 
     mounted() {
-        watch(
-            () => data_get(this.publishContainer.values.value, this.fieldPathPrefix),
-            (values) => {
-				if (! values) return;
-                if (JSON.stringify(values) === JSON.stringify(this.node.attrs.values)) return;
+        if (!this.collapsed) {
+            this.hasBeenExpanded = true;
+            this.fieldsReady = true;
+        }
 
-                this.updateAttributes({ values });
-            },
-            { deep: true }
-        );
+        const startSyncWatcher = () => {
+            this._syncWatcherStop = watch(
+                () => data_get(this.publishContainer.values.value, this.fieldPathPrefix),
+                (values) => {
+                    if (!values) return;
+                    if (values === this.node.attrs.values) return;
+                    if (JSON.stringify(values) === JSON.stringify(this.node.attrs.values)) return;
+
+                    this.updateAttributes({ values });
+                },
+                { deep: true, immediate: true }
+            );
+        };
+
+        if (this.fieldsReady) {
+            startSyncWatcher();
+        } else {
+            // Collapsed on mount — don't stand up the sync watcher (or its
+            // initial deep JSON.stringify comparison) until this Set's fields
+            // are actually scheduled to render.
+            this._syncWatcherFieldsReadyStop = this.$watch('fieldsReady', (ready) => {
+                if (ready) {
+                    startSyncWatcher();
+                    this._syncWatcherFieldsReadyStop?.();
+                }
+            });
+        }
 
         reveal.mount(this.$refs.container, this.expand);
 
@@ -385,10 +435,16 @@ export default {
         // draggable ancestor. ProseMirror sets draggable=true on the node-view-wrapper
         // because the Set node spec has draggable:true. We must keep it false.
         this.$el.setAttribute('draggable', false);
+        this._draggablePending = false;
         this._draggableObserver = new MutationObserver(() => {
-            if (this.$el.getAttribute('draggable') !== 'false') {
-                this.$el.setAttribute('draggable', false);
-            }
+            if (this._draggablePending) return;
+            this._draggablePending = true;
+            requestAnimationFrame(() => {
+                this._draggablePending = false;
+                if (!this._unmounted && this.$el.getAttribute('draggable') !== 'false') {
+                    this.$el.setAttribute('draggable', false);
+                }
+            });
         });
         this._draggableObserver.observe(this.$el, { attributes: true, attributeFilter: ['draggable'] });
     },
@@ -398,7 +454,10 @@ export default {
     },
 
     beforeUnmount() {
+        this._unmounted = true;
         this._draggableObserver?.disconnect();
+        this._syncWatcherStop?.();
+        this._syncWatcherFieldsReadyStop?.();
     },
 };
 </script>
diff --git a/resources/js/tests/createMountScheduler.test.js b/resources/js/tests/createMountScheduler.test.js
new file mode 100644
index 00000000000..380df6c2dec
--- /dev/null
+++ b/resources/js/tests/createMountScheduler.test.js
@@ -0,0 +1,282 @@
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createMountScheduler } from '../util/createMountScheduler.js';
+import { mount } from '@vue/test-utils';
+import { nextTick, ref, h } from 'vue';
+
+beforeEach(() => {
+    vi.useFakeTimers({
+        toFake: [
+            'setTimeout', 'clearTimeout',
+            'setInterval', 'clearInterval',
+            'setImmediate', 'clearImmediate',
+            'queueMicrotask',
+            'requestAnimationFrame', 'cancelAnimationFrame',
+            'requestIdleCallback', 'cancelIdleCallback',
+            'Date',
+        ],
+    });
+});
+
+afterEach(() => {
+    vi.useRealTimers();
+});
+
+test('zero-arg factory still works (backward compat)', () => {
+    const scheduler = createMountScheduler();
+    expect(scheduler).toHaveProperty('schedule');
+    expect(typeof scheduler.schedule).toBe('function');
+});
+
+// Helper to flush requestAnimationFrame / requestIdleCallback
+const flushTick = async () => {
+    await vi.advanceTimersToNextTimerAsync();
+};
+
+test('processes multiple cheap callbacks within budget', async () => {
+    const scheduler = createMountScheduler({ budgetMs: 8 });
+    const results = [];
+
+    // Schedule 5 cheap callbacks
+    for (let i = 0; i < 5; i++) {
+        scheduler.schedule(() => results.push(i));
+    }
+
+    await flushTick();
+
+    // All 5 should complete in one tick since they're cheap
+    expect(results).toEqual([0, 1, 2, 3, 4]);
+});
+
+test('resumes remaining callbacks on next tick when budget exceeded', async () => {
+    let processedCount = 0;
+    const scheduler = createMountScheduler({ budgetMs: 5 });
+
+    // Schedule callbacks - first one is slow, others are fast
+    scheduler.schedule(() => {
+        const start = performance.now();
+        while (performance.now() - start < 10) {} // 10ms sync delay
+        processedCount++;
+    });
+
+    for (let i = 0; i < 4; i++) {
+        scheduler.schedule(() => processedCount++);
+    }
+
+    await flushTick();
+    // Budget was blown by first callback, so only 1 processed
+    expect(processedCount).toBe(1);
+
+    await flushTick();
+    // Next tick should process the rest
+    expect(processedCount).toBe(5);
+});
+
+test('error in one callback does not prevent others from running', async () => {
+    const scheduler = createMountScheduler({ budgetMs: 8 });
+    const results = [];
+
+    scheduler.schedule(() => results.push(1));
+    scheduler.schedule(() => { throw new Error('Intentional error'); });
+    scheduler.schedule(() => results.push(3));
+
+    // Spy on console.error
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await flushTick();
+
+    expect(results).toEqual([1, 3]);
+    expect(consoleSpy).toHaveBeenCalledOnce();
+
+    consoleSpy.mockRestore();
+});
+
+test('many cheap callbacks finish within reasonable iterations', async () => {
+    const scheduler = createMountScheduler({ budgetMs: 8 });
+    const results = [];
+
+    // 20 cheap callbacks
+    for (let i = 0; i < 20; i++) {
+        scheduler.schedule(() => results.push(i));
+    }
+
+    let iterations = 0;
+    while (results.length < 20 && iterations < 10) {
+        await flushTick();
+        iterations++;
+    }
+
+    expect(results.length).toBe(20);
+    expect(iterations).toBeLessThanOrEqual(3);
+});
+
+test('vue render time from a callback counts against the budget', async () => {
+    // Component that takes measurable time to render when it mounts.
+    const HeavyChild = {
+        setup() {
+            // Synthetic cost at setup time.
+            const start = performance.now();
+            while (performance.now() - start < 6) {}
+            return () => h('div');
+        },
+    };
+    const Parent = {
+        setup() {
+            const show = ref(false);
+            return { show };
+        },
+        render() {
+            return this.show ? h(HeavyChild) : h('div');
+        },
+    };
+
+    const scheduler = createMountScheduler({ budgetMs: 5 });
+    const wrappers = [mount(Parent), mount(Parent), mount(Parent)];
+    const mounted = [];
+
+    wrappers.forEach((w, i) => {
+        scheduler.schedule(() => {
+            w.vm.show = true;
+            mounted.push(i);
+        });
+    });
+
+    await flushTick();
+    // First flip triggers HeavyChild mount (~6ms real time via nextTick);
+    // budget is 5ms, so only one should process this tick.
+    expect(mounted.length).toBe(1);
+
+    await flushTick();
+    await flushTick();
+    expect(mounted.length).toBe(3);
+
+    wrappers.forEach(w => w.unmount());
+});
+
+test('scheduler recovers after a nextTick rejection', async () => {
+    const scheduler = createMountScheduler({ budgetMs: 8 });
+    const results = [];
+
+    // Mock nextTick to reject on the first invocation only.
+    const realNextTick = nextTick;
+    let first = true;
+    const spy = vi.spyOn(await import('vue'), 'nextTick').mockImplementation((...args) => {
+        if (first) { first = false; return Promise.reject(new Error('boom')); }
+        return realNextTick(...args);
+    });
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    scheduler.schedule(() => results.push('a'));
+    scheduler.schedule(() => results.push('b'));
+
+    await flushTick();
+    await flushTick();
+
+    expect(results).toEqual(['a', 'b']);
+    expect(consoleSpy).toHaveBeenCalled();
+
+    spy.mockRestore();
+    consoleSpy.mockRestore();
+});
+
+test('a callback that schedules more work runs on a later tick', async () => {
+    const scheduler = createMountScheduler({ budgetMs: 8 });
+    const order = [];
+
+    scheduler.schedule(() => {
+        order.push('a');
+        scheduler.schedule(() => order.push('b'));
+    });
+
+    await flushTick();
+    expect(order).toEqual(['a', 'b']);
+});
+
+test('respects budgetMs when requestIdleCallback fires with didTimeout', async () => {
+    const originalRIC = globalThis.requestIdleCallback;
+    let ricCallCount = 0;
+    globalThis.requestIdleCallback = (cb) => {
+        ricCallCount++;
+        setTimeout(() => cb({ didTimeout: true, timeRemaining: () => 0 }), 0);
+        return 0;
+    };
+
+    try {
+        const scheduler = createMountScheduler({ budgetMs: 5 });
+        const results = [];
+
+        // First callback exceeds the 5ms budget.
+        scheduler.schedule(() => {
+            const start = performance.now();
+            while (performance.now() - start < 10) {}
+            results.push('heavy');
+        });
+        for (let i = 0; i < 4; i++) scheduler.schedule(() => results.push(i));
+
+        // Drain until all five have run; cap iterations to avoid infinite loops on regression.
+        for (let i = 0; i < 10 && results.length < 5; i++) {
+            await flushTick();
+        }
+
+        expect(results).toEqual(['heavy', 0, 1, 2, 3]);
+
+        // With the fix the busy callback forces a yield, so rIC is entered at
+        // least twice. With the old `return false` bypass, all 5 drain in one
+        // batch and ricCallCount stays at 1.
+        expect(ricCallCount).toBeGreaterThan(1);
+    } finally {
+        if (originalRIC) globalThis.requestIdleCallback = originalRIC;
+        else delete globalThis.requestIdleCallback;
+    }
+});
+
+test('yields based on IdleDeadline.timeRemaining when idle is granted', async () => {
+    const originalRIC = globalThis.requestIdleCallback;
+    let ricCallCount = 0;
+    globalThis.requestIdleCallback = (cb) => {
+        ricCallCount++;
+        const grantTime = performance.now();
+        const deadline = {
+            didTimeout: false,
+            timeRemaining: () => Math.max(0, 10 - (performance.now() - grantTime)),
+        };
+        setTimeout(() => cb(deadline), 0);
+        return 0;
+    };
+
+    try {
+        const scheduler = createMountScheduler({ budgetMs: 100 });
+        const results = [];
+
+        for (let i = 0; i < 3; i++) {
+            scheduler.schedule(() => {
+                const start = performance.now();
+                while (performance.now() - start < 6) {}
+                results.push(i);
+            });
+        }
+
+        for (let i = 0; i < 10 && results.length < 3; i++) {
+            await flushTick();
+        }
+
+        expect(results).toEqual([0, 1, 2]);
+        expect(ricCallCount).toBeGreaterThan(1);
+    } finally {
+        if (originalRIC) globalThis.requestIdleCallback = originalRIC;
+        else delete globalThis.requestIdleCallback;
+    }
+});
+
+test('scheduler resumes cleanly after an earlier flush completes', async () => {
+    const scheduler = createMountScheduler({ budgetMs: 8 });
+    const results = [];
+
+    scheduler.schedule(() => results.push('a'));
+    await flushTick();
+    expect(results).toEqual(['a']);
+
+    scheduler.schedule(() => results.push('b'));
+    scheduler.schedule(() => results.push('c'));
+    await flushTick();
+    expect(results).toEqual(['a', 'b', 'c']);
+});
diff --git a/resources/js/util/createMountScheduler.js b/resources/js/util/createMountScheduler.js
new file mode 100644
index 00000000000..2554fcf0937
--- /dev/null
+++ b/resources/js/util/createMountScheduler.js
@@ -0,0 +1,49 @@
+import { nextTick } from 'vue';
+
+const DEFAULT_BUDGET_MS = 8;
+
+export function createMountScheduler({ budgetMs = DEFAULT_BUDGET_MS } = {}) {
+    const queue = [];
+    let flushing = false;
+
+    const waitForIdle = () => new Promise((resolve) => {
+        if (typeof requestIdleCallback === 'function') {
+            requestIdleCallback(resolve, { timeout: 50 });
+        } else {
+            requestAnimationFrame(() => resolve());
+        }
+    });
+
+    function schedule(callback) {
+        queue.push(callback);
+        if (!flushing) flush();
+    }
+
+    async function flush() {
+        flushing = true;
+        try {
+            while (queue.length) {
+                let deadline;
+                deadline = await waitForIdle();
+
+                const frameStart = performance.now();
+                const shouldYield = () => {
+                    if (deadline && typeof deadline.timeRemaining === 'function' && !deadline.didTimeout) {
+                        return deadline.timeRemaining() < 1;
+                    }
+                    return performance.now() - frameStart >= budgetMs;
+                };
+
+                while (queue.length && !shouldYield()) {
+                    const cb = queue.shift();
+                    try { cb?.(); } catch (e) { console.error(e); }
+                    try { await nextTick(); } catch (e) { console.error(e); }
+                }
+            }
+        } finally {
+            flushing = false;
+        }
+    }
+
+    return { schedule };
+}

From f021911e7acc1fceced5bc74dd85d431e7cca667 Mon Sep 17 00:00:00 2001
From: Jan Willem Rigters <janwillem@steets.nl>
Date: Thu, 23 Jul 2026 16:39:08 +0200
Subject: [PATCH 2/2] Reset files before commit, keep PublishForm timeout
 settings

---
 .../js/components/fieldtypes/Fieldtype.vue    |  39 +--
 .../fieldtypes/bard/BardFieldtype.vue         |  50 ++--
 .../js/components/fieldtypes/bard/Set.vue     | 119 ++------
 .../js/tests/createMountScheduler.test.js     | 282 ------------------
 resources/js/util/createMountScheduler.js     |  49 ---
 5 files changed, 56 insertions(+), 483 deletions(-)
 delete mode 100644 resources/js/tests/createMountScheduler.test.js
 delete mode 100644 resources/js/util/createMountScheduler.js

diff --git a/resources/js/components/fieldtypes/Fieldtype.vue b/resources/js/components/fieldtypes/Fieldtype.vue
index 249115f7b07..c6ee19b8aa3 100644
--- a/resources/js/components/fieldtypes/Fieldtype.vue
+++ b/resources/js/components/fieldtypes/Fieldtype.vue
@@ -43,39 +43,12 @@ export default {
             // When using the Options API, this feels more natural. However since this is a
             // computed, it won't be avaialble within data(). In those cases you will
             // need to use this.injectedPublishContainer.someValue.value directly.
-            //
-            // We build the cache once with lazy getters, so this computed has zero reactive
-            // deps and is never invalidated/recomputed itself — reading a specific key still
-            // goes through to the live ref, so dependency tracking happens correctly in
-            // whichever consumer's reactive scope reads it (e.g. a field's own condition
-            // computed), rather than recomputing this whole object for every field on the
-            // page whenever any one of the injected refs changes.
-            if (this._publishContainerCache) return this._publishContainerCache;
-
-            const cache = {};
-            const src = this.injectedPublishContainer;
-
-            for (const key in src) {
-                const val = src[key];
-
-                if (isRef(val)) {
-                    Object.defineProperty(cache, key, {
-                        enumerable: true,
-                        configurable: true,
-                        get: () => val.value,
-                    });
-                } else {
-                    Object.defineProperty(cache, key, {
-                        enumerable: true,
-                        configurable: true,
-                        writable: false,
-                        value: val,
-                    });
-                }
-            }
-
-            this._publishContainerCache = cache;
-            return cache;
+            return Object.fromEntries(
+               Object.entries(this.injectedPublishContainer).map(([key, value]) => [
+                   key,
+                   isRef(value) ? value.value : value,
+               ])
+           );
         },
 
         name() {
diff --git a/resources/js/components/fieldtypes/bard/BardFieldtype.vue b/resources/js/components/fieldtypes/bard/BardFieldtype.vue
index 794da78f86d..e682303b6f1 100644
--- a/resources/js/components/fieldtypes/bard/BardFieldtype.vue
+++ b/resources/js/components/fieldtypes/bard/BardFieldtype.vue
@@ -175,9 +175,8 @@ import readTimeEstimate from 'read-time-estimate';
 import { common, createLowlight } from 'lowlight';
 import 'highlight.js/styles/github.css';
 import importTiptap from '@/util/tiptap.js';
-import { computed, markRaw } from 'vue';
+import { computed } from 'vue';
 import { data_get } from "@/bootstrap/globals.js";
-import { createMountScheduler } from '@/util/createMountScheduler.js';
 import { useContentDirection } from '@/composables/content-direction';
 
 const lowlight = createLowlight(common);
@@ -225,7 +224,6 @@ export default {
                 bard: this.makeBardProvide(),
                 bardSets: this.config.sets,
                 showReplicatorFieldPreviews: this.config.previews,
-                mountScheduler: createMountScheduler(),
             },
             errorsById: {},
             debounceNextUpdate: true,
@@ -398,9 +396,8 @@ export default {
         this.initToolbarButtons();
         this.initEditor();
 
-        this.json = markRaw(this.editor.getJSON().content);
+        this.json = this.editor.getJSON().content;
         this.html = this.editor.getHTML();
-        this._lastDocSize = this.editor.state.doc.content.size;
 
 		this.$nextTick(() => this.mounted = true);
 
@@ -880,31 +877,24 @@ export default {
                         }
                     }, 1);
                 },
-                onUpdate: ({ transaction }) => {
-                    // Selection-only transactions (cursor moves, etc.) don't change the
-                    // document at all — skip all of the work below entirely for those.
-                    if (!transaction.docChanged) return;
-
-                    const newDocSize = this.editor.state.doc.content.size;
-                    const oldDocSize = this._lastDocSize ?? newDocSize;
-
-                    // doc.content.size changes on every keystroke, not just structural
-                    // edits (block add/remove). That's intentional here — debounceNextUpdate
-                    // previously used a recursive node-count comparison to approximate this,
-                    // but that required a full clone() + tree walk on every transaction just
-                    // to produce a coarser signal. If a debounce-suppression distinction
-                    // between "typed a character" and "added/removed a node" turns out to be
-                    // load-bearing elsewhere, this may need revisiting.
-                    if (oldDocSize !== newDocSize) this.debounceNextUpdate = false;
-                    this._lastDocSize = newDocSize;
-
-                    // markRaw prevents Vue from deep-reactive-proxying the full document
-                    // tree. Every node in a large Bard document would otherwise get its own
-                    // Proxy plus a dependency-tracking map, regenerated on every update — this
-                    // is the dominant cost (both CPU and memory) on large documents. json/html
-                    // are only used here for display/emit purposes and don't rely on deep
-                    // reactivity elsewhere in this component.
-                    this.json = markRaw(this.editor.getJSON().content);
+                onUpdate: () => {
+                    const oldJson = this.json;
+                    const newJson = clone(this.editor.getJSON().content);
+
+                    const countNodes = (nodes) => {
+                        if (!nodes || !Array.isArray(nodes)) return 0;
+                        let count = nodes.length;
+                        nodes.forEach(node => {
+                            if (node.content) {
+                                count += countNodes(node.content);
+                            }
+                        });
+                        return count;
+                    };
+
+                    if (countNodes(oldJson) !== countNodes(newJson)) this.debounceNextUpdate = false;
+
+                    this.json = newJson;
                     this.html = this.editor.getHTML();
                 },
                 onCreate: ({ editor }) => {
diff --git a/resources/js/components/fieldtypes/bard/Set.vue b/resources/js/components/fieldtypes/bard/Set.vue
index 9116763adc2..1c99d83d775 100644
--- a/resources/js/components/fieldtypes/bard/Set.vue
+++ b/resources/js/components/fieldtypes/bard/Set.vue
@@ -56,16 +56,14 @@
                             <Button icon="dots" variant="ghost" size="xs" :aria-label="__('Open dropdown menu')" @mousedown.prevent />
                         </template>
                         <DropdownMenu>
-                            <template v-if="fieldActions.length">
-                                <DropdownItem
-                                    v-for="action in fieldActions"
-                                    :key="action.title"
-                                    :text="action.title"
-                                    :variant="action.dangerous ? 'destructive' : 'default'"
-                                    @click="action.run(action)"
-                                />
-                                <DropdownSeparator />
-                            </template>
+                            <DropdownItem
+                                v-if="fieldActions.length"
+                                v-for="action in fieldActions"
+                                :text="action.title"
+                                :variant="action.dangerous ? 'destructive' : 'default'"
+                                @click="action.run(action)"
+                            />
+                            <DropdownSeparator v-if="fieldActions.length" />
                             <DropdownItem
                                 :text="__(collapsed ? __('Expand Set') : __('Collapse Set'))"
                                 @click="toggleCollapsedState"
@@ -82,22 +80,20 @@
             </header>
 
             <div
-                v-if="index !== undefined && hasFields && hasBeenExpanded"
+                v-if="index !== undefined && hasFields"
                 v-show="!collapsed"
                 :class="{ 'contain-paint': collapsed, 'isolate': !collapsed }"
                 class="border-t border-t-gray-300! dark:border-t-white/10!"
             >
-                <template v-if="fieldsReady">
-                    <FieldsProvider
-                        :fields="fields"
-                        :as-config="false"
-                        :read-only="isReadOnly"
-                        :field-path-prefix="fieldPathPrefix"
-                        :meta-path-prefix="metaPathPrefix"
-                    >
-                        <Fields class="p-4" />
-                    </FieldsProvider>
-                </template>
+                <FieldsProvider
+                    :fields="fields"
+                    :as-config="false"
+                    :read-only="isReadOnly"
+                    :field-path-prefix="fieldPathPrefix"
+                    :meta-path-prefix="metaPathPrefix"
+                >
+                    <Fields class="p-4" />
+                </FieldsProvider>
             </div>
         </div>
     </node-view-wrapper>
@@ -124,7 +120,6 @@ import { containerContextKey } from '@/components/ui/Publish/Container.vue';
 import { watch } from 'vue';
 import { reveal } from '@api';
 import { useUiDirection } from '@/composables/ui-direction';
-import { createMountScheduler } from '@/util/createMountScheduler.js';
 
 export default {
     props: nodeViewProps,
@@ -152,32 +147,9 @@ export default {
 
     mixins: [ManagesPreviewText, HasFieldActions],
 
-    data() {
-        return {
-            hasBeenExpanded: false,
-            fieldsReady: false,
-        };
-    },
-
-    watch: {
-        collapsed(collapsed) {
-            if (!collapsed && !this.hasBeenExpanded) {
-                this.hasBeenExpanded = true;
-                this.mountScheduler.schedule(() => {
-                    if (!this._unmounted) {
-                        this.fieldsReady = true;
-                    }
-                });
-            } else if (!collapsed) {
-                this.fieldsReady = true;
-            }
-        },
-    },
-
     inject: {
         bard: {},
         bardSets: {},
-        mountScheduler: { default: createMountScheduler() },
         publishContainer: { from: containerContextKey },
     },
 
@@ -396,38 +368,16 @@ export default {
     },
 
     mounted() {
-        if (!this.collapsed) {
-            this.hasBeenExpanded = true;
-            this.fieldsReady = true;
-        }
+        watch(
+            () => data_get(this.publishContainer.values.value, this.fieldPathPrefix),
+            (values) => {
+				if (! values) return;
+                if (JSON.stringify(values) === JSON.stringify(this.node.attrs.values)) return;
 
-        const startSyncWatcher = () => {
-            this._syncWatcherStop = watch(
-                () => data_get(this.publishContainer.values.value, this.fieldPathPrefix),
-                (values) => {
-                    if (!values) return;
-                    if (values === this.node.attrs.values) return;
-                    if (JSON.stringify(values) === JSON.stringify(this.node.attrs.values)) return;
-
-                    this.updateAttributes({ values });
-                },
-                { deep: true, immediate: true }
-            );
-        };
-
-        if (this.fieldsReady) {
-            startSyncWatcher();
-        } else {
-            // Collapsed on mount — don't stand up the sync watcher (or its
-            // initial deep JSON.stringify comparison) until this Set's fields
-            // are actually scheduled to render.
-            this._syncWatcherFieldsReadyStop = this.$watch('fieldsReady', (ready) => {
-                if (ready) {
-                    startSyncWatcher();
-                    this._syncWatcherFieldsReadyStop?.();
-                }
-            });
-        }
+                this.updateAttributes({ values });
+            },
+            { deep: true }
+        );
 
         reveal.mount(this.$refs.container, this.expand);
 
@@ -435,16 +385,10 @@ export default {
         // draggable ancestor. ProseMirror sets draggable=true on the node-view-wrapper
         // because the Set node spec has draggable:true. We must keep it false.
         this.$el.setAttribute('draggable', false);
-        this._draggablePending = false;
         this._draggableObserver = new MutationObserver(() => {
-            if (this._draggablePending) return;
-            this._draggablePending = true;
-            requestAnimationFrame(() => {
-                this._draggablePending = false;
-                if (!this._unmounted && this.$el.getAttribute('draggable') !== 'false') {
-                    this.$el.setAttribute('draggable', false);
-                }
-            });
+            if (this.$el.getAttribute('draggable') !== 'false') {
+                this.$el.setAttribute('draggable', false);
+            }
         });
         this._draggableObserver.observe(this.$el, { attributes: true, attributeFilter: ['draggable'] });
     },
@@ -454,10 +398,7 @@ export default {
     },
 
     beforeUnmount() {
-        this._unmounted = true;
         this._draggableObserver?.disconnect();
-        this._syncWatcherStop?.();
-        this._syncWatcherFieldsReadyStop?.();
     },
 };
 </script>
diff --git a/resources/js/tests/createMountScheduler.test.js b/resources/js/tests/createMountScheduler.test.js
deleted file mode 100644
index 380df6c2dec..00000000000
--- a/resources/js/tests/createMountScheduler.test.js
+++ /dev/null
@@ -1,282 +0,0 @@
-import { test, expect, vi, beforeEach, afterEach } from 'vitest';
-import { createMountScheduler } from '../util/createMountScheduler.js';
-import { mount } from '@vue/test-utils';
-import { nextTick, ref, h } from 'vue';
-
-beforeEach(() => {
-    vi.useFakeTimers({
-        toFake: [
-            'setTimeout', 'clearTimeout',
-            'setInterval', 'clearInterval',
-            'setImmediate', 'clearImmediate',
-            'queueMicrotask',
-            'requestAnimationFrame', 'cancelAnimationFrame',
-            'requestIdleCallback', 'cancelIdleCallback',
-            'Date',
-        ],
-    });
-});
-
-afterEach(() => {
-    vi.useRealTimers();
-});
-
-test('zero-arg factory still works (backward compat)', () => {
-    const scheduler = createMountScheduler();
-    expect(scheduler).toHaveProperty('schedule');
-    expect(typeof scheduler.schedule).toBe('function');
-});
-
-// Helper to flush requestAnimationFrame / requestIdleCallback
-const flushTick = async () => {
-    await vi.advanceTimersToNextTimerAsync();
-};
-
-test('processes multiple cheap callbacks within budget', async () => {
-    const scheduler = createMountScheduler({ budgetMs: 8 });
-    const results = [];
-
-    // Schedule 5 cheap callbacks
-    for (let i = 0; i < 5; i++) {
-        scheduler.schedule(() => results.push(i));
-    }
-
-    await flushTick();
-
-    // All 5 should complete in one tick since they're cheap
-    expect(results).toEqual([0, 1, 2, 3, 4]);
-});
-
-test('resumes remaining callbacks on next tick when budget exceeded', async () => {
-    let processedCount = 0;
-    const scheduler = createMountScheduler({ budgetMs: 5 });
-
-    // Schedule callbacks - first one is slow, others are fast
-    scheduler.schedule(() => {
-        const start = performance.now();
-        while (performance.now() - start < 10) {} // 10ms sync delay
-        processedCount++;
-    });
-
-    for (let i = 0; i < 4; i++) {
-        scheduler.schedule(() => processedCount++);
-    }
-
-    await flushTick();
-    // Budget was blown by first callback, so only 1 processed
-    expect(processedCount).toBe(1);
-
-    await flushTick();
-    // Next tick should process the rest
-    expect(processedCount).toBe(5);
-});
-
-test('error in one callback does not prevent others from running', async () => {
-    const scheduler = createMountScheduler({ budgetMs: 8 });
-    const results = [];
-
-    scheduler.schedule(() => results.push(1));
-    scheduler.schedule(() => { throw new Error('Intentional error'); });
-    scheduler.schedule(() => results.push(3));
-
-    // Spy on console.error
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    await flushTick();
-
-    expect(results).toEqual([1, 3]);
-    expect(consoleSpy).toHaveBeenCalledOnce();
-
-    consoleSpy.mockRestore();
-});
-
-test('many cheap callbacks finish within reasonable iterations', async () => {
-    const scheduler = createMountScheduler({ budgetMs: 8 });
-    const results = [];
-
-    // 20 cheap callbacks
-    for (let i = 0; i < 20; i++) {
-        scheduler.schedule(() => results.push(i));
-    }
-
-    let iterations = 0;
-    while (results.length < 20 && iterations < 10) {
-        await flushTick();
-        iterations++;
-    }
-
-    expect(results.length).toBe(20);
-    expect(iterations).toBeLessThanOrEqual(3);
-});
-
-test('vue render time from a callback counts against the budget', async () => {
-    // Component that takes measurable time to render when it mounts.
-    const HeavyChild = {
-        setup() {
-            // Synthetic cost at setup time.
-            const start = performance.now();
-            while (performance.now() - start < 6) {}
-            return () => h('div');
-        },
-    };
-    const Parent = {
-        setup() {
-            const show = ref(false);
-            return { show };
-        },
-        render() {
-            return this.show ? h(HeavyChild) : h('div');
-        },
-    };
-
-    const scheduler = createMountScheduler({ budgetMs: 5 });
-    const wrappers = [mount(Parent), mount(Parent), mount(Parent)];
-    const mounted = [];
-
-    wrappers.forEach((w, i) => {
-        scheduler.schedule(() => {
-            w.vm.show = true;
-            mounted.push(i);
-        });
-    });
-
-    await flushTick();
-    // First flip triggers HeavyChild mount (~6ms real time via nextTick);
-    // budget is 5ms, so only one should process this tick.
-    expect(mounted.length).toBe(1);
-
-    await flushTick();
-    await flushTick();
-    expect(mounted.length).toBe(3);
-
-    wrappers.forEach(w => w.unmount());
-});
-
-test('scheduler recovers after a nextTick rejection', async () => {
-    const scheduler = createMountScheduler({ budgetMs: 8 });
-    const results = [];
-
-    // Mock nextTick to reject on the first invocation only.
-    const realNextTick = nextTick;
-    let first = true;
-    const spy = vi.spyOn(await import('vue'), 'nextTick').mockImplementation((...args) => {
-        if (first) { first = false; return Promise.reject(new Error('boom')); }
-        return realNextTick(...args);
-    });
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    scheduler.schedule(() => results.push('a'));
-    scheduler.schedule(() => results.push('b'));
-
-    await flushTick();
-    await flushTick();
-
-    expect(results).toEqual(['a', 'b']);
-    expect(consoleSpy).toHaveBeenCalled();
-
-    spy.mockRestore();
-    consoleSpy.mockRestore();
-});
-
-test('a callback that schedules more work runs on a later tick', async () => {
-    const scheduler = createMountScheduler({ budgetMs: 8 });
-    const order = [];
-
-    scheduler.schedule(() => {
-        order.push('a');
-        scheduler.schedule(() => order.push('b'));
-    });
-
-    await flushTick();
-    expect(order).toEqual(['a', 'b']);
-});
-
-test('respects budgetMs when requestIdleCallback fires with didTimeout', async () => {
-    const originalRIC = globalThis.requestIdleCallback;
-    let ricCallCount = 0;
-    globalThis.requestIdleCallback = (cb) => {
-        ricCallCount++;
-        setTimeout(() => cb({ didTimeout: true, timeRemaining: () => 0 }), 0);
-        return 0;
-    };
-
-    try {
-        const scheduler = createMountScheduler({ budgetMs: 5 });
-        const results = [];
-
-        // First callback exceeds the 5ms budget.
-        scheduler.schedule(() => {
-            const start = performance.now();
-            while (performance.now() - start < 10) {}
-            results.push('heavy');
-        });
-        for (let i = 0; i < 4; i++) scheduler.schedule(() => results.push(i));
-
-        // Drain until all five have run; cap iterations to avoid infinite loops on regression.
-        for (let i = 0; i < 10 && results.length < 5; i++) {
-            await flushTick();
-        }
-
-        expect(results).toEqual(['heavy', 0, 1, 2, 3]);
-
-        // With the fix the busy callback forces a yield, so rIC is entered at
-        // least twice. With the old `return false` bypass, all 5 drain in one
-        // batch and ricCallCount stays at 1.
-        expect(ricCallCount).toBeGreaterThan(1);
-    } finally {
-        if (originalRIC) globalThis.requestIdleCallback = originalRIC;
-        else delete globalThis.requestIdleCallback;
-    }
-});
-
-test('yields based on IdleDeadline.timeRemaining when idle is granted', async () => {
-    const originalRIC = globalThis.requestIdleCallback;
-    let ricCallCount = 0;
-    globalThis.requestIdleCallback = (cb) => {
-        ricCallCount++;
-        const grantTime = performance.now();
-        const deadline = {
-            didTimeout: false,
-            timeRemaining: () => Math.max(0, 10 - (performance.now() - grantTime)),
-        };
-        setTimeout(() => cb(deadline), 0);
-        return 0;
-    };
-
-    try {
-        const scheduler = createMountScheduler({ budgetMs: 100 });
-        const results = [];
-
-        for (let i = 0; i < 3; i++) {
-            scheduler.schedule(() => {
-                const start = performance.now();
-                while (performance.now() - start < 6) {}
-                results.push(i);
-            });
-        }
-
-        for (let i = 0; i < 10 && results.length < 3; i++) {
-            await flushTick();
-        }
-
-        expect(results).toEqual([0, 1, 2]);
-        expect(ricCallCount).toBeGreaterThan(1);
-    } finally {
-        if (originalRIC) globalThis.requestIdleCallback = originalRIC;
-        else delete globalThis.requestIdleCallback;
-    }
-});
-
-test('scheduler resumes cleanly after an earlier flush completes', async () => {
-    const scheduler = createMountScheduler({ budgetMs: 8 });
-    const results = [];
-
-    scheduler.schedule(() => results.push('a'));
-    await flushTick();
-    expect(results).toEqual(['a']);
-
-    scheduler.schedule(() => results.push('b'));
-    scheduler.schedule(() => results.push('c'));
-    await flushTick();
-    expect(results).toEqual(['a', 'b', 'c']);
-});
diff --git a/resources/js/util/createMountScheduler.js b/resources/js/util/createMountScheduler.js
deleted file mode 100644
index 2554fcf0937..00000000000
--- a/resources/js/util/createMountScheduler.js
+++ /dev/null
@@ -1,49 +0,0 @@
-import { nextTick } from 'vue';
-
-const DEFAULT_BUDGET_MS = 8;
-
-export function createMountScheduler({ budgetMs = DEFAULT_BUDGET_MS } = {}) {
-    const queue = [];
-    let flushing = false;
-
-    const waitForIdle = () => new Promise((resolve) => {
-        if (typeof requestIdleCallback === 'function') {
-            requestIdleCallback(resolve, { timeout: 50 });
-        } else {
-            requestAnimationFrame(() => resolve());
-        }
-    });
-
-    function schedule(callback) {
-        queue.push(callback);
-        if (!flushing) flush();
-    }
-
-    async function flush() {
-        flushing = true;
-        try {
-            while (queue.length) {
-                let deadline;
-                deadline = await waitForIdle();
-
-                const frameStart = performance.now();
-                const shouldYield = () => {
-                    if (deadline && typeof deadline.timeRemaining === 'function' && !deadline.didTimeout) {
-                        return deadline.timeRemaining() < 1;
-                    }
-                    return performance.now() - frameStart >= budgetMs;
-                };
-
-                while (queue.length && !shouldYield()) {
-                    const cb = queue.shift();
-                    try { cb?.(); } catch (e) { console.error(e); }
-                    try { await nextTick(); } catch (e) { console.error(e); }
-                }
-            }
-        } finally {
-            flushing = false;
-        }
-    }
-
-    return { schedule };
-}