GeezerVison

coderabbitai Bot left a comment

coderabbitai Bot left a comment

coderabbitai Bot left a comment

coderabbitai Bot left a comment

…and node:worker_threads

Ports are Node's three-way split without libuv: an isolate-free PortData
(mutex-guarded queue, sibling-group entanglement) under a per-isolate
NativeMessagePort whose wake is a coalesced EventLoop::PostInternal —
producers never take a foreign isolate's Locker. Pairwise channels and
named BroadcastChannel groups share one SiblingGroup mechanism; close
sentinels are empty messages ordered behind queued traffic.

Ports transfer through postMessage and structuredClone as host-object
tag 2 on the DOMException wire format: index in-stream, PortData
out-of-band, nothing detached until the whole graph has written, and
received ports pre-constructed before ReadValue since no JS may run
inside ReadHostObject. In passing this fixes claimed host objects
suppressing V8's embedder-field detection (ObjC wrappers were written
as plain objects once any DOMException existed) and a dangling handle
in Deserialize's ports out-parameter.

Worker and the worker global scope are now real EventTargets: delivery
dispatches MessageEvents through defineEventHandler-backed onmessage
attributes (position-fixed HTML handler semantics), replacing the
direct property calls. Handler wrappers live on the target's own
listener bag — a WeakMap keyed by ObjectManager-registered objects
corrupts the heap when the finalizer resurrects them.

node:worker_threads ships the real MessageChannel/MessagePort/
BroadcastChannel/receiveMessageOnPort/threadId/environment-data
surface with documented shims for the rest (docs/worker-threads.md).
New globals ride the lazy tier: MessagePort, MessageChannel,
BroadcastChannel, MessageEvent.

Suite: 1664/0 (+154 messaging specs in the shared submodule).

…ndler

Deletes the bespoke private-field handler mechanism; the shared
attribute keeps every observable behavior — assignment-order
interleaving, LegacyTreatNonObjectAsNull, and the kListenerChanged
transitions the GC-transparency accounting depends on — while the slot
now claims at the first assignment, null included, matching HTML. The
getter is unbranded on foreign receivers, as in Node.

An unhandled worker error now always propagates: a scope with no
onerror falls through to the parent instead of dropping silently, and a
scope handler that throws forwards its own error once. The parent-side
delivery is a real ErrorEvent dispatched through the Worker EventTarget
— addEventListener('error') fires in registration order, and handled
means preventDefault() or a truthy onerror return (HTML's special error
handling). Only primitives cross the isolate boundary, so the event
carries message/filename/lineno plus stackTrace, this runtime's
documented extension, and error stays null.

Review round: an event handler attribute's count correction is now
absolute rather than cumulative, so clearing a handler after a
first-null claim reports zero again — a port stops and queues instead
of discarding forever, and a GC-persisted AbortSignal is released.
initMessageEvent resets the propagation flags per DOM's initialize
steps. The transfer docs no longer promise rollback of user getter
side effects, and the drain-budget comment states the Node floor
semantics it implements.

Suite: 1668/0. The shared Workers suite no longer pins the
double-forward, so the android runtime must land the matching
error-path fix before bumping its shared-tests submodule.

…eue locks

A message dropped by EventLoop::Shutdown or ConcurrentQueue::Terminate owns
transferred buffers and ports, and destroying a port sentinels its sibling,
which posts to the sibling's loop. Shutdown destroyed the dropped lanes while
holding the loop mutex, so a sibling owned by the isolate shutting down
re-entered that mutex and hung the thread. Terminate never emptied the
message queue at all, so ports and buffers transferred to a worker that was
terminated before its entry settled stayed pinned for the wrapper's lifetime
and the sibling never learned the channel was gone.

Both now move the queued entries out under the lock and let them die after
it is released, and a push racing Terminate is dropped under the same mutex
instead of landing in a queue nothing pops again.

…e adopted ports nothing reaches

A getter run while the graph was written could detach a listed ArrayBuffer;
V8 still wrote it as a transfer and detaching it again succeeded on zero
bytes, so the receiver silently got an empty buffer. The post-write check
that already covered ports now covers buffers.

A listed port the value never named was adopted into the receiving isolate's
registry with no JS handle, pinned until isolate teardown with its sibling
queueing into it. Deserialize now records which adopted ports the stream
referenced and, for callers that surface no port list (structuredClone,
receiveMessageOnPort), closes the rest; a read that fails after adoption
closes every port it adopted.

…ing AbortSignals

The handler-attribute helper expressed HTML's "setting onmessage enables the
port" as a listener-count increase on the first assignment, null included.
The same count feeds AbortSignal's persistence, so a signal whose onabort was
only ever set to null was held strongly until it aborted. The wrapper now
cancels its own slot while its handler is inactive, and MessagePort enables
itself through a separate first-assignment hook.

… edges

…MessagePort.onclose

parentPort gains Node's on/once/off/removeListener/addListener, delivering
the payload rather than the event as Node does. The node:worker_threads
Worker passes its option bag to the runtime's Worker so ios and
resourceLimits reach it. MessagePort exposes the onclose handler attribute
the HTML IDL defines for the close event this runtime already dispatches.

…onymous pair

…e host object throw DataCloneError

The single-read guard on a message carrying transferables was an assert that
Release builds compile out, leaving a second read to hand out emptied slots.
It now throws, and the moved-from transfer lists are cleared so the message
stops reporting transferables it no longer holds. A host object the stream
names but this side cannot hand out surfaces as a DataCloneError as well,
raised after the read since no JS may run inside it, instead of V8's generic
deserialization error.

…to the parent scope

EmitError returned whether a listener handled the error and nothing read the
result, so a worker error with no parent-side listener vanished. Per HTML the
error is now dispatched as an ErrorEvent on the parent's global scope, and
logged when nothing there handles it either.

…ards its own error once

The other two worker error paths forward the handler's exception when the
scope onerror throws; the rejection path dropped it and forwarded the
original reason. It now forwards the thrown error, with its stack, once.

… port on

…emitter, option forwarding, and error reporting

… ports, and a throwing stack accessor only drops the stack

A once() wrapper removed the first registration holding the same listener,
which with on() and once() sharing a function could detach the wrong one and
leave the once() wrapper firing forever; each registration is now its own
entry and removeListener() takes the most recent, as Node does. The relay
onto parentPort forwards event.ports. Reading `stack` off the error a
scope onerror threw runs under a TryCatch so a throwing accessor cannot
leave an exception pending past the rejection drain.

…the error-reporting specs

The serializer claims custom host objects unconditionally now, so the
"any ports or transfer brands exist" flag that extended the former gate has
no reader.

…dopted port is recorded before the list write can fail

WorkerEmitter.removeListener scanned forwards while ParentPort and Node
remove the most recently added registration. In Deserialize a port adopted
successfully but not yet recorded was skipped by the failure cleanup when
the ports array write failed, leaving it registered with no handle.