@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.2

package/dist/prod/core/async.js

@@ -1,6 +1,6 @@
-import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DISPOSED } from "./constants.js";
+import { STATUS_UNINITIALIZED, CONFIG_CHILD_COMPANIONS, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DISPOSED } from "./constants.js";
 
-import { untrack, setSignal, context } from "./core.js";
+import { untrack, ext, setSignal, context } from "./core.js";
 
 import "./invariants.js";
 
@@ -22,20 +22,20 @@ import { GlobalQueue, schedule, flush, queuePendingNode, insertSubs, clock, curr
 // overlapping source landed beside the Set and removePendingSource refused
 // to clear it, stranding the Set members' pending forever (#2893).
 function addPendingSource(e, n) {
-    if (e.oe?.has(n)) return false;
-    (e.oe ??= new Set).add(n);
+    if (e.o?.le?.has(n)) return false;
+    (ext(e).le ??= new Set).add(n);
     return true;
 }
 
 function removePendingSource(e, n) {
-    if (!e.oe?.delete(n)) return false;
-    if (e.oe.size === 0) e.oe = undefined;
+    if (!e.o?.le?.delete(n)) return false;
+    if (e.o?.le.size === 0) if (e.o !== null) e.o.le = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
-    e.oe?.clear();
-    e.oe = undefined;
+    e.o?.le?.clear();
+    if (e.o !== null) e.o.le = undefined;
 }
 
 /**
@@ -45,7 +45,7 @@ function clearPendingSources(e) {
  * with NO read-visible pending status, no downstream propagation, no
  * transition, no lane registration. Commit #0 keeps serving.
  */ function parkLoadingWindow(e, n) {
-    e.le = true;
+    ext(e).ue = true;
     if (n.source) addPendingSource(e, n.source);
     // A settled error is the node's answer ("the error stays the answer until
     // this retry can actually run") — the park must not replace it: reads
@@ -56,24 +56,24 @@ function clearPendingSources(e) {
 
 function setPendingError(e, n, t) {
     if (!n) {
-        e._ = null;
+        if (e.o !== null) e.o._ = null;
         return;
     }
     if (t instanceof NotReadyError && t.source === n) {
-        e._ = t;
+        ext(e)._ = t;
         return;
     }
-    const r = e._;
+    const r = e.o?._;
     if (!(r instanceof NotReadyError) || r.source !== n) {
-        e._ = new NotReadyError(n);
+        ext(e)._ = new NotReadyError(n);
     }
 }
 
 function forEachDependent(e, n) {
-    for (let t = e.o; t !== null; t = t.ue) n(t.fe, t);
+    for (let t = e.u; t !== null; t = t.fe) n(t.ae, t);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let t = e.u ?? null; t !== null; t = t.ae) {
-        for (let e = t.o; e !== null; e = e.ue) n(e.fe, e);
+        for (let t = e.o?.l ?? null; t !== null; t = t.ce) {
+        for (let e = t.u; e !== null; e = e.fe) n(e.ae, e);
     }
 }
 
@@ -88,7 +88,7 @@ function forEachDependent(e, n) {
 // callbacks handle their own release (settleAutodispose in handleAsync); this
 // covers derivatively-pending dependents, which have no callbacks of their own.
 function releaseIfSettledUnobserved(e) {
-    e.ce && e.T & CONFIG_AUTO_DISPOSE && !e.o && !(e.se & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+    e.Se && e.T & CONFIG_AUTO_DISPOSE && !e.u && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -101,7 +101,7 @@ function releaseSettledDependents(e) {
     const visit = e => {
         if (t.has(e)) return;
         t.add(e);
-        if (!e.o && e.T & CONFIG_AUTO_DISPOSE) (n ??= []).push(e);
+        if (!e.u && e.T & CONFIG_AUTO_DISPOSE) (n ??= []).push(e);
         forEachDependent(e, visit);
     };
     forEachDependent(e, visit);
@@ -129,7 +129,7 @@ function settleErroredDependents(e, n) {
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e._ === n) {
+        if (e.o?._ === n) {
             enqueueSub(e);
             t = true;
         }
@@ -144,12 +144,12 @@ function settlePendingSource(e) {
     let t;
     const r = new Set;
     // Companion updates no-op without the verdict layer (null hook).
-        const o = GlobalQueue.Se;
+        const o = GlobalQueue.de;
     const settle = l => {
         if (r.has(l) || !removePendingSource(l, e)) return;
         r.add(l);
-        l.de = clock;
-        const u = l.oe?.values().next().value;
+        l.Te = clock;
+        const u = l.o?.le?.values().next().value;
         // STATUS_ERROR + pending sources only coexist via an errored loading
         // window's park (notifyStatus(STATUS_ERROR) clears pending sources
         // otherwise): the settled error stays the answer through the settle —
@@ -163,15 +163,15 @@ function settlePendingSource(e) {
             l.S &= ~STATUS_PENDING;
             if (!i) setPendingError(l);
             o !== null && o(l);
-            if (l.le) {
+            if (l.o?.ue) {
                 enqueueSub(l);
                 n = true;
             }
-            l.le = false;
+            if (l.o !== null) l.o.ue = false;
             // Fully settled with nobody watching: release candidate (#2934). Checked
             // again at release time — deferred so unobserved() can't unlink subs
             // lists this walk is still iterating.
-                        if (!l.o && l.T & CONFIG_AUTO_DISPOSE) (t ??= []).push(l);
+                        if (!l.u && l.T & CONFIG_AUTO_DISPOSE) (t ??= []).push(l);
         }
         forEachDependent(l, settle);
     };
@@ -197,12 +197,12 @@ function handleAsync(e, n, t) {
         });
     }
     if (!o && !r) {
-        e.Te = null;
+        if (e.o !== null) e.o.Ee = null;
         // A sync landing is the first real answer for a loadingValue node.
-                e.Ee = false;
+                e.Ie = false;
         return n;
     }
-    e.Te = n;
+    ext(e).Ee = n;
     let l;
     // Settle-time transition re-entry. The loading rail is invisible to
     // transactions (#2933): a boundary-caught first load never registers as an
@@ -216,42 +216,42 @@ function handleAsync(e, n, t) {
     // are the transaction's reveal machinery and always re-enter.
         const settleTransition = () => {
         const n = resolveTransition(e);
-        if (n && e.S & STATUS_UNINITIALIZED && !currentTransition(n).Ie.has(e)) {
+        if (n && e.S & STATUS_UNINITIALIZED && !currentTransition(n).Ne.has(e)) {
             // Drop the stale stamp too: the plain settle write (setSignal) and the
             // stash-path restamp both re-enter the transaction through it.
-            e.Ne = null;
+            e._e = null;
             return;
         }
         globalQueue.initTransition(n);
     };
     const handleError = t => {
-        if (e.Te !== n) return;
+        if (e.o?.Ee !== n) return;
         // NotReadyError from rejected promises should be treated as pending, not error
                 let r = t instanceof NotReadyError;
-        if (r && e.Ee) {
+        if (r && e.Ie) {
             // Loading window: the flight died waiting on an unready source. Keep
             // serving commit #0 — same parking as recompute's catch for sync
             // dependency throws. The dead flight is released so the clock-gated
             // error-retry pull (updateIfNecessary) can also re-ask.
-            e.Te = null;
+            if (e.o !== null) e.o.Ee = null;
             parkLoadingWindow(e, t);
-            e.de = clock;
+            e.Te = clock;
             return;
         }
         settleTransition();
         notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, t);
-        e.de = clock;
+        e.Te = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
         // the error twin of settlePendingSource's release (#2934).
                 if (!r) releaseSettledDependents(e);
     };
     const asyncWrite = (r, o) => {
-        if (e.Te !== n) return;
+        if (e.o?.Ee !== n) return;
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
-                if (e.se & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+                if (e.ie & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         settleTransition();
         const l = !!(e.S & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
@@ -261,7 +261,7 @@ function handleAsync(e, n, t) {
         if (t) {
             t(r);
             if (l) clearStatus(e, true);
-        } else if (e.De !== undefined) {
+        } else if (e.o?.De !== undefined) {
             // Optimistic node — resting OR covered by an active override — holds
             // through the shared pending-node path, exactly like a plain async memo,
             // so the commit clears STATUS_UNINITIALIZED (#2806) and elevation to
@@ -271,8 +271,8 @@ function handleAsync(e, n, t) {
             // (A17 — every reader sees the override); the revert reveals whatever
             // has committed by then, so corrections reveal atomically with their
             // transition rather than escaping it.
-            if (e._e === NOT_PENDING) queuePendingNode(e);
-            e._e = r;
+            if (e.Pe === NOT_PENDING) queuePendingNode(e);
+            e.Pe = r;
             // The hold is a companion-visible write like any other (A13/A19): the
             // clearStatus() above computed its verdict before the hold existed, so
             // isPending must re-derive (the value is not final until commit — V1)
@@ -280,9 +280,11 @@ function handleAsync(e, n, t) {
             // only notified when the hold is visible to them: under an active
             // override every reader sees the override (A17), so waking subs would
             // re-show an unchanged view — the revert is the notification point.
-                        GlobalQueue.Pe !== null && GlobalQueue.Pe(e, r);
-            if (!hasActiveOverride(e)) insertSubs(e);
-            e.de = clock;
+                        GlobalQueue.Oe !== null && GlobalQueue.Oe(e, r);
+            if (!hasActiveOverride(e)) {
+                insertSubs(e);
+            }
+            e.Te = clock;
         } else if (u) {
             // Route through lane's effect queue for independent flushing
             const n = e.Re;
@@ -291,11 +293,11 @@ function handleAsync(e, n, t) {
             try {
                 if (!n && l || !o || !o(r, t)) {
                     e.be = r;
-                    e.de = clock;
+                    e.Te = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
                     // (computePendingState doesn't read _value).
-                                        GlobalQueue.Pe !== null && GlobalQueue.Pe(e, r);
+                                        GlobalQueue.Oe !== null && GlobalQueue.Oe(e, r);
                     insertSubs(e, true);
                 }
             } catch (n) {
@@ -320,7 +322,7 @@ function handleAsync(e, n, t) {
         // held-value branch is window-gated, and commitPendingNode closes the
         // window when the hold commits, so no one-frame isPending pulse can leak
         // to live observers between the landing and its commit (#2990).
-                if (e._e === NOT_PENDING) e.Ee = false;
+                if (e.Pe === NOT_PENDING) e.Ie = false;
         settlePendingSource(e);
         schedule();
         flush();
@@ -334,7 +336,7 @@ function handleAsync(e, n, t) {
     // Returns whether the node released, so the iterator branch can stop
     // pulling values instead of pumping an unobserved stream forever (#2935).
         const settleAutodispose = () => {
-        if (e.T & CONFIG_AUTO_DISPOSE && !e.o && !(e.S & STATUS_PENDING)) {
+        if (e.T & CONFIG_AUTO_DISPOSE && !e.u && !(e.S & STATUS_PENDING)) {
             unobserved(e);
             return true;
         }
@@ -394,7 +396,7 @@ function handleAsync(e, n, t) {
                     t = r;
                     f = true;
                     if (r.done) i = true;
-                } else if (e.Te !== n) {
+                } else if (e.o?.Ee !== n) {
                     return;
                 } else if (!r.done) {
                     u = true;
@@ -414,7 +416,7 @@ function handleAsync(e, n, t) {
                 if (c && s) {
                     r = t;
                     a = true;
-                } else if (e.Te === n) {
+                } else if (e.o?.Ee === n) {
                     i = true;
                     handleError(t);
                     settleAutodispose();
@@ -480,7 +482,7 @@ function handleAsync(e, n, t) {
             if (u) {
                 l = r;
                 t = true;
-            } else if (e.Te === n && !(e.se & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
+            } else if (e.o?.Ee === n && !(e.ie & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
                 asyncWrite(r);
                 settleAutodispose();
             }
@@ -505,12 +507,12 @@ function handleAsync(e, n, t) {
             // is opened — first-flight work on a loadingValue node is loading-class
             // (invisible to boundaries and transitions); the flight itself is
             // already registered in _inFlight and lands through asyncWrite.
-            if (e.Ee) return e.be;
+            if (e.Ie) return e.be;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         } else if (!flattenIfIterable(l)) {
             // Synchronously-resolved promise: the first real answer landed.
-            e.Ee = false;
+            e.Ie = false;
         }
         // A sync-resolved promise holding an AsyncIterable flattened LIVE (we
         // are still inside the synchronous read): full initial-drain semantics
@@ -520,31 +522,31 @@ function handleAsync(e, n, t) {
     if (u !== null) {
         if (!u) {
             // Loading window: serve commit #0 (see the promise branch above).
-            if (e.Ee) return e.be;
+            if (e.Ie) return e.be;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         }
         // A sync first yield (or immediate empty completion) is the first real
         // answer; async yields clear inside asyncWrite.
-                e.Ee = false;
+                e.Ie = false;
     }
     return l;
 }
 
 function clearStatus(e, n = false) {
-    if (e.oe) clearPendingSources(e);
-    if (e.le) e.le = false;
+    if (e.o?.le) clearPendingSources(e);
+    if (e.o?.ue) if (e.o !== null) e.o.ue = false;
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        e.pe = false;
+        if (e.o !== null) e.o.pe = false;
     e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
-    if (e._) setPendingError(e);
+    if (e.o?._) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e.Oe || e.ge) GlobalQueue.Se(e);
-    if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
-    if (e.i) e.i();
+        if (e.o?.Ge || e.o?.ge) GlobalQueue.de(e);
+    if (e.o?.l && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
+    if (e.o?.A) e.o.A.call(e);
 }
 
 function notifyStatus(e, n, t, r, o) {
@@ -552,7 +554,7 @@ function notifyStatus(e, n, t, r, o) {
     if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
     const l = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
     const u = l === e;
-    const i = n === STATUS_PENDING && e.De !== undefined && !u;
+    const i = n === STATUS_PENDING && e.o?.De !== undefined && !u;
     const s = i && hasActiveOverride(e);
     if (!r) {
         if (n === STATUS_PENDING && l) {
@@ -564,41 +566,41 @@ function notifyStatus(e, n, t, r, o) {
         } else {
             clearPendingSources(e);
             e.S = n | (n !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
-            e._ = t;
+            ext(e)._ = t;
         }
-        GlobalQueue.Se !== null && GlobalQueue.Se(e);
-        if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
+        GlobalQueue.de !== null && GlobalQueue.de(e);
+        if (e.o?.l && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
     }
     if (o && !r) {
         assignOrMergeLane(e, o);
     }
     const f = r || s;
     const a = r || i ? undefined : o;
-    if (e.i) {
+    if (e.o?.A) {
         if (r && n === STATUS_PENDING) {
             return;
         }
         if (f) {
-            e.i(n, t);
+            e.o.A.call(e, n, t);
         } else {
-            e.i();
+            e.o.A.call(e);
         }
         return;
     }
     forEachDependent(e, (e, r) => {
-        e.de = clock;
-        if (n === STATUS_PENDING && l && !e.oe?.has(l) || n !== STATUS_PENDING && (e._ !== t || e.oe)) {
+        e.Te = clock;
+        if (n === STATUS_PENDING && l && !e.o?.le?.has(l) || n !== STATUS_PENDING && (e.o?._ !== t || e.o?.le)) {
             // A pending-observer link is the subscription an `isPending` read created.
             // It exists so the observer re-runs when the source settles, but it must
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
             // read swallows those, and the async path must match. Re-run the observer
             // so `isPending` re-evaluates (to not-pending) instead of forwarding.
-            if (r.ye && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
+            if (r.me && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
             }
-            if (!f && !e.Ne) queuePendingNode(e);
+            if (!f && !e._e) queuePendingNode(e);
             notifyStatus(e, n, t, f, a);
         }
     });

package/dist/prod/core/constants.js

@@ -30,6 +30,15 @@ const REACTIVE_MANUAL_WRITE = 1 << 10;
  * pending window does not read as pending (question-scoped pending model).
  */ const REACTIVE_REASK = 1 << 11;
 
+/**
+ * A dependency write landed while this subscriber was mid-recompute — a
+ * nested pull committed beneath one of its reads (#3037). The heap refuses
+ * RECOMPUTING nodes, so recompute's tail consumes this latch and reschedules:
+ * values the pass read before the nested commit are stale. Only set for
+ * links validated this pass (gen-current): a write to an untouched link is
+ * either re-read later in the pass (fresh) or trimmed with it (not a dep).
+ */ const REACTIVE_MISSED_WAKE = 1 << 12;
+
 // Static configuration bits packed into Owner/Computed/Signal _config.
 const CONFIG_OWNED_WRITE = 1 << 0;
 
@@ -45,6 +54,35 @@ const CONFIG_AUTO_DISPOSE = 1 << 5;
 
 const CONFIG_SYNC = 1 << 6;
 
+// Presence bits (stage-3 hot-path monomorphism, DESIGN-PATCH-CHANNEL §11b):
+// optional per-node slots (_overrideValue, _pendingSignal/_latestValueComputed,
+// _snapshotValue, _optimisticLane) are NOT part of every node's hidden class —
+// reading a missing property defeats V8's inline caches on the hottest write/
+// notify loops. These bits live on the always-present `_config` so hot paths
+// pay one monomorphic masked read and only touch the optional field when its
+// installer flagged it. Bits are STICKY ("may be set") — the guarded field
+// read remains authoritative.
+const CONFIG_OPTIMISTIC = 1 << 7;
+
+const CONFIG_HAS_COMPANIONS = 1 << 8;
+
+const CONFIG_HAS_SNAPSHOT = 1 << 9;
+
+const CONFIG_HAS_LANE = 1 << 10;
+
+/** Set on a FIREWALL computed when any of its child signals creates an
+ * isPending()/latest() companion. Gates the post-recompute child-companion
+ * walk (#3038): a store computed's `_child` chain holds one node per
+ * materialized leaf, so walking it unconditionally makes every update cost
+ * O(all leaves ever read). Sticky — set at companion creation, never
+ * cleared; sync-only apps never set it and never pay the walk. */ const CONFIG_CHILD_COMPANIONS = 1 << 11;
+
+/** Set on a computed when its first firewall child signal is installed
+ * (projection machinery). Gates markNode's firewall-children walk with one
+ * masked read of the always-present _config — the walk's old `_child` read
+ * moved into the cold extension (§12), and an unconditional `_x` deref per
+ * marked node measurably taxed the propagation hot path (diamond -22%). */ const CONFIG_FW_CHILDREN = 1 << 12;
+
 const STATUS_PENDING = 1 << 0;
 
 const STATUS_ERROR = 1 << 1;
@@ -89,4 +127,4 @@ const defaultContext = {};
  * @internal
  */ const $REFRESH = Symbol("refresh");
 
-export { $REFRESH, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OWNED_WRITE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };
+export { $REFRESH, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_CHILD_COMPANIONS, CONFIG_FW_CHILDREN, CONFIG_HAS_COMPANIONS, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OPTIMISTIC, CONFIG_OWNED_WRITE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };