Skip to content

Commit d8acbf7

Browse files
probe(signals): #4544 probed-held bit — a probe of an unheld node earns no frame posture (measurement, not for merge)
Encoding: REACTIVE_PROBED_HELD / CONFIG_PROBED_HELD (1 << 30, same-bit promotion as REACTIVE_PROBED → CONFIG_VERDICT) set by a probe that finds a held, staged, in-flight or lane's node (verdict.ts `probedHeld`, from `verdictRead`/`watchVerdict`/`pendingVerdict`), inherited through the #4050 arm (core.ts `read`, config at once unless `creatorReads`), and checked where CONFIG_VERDICT alone decided frame/screen reading: `recompute`'s head join, `frameRead`, both `stagedScreen` callers, the pending-node `observeFlight` arm, store.ts's staging arms, lanes.ts `enterLane`/`laneRead`, scheduler.ts zombies, boundaries.ts `on`, and the shadow seat table. Findings (signals suite: 50 pins flip across 15 files; Shape 1 of #4544 does not flip): - D-25 "either read order" is carried by the posture a nothing-found probe leaves: `[h(), isPending(h)]` on the pass where `h` first goes pending or held reads `h` plainly before the probe, and only the earlier probe's posture serves the screen. Under the ruling that pass has no posture and throws/joins (verdict-contract, #4050 "memo [h, inline probe]", #3028, #4393, #4402, #4491, #4504, D-30 store rows, …). A sound encoding needs per-dependency memory ("this pass probes x"), not a node bit. - Once `params` joins T, the `plan` write is held by T (L2); `chrome`'s seam re-derive probes a T-held node and is T's verdict reader; `params` inherits the posture (#4050) / enters T's verdict lane (#4399) and is served the committed `session` again. A "head-joined pass is the hold's work" gate flips Shape 1 but adds #4399/#4408 pins (74 failures). Size (local, base d1d6d51): core floor +1 B br / +3 B min; hello world −5 B br / +3 B min; + isPending/latest +45 B br / +200 B min; compiled live page +75 B br / +250 B min; live + router +151 B br / +254 B min. Co-authored-by: Cursor <[email protected]>
1 parent d1d6d51 commit d8acbf7

12 files changed

Lines changed: 542 additions & 47 deletions
Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
---
2+
"@solidjs/signals": patch
3+
---
4+
5+
Probe (#4544, not for merge): a probe of a node that is neither held nor pending earns the pass no frame posture — measurement branch for the REACTIVE_PROBED_HELD / CONFIG_PROBED_HELD encoding

‎packages/signals/src/boundaries.ts‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -46,13 +46,14 @@ import {
4646
CONFIG_FRAME,
4747
CONFIG_HELD,
4848
CONFIG_OVERRIDE,
49-
CONFIG_VERDICT,
49+
CONFIG_PROBED_HELD,
5050
EFFECT_RENDER,
5151
EFFECT_TRACKED,
5252
EFFECT_USER,
5353
REACTIVE_DISPOSED,
5454
REACTIVE_LANE_READ,
5555
REACTIVE_PROBED,
56+
REACTIVE_PROBED_HELD,
5657
REACTIVE_ZOMBIE,
5758
STATUS_ERROR,
5859
STATUS_PENDING,
@@ -538,7 +539,7 @@ function arm(b: Boundary): void {
538539
if (
539540
lane === null &&
540541
globalQueue._running &&
541-
(getOwner() as Computed<any>)._config & CONFIG_VERDICT
542+
(getOwner() as Computed<any>)._config & CONFIG_PROBED_HELD
542543
) {
543544
joinFuture(null);
544545
lane = GlobalQueue._verdictLane!(flushTransaction!);
@@ -892,7 +893,7 @@ function fallback<T>(b: Boundary): T {
892893
const v = read(b._fb) as T;
893894
setPassLane(p);
894895
if (__TEST__) shadowSeatRestore(out, saved);
895-
out._flags ^= (out._flags ^ f) & (REACTIVE_PROBED | REACTIVE_LANE_READ);
896+
out._flags ^= (out._flags ^ f) & (REACTIVE_PROBED | REACTIVE_PROBED_HELD | REACTIVE_LANE_READ);
896897
return v;
897898
}
898899

‎packages/signals/src/core/constants.ts‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -80,6 +80,16 @@ export const REACTIVE_WINDOW = 1 << 21;
8080
* missed gave it (D-22, #4474), so the queued pass runs, then `recompute`'s
8181
* tail releases the node. Survives the head wipe; the tail consumes it. */
8282
export const REACTIVE_RELEASE_AFTER = 1 << 22;
83+
/** The pass's probe (`isPending`/`latest`) found a node that is not the
84+
* screen's — held, staged this flush, in flight, or a lane's (verdict.ts
85+
* `probedHeld`) — or read a verdict memo that did (core.ts `read`, #4050).
86+
* The frame-reader half of the verdict posture (#4544, ruled 2026-10-31): a
87+
* probe of a node that is neither held nor pending earns the pass no frame
88+
* posture — it stays an ordinary derivation of any hold that dirties it;
89+
* a probe that finds one makes the pass that hold's verdict reader. The same
90+
* bit as CONFIG_PROBED_HELD: carried into the config at the pass's end
91+
* without a shift, as REACTIVE_PROBED is. Per pass. */
92+
export const REACTIVE_PROBED_HELD = 1 << 30;
8393

8494
// Static configuration bits packed into Owner/Computed/Signal _config.
8595
export const CONFIG_OWNED_WRITE = 1 << 0;
@@ -150,6 +160,13 @@ export const CONFIG_GUESS = 1 << 13;
150160
* bit as REACTIVE_PROBED: a pass's probe (or a read of a verdict memo,
151161
* core.ts `read`) carries into the config at its end without a shift. */
152162
export const CONFIG_VERDICT = 1 << 15;
163+
/** The node's last pass probed something held (REACTIVE_PROBED_HELD, the
164+
* same bit): the pass is a frame reader — its plain read of a held node is
165+
* the screen's (`frameRead`, `stagedScreen`), a flight's committed value
166+
* (`observeFlight`), and it joins no hold at its head (`recompute`). Only
167+
* with CONFIG_VERDICT (the re-derive-on-pending half, stamped at the window
168+
* whatever the probe finds); set, cleared and inherited beside it. */
169+
export const CONFIG_PROBED_HELD = 1 << 30;
153170
/** A dependency's status is a question for this node's pass, not a fact
154171
* about its current one: the propagation re-derives it instead of marking
155172
* it, for errors as for pending (as CONFIG_VERDICT). A boundary's output

‎packages/signals/src/core/core.ts‎

Lines changed: 45 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ import {
2020
CONFIG_FRESH_READ,
2121
CONFIG_GUESS,
2222
CONFIG_VERDICT,
23+
CONFIG_PROBED_HELD,
2324
CONFIG_HELD,
2425
CONFIG_IN_SNAPSHOT_SCOPE,
2526
CONFIG_INPUTS_PUBLISHED,
@@ -59,6 +60,7 @@ import {
5960
REACTIVE_MANUAL_WRITE,
6061
REACTIVE_MISSED_WAKE,
6162
REACTIVE_PROBED,
63+
REACTIVE_PROBED_HELD,
6264
REACTIVE_REASK,
6365
REACTIVE_STAGED_READ,
6466
REACTIVE_NONE,
@@ -436,7 +438,7 @@ export function recompute(el: Computed<any>, create: boolean = false): void {
436438
(el._statusFlags & STATUS_PENDING ||
437439
(el._config & (CONFIG_ASYNC | CONFIG_HELD)) === (CONFIG_ASYNC | CONFIG_HELD))
438440
)
439-
el._config &= ~CONFIG_VERDICT;
441+
el._config &= ~(CONFIG_VERDICT | CONFIG_PROBED_HELD);
440442
if (el._x !== null) {
441443
// The seam's re-derive runs with the parked flight still current; any
442444
// later pass asks its own question (`_parked`; only the lane engine
@@ -473,9 +475,13 @@ export function recompute(el: Computed<any>, create: boolean = false): void {
473475
// A verdict reader born into `tx` (`bornInto`: never committed) is the
474476
// hold's own work, whatever it asked before (D-25): it joins like any
475477
// held pass, so what it mounts is the hold's (D-13, #4467).
478+
// A verdict reader here is one whose probe found something held
479+
// (CONFIG_PROBED_HELD, #4544): a pass whose probe found its node
480+
// neither held nor pending has no frame posture and re-enters the
481+
// hold like any held pass, whatever it asked.
476482
if (tx._lane || el._config & CONFIG_LAGS) {
477483
} else if (
478-
!(el._config & (CONFIG_VERDICT | (EFFECT_RENDER << 23))) ||
484+
!(el._config & (CONFIG_PROBED_HELD | (EFFECT_RENDER << 23))) ||
479485
(observeFlightHook && !(el._config & (EFFECT_RENDER << 23)) && bornInto(el, tx))
480486
)
481487
joinPassTx(tx, freshHook?.(el, el._statusFlags & STATUS_UNINITIALIZED));
@@ -725,11 +731,15 @@ export function recompute(el: Computed<any>, create: boolean = false): void {
725731
if (__TEST__) shadowSeatClose(el, !!isEffect, joined, creatorPass(oldcontext), mount);
726732
// A verdict reader is one for as long as it probes, or reads a memo
727733
// that does (`read`): a pass that did neither (REACTIVE_PROBED, the same
728-
// bit) is an ordinary derivation again. Its async posture is the
729-
// verdict engine's to keep (CONFIG_ASYNC, verdict.ts `holdWork`, D-25).
734+
// bit) is an ordinary derivation again. A frame reader for as long as
735+
// its probe finds something held (REACTIVE_PROBED_HELD, the same bit as
736+
// CONFIG_PROBED_HELD; #4544). Its async posture is the verdict engine's
737+
// to keep (CONFIG_ASYNC, verdict.ts `holdWork`, D-25).
730738
// (Only the verdict engine probes: without it the line folds away.)
731739
if (observeFlightHook)
732-
el._config = (el._config & ~CONFIG_VERDICT) | (el._flags & REACTIVE_PROBED);
740+
el._config =
741+
(el._config & ~(CONFIG_VERDICT | CONFIG_PROBED_HELD)) |
742+
(el._flags & (REACTIVE_PROBED | REACTIVE_PROBED_HELD));
733743
// REACTIVE_DISPOSED survives too (#3621): the pass may have disposed its
734744
// own owner (a memo calling its root's `dispose()`, a cleanup doing so
735745
// #3601/#3606), and `disposeChildren` set the flag on this node
@@ -1323,9 +1333,11 @@ export function joinPassAt(c: Computed<any>, t: Transaction): void {
13231333
* dissolves the lane, and the refetching pass is the parent's own, reading
13241334
* the truth as a member (`joinPass`). */
13251335
function frameRead(c: Computed<any>, el: Signal<any> | Computed<any>): boolean {
1326-
// Frame readers: a render effect, a verdict reader (CONFIG_VERDICT — it
1327-
// reads the screen like one: `[isPending(x), x()]` never pairs the fresh
1328-
// value with pending, A10, because the reader never sees the fresh value),
1336+
// Frame readers: a render effect, a verdict reader whose probe found
1337+
// something held (CONFIG_PROBED_HELD — it reads the screen like one:
1338+
// `[isPending(x), x()]` never pairs the fresh value with pending, A10,
1339+
// because the reader never sees the fresh value; a probe that found its
1340+
// node neither held nor pending earns no frame posture, #4544),
13291341
// and lane work (a lane sees the screen plus its own guesses). Not a
13301342
// mount's memo (2026-10-02, considered and reverted): a memo is not a
13311343
// leaf — the transaction's own later passes read it — so a mainline mount's
@@ -1338,7 +1350,7 @@ function frameRead(c: Computed<any>, el: Signal<any> | Computed<any>): boolean {
13381350
// under a hold still enters it: the content memo it reads is born held,
13391351
// with no committed value to serve.
13401352
// (Verdict readers and lanes exist only with their engines installed.)
1341-
const verdict = observeFlightHook && c._config & CONFIG_VERDICT;
1353+
const verdict = observeFlightHook && c._config & CONFIG_PROBED_HELD;
13421354
const lane = laneStageHook && passLane !== null;
13431355
if (
13441356
(!lane ||
@@ -2135,7 +2147,8 @@ export function read<T>(el: Signal<T> | Computed<T>): T {
21352147
// reads the screen too.
21362148
if (
21372149
netted ||
2138-
(((observeFlightHook && c._config & CONFIG_VERDICT) || (laneStageHook && passLane?.folded)) &&
2150+
(((observeFlightHook && c._config & CONFIG_PROBED_HELD) ||
2151+
(laneStageHook && passLane?.folded)) &&
21392152
stagedScreen(c as Computed<any>, el))
21402153
) {
21412154
if (__TEST__) shadowActual(netted ? SLOT_P : SLOT_C);
@@ -2182,16 +2195,29 @@ export function read<T>(el: Signal<T> | Computed<T>): T {
21822195
// verdict memo showed its re-run's staging ahead of the lane that
21832196
// staging lands with (#4408). A
21842197
// verdict reader keeps the posture it is served the screen with
2185-
// (`observeFlight`). (A verdict memo exists only with the verdict
2186-
// engine installed.)
2187-
if (observeFlightHook && !(c as any)._type)
2188-
(c as Computed<any>)._flags |=
2198+
// (`observeFlight`). The frame-reader half travels with it
2199+
// (CONFIG_PROBED_HELD, #4544): a memo over a verdict memo whose
2200+
// probe found nothing held is no frame reader either — and one
2201+
// over a verdict memo that did is a frame reader from this read on,
2202+
// as the inline probe makes the pass (verdict.ts `probedHeld`): its
2203+
// later plain reads in the same pass are the screen's (A10, either
2204+
// read order — `[V(), x()]` never pairs the verdict with the fresh
2205+
// value), unless its running creators read the future or a staging
2206+
// (`creatorReads`, #4341: then it is in their world until the pass
2207+
// ends). (A verdict memo exists only with the verdict engine
2208+
// installed.)
2209+
if (observeFlightHook && !(c as any)._type) {
2210+
const v =
21892211
owner._config &
2190-
CONFIG_VERDICT &
2212+
(CONFIG_VERDICT | CONFIG_PROBED_HELD) &
21912213
(owner._statusFlags & STATUS_PENDING &&
21922214
(c._config & CONFIG_STAGED || (c as Computed<any>)._statusFlags & STATUS_UNINITIALIZED)
21932215
? c._config
21942216
: -1);
2217+
(c as Computed<any>)._flags |= v;
2218+
if (v & CONFIG_PROBED_HELD && !creatorReads(c as Computed<any>, 0))
2219+
c._config |= CONFIG_PROBED_HELD;
2220+
}
21952221
}
21962222
}
21972223
if (__TEST__)
@@ -2260,7 +2286,8 @@ export function read<T>(el: Signal<T> | Computed<T>): T {
22602286
// mainline's): a lane breaks out of its parent's hold and waits only on
22612287
// what derives from the guess (A31: "under a lane, a pending node on no
22622288
// lane serves its committed value").
2263-
// A verdict reader likewise (CONFIG_VERDICT): a frame reader sees the
2289+
// A verdict reader whose probe found something held likewise
2290+
// (CONFIG_PROBED_HELD, #4544): a frame reader sees the
22642291
// screen, and for a flight the screen is the committed value — a render
22652292
// effect keeps its DOM by throwing, a memo has no DOM and is handed the
22662293
// value. `[isPending(x), x()]` reads `[true, stale]` in either order (A10)
@@ -2280,7 +2307,7 @@ export function read<T>(el: Signal<T> | Computed<T>): T {
22802307
// boundary a lane mounts shows its fallback (A29's boundary exemption).
22812308
if (passLane !== null && !((c as Computed<any> | null)?._statusFlags! & STATUS_UNINITIALIZED))
22822309
committed = true;
2283-
else if (c !== null && c._config & CONFIG_VERDICT)
2310+
else if (c !== null && c._config & CONFIG_PROBED_HELD)
22842311
committed = observeFlightHook!(c as Computed<any>, owner);
22852312
}
22862313
if (owner._statusFlags & STATUS_PENDING && !committed) {
@@ -2422,7 +2449,7 @@ export function serve(el: Signal<any> | Computed<any>, c: Computed<any> | null):
24222449
if (
24232450
readerSeesCommitted(el, c) ||
24242451
(observeFlightHook &&
2425-
c!._config & CONFIG_VERDICT &&
2452+
c!._config & CONFIG_PROBED_HELD &&
24262453
!((el as Computed<any>)._statusFlags & STATUS_UNINITIALIZED) &&
24272454
stagedScreen(c!, el) &&
24282455
!throwShown(el))

‎packages/signals/src/core/lanes.ts‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,7 @@ import {
4242
CONFIG_SLOT_NODE,
4343
CONFIG_STAGED,
4444
CONFIG_VERDICT,
45+
CONFIG_PROBED_HELD,
4546
EFFECT_RENDER,
4647
NOT_PENDING,
4748
REACTIVE_CHECK,
@@ -310,7 +311,7 @@ export function enterLane(l: Transaction, c: Computed<any>): void {
310311
(creatorReads(c, (c as any)._type || f) ||
311312
((hold = resolveTx(l._parent!)),
312313
(c._config &
313-
(CONFIG_HELD | CONFIG_VERDICT | CONFIG_FRAME | CONFIG_LAGS | CONFIG_OVERRIDE)) ===
314+
(CONFIG_HELD | CONFIG_PROBED_HELD | CONFIG_FRAME | CONFIG_LAGS | CONFIG_OVERRIDE)) ===
314315
CONFIG_HELD && txOf(c) !== hold) ||
315316
(c._config & CONFIG_HELD_FRAME && bornInto(c, hold!)))
316317
)
@@ -776,7 +777,7 @@ export function laneRead(c: Computed<any> | null, el: Signal<any> | Computed<any
776777
}
777778
// A verdict reader reads ahead of the seam's verdict: re-derived on the
778779
// screen if the lane holds (#4284).
779-
if (c._config & CONFIG_VERDICT && l._parent!._verdict !== l) entered.push(c);
780+
if (c._config & CONFIG_PROBED_HELD && l._parent!._verdict !== l) entered.push(c);
780781
}
781782
}
782783
enterLane(l, c);

‎packages/signals/src/core/scheduler.ts‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@ import {
1010
CONFIG_STAGED,
1111
CONFIG_STAGED_ERROR,
1212
CONFIG_VERDICT,
13+
CONFIG_PROBED_HELD,
1314
EFFECT_RENDER,
1415
EFFECT_TRACKED,
1516
EFFECT_USER,
@@ -1038,7 +1039,7 @@ export class GlobalQueue implements IQueue {
10381039
for (let i = 0; i < zombies.length; i++)
10391040
if (
10401041
(zombies[i]._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE)) === REACTIVE_ZOMBIE &&
1041-
zombies[i]._config & CONFIG_VERDICT
1042+
zombies[i]._config & CONFIG_PROBED_HELD
10421043
)
10431044
recompute(zombies[i]);
10441045
}
@@ -1399,7 +1400,8 @@ export function laneDirty(node: Signal<any> | Computed<any>, l: Transaction): vo
13991400
const c = s._sub,
14001401
t = c._x?._transaction;
14011402
if ((c as any)._type === EFFECT_RENDER && node._config & CONFIG_VERDICT)
1402-
((c._config |= CONFIG_VERDICT), (c._flags &= ~REACTIVE_LANE_DIRTY));
1403+
((c._config |= node._config & (CONFIG_VERDICT | CONFIG_PROBED_HELD)),
1404+
(c._flags &= ~REACTIVE_LANE_DIRTY));
14031405
if (t?._lane ? sameLane(t, l) : (c as any)._type) c._flags |= REACTIVE_LANE_DIRTY;
14041406
}
14051407
}

‎packages/signals/src/core/seat.ts‎

Lines changed: 16 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@ import {
5555
CONFIG_OVERRIDE,
5656
CONFIG_PROMOTED,
5757
CONFIG_STAGED_ERROR,
58-
CONFIG_VERDICT,
58+
CONFIG_PROBED_HELD,
5959
EFFECT_RENDER,
6060
NOT_PENDING,
6161
REACTIVE_JOINED,
@@ -219,11 +219,14 @@ export function postureOf(c: Computed<any> | null, window: number): number {
219219
if (c._config & CONFIG_CHILDREN_FORBIDDEN) return POSTURE_F;
220220
if (c._config & CONFIG_AUTHORITATIVE) return POSTURE_A;
221221
if (window) return window === 2 ? POSTURE_VL : POSTURE_VP;
222-
// A pass that asked (`latest`/`isPending`) is a verdict reader from the
223-
// window on, and stays one on every re-run until a pass asks nothing
224-
// (D-25 "a verdict posture outlives the pass that asked"): the sticky
225-
// CONFIG_VERDICT, set at the window (`markVerdictReader`).
226-
if (c._config & CONFIG_VERDICT) return POSTURE_V;
222+
// A pass whose probe (`latest`/`isPending`) found something held is a
223+
// frame reader from that read on, and stays one on every re-run until a
224+
// pass's probe finds nothing (D-25 "a verdict posture outlives the pass
225+
// that asked"; #4544: a probe of a node neither held nor pending earns no
226+
// frame posture — the pass reads as D below, CONFIG_VERDICT's
227+
// re-derive-on-pending half notwithstanding): the sticky
228+
// CONFIG_PROBED_HELD, set by the probe (verdict.ts `probedHeld`).
229+
if (c._config & CONFIG_PROBED_HELD) return POSTURE_V;
227230
if ((c as any)._type === EFFECT_RENDER || c._config & CONFIG_FRAME) return POSTURE_L;
228231
return POSTURE_D;
229232
}
@@ -703,7 +706,7 @@ export function slot(
703706
// window of its own — reads a hold's node as a verdict reader does:
704707
// `truthRead` is for lane nodes only.)
705708
const verdictReader =
706-
posture === POSTURE_V || (posture === POSTURE_A && (c!._config & CONFIG_VERDICT) !== 0);
709+
posture === POSTURE_V || (posture === POSTURE_A && (c!._config & CONFIG_PROBED_HELD) !== 0);
707710
const rowBase = posture === POSTURE_A ? "A1/" : "";
708711
const isEffect = !!cType;
709712
// D-28's leaf treatment of a lane (L6/L7: a stale reader of the lane,
@@ -853,7 +856,7 @@ export function slot(
853856
stagedError &&
854857
!uninit &&
855858
!(p.raise & MARK_ST) &&
856-
!(verdictReader && c!._config & CONFIG_VERDICT && stagedScreen)
859+
!(verdictReader && c!._config & CONFIG_PROBED_HELD && stagedScreen)
857860
)
858861
p.raise |= RAISE_FL;
859862
return carry(p);
@@ -919,7 +922,7 @@ export function slot(
919922
// nothing: not a read of the frame's future, nor a verdict reader's
920923
// stale read of the tick's hold.
921924
if (netted) return carry(pred(row + "''", SLOT_P));
922-
if (verdictReader && !uninit && c!._config & CONFIG_VERDICT) {
925+
if (verdictReader && !uninit && c!._config & CONFIG_PROBED_HELD) {
923926
// V2/V3 (D-23 D-32 [R5]): the screen once the tick has a hold, the
924927
// staging before (the seam's verdict).
925928
if (stagedScreen) return carry(pred("V2", screen, MARK_ST, flushTransaction));
@@ -1314,7 +1317,7 @@ const known: KnownDifference[] = [
13141317
expected: SLOT_P,
13151318
actual: SLOT_C,
13161319
when: (c, el, seat) =>
1317-
(c._config & CONFIG_VERDICT) !== 0 &&
1320+
(c._config & CONFIG_PROBED_HELD) !== 0 &&
13181321
flushTransaction !== null &&
13191322
seatBornInto(seat, txOf(el!)) &&
13201323
resolveTx(flushTransaction) !== resolveTx(txOf(el!))
@@ -1584,11 +1587,12 @@ export function shadowSeatClose(
15841587
);
15851588
}
15861589
// (A boundary's output sets its own CONFIG_FRAME at the head of its body,
1587-
// and a probe sets CONFIG_VERDICT: the node's own transitions.)
1590+
// and a probe that finds something held sets CONFIG_PROBED_HELD: the
1591+
// node's own transitions.)
15881592
const posture = postureOf(el, 0);
15891593
if (
15901594
seat.posture !== posture &&
1591-
!(el._config & CONFIG_VERDICT) &&
1595+
!(el._config & CONFIG_PROBED_HELD) &&
15921596
seat.posture !== POSTURE_V &&
15931597
posture !== POSTURE_L
15941598
)

0 commit comments

Comments
 (0)