Skip to content

Lightpanda: the headless browser designed for AI and automation

Rework scheduler

Karl Seguin3b9359dc98c4
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 542f9a4cf..62d701eef 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -463,7 +463,7 @@ pub fn init(self: *Frame, frame_id: u32, page: *Page, opts: InitOpts) !void {
b.runIdleTasks();
return 200;
}
- }.runIdleTasks, 200, .{ .name = "frame.runIdleTasks", .low_priority = true });
+ }.runIdleTasks, 200, .{ .name = "frame.runIdleTasks", .blocks_done = false });
}
}
}
diff --git a/src/browser/js/Env.zig b/src/browser/js/Env.zig
index 77dc8780b..d56a2d8a8 100644
--- a/src/browser/js/Env.zig
+++ b/src/browser/js/Env.zig
@@ -461,7 +461,7 @@ pub fn runMacrotasks(self: *Env) !void {
pub fn hasMacrotasks(self: *Env) bool {
for (self.contexts.items) |ctx| {
- if (ctx.scheduler.high_priority.count() > 0) {
+ if (ctx.scheduler.blocksCompletion()) {
return true;
}
}
diff --git a/src/browser/js/Scheduler.zig b/src/browser/js/Scheduler.zig
index 9638ff29d..ae86e05a4 100644
--- a/src/browser/js/Scheduler.zig
+++ b/src/browser/js/Scheduler.zig
@@ -20,108 +20,106 @@ const std = @import("std");
const lp = @import("lightpanda");
const log = lp.log;
+const Allocator = std.mem.Allocator;
-const Queue = std.PriorityQueue(Task, void, struct {
- fn compare(_: void, a: Task, b: Task) std.math.Order {
- const time_order = std.math.order(a.run_at, b.run_at);
- if (time_order != .eq) return time_order;
- // Break ties with sequence number to maintain FIFO order
- return std.math.order(a.sequence, b.sequence);
- }
-}.compare);
+// low bits of a Task.key hold the FIFO sequence; the high 40 hold run_at
+// (~34 years of process uptime).
+const SEQ_BITS = 24;
+const SEQ_MASK = (@as(u64, 1) << SEQ_BITS) - 1;
const Scheduler = @This();
_sequence: u64,
-allocator: std.mem.Allocator,
+allocator: Allocator,
+
+// Tasks queued to be run at a specific time
+timed: Queue,
+
+// Tasks queued to be run at the next (optimization for when .run_at = 0)
+immediate: Immediate,
+
+// Tasks queued to run before anything else (i.e. scheduler.yield)
+front: Immediate,
+
// Some things (e.g. IndexedDB) can have operations that are only valid for a
// specific task boundary. So every time we start a task, we increment the
// scheduler's generation. Code can snapshot this version and then compare it
// later to see if we're still in the same task.
generation: u64,
-low_priority: Queue,
-high_priority: Queue,
-pub fn init(allocator: std.mem.Allocator) Scheduler {
+// Number of pending tasks with blocks_done=true. While > 0, the page isn't
+// considered done.
+blocking: u32,
+
+pub fn init(allocator: Allocator) Scheduler {
return .{
._sequence = 0,
.allocator = allocator,
.generation = 0,
- .low_priority = Queue.initContext({}),
- .high_priority = Queue.initContext({}),
+ .blocking = 0,
+ .timed = Queue.initContext({}),
+ .immediate = .{},
+ .front = .{},
};
}
pub fn deinit(self: *Scheduler) void {
- finalizeTasks(&self.low_priority);
- finalizeTasks(&self.high_priority);
+ self.finalizeTasks();
}
pub fn reset(self: *Scheduler) void {
- finalizeTasks(&self.low_priority);
- finalizeTasks(&self.high_priority);
- self.low_priority.clearRetainingCapacity();
- self.high_priority.clearRetainingCapacity();
+ self.finalizeTasks();
+ self.blocking = 0;
+ self.front.clear();
+ self.immediate.clear();
+ self.timed.clearRetainingCapacity();
}
const AddOpts = struct {
name: []const u8 = "",
- front: bool = false, // run before any timed tasks, multi-fronts are FIFO amongst themselves
- low_priority: bool = false,
+ front: bool = false, // run before any other tasks, multi-fronts are FIFO amongst themselves
+ blocks_done: bool = true,
finalizer: ?Finalizer = null,
};
pub fn add(self: *Scheduler, ctx: *anyopaque, cb: Callback, run_in_ms: u32, opts: AddOpts) !void {
if (comptime lp.IS_DEBUG) {
- log.debug(.scheduler, "scheduler.add", .{ .name = opts.name, .run_in_ms = run_in_ms, .low_priority = opts.low_priority });
+ log.debug(.scheduler, "scheduler.add", .{ .name = opts.name, .run_in_ms = run_in_ms, .blocks_done = opts.blocks_done });
+ }
+ if (comptime lp.IS_DEBUG) {
+ // run_in_ms is ignored when opts.front == true, but let's enforce this
+ // so that a caller isn't expecting something we don't support
+ std.debug.assert(opts.front == false or run_in_ms == 0);
}
- var queue = if (opts.low_priority) &self.low_priority else &self.high_priority;
- const seq = self._sequence + 1;
- self._sequence = seq;
- return queue.push(self.allocator, .{
+
+ const run_at = lp.datetime.milliTimestamp(.boot) + run_in_ms;
+ const task: Task = .{
.ctx = ctx,
.callback = cb,
- .sequence = seq,
.name = opts.name,
+ .key = self.nextKey(run_at),
.finalizer = opts.finalizer,
- .run_at = if (opts.front) 0 else lp.datetime.milliTimestamp(.boot) + run_in_ms,
- });
-}
-
-pub fn run(self: *Scheduler) !void {
- try self.runQueue(&self.low_priority);
- try self.runQueue(&self.high_priority);
-}
+ .blocks_done = opts.blocks_done,
+ };
-pub fn hasReadyTasks(self: *Scheduler) bool {
- const now = lp.datetime.milliTimestamp(.boot);
- return queueHasReadyTask(&self.low_priority, now) or queueHasReadyTask(&self.high_priority, now);
-}
+ if (opts.front) {
+ try self.front.push(self.allocator, task);
+ } else if (run_in_ms == 0) {
+ try self.immediate.push(self.allocator, task);
+ } else {
+ try self.timed.push(self.allocator, task);
+ }
-pub fn msToNext(self: *Scheduler) ?u64 {
- var next: ?u64 = null;
- const now = lp.datetime.milliTimestamp(.boot);
- for ([_]*Queue{ &self.high_priority, &self.low_priority }) |queue| {
- const task = queue.peek() orelse continue;
- const ms = if (task.run_at <= now) 0 else task.run_at - now;
- if (next == null or ms < next.?) {
- next = ms;
- }
+ if (opts.blocks_done) {
+ self.blocking += 1;
}
- return next;
}
-fn runQueue(self: *Scheduler, queue: *Queue) !void {
- if (queue.count() == 0) {
- return;
- }
+pub fn run(self: *Scheduler) !void {
const start = lp.datetime.milliTimestamp(.boot);
var now = start;
- while (queue.peek()) |*task_| {
- if (task_.run_at > now) {
- return;
- }
- var task = queue.pop().?;
+ while (self.popReady(now)) |task_| {
+ var task = task_;
if (comptime lp.IS_DEBUG) {
log.debug(.scheduler, "scheduler.runTask", .{ .name = task.name });
}
@@ -138,8 +136,11 @@ fn runQueue(self: *Scheduler, queue: *Queue) !void {
if (comptime lp.IS_DEBUG) {
std.debug.assert(ms != 0);
}
- task.run_at = now + ms;
- try self.low_priority.push(self.allocator, task);
+ // A task that endlessly reschedules itself would keep the page
+ // alive forever, so repeats never block completion.
+ task.blocks_done = false;
+ task.key = self.nextKey(now + ms);
+ try self.timed.push(self.allocator, task);
}
now = lp.datetime.milliTimestamp(.boot);
@@ -147,16 +148,81 @@ fn runQueue(self: *Scheduler, queue: *Queue) !void {
return;
}
}
- return;
}
-fn queueHasReadyTask(queue: *Queue, now: u64) bool {
- const task = queue.peek() orelse return false;
- return task.run_at <= now;
+pub fn hasReadyTasks(self: *Scheduler) bool {
+ const ms = self.msToNext() orelse return false;
+ return ms == 0;
+}
+
+pub fn blocksCompletion(self: *const Scheduler) bool {
+ return self.blocking > 0;
+}
+
+pub fn msToNext(self: *Scheduler) ?u64 {
+ if (self.immediate.peek() != null or self.front.peek() != null) {
+ return 0;
+ }
+ const task = self.timed.peek() orelse return null;
+ const run_at = task.runAt();
+ const now = lp.datetime.milliTimestamp(.boot);
+ return if (run_at <= now) 0 else run_at - now;
+}
+
+fn nextKey(self: *Scheduler, run_at: u64) u64 {
+ if (comptime lp.IS_DEBUG) {
+ std.debug.assert(run_at >> (64 - SEQ_BITS) == 0);
+ }
+ self._sequence +%= 1;
+ return (run_at << SEQ_BITS) | (self._sequence & SEQ_MASK);
+}
+
+fn popReady(self: *Scheduler, now: u64) ?Task {
+ const task = task: {
+ if (self.front.peek() != null) {
+ break :task self.front.pop();
+ }
+
+ const immediate = self.immediate.peek();
+ const timed = self.timed.peek();
+
+ const pick_immediate = if (immediate == null)
+ false
+ else if (timed == null)
+ true
+ else
+ immediate.?.key < timed.?.key;
+
+ if (pick_immediate) {
+ break :task self.immediate.pop();
+ }
+
+ const candidate = timed orelse return null;
+ if (candidate.runAt() > now) {
+ return null;
+ }
+
+ break :task self.timed.pop().?;
+ };
+
+ if (task.blocks_done) {
+ self.blocking -= 1;
+ }
+ return task;
}
-fn finalizeTasks(queue: *Queue) void {
- var it = queue.iterator();
+fn finalizeTasks(self: *Scheduler) void {
+ for (self.front.pending()) |task| {
+ if (task.finalizer) |func| {
+ func(task.ctx);
+ }
+ }
+ for (self.immediate.pending()) |task| {
+ if (task.finalizer) |func| {
+ func(task.ctx);
+ }
+ }
+ var it = self.timed.iterator();
while (it.next()) |t| {
if (t.finalizer) |func| {
func(t.ctx);
@@ -165,13 +231,152 @@ fn finalizeTasks(queue: *Queue) void {
}
const Task = struct {
- run_at: u64,
- sequence: u64,
+ key: u64, // (run_at << SEQ_BITS) | sequence — tasks execute in key order
ctx: *anyopaque,
name: []const u8,
+ blocks_done: bool,
callback: Callback,
finalizer: ?Finalizer,
+
+ fn runAt(self: Task) u64 {
+ return self.key >> SEQ_BITS;
+ }
+};
+
+const Queue = std.PriorityQueue(Task, void, struct {
+ fn compare(_: void, a: Task, b: Task) std.math.Order {
+ return std.math.order(a.key, b.key);
+ }
+}.compare);
+
+// FIFO for 0-delay and front tasks. They dominate real pages and this avoids
+// the PriorityQueue sorting.
+const Immediate = struct {
+ head: usize = 0,
+ tasks: std.ArrayList(Task) = .empty,
+
+ fn push(self: *Immediate, allocator: Allocator, task: Task) !void {
+ // pop can only reset tasks when its fully drained (which might not
+ // be possible to do per-run in our 500ms budget). To prevent timer loop
+ // from preventing the cleanup from ever happening, we compact on push
+ // once we have enough entries to justify it (16 is arbitrarily chosen).
+ const head = self.head;
+ const live = self.tasks.items.len - head;
+ if (head > 16 and head >= live) {
+ std.mem.copyForwards(Task, self.tasks.items[0..live], self.tasks.items[head..]);
+ self.tasks.shrinkRetainingCapacity(live);
+ self.head = 0;
+ }
+ return self.tasks.append(allocator, task);
+ }
+
+ fn peek(self: *const Immediate) ?Task {
+ if (self.head == self.tasks.items.len) {
+ return null;
+ }
+ return self.tasks.items[self.head];
+ }
+
+ fn pop(self: *Immediate) Task {
+ const task = self.tasks.items[self.head];
+ self.head += 1;
+ if (self.head == self.tasks.items.len) {
+ self.clear();
+ }
+ return task;
+ }
+
+ fn pending(self: *const Immediate) []Task {
+ return self.tasks.items[self.head..];
+ }
+
+ fn clear(self: *Immediate) void {
+ self.head = 0;
+ self.tasks.clearRetainingCapacity();
+ }
};
const Callback = *const fn (ctx: *anyopaque) anyerror!?u32;
const Finalizer = *const fn (ctx: *anyopaque) void;
+
+const testing = @import("../../testing.zig");
+test "Scheduler: immediates are FIFO, front runs first" {
+ var s = Scheduler.init(testing.arena_allocator);
+ var ran: std.ArrayList(u8) = .empty;
+ var t1: TestTask = .{ .id = 1, .ran = &ran };
+ var t2: TestTask = .{ .id = 2, .ran = &ran };
+ var t3: TestTask = .{ .id = 3, .ran = &ran };
+ var t4: TestTask = .{ .id = 4, .ran = &ran };
+
+ try s.add(&t1, TestTask.run, 0, .{});
+ try s.add(&t2, TestTask.run, 0, .{});
+ try s.add(&t3, TestTask.run, 0, .{ .front = true });
+ try s.add(&t4, TestTask.run, 0, .{ .front = true });
+ try s.run();
+ try testing.expectEqualSlices(u8, &.{ 3, 4, 1, 2 }, ran.items);
+}
+
+test "Scheduler: due timed tasks run before newer immediates" {
+ var s = Scheduler.init(testing.arena_allocator);
+ var ran: std.ArrayList(u8) = .empty;
+ var t1: TestTask = .{ .id = 1, .ran = &ran };
+ var t2: TestTask = .{ .id = 2, .ran = &ran };
+
+ try s.add(&t1, TestTask.run, 1, .{});
+ lp.io.sleep(.fromMilliseconds(5), .awake) catch {};
+ try s.add(&t2, TestTask.run, 0, .{});
+ try s.run();
+ try testing.expectEqualSlices(u8, &.{ 1, 2 }, ran.items);
+}
+
+test "Scheduler: blocksCompletion" {
+ var s = Scheduler.init(testing.arena_allocator);
+ var ran: std.ArrayList(u8) = .empty;
+ var t1: TestTask = .{ .id = 1, .ran = &ran, .repeat = 20 };
+ var t2: TestTask = .{ .id = 2, .ran = &ran };
+
+ try testing.expectEqual(false, s.blocksCompletion());
+ try s.add(&t1, TestTask.run, 0, .{});
+ try s.add(&t2, TestTask.run, 0, .{ .blocks_done = false });
+ try testing.expectEqual(true, s.blocksCompletion());
+
+ try s.run();
+ try testing.expectEqualSlices(u8, &.{ 1, 2 }, ran.items);
+ // t1 was re-queued 20ms out, but repeats don't block completion
+ try testing.expectEqual(1, s.timed.count());
+ try testing.expectEqual(false, s.blocksCompletion());
+}
+
+test "Scheduler: immediate queue reclaims consumed prefix" {
+ var im: Immediate = .{};
+ const dummy: Task = .{
+ .key = 0,
+ .name = "",
+ .ctx = undefined,
+ .finalizer = null,
+ .blocks_done = false,
+ .callback = undefined,
+ };
+
+ // keep 2 tasks live at all times so pop never fully drains
+ try im.push(testing.arena_allocator, dummy);
+ try im.push(testing.arena_allocator, dummy);
+ for (0..10_000) |_| {
+ _ = im.pop();
+ try im.push(testing.arena_allocator, dummy);
+ }
+ try testing.expect(im.tasks.items.len <= 64);
+}
+
+const TestTask = struct {
+ id: u8,
+ ran: *std.ArrayList(u8),
+ repeat: ?u32 = null,
+
+ fn run(ptr: *anyopaque) anyerror!?u32 {
+ const self: *TestTask = @ptrCast(@alignCast(ptr));
+ try self.ran.append(testing.arena_allocator, self.id);
+ defer self.repeat = null;
+ return self.repeat;
+ }
+};
diff --git a/src/browser/webapi/BroadcastChannel.zig b/src/browser/webapi/BroadcastChannel.zig
index 7da78b72d..4ad4e706e 100644
--- a/src/browser/webapi/BroadcastChannel.zig
+++ b/src/browser/webapi/BroadcastChannel.zig
@@ -103,7 +103,6 @@ pub fn postMessage(self: *BroadcastChannel, message: js.Value, exec: *Execution)
try exec.js.scheduler.add(callback, PostMessageCallback.run, 0, .{
.name = "BroadcastChannel.postMessage",
- .low_priority = false,
.finalizer = PostMessageCallback.cancelled,
});
}
diff --git a/src/browser/webapi/DedicatedWorkerGlobalScope.zig b/src/browser/webapi/DedicatedWorkerGlobalScope.zig
index 249bf4aa0..d6859575d 100644
--- a/src/browser/webapi/DedicatedWorkerGlobalScope.zig
+++ b/src/browser/webapi/DedicatedWorkerGlobalScope.zig
@@ -161,7 +161,6 @@ fn scheduleMessage(self: *DedicatedWorkerGlobalScope, cloned_data: ?js.Value.Glo
try wgs.js.scheduler.add(callback, ReceiveMessageCallback.run, 0, .{
.name = "WorkerGlobalScope.receiveMessage",
- .low_priority = false,
.finalizer = ReceiveMessageCallback.cancelled,
});
}
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index 5fa85dd97..180addb36 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -1827,7 +1827,7 @@ fn scheduleScrollEvents(self: *Element, frame: *Frame) !void {
}
try frame.js.scheduler.add(task, ScrollEventTask.run, 10, .{
.name = "element.scrollEvents",
- .low_priority = true,
+ .blocks_done = false,
.finalizer = ScrollEventTask.cancelled,
});
}
diff --git a/src/browser/webapi/MessagePort.zig b/src/browser/webapi/MessagePort.zig
index 59b8740f9..95b3b4ac5 100644
--- a/src/browser/webapi/MessagePort.zig
+++ b/src/browser/webapi/MessagePort.zig
@@ -173,7 +173,6 @@ fn scheduleDelivery(self: *MessagePort, message: js.Value.Global) !void {
try exec.js.scheduler.add(callback, DeliverCallback.run, 0, .{
.name = "MessagePort.postMessage",
- .low_priority = false,
.finalizer = DeliverCallback.cancelled,
});
}
diff --git a/src/browser/webapi/SharedWorkerGlobalScope.zig b/src/browser/webapi/SharedWorkerGlobalScope.zig
index c4ac47c95..afa2eec6c 100644
--- a/src/browser/webapi/SharedWorkerGlobalScope.zig
+++ b/src/browser/webapi/SharedWorkerGlobalScope.zig
@@ -348,7 +348,6 @@ fn scheduleConnect(self: *SharedWorkerGlobalScope, port: *MessagePort) !void {
try wgs.js.scheduler.add(callback, ConnectCallback.run, 0, .{
.name = "SharedWorkerGlobalScope.connect",
- .low_priority = false,
.finalizer = ConnectCallback.cancelled,
});
}
diff --git a/src/browser/webapi/Timers.zig b/src/browser/webapi/Timers.zig
index a3d6d4e59..dea31bf5c 100644
--- a/src/browser/webapi/Timers.zig
+++ b/src/browser/webapi/Timers.zig
@@ -31,6 +31,11 @@ const log = lp.log;
const CLAMP_MS = 4;
const CLAMP_NESTING = 5;
+// Once we hit this depth, tasks are scheduled with blocks_done = false. This
+// prevents, for example, a setTimeout that sets itself, from blocking the Runner
+// from considering the page "done" forever (more commonly seen with requestAnimationFrame)
+const BLOCKING_NESTING = 10;
+
// airbnb has 600+ timers
const MAX_CALLBACKS = 2048;
@@ -45,10 +50,10 @@ _repeating: u32 = 0, // # of repeating timers we have
_callbacks: CallbackHashMap = .{},
// We keep the depth of the timers (a setTimeout calling a setTimeout). When
-// the depth reaches CLAMP_NESTING, the minimum timeout is 4ms. This is per-
-// spec and it's necessary to prevent some sites from virtually breaking because
-// they repeatedly do heavy work in endlessly looping setTimeout with a short
-// timeout (often of 0ms)
+// the timer depth reaches CLAMP_NESTING, the minimum timeout is 4ms. This is
+// per-spec and it's necessary to prevent some sites from virtually breaking
+// because they repeatedly do heavy work in endlessly looping setTimeout with
+// a short timeout (often of 0ms).
_nesting_level: u8 = 0,
const Key = u32;
@@ -77,7 +82,7 @@ pub const ScheduleOpts = struct {
repeat: bool,
params: []js.Value.Global,
name: []const u8,
- low_priority: bool = false,
+ blocks_done: bool = true,
mode: Mode = .normal,
};
@@ -101,7 +106,7 @@ pub fn schedule(
const timer_id = self._timer_id +% 1;
self._timer_id = timer_id;
- const nesting = @min(self._nesting_level + 1, CLAMP_NESTING + 1);
+ const nesting = @min(self._nesting_level + 1, BLOCKING_NESTING + 1);
const delay = if (nesting > CLAMP_NESTING and delay_ms < CLAMP_MS) CLAMP_MS else delay_ms;
var persisted_params: []js.Value.Global = &.{};
@@ -133,7 +138,7 @@ pub fn schedule(
try exec.js.scheduler.add(callback, ScheduleCallback.run, delay, .{
.name = opts.name,
- .low_priority = opts.low_priority,
+ .blocks_done = opts.blocks_done and nesting <= BLOCKING_NESTING,
.finalizer = ScheduleCallback.cancelled,
});
@@ -253,7 +258,7 @@ const ScheduleCallback = struct {
if (self.repeat_ms) |ms| {
// each repeat re-enters the timer initialization steps, so the
// nesting level keeps growing and sub-4ms intervals get clamped.
- self.nesting = @min(self.nesting + 1, CLAMP_NESTING + 1);
+ self.nesting = @min(self.nesting + 1, BLOCKING_NESTING + 1);
if (self.nesting > CLAMP_NESTING and ms < CLAMP_MS) {
return CLAMP_MS;
}
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index 507009dd8..4181ffbbd 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -567,7 +567,7 @@ pub fn requestIdleCallback(self: *Window, cb: js.Function.Global, opts_: ?Reques
.mode = .idle,
.repeat = false,
.params = &.{},
- .low_priority = true,
+ .blocks_done = false,
.name = "window.requestIdleCallback",
});
}
@@ -858,7 +858,6 @@ pub fn postMessage(self: *Window, message: js.Value, target_origin: ?[]const u8,
try target_frame.js.scheduler.add(callback, PostMessageCallback.run, 0, .{
.name = "postMessage",
- .low_priority = false,
.finalizer = PostMessageCallback.cancelled,
});
}
@@ -969,7 +968,7 @@ pub fn scrollTo(self: *Window, opts: ScrollToOpts, y: ?i32, frame: *Frame) !void
}
}.dispatch,
10,
- .{ .low_priority = true },
+ .{ .blocks_done = false },
);
// We dispatch scrollend event asynchronously after 20ms.
try frame.js.scheduler.add(
@@ -995,7 +994,7 @@ pub fn scrollTo(self: *Window, opts: ScrollToOpts, y: ?i32, frame: *Frame) !void
}
}.dispatch,
20,
- .{ .low_priority = true },
+ .{ .blocks_done = false },
);
}
diff --git a/src/browser/webapi/Worker.zig b/src/browser/webapi/Worker.zig
index c775d8626..2a572d986 100644
--- a/src/browser/webapi/Worker.zig
+++ b/src/browser/webapi/Worker.zig
@@ -365,7 +365,6 @@ pub fn receiveMessage(self: *Worker, data: js.Value) !void {
try frame.js.scheduler.add(callback, ReceiveMessageCallback.run, 0, .{
.name = "Worker.receiveMessage",
- .low_priority = false,
.finalizer = ReceiveMessageCallback.cancelled,
});
}
diff --git a/src/browser/webapi/storage/CookieStore.zig b/src/browser/webapi/storage/CookieStore.zig
index 5ff69cee4..62451e734 100644
--- a/src/browser/webapi/storage/CookieStore.zig
+++ b/src/browser/webapi/storage/CookieStore.zig
@@ -117,7 +117,6 @@ fn onCookieChanged(ctx: *anyopaque, data: *const Notification.CookieChanged) !vo
try exec.js.scheduler.add(cb, ChangeCallback.run, 0, .{
.name = "CookieStore.change",
- .low_priority = false,
.finalizer = ChangeCallback.cancelled,
});
}