Lightpanda: the headless browser designed for AI and automation
webapi: Make MessagePort transferable
Karl Seguin253bf79f3766
diff --git a/src/browser/js/Value.zig b/src/browser/js/Value.zigindex a2ab7fa6f..015d06d8a 100644--- a/src/browser/js/Value.zig+++ b/src/browser/js/Value.zig@@ -410,8 +410,8 @@ pub fn jsonStringify(self: Value, jws: anytype) !void {}// Clones host objects listed in cloneable_types; throws a DataCloneError for-// any other. Does not support transferables which require additional delegate-// callbacks.+// any other. Transferring MessagePorts goes through serializeTransfer /+// deserializeTransfer (see MessagePort.cloneMessage).pub fn structuredClone(self: Value) !Value {return self.structuredCloneTo(self.local);}@@ -442,9 +442,17 @@ pub const Serialized = struct {// Serialize `self` into a V8-owned buffer. The caller must call deinit on the// result. Raises a JS exception (DataCloneError) for unserializable values.pub fn serialize(self: Value) !Serialized {+ return self.serializeTransfer(&.{});+}++// Like serialize, but each MessagePort in `transfer` is written as its index+// in that list, for deserializeTransfer to swap in the moved port. A port not+// in `transfer` is still a DataCloneError.+pub fn serializeTransfer(self: Value, transfer: []const *MessagePort) !Serialized {var delegate_ctx = CloneDelegate.SerializeContext{.local = self.local,.serializer = undefined,+ .transfer = transfer,};const serializer = v8.v8__ValueSerializer__New(self.local.isolate.handle, &.{.data = &delegate_ctx,@@ -472,9 +480,16 @@ pub fn serialize(self: Value) !Serialized {// Deserialize a structured-serialized buffer (from `serialize`) into a value in// `local`'s context. A malformed buffer surfaces as error.JsException.pub fn deserialize(local: *const js.Local, bytes: []const u8) !Value {+ return deserializeTransfer(local, bytes, &.{});+}++// `ports` are the transferred ports, already moved into `local`'s context, in+// the order of the `transfer` list given to serializeTransfer.+pub fn deserializeTransfer(local: *const js.Local, bytes: []const u8, ports: []const *MessagePort) !Value {var delegate_ctx = CloneDelegate.DeserializeContext{.local = local,.deserializer = undefined,+ .ports = ports,};const deserializer = v8.v8__ValueDeserializer__New(local.isolate.handle, bytes.ptr, bytes.len, &.{.data = &delegate_ctx,@@ -513,6 +528,11 @@ const cloneable_types = .{@import("../webapi/webcodecs/VideoFrame.zig"),};+const MessagePort = @import("../webapi/MessagePort.zig");++// Tag for a transferred MessagePort, after the cloneable_types tags.+const transferred_port_tag: u32 = cloneable_types.len;+comptime {// writeHostObject relies on subtypes coming after their prototypes.for (0..cloneable_types.len) |i| {@@ -587,11 +607,13 @@ const CloneDelegate = struct {const SerializeContext = struct {local: *const js.Local,serializer: *v8.ValueSerializer,+ transfer: []const *MessagePort,};const DeserializeContext = struct {local: *const js.Local,deserializer: *v8.ValueDeserializer,+ ports: []const *MessagePort,};// Called when V8 encounters an object with embedder fields, i.e. one of@@ -605,6 +627,13 @@ const CloneDelegate = struct {const obj = object orelse break :blk;const tao = TaggedOpaque.fromObject(obj) orelse break :blk;+ if (tao.as(MessagePort)) |port| {+ const index = std.mem.findScalar(*MessagePort, ctx.transfer, port) orelse break :blk;+ v8.v8__ValueSerializer__WriteUint32(ctx.serializer, transferred_port_tag);+ v8.v8__ValueSerializer__WriteUint32(ctx.serializer, @intCast(index));+ return .{ .has_value = true, .value = true };+ }+// Serialize as the closest cloneable type: subtypes are listed// after their prototypes, so the last match is the closest.inline for (0..cloneable_types.len) |i| {@@ -637,6 +666,12 @@ const CloneDelegate = struct {var tag: u32 = undefined;if (v8.v8__ValueDeserializer__ReadUint32(ctx.deserializer, &tag)) {+ if (tag == transferred_port_tag) {+ return readTransferredPort(ctx) orelse {+ throwDataCloneException(local, null);+ return null;+ };+ }var reader = StructuredReader{ .local = local, .deserializer = ctx.deserializer };inline for (cloneable_types, 0..) |T, i| {if (tag == i) {@@ -652,6 +687,18 @@ const CloneDelegate = struct {return null;}+ fn readTransferredPort(ctx: *DeserializeContext) ?*const v8.Object {+ var index: u32 = undefined;+ if (!v8.v8__ValueDeserializer__ReadUint32(ctx.deserializer, &index)) {+ return null;+ }+ if (index >= ctx.ports.len) {+ return null;+ }+ const js_obj = ctx.local.mapZigInstanceToJs(null, ctx.ports[index]) catch return null;+ return js_obj.handle;+ }+fn readCloneable(comptime T: type, reader: *StructuredReader) ?*const v8.Object {const local = reader.local;const instance = T.structuredDeserialize(reader, local.ctx.page) catch return null;diff --git a/src/browser/tests/message_channel.html b/src/browser/tests/message_channel.htmlindex 12c5e5cc9..f95268ed3 100644--- a/src/browser/tests/message_channel.html+++ b/src/browser/tests/message_channel.html@@ -103,4 +103,187 @@}</script>+<script id="transfer" type=module>+ const state = await testing.async();++ // a port nested in the message and listed in transfer arrives as the moved+ // port, in both e.data and e.ports+ const carrier = new MessageChannel();+ const inner = new MessageChannel();+ const received = await new Promise((resolve) => {+ carrier.port2.onmessage = (e) => resolve(e);+ carrier.port1.postMessage({ port: inner.port2 }, [inner.port2]);+ });++ // the moved port stays entangled with inner.port1+ const echoed = await new Promise((resolve) => {+ inner.port1.onmessage = (e) => resolve(e.data);+ received.data.port.postMessage('through moved port');+ });++ // StructuredSerializeOptions form+ const viaOptions = new MessageChannel();+ const optionsEvent = await new Promise((resolve) => {+ carrier.port2.onmessage = (e) => resolve(e);+ carrier.port1.postMessage('opts', { transfer: [viaOptions.port1] });+ });++ state.resolve();+ await state.done(() => {+ testing.expectEqual(1, received.ports.length);+ testing.expectEqual(true, received.ports[0] === received.data.port);+ testing.expectEqual(false, received.data.port === inner.port2);+ testing.expectEqual('through moved port', echoed);++ testing.expectEqual('opts', optionsEvent.data);+ testing.expectEqual(1, optionsEvent.ports.length);+ });+</script>++<script id="transfer-errors" type=module>+ function dataCloneError(fn) {+ try {+ fn();+ } catch (e) {+ return e.name;+ }+ return 'no error';+ }++ const channel = new MessageChannel();+ const other = new MessageChannel();++ // a port in the message must be in the transfer list+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(other.port1)));+ // a port can't transfer itself+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(null, [channel.port1])));+ // duplicates+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(null, [other.port1, other.port1])));+ // non-transferable+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(null, [{}])));++ // once transferred, a port is detached and can't be transferred again+ channel.port1.postMessage(null, [other.port1]);+ testing.expectEqual('DataCloneError', dataCloneError(() => channel.port1.postMessage(null, [other.port1])));+</script>++<script id="window-transfer" type=module>+ const state = await testing.async();++ const channel = new MessageChannel();+ const event = await new Promise((resolve) => {+ window.addEventListener('message', function listener(e) {+ if (e.data && e.data.port) {+ window.removeEventListener('message', listener);+ resolve(e);+ }+ });+ window.postMessage({ port: channel.port2 }, '*', [channel.port2]);+ });++ const echoed = await new Promise((resolve) => {+ channel.port1.onmessage = (e) => resolve(e.data);+ event.data.port.postMessage('from window message');+ });++ state.resolve();+ await state.done(() => {+ testing.expectEqual(true, event.ports[0] === event.data.port);+ testing.expectEqual('from window message', echoed);+ });+</script>++<script id="transfer-in-flight" type=module>+ const state = await testing.async();++ // port2 is started, so 'first' and 'second' are already scheduled for+ // delivery when port2 is transferred: they follow it, ahead of 'third'+ const channel = new MessageChannel();+ const carrier = new MessageChannel();+ const lost = [];+ channel.port2.onmessage = (e) => lost.push(e.data);+ channel.port1.postMessage('first');+ channel.port1.postMessage('second');++ const moved = await new Promise((resolve) => {+ carrier.port2.onmessage = (e) => resolve(e.ports[0]);+ carrier.port1.postMessage(null, [channel.port2]);+ });+ channel.port1.postMessage('third');++ const received = [];+ await new Promise((resolve) => {+ moved.onmessage = (e) => {+ received.push(e.data);+ if (received.length === 3) resolve();+ };+ });++ state.resolve();+ await state.done(() => {+ testing.expectEqual(0, lost.length);+ testing.expectEqual('first,second,third', received.join(','));+ });+</script>++<script id="transfer-closed-port" type=module>+ // a closed (disentangled) port still serializes: bad data throws and the+ // transferred ports detach+ const channel = new MessageChannel();+ channel.port1.close();++ let name = 'no error';+ try {+ channel.port1.postMessage(Symbol());+ } catch (e) {+ name = e.name;+ }+ testing.expectEqual('DataCloneError', name);++ const other = new MessageChannel();+ channel.port1.postMessage(null, [other.port1]);+ name = 'no error';+ try {+ channel.port1.postMessage(null, [other.port1]);+ } catch (e) {+ name = e.name;+ }+ testing.expectEqual('DataCloneError', name);+</script>++<script id="window-transfer-forms" type=module>+ const state = await testing.async();++ // other scripts post to window too; only take the message that matches+ function nextMessage(match) {+ return new Promise((resolve) => {+ window.addEventListener('message', function listener(e) {+ if (match(e.data)) {+ window.removeEventListener('message', listener);+ resolve(e);+ }+ });+ });+ }++ // an ArrayBuffer in the transfer list is accepted+ const buffer = new Uint8Array([1, 2, 3]).buffer;+ const bufferPromise = nextMessage((data) => data instanceof ArrayBuffer);+ window.postMessage(buffer, '*', [buffer]);+ const bufferEvent = await bufferPromise;++ // the options form carries its transfer list+ const channel = new MessageChannel();+ const optionsPromise = nextMessage((data) => data === 'opts');+ window.postMessage('opts', { targetOrigin: '*', transfer: [channel.port2] });+ const optionsEvent = await optionsPromise;++ state.resolve();+ await state.done(() => {+ testing.expectEqual(3, bufferEvent.data.byteLength);+ testing.expectEqual('opts', optionsEvent.data);+ testing.expectEqual(1, optionsEvent.ports.length);+ });+</script>+</body>diff --git a/src/browser/tests/worker/port-worker.js b/src/browser/tests/worker/port-worker.jsnew file mode 100644index 000000000..74f37e848--- /dev/null+++ b/src/browser/tests/worker/port-worker.js@@ -0,0 +1,12 @@+// Comlink-style: replies through a port transferred in with the message, then+// hands a port of its own back to the page.+onmessage = function(event) {+ const port = event.data.port;+ port.onmessage = (e) => {+ port.postMessage({ echo: e.data, ports: event.ports.length, same: event.ports[0] === port });+ };++ const back = new MessageChannel();+ back.port1.onmessage = (e) => postMessage({ back: e.data });+ postMessage({ port: back.port2 }, [back.port2]);+};diff --git a/src/browser/tests/worker/worker.html b/src/browser/tests/worker/worker.htmlindex 778474552..69df173f7 100644--- a/src/browser/tests/worker/worker.html+++ b/src/browser/tests/worker/worker.html@@ -1,5 +1,47 @@<!DOCTYPE html>-<body></body>+<body><script id="worker_transfer_port" type=module>+ {+ const state = await testing.async();+ const worker = new Worker('./port-worker.js');++ const channel = new MessageChannel();+ // queued before the transfer: moves with port2 into the worker+ channel.port1.postMessage('early');++ const replies = [];+ channel.port1.onmessage = (e) => {+ replies.push(e.data);+ if (replies.length === 1) {+ channel.port1.postMessage('late');+ } else {+ // the worker transferred a port of its own back to us+ workerPort.postMessage('to worker');+ }+ };++ let workerPort = null;+ worker.onmessage = (e) => {+ if (e.data.port) {+ workerPort = e.data.port;+ } else {+ state.resolve({ replies, back: e.data.back, ports: e.ports.length });+ }+ };++ worker.postMessage({ port: channel.port2 }, [channel.port2]);++ await state.done((result) => {+ testing.expectEqual(2, result.replies.length);+ testing.expectEqual('early', result.replies[0].echo);+ testing.expectEqual(1, result.replies[0].ports);+ testing.expectEqual(true, result.replies[0].same);+ testing.expectEqual('late', result.replies[1].echo);+ testing.expectEqual('to worker', result.back);+ testing.expectEqual(0, result.ports);+ });+ }+</script>+</body><script src="../testing.js"></script><script id="worker_creation">diff --git a/src/browser/webapi/DedicatedWorkerGlobalScope.zig b/src/browser/webapi/DedicatedWorkerGlobalScope.zigindex d0b2ad8f3..5ffd91743 100644--- a/src/browser/webapi/DedicatedWorkerGlobalScope.zig+++ b/src/browser/webapi/DedicatedWorkerGlobalScope.zig@@ -29,6 +29,7 @@ const lp = @import("lightpanda");const js = @import("../js/js.zig");const EventTarget = @import("EventTarget.zig");+const MessagePort = @import("MessagePort.zig");const Worker = @import("Worker.zig");const WorkerGlobalScope = @import("WorkerGlobalScope.zig");@@ -47,7 +48,7 @@ _closed: bool = false,// and delivered once the worker is ready (i.e. once onmessage can be set).// Drained by drainPendingMessages, called from Worker.loadInitialScript// after the initial script has been evaluated.-_pending_messages: std.ArrayList(?js.Value.Global) = .empty,+_pending_messages: std.ArrayList(MessagePort.Message) = .empty,pub fn init(worker: *Worker, url: [:0]const u8) !*DedicatedWorkerGlobalScope {return WorkerGlobalScope.init(@@ -66,16 +67,14 @@ pub fn init(worker: *Worker, url: [:0]const u8) !*DedicatedWorkerGlobalScope {}pub fn deinit(self: *DedicatedWorkerGlobalScope) void {- for (self._pending_messages.items) |maybe_data| {- if (maybe_data) |d| {- d.release();- }+ for (self._pending_messages.items) |message| {+ message.release();}self._proto.deinit();}-pub fn postMessage(self: *DedicatedWorkerGlobalScope, data: js.Value) !void {- try self._worker.receiveMessage(data);+pub fn postMessage(self: *DedicatedWorkerGlobalScope, data: js.Value, transfer: ?js.Value) !void {+ try self._worker.receiveMessage(data, try MessagePort.transferList(transfer));}pub fn close(self: *DedicatedWorkerGlobalScope) void {@@ -99,21 +98,16 @@ pub fn cancelAnimationFrame(self: *DedicatedWorkerGlobalScope, id: u32) void {}// Called internally by Worker when it wants to post a message to us-pub fn receiveMessage(self: *DedicatedWorkerGlobalScope, data: js.Value) !void {+pub fn receiveMessage(self: *DedicatedWorkerGlobalScope, data: js.Value, transfer: []const *MessagePort) !void {+ // clones from where it currently is (the Worker's Page context) to our Context.+ // Done even when closed (per spec), so transferred ports still detach and+ // bad data still throws.+ const cloned_data = try MessagePort.cloneMessage(data, transfer, &self._proto.js.execution);if (self._closed) {+ cloned_data.release();return;}-- const cloned_data: ?js.Value.Global = blk: {- // Enter our context to clone the message- var ls: js.Local.Scope = undefined;- self._proto.js.localScope(&ls);- defer ls.deinit();-- // clones from where it currently is (the Worker's Page context) to our Context- const cloned = data.structuredCloneTo(&ls.local) catch break :blk null;- break :blk cloned.persist() catch break :blk null;- };+ errdefer cloned_data.release();if (!self._worker._script_loaded) {// Buffer until Worker.loadInitialScript calls drainPendingMessages.@@ -128,7 +122,7 @@ pub fn receiveMessage(self: *DedicatedWorkerGlobalScope, data: js.Value) !void {try self.scheduleMessage(cloned_data);}-fn scheduleMessage(self: *DedicatedWorkerGlobalScope, cloned_data: ?js.Value.Global) !void {+fn scheduleMessage(self: *DedicatedWorkerGlobalScope, cloned_data: MessagePort.Message) !void {const wgs = self._proto;const session = wgs._session;@@ -156,22 +150,20 @@ pub fn drainPendingMessages(self: *DedicatedWorkerGlobalScope) void {for (self._pending_messages.items) |cloned_data| {self.scheduleMessage(cloned_data) catch |err| {lp.log.debug(.browser, "worker drain msg failed", .{ .err = err });- if (cloned_data) |d| d.release();+ cloned_data.release();};}self._pending_messages.clearRetainingCapacity();}const ReceiveMessageCallback = struct {- data: ?js.Value.Global,+ data: MessagePort.Message,arena: *lp.Arena,worker_scope: *DedicatedWorkerGlobalScope,fn cancelled(ctx: *anyopaque) void {const self: *ReceiveMessageCallback = @ptrCast(@alignCast(ctx));- if (self.data) |d| {- d.release();- }+ self.data.release();self.deinit();}@@ -182,32 +174,35 @@ const ReceiveMessageCallback = struct {fn run(ctx: *anyopaque) !?u32 {const self: *ReceiveMessageCallback = @ptrCast(@alignCast(ctx));defer self.deinit();+ defer self.data.releasePorts();const worker_scope = self.worker_scope;const wsg = worker_scope._proto;const target = wsg.asEventTarget();- // If data is null, structured clone failed - fire messageerror- if (self.data == null) {+ // If data is null, deserialization failed - fire messageerror+ const data = self.data.data orelse {if (!wsg._event_manager.hasDirectListeners(target, "messageerror")) {return null;}const event = (try MessageEvent.initTrusted(comptime .wrap("messageerror"), .{+ .ports = self.data.ports,.bubbles = false,.cancelable = false,}, wsg.page)).asEvent();try wsg.dispatch(target, event, .{});return null;- }+ };// Check if there are any listeners before creating the eventif (!wsg._event_manager.hasDirectListeners(target, "message")) {- self.data.?.release();+ data.release();return null;}const event = (try MessageEvent.initTrusted(comptime .wrap("message"), .{- .data = .{ .value = self.data.? },+ .data = .{ .value = data },+ .ports = self.data.ports,.bubbles = false,.cancelable = false,}, wsg.page)).asEvent();diff --git a/src/browser/webapi/MessagePort.zig b/src/browser/webapi/MessagePort.zigindex 84fa8f667..e316c35d9 100644--- a/src/browser/webapi/MessagePort.zig+++ b/src/browser/webapi/MessagePort.zig@@ -38,10 +38,17 @@ _proto: *EventTarget,_exec: *Execution,_enabled: bool = false,_closed: bool = false,++// set once transfered to another context+_detached: bool = false,_entangled_port: ?*MessagePort = null,// queued message received before the port is started.-_pending: std.ArrayList(js.Value.Global) = .empty,+_pending: std.ArrayList(Message) = .empty,++// DeliverCallbacks scheduled but not yet run, in order. A transfer takes their+// messages along to the new port.+_in_flight: std.DoublyLinkedList = .{},// Link list into the owning Frame or WorkerGlobalScope. When the frame/WGS is// shutdown, the port will be closed.@@ -65,45 +72,211 @@ pub fn entangle(port1: *MessagePort, port2: *MessagePort) void {port2._entangled_port = port1;}-pub fn postMessage(self: *MessagePort, message: js.Value) !void {- if (self._closed) {+pub fn postMessage(self: *MessagePort, message: js.Value, transfer: ?js.Value) !void {+ const ports = try transferList(transfer);+ if (std.mem.findScalar(*MessagePort, ports, self) != null) {+ return error.DataClone;+ }++ const other: ?*MessagePort = if (self._closed) null else self._entangled_port;++ // With no live receiver, or when the receiving port is itself being+ // transferred, the message is doomed. It's still serialized (per spec), so+ // the transferred ports detach and bad data throws, but nothing is+ // delivered.+ var doomed = true;+ if (other) |o| {+ doomed = o._closed or std.mem.findScalar(*MessagePort, ports, o) != null;+ }++ // The clone is made directly into the receiving port's context, which may+ // not be the sender's.+ const target_exec = if (other) |o| o._exec else self._exec;+ const cloned = try cloneMessage(message, ports, target_exec);+ if (doomed) {+ cloned.release();return;}+ errdefer cloned.release();- const other = self._entangled_port orelse return;- if (other._closed) {+ const receiver = other.?;+ if (!receiver._enabled) {+ try receiver._pending.append(receiver._exec.page_arena, cloned);return;}- // StructuredSerialize runs synchronously (per spec): clone the message now- // so the receiver gets an independent copy (a mutation on one side isn't- // visible to the other) and an unserializable value throws a DataCloneError- // to the caller. The clone is made directly into the receiving port's- // context, which may not be the sender's.- const cloned = blk: {- var ls: js.Local.Scope = undefined;- other._exec.js.localScope(&ls);- defer ls.deinit();+ try receiver.scheduleDelivery(cloned);+}- // Contain any V8 exception from a failed serialization so it surfaces as- // a clean DataCloneError; deinit() (no rethrow) clears it.+// A message cloned into the receiving context. `data` is null when it couldn't+// be deserialized there, which the receiver reports as a messageerror.+pub const Message = struct {+ data: ?js.Value.Global,+ // The transferred ports, already moved into the receiving context.+ ports: []const *MessagePort,+ // Owns `ports`; null when there are none.+ ports_arena: ?*lp.Arena = null,++ // For a message that's dropped.+ pub fn release(self: Message) void {+ if (self.data) |d| {+ d.release();+ }+ self.releasePorts();+ }++ // For a message that's delivered: the event owns `data` and has copied+ // `ports`.+ pub fn releasePorts(self: Message) void {+ if (self.ports_arena) |arena| {+ arena.release();+ }+ }+};++// StructuredSerializeWithTransfer in the sender's realm, then+// StructuredDeserializeWithTransfer in `target`'s, done back to back since+// every realm lives in the same isolate. Serialization runs synchronously (per+// spec) so an unserializable value throws a DataCloneError to the sender, and+// the receiver gets an independent copy. Each port in `transfer` moves to+// `target`; one nested in `message` comes out as its moved counterpart.+pub fn cloneMessage(message: js.Value, transfer: []const *MessagePort, target: *Execution) !Message {+ for (transfer, 0..) |port, i| {+ if (port._detached or std.mem.findScalar(*MessagePort, transfer[0..i], port) != null) {+ return error.DataClone;+ }+ }++ const serialized = blk: {+ // Contain any V8 exception from a failed serialization so it surfaces+ // as a clean DataCloneError; deinit() (no rethrow) clears it.var try_catch: js.TryCatch = undefined;- try_catch.init(&ls.local);+ try_catch.init(message.local);defer try_catch.deinit();+ break :blk message.serializeTransfer(transfer) catch return error.DataClone;+ };+ defer serialized.deinit();++ var ports: []*MessagePort = &.{};+ var ports_arena: ?*lp.Arena = null;+ errdefer if (ports_arena) |arena| arena.release();+ if (transfer.len > 0) {+ const arena = try target.getArena(.tiny, "MessagePort.Message");+ ports_arena = arena;+ ports = try arena.allocator().alloc(*MessagePort, transfer.len);+ }+ for (transfer, ports) |port, *moved| {+ moved.* = try port.transferTo(target);+ }- const c = message.structuredCloneTo(&ls.local) catch {- return error.DataClone;- };- break :blk try c.persist();+ var ls: js.Local.Scope = undefined;+ target.js.localScope(&ls);+ defer ls.deinit();++ var try_catch: js.TryCatch = undefined;+ try_catch.init(&ls.local);+ defer try_catch.deinit();++ const value = js.Value.deserializeTransfer(&ls.local, serialized.bytes(), ports) catch {+ return .{ .data = null, .ports = ports, .ports_arena = ports_arena };};- errdefer cloned.release();+ return .{ .data = try value.persist(), .ports = ports, .ports_arena = ports_arena };+}- if (!other._enabled) {- try other._pending.append(other._exec.page_arena, cloned);- return;+// The `transfer` argument of postMessage: a sequence of transferables, or a+// StructuredSerializeOptions dictionary. Only MessagePorts move; an+// ArrayBuffer is accepted but left attached (the clone copies it).+pub fn transferList(arg: ?js.Value) ![]const *MessagePort {+ const value = arg orelse return &.{};+ if (value.isNullOrUndefined()) {+ return &.{};}+ if (value.isObject() == false) {+ return error.TypeError;+ }++ const local = value.local;+ const list = if (value.isArray()) value else blk: {+ const t = try value.toObject().get("transfer");+ if (t.isNullOrUndefined()) {+ return &.{};+ }+ break :blk t;+ };- try other.scheduleDelivery(cloned);+ const items = try local.jsValueToZig([]const js.Value, list);+ const ports = try local.call_arena.alloc(*MessagePort, items.len);+ var count: usize = 0;+ for (items) |item| {+ if (item.isArrayBuffer()) {+ continue;+ }+ const port = if (item.isObject()) if (item.taggedOpaque()) |tao| tao.as(MessagePort) else null else null;+ ports[count] = port orelse return error.DataClone;+ count += 1;+ }+ return ports[0..count];+}++// Moves this port into `exec`: a fresh port there takes over the entanglement+// and any queued messages, and this one is left detached.+fn transferTo(self: *MessagePort, exec: *Execution) !*MessagePort {+ const port = try MessagePort.init(exec);++ if (self._entangled_port) |other| {+ entangle(port, other);+ }+ self._entangled_port = null;++ // Scheduled deliveries were queued before anything still pending (which+ // only exists if the port was never started), so they go first.+ while (self._in_flight.popFirst()) |node| {+ const callback: *DeliverCallback = @fieldParentPtr("node", node);+ const message = callback.message.?;+ callback.message = null;+ port.adoptPending(message, self._exec);+ }+ for (self._pending.items) |message| {+ port.adoptPending(message, self._exec);+ }+ self._pending.clearRetainingCapacity();++ if (self._closed) {+ port.close();+ }+ self._detached = true;+ self.close();+ return port;+}++// Queues a message the port's previous incarnation (in `from`) hadn't+// delivered yet. The new port isn't started, so it waits in _pending.+fn adoptPending(self: *MessagePort, message: Message, from: *Execution) void {+ const moved = moveMessage(message, from, self._exec) orelse return;+ self._pending.append(self._exec.page_arena, moved) catch |err| {+ log.debug(.dom, "MessagePort transfer", .{ .err = err });+ moved.release();+ };+}++// Re-homes a queued message (and the ports it carries) into another context.+// Takes ownership of `message`; null if it couldn't be moved.+fn moveMessage(message: Message, from: *Execution, to: *Execution) ?Message {+ if (from == to) {+ return message;+ }+ defer message.release();++ const data = message.data orelse return null;++ var ls: js.Local.Scope = undefined;+ from.js.localScope(&ls);+ defer ls.deinit();++ return cloneMessage(data.local(&ls.local), message.ports, to) catch |err| {+ log.debug(.dom, "MessagePort transfer", .{ .err = err });+ return null;+ };}pub fn start(self: *MessagePort) void {@@ -142,7 +315,7 @@ pub fn close(self: *MessagePort) void {// Queues delivery of `message` (a clone already living in this port's// context) on this port's scheduler.-fn scheduleDelivery(self: *MessagePort, message: js.Value.Global) !void {+fn scheduleDelivery(self: *MessagePort, message: Message) !void {const exec = self._exec;const callback = try exec._factory.create(DeliverCallback{.port = self,@@ -150,6 +323,9 @@ fn scheduleDelivery(self: *MessagePort, message: js.Value.Global) !void {});errdefer exec._factory.destroy(callback);+ self._in_flight.append(&callback.node);+ errdefer self._in_flight.remove(&callback.node);+try exec.js.scheduler.add(callback, DeliverCallback.run, 0, .{.name = "MessagePort.postMessage",.finalizer = DeliverCallback.cancelled,@@ -158,13 +334,19 @@ fn scheduleDelivery(self: *MessagePort, message: js.Value.Global) !void {const DeliverCallback = struct {port: *MessagePort,- message: js.Value.Global,+ // null once a transfer has taken it to the port's new incarnation (and+ // unlinked this callback from _in_flight).+ message: ?Message,+ node: std.DoublyLinkedList.Node = .{},// Called by the scheduler if the task is dropped before it runs. `run` and// `cancelled` are mutually exclusive, so the temp is released exactly once.fn cancelled(ctx: *anyopaque) void {const self: *DeliverCallback = @ptrCast(@alignCast(ctx));- self.message.release();+ if (self.message) |message| {+ self.port._in_flight.remove(&self.node);+ message.release();+ }self.deinit();}@@ -178,26 +360,49 @@ const DeliverCallback = struct {const port = self.port;const exec = port._exec;+ const message = self.message orelse return null;+ port._in_flight.remove(&self.node);+ defer message.releasePorts();+// The MessageEvent takes ownership of the cloned temp and releases it on// teardown; on any path where we don't hand it over, release it here so// it doesn't leak.if (port._closed) {- self.message.release();+ if (message.data) |d| {+ d.release();+ }return null;}const target = port.asEventTarget();+ const data = message.data orelse {+ if (exec.hasDirectListeners(target, "messageerror")) {+ const event = (MessageEvent.initTrusted(comptime .wrap("messageerror"), .{+ .origin = "",+ .ports = message.ports,+ }, exec.page) catch |err| {+ log.debug(.dom, "MessagePort.postMessage", .{ .err = err });+ return null;+ }).asEvent();+ exec.dispatch(target, event, .{ .context = "MessagePort messageerror" }) catch |err| {+ log.debug(.dom, "MessagePort.postMessage", .{ .err = err });+ };+ }+ return null;+ };+if (!exec.hasDirectListeners(target, "message")) {- self.message.release();+ data.release();return null;}const event = (MessageEvent.initTrusted(comptime .wrap("message"), .{- .data = .{ .value = self.message },+ .data = .{ .value = data },.origin = "",.source = null,+ .ports = message.ports,}, exec.page) catch |err| {- self.message.release();+ data.release();log.debug(.dom, "MessagePort.postMessage", .{ .err = err });return null;}).asEvent();diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zigindex 7407d8d24..37fced885 100644--- a/src/browser/webapi/Window.zig+++ b/src/browser/webapi/Window.zig@@ -689,10 +689,17 @@ pub fn stop(self: *Window) void {self._frame.stopLoading();}-pub fn postMessage(self: *Window, message: js.Value, target_origin: ?[]const u8, transfer: ?[]const *MessagePort, frame: *Frame) !void {+// postMessage(message, targetOrigin, transfer) or postMessage(message, options).+pub fn postMessage(self: *Window, message: js.Value, target_origin_or_options: ?js.Value, transfer: ?js.Value, frame: *Frame) !void {// For now, we ignore targetOrigin checking and just dispatch the message// In a full implementation, we would validate the origin- _ = target_origin;+ var transfer_arg = transfer;+ if (target_origin_or_options) |arg| {+ if (arg.isObject()) {+ transfer_arg = arg;+ }+ }+ const ports = try MessagePort.transferList(transfer_arg);const target_frame = self._frame;const source_window = target_frame.js.getIncumbent().window;@@ -700,27 +707,10 @@ pub fn postMessage(self: *Window, message: js.Value, target_origin: ?[]const u8,const arena = try target_frame.getArena(.medium, "Window.postMessage");errdefer arena.release();- // StructuredSerialize runs synchronously (per spec): clone the message into- // the target window's realm now. The receiver gets a fresh, independent copy- // minted in its own realm (not the source realm's object), an unserializable- // value throws a DataCloneError to the caller, and the source-realm temp- // doesn't leak into the destination context. Mirrors Worker.postMessage.- const cloned = blk: {- var ls: js.Local.Scope = undefined;- target_frame.js.localScope(&ls);- defer ls.deinit();-- // Contain any V8 exception from a failed serialization so it surfaces as- // a clean DataCloneError; deinit() (no rethrow) clears it.- var try_catch: js.TryCatch = undefined;- try_catch.init(&ls.local);- defer try_catch.deinit();-- const c = message.structuredCloneTo(&ls.local) catch {- return error.DataClone;- };- break :blk try c.persist();- };+ // Clone the message into the target window's realm now: the receiver gets+ // a fresh copy minted in its own realm, and the transferred ports move+ // there. Mirrors Worker.postMessage.+ const cloned = try MessagePort.cloneMessage(message, ports, &target_frame.js.execution);errdefer cloned.release();// Origin should be the source window's origin (where the message came from)@@ -732,7 +722,6 @@ pub fn postMessage(self: *Window, message: js.Value, target_origin: ?[]const u8,.frame = target_frame,.source = source_window,.origin = try arena.dupe(u8, origin),- .ports = if (transfer) |t| try arena.dupe(*MessagePort, t) else &.{},};try target_frame.js.scheduler.add(callback, PostMessageCallback.run, 0, .{@@ -963,8 +952,7 @@ const PostMessageCallback = struct {source: *Window,arena: *lp.Arena,origin: []const u8,- message: js.Value.Global,- ports: []const *MessagePort,+ message: MessagePort.Message,fn deinit(self: *PostMessageCallback) void {self.arena.release();@@ -981,24 +969,39 @@ const PostMessageCallback = struct {fn run(ctx: *anyopaque) !?u32 {const self: *PostMessageCallback = @ptrCast(@alignCast(ctx));defer self.deinit();+ defer self.message.releasePorts();const frame = self.frame;const window = frame.window;const event_target = window.asEventTarget();+ const data = self.message.data orelse {+ if (frame._event_manager.hasDirectListeners(event_target, "messageerror")) {+ const event = (try MessageEvent.initTrusted(comptime .wrap("messageerror"), .{+ .origin = self.origin,+ .source = .{ .window = self.source },+ .ports = self.message.ports,+ .bubbles = false,+ .cancelable = false,+ }, frame.page)).asEvent();+ try frame._event_manager.dispatchDirect(event_target, event, .{ .context = "window.postMessage" });+ }+ return null;+ };+// The MessageEvent takes ownership of the cloned temp and releases it on// teardown; if there are no listeners, release it here so it doesn't leak.if (!frame._event_manager.hasDirectListeners(event_target, "message")) {- self.message.release();+ data.release();return null;}const event = (try MessageEvent.initTrusted(comptime .wrap("message"), .{- .data = .{ .value = self.message },+ .data = .{ .value = data },.origin = self.origin,.source = .{ .window = self.source },- .ports = self.ports,+ .ports = self.message.ports,.bubbles = false,.cancelable = false,}, frame.page)).asEvent();@@ -1267,8 +1270,8 @@ pub const JsApi = struct {const CrossOriginWindow = struct {window: *Window,- pub fn postMessage(self: *CrossOriginWindow, message: js.Value, target_origin: ?[]const u8, transfer: ?[]const *MessagePort, frame: *Frame) !void {- return self.window.postMessage(message, target_origin, transfer, frame);+ pub fn postMessage(self: *CrossOriginWindow, message: js.Value, target_origin_or_options: ?js.Value, transfer: ?js.Value, frame: *Frame) !void {+ return self.window.postMessage(message, target_origin_or_options, transfer, frame);}pub fn getTop(self: *CrossOriginWindow, frame: *Frame) Access {diff --git a/src/browser/webapi/Worker.zig b/src/browser/webapi/Worker.zigindex 2353e2d74..a05c676f0 100644--- a/src/browser/webapi/Worker.zig+++ b/src/browser/webapi/Worker.zig@@ -26,6 +26,7 @@ const Frame = @import("../Frame.zig");const Transfer = @import("../../network/HttpClient.zig").Transfer;const EventTarget = @import("EventTarget.zig");+const MessagePort = @import("MessagePort.zig");const MessageEvent = @import("event/MessageEvent.zig");const ErrorEvent = @import("event/ErrorEvent.zig");const DedicatedWorkerGlobalScope = @import("DedicatedWorkerGlobalScope.zig");@@ -332,22 +333,17 @@ pub fn terminate(self: *Worker) void {}// Posts a message from the frame to the worker.-pub fn postMessage(self: *Worker, data: js.Value) !void {- try self._worker_scope.receiveMessage(data);+pub fn postMessage(self: *Worker, data: js.Value, transfer: ?js.Value) !void {+ try self._worker_scope.receiveMessage(data, try MessagePort.transferList(transfer));}// Called internally by DedicatedWorkerGlobalScope when it wants to post a message to us-pub fn receiveMessage(self: *Worker, data: js.Value) !void {+pub fn receiveMessage(self: *Worker, data: js.Value, transfer: []const *MessagePort) !void {const frame = self._frame;- const cloned_data = blk: {- var ls: js.Local.Scope = undefined;- frame.js.localScope(&ls);- defer ls.deinit();-- // clones from where it currently is (the Worker context) to our Page's context- const cloned = data.structuredCloneTo(&ls.local) catch |err| break :blk err;- break :blk cloned.persist();- };++ // clones from where it currently is (the Worker context) to our Page's context+ const message = try MessagePort.cloneMessage(data, transfer, &frame.js.execution);+ errdefer message.release();const message_arena = try frame.getArena(.tiny, "Worker.receiveMessage");errdefer message_arena.release();@@ -355,7 +351,7 @@ pub fn receiveMessage(self: *Worker, data: js.Value) !void {const callback = try message_arena.create(ReceiveMessageCallback);callback.* = .{.worker = self,- .data = cloned_data,+ .message = message,.arena = message_arena,};@@ -366,15 +362,13 @@ pub fn receiveMessage(self: *Worker, data: js.Value) !void {}const ReceiveMessageCallback = struct {- data: anyerror!js.Value.Global,+ message: MessagePort.Message,arena: *lp.Arena,worker: *Worker,fn cancelled(ctx: *anyopaque) void {const self: *ReceiveMessageCallback = @ptrCast(@alignCast(ctx));- if (self.data) |d| {- d.release();- } else |_| {}+ self.message.release();self.deinit();}@@ -385,18 +379,19 @@ const ReceiveMessageCallback = struct {fn run(ctx: *anyopaque) !?u32 {const self: *ReceiveMessageCallback = @ptrCast(@alignCast(ctx));defer self.deinit();+ defer self.message.releasePorts();const worker = self.worker;const frame = worker._frame;const target = worker.asEventTarget();- // If data is null, structured clone failed - fire messageerror- const data = self.data catch |err| {+ // If data is null, deserialization failed - fire messageerror+ const data = self.message.data orelse {if (!frame._event_manager.hasDirectListeners(target, "messageerror")) {return null;}const event = (try MessageEvent.initTrusted(comptime .wrap("messageerror"), .{- .data = .{ .string = @errorName(err) },+ .ports = self.message.ports,.bubbles = false,.cancelable = false,}, frame.page)).asEvent();@@ -412,6 +407,7 @@ const ReceiveMessageCallback = struct {const event = (try MessageEvent.initTrusted(comptime .wrap("message"), .{.data = .{ .value = data },+ .ports = self.message.ports,.bubbles = false,.cancelable = false,}, frame.page)).asEvent();