@solidjs/signals 0.13.12 → 2.0.0-beta.10

package/dist/dev.js

@@ -35,6 +35,12 @@ const REACTIVE_DISPOSED = 1 << 6;
 const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
 const REACTIVE_SNAPSHOT_STALE = 1 << 8;
 const REACTIVE_LAZY = 1 << 9;
+const CONFIG_OWNED_WRITE = 1 << 0;
+const CONFIG_NO_SNAPSHOT = 1 << 1;
+const CONFIG_TRANSPARENT = 1 << 2;
+const CONFIG_IN_SNAPSHOT_SCOPE = 1 << 3;
+const CONFIG_CHILDREN_FORBIDDEN = 1 << 4;
+const CONFIG_AUTO_DISPOSE = 1 << 5;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
@@ -240,6 +246,23 @@ let inTrackedQueueCallback = false;
 let _enforceLoadingBoundary = false;
 let _hitUnhandledAsync = false;
 let stashedOptimisticReads = null;
+const transientStoreNodes = new Set();
+function registerTransientStoreNode(node) {
+  transientStoreNodes.add(node);
+}
+function sweepTransientStoreNodes() {
+  if (transientStoreNodes.size === 0) return;
+  for (const node of transientStoreNodes) {
+    if (node._subs !== null) {
+      transientStoreNodes.delete(node);
+      continue;
+    }
+    if (node._pendingValue !== NOT_PENDING) continue;
+    if (node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING) continue;
+    transientStoreNodes.delete(node);
+    node._unobserved?.();
+  }
+}
 function resetUnhandledAsync() {
   _hitUnhandledAsync = false;
 }
@@ -292,6 +315,7 @@ function mergeTransitionState(target, outgoing) {
     if (!targetReporters) target._asyncReporters.set(source, (targetReporters = new Set()));
     for (const reporter of reporters) targetReporters.add(reporter);
   }
+  for (const sub of outgoing._gatedSubs) target._gatedSubs.add(sub);
 }
 function resolveOptimisticNodes(nodes) {
   for (let i = 0; i < nodes.length; i++) {
@@ -422,11 +446,15 @@ class GlobalQueue extends Queue {
           scheduled = dirtyQueue._max >= dirtyQueue._min;
           reassignPendingTransition(stashedTransition._pendingNodes);
           activeTransition = null;
-          if (!stashedTransition._actions.length && stashedTransition._optimisticNodes.length) {
+          if (
+            !stashedTransition._actions.length &&
+            !stashedTransition._asyncReporters.size &&
+            stashedTransition._optimisticNodes.length
+          ) {
             stashedOptimisticReads = new Set();
             for (let i = 0; i < stashedTransition._optimisticNodes.length; i++) {
               const node = stashedTransition._optimisticNodes[i];
-              if (node._fn || node._pureWrite) continue;
+              if (node._fn || node._config & CONFIG_OWNED_WRITE) continue;
               stashedOptimisticReads.add(node);
               queueStashedOptimisticEffects(node);
             }
@@ -492,7 +520,8 @@ class GlobalQueue extends Queue {
         _optimisticStores: new Set(),
         _actions: [],
         _queueStash: { _queues: [[], []], _children: [] },
-        _done: false
+        _done: false,
+        _gatedSubs: new Set()
       };
     } else if (transition) {
       const outgoing = activeTransition;
@@ -531,7 +560,7 @@ function insertSubs(node, optimistic = false) {
   const sourceLane = node._optimisticLane || currentOptimisticLane;
   const hasSnapshot = node._snapshotValue !== undefined;
   for (let s = node._subs; s !== null; s = s._nextSub) {
-    if (hasSnapshot && s._sub._inSnapshotScope) {
+    if (hasSnapshot && s._sub._config & CONFIG_IN_SNAPSHOT_SCOPE) {
       s._sub._flags |= REACTIVE_SNAPSHOT_STALE;
       continue;
     }
@@ -579,6 +608,22 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
     resolveOptimisticNodes(
       completingTransition ? completingTransition._optimisticNodes : globalQueue._optimisticNodes
     );
+    if (completingTransition && completingTransition._gatedSubs.size) {
+      for (const sub of completingTransition._gatedSubs) {
+        if (sub._flags & REACTIVE_DISPOSED) continue;
+        if (sub._type === EFFECT_TRACKED) {
+          if (!sub._modified) {
+            sub._modified = true;
+            sub._queue.enqueue(EFFECT_USER, sub._run);
+          }
+          continue;
+        }
+        const queue = sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+        if (queue._min > sub._height) queue._min = sub._height;
+        insertIntoHeap(sub, queue);
+      }
+      completingTransition._gatedSubs.clear();
+    }
     const optimisticStores = completingTransition
       ? completingTransition._optimisticStores
       : globalQueue._optimisticStores;
@@ -589,6 +634,7 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
       optimisticStores.clear();
       schedule();
     }
+    sweepTransientStoreNodes();
     cleanupCompletedLanes(completingTransition);
   }
 }
@@ -778,7 +824,8 @@ function unlinkSubs(link) {
     dep._subs = nextSub;
     if (nextSub === null) {
       dep._unobserved?.();
-      dep._fn && !dep._preventAutoDisposal && !(dep._flags & REACTIVE_ZOMBIE) && unobserved(dep);
+      const c = dep;
+      c._fn && c._config & CONFIG_AUTO_DISPOSE && !(c._flags & REACTIVE_ZOMBIE) && unobserved(c);
     }
   }
   return nextDep;
@@ -790,6 +837,7 @@ function unobserved(el) {
     dep = unlinkSubs(dep);
   }
   el._deps = null;
+  el._depsTail = null;
   disposeChildren(el, true);
 }
 function link(dep, sub) {
@@ -894,7 +942,7 @@ function runDisposal(node, zombie) {
 }
 function childId(owner, consume) {
   let counter = owner;
-  while (counter._transparent && counter._parent) counter = counter._parent;
+  while (counter._config & CONFIG_TRANSPARENT && counter._parent) counter = counter._parent;
   if (counter.id != null)
     return formatId(counter.id, consume ? counter._childCount++ : counter._childCount);
   throw new Error("Cannot get child id from owner without an id");
@@ -934,7 +982,7 @@ function createOwner(options) {
     id:
       options?.id ??
       (transparent ? parent?.id : parent?.id != null ? getNextChildId(parent) : undefined),
-    _transparent: transparent || undefined,
+    _config: transparent ? CONFIG_TRANSPARENT : 0,
     _root: true,
     _parentComputed: parent?._root ? parent._parentComputed : parent,
     _firstChild: null,
@@ -950,10 +998,16 @@ function createOwner(options) {
       disposeChildren(owner, self);
     }
   };
-  if (parent?._childrenForbidden) {
-    throw new Error(
-      "Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled"
-    );
+  if (parent && parent._config & CONFIG_CHILDREN_FORBIDDEN) {
+    emitDiagnostic({
+      code: "PRIMITIVE_IN_FORBIDDEN_SCOPE",
+      kind: "lifecycle",
+      severity: "error",
+      message: PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE,
+      ownerId: parent.id,
+      ownerName: parent._name
+    });
+    throw new Error(PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE);
   }
   if (parent) {
     const lastChild = parent._firstChild;
@@ -1081,6 +1135,7 @@ function handleAsync(el, result, setter) {
     if (el._inFlight !== result) return;
     if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
     globalQueue.initTransition(resolveTransition(el));
+    const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
     clearStatus(el);
     const lane = resolveLane(el);
     if (lane) lane._pendingAsync.delete(el);
@@ -1094,9 +1149,10 @@ function handleAsync(el, result, setter) {
       }
       el._time = clock;
     } else if (lane) {
+      const isEffect = el._type;
       const prevValue = el._value;
       const equals = el._equals;
-      if (!equals || !equals(value, prevValue)) {
+      if ((!isEffect && wasUninitialized) || !equals || !equals(value, prevValue)) {
         el._value = value;
         el._time = clock;
         if (el._latestValueComputed) {
@@ -1278,6 +1334,8 @@ function enableExternalSource(config) {
 }
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
+const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE =
+  "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
 let tracking = false;
 let stale = false;
 let refreshing = false;
@@ -1316,7 +1374,7 @@ function releaseSubtree(owner) {
     }
     if (child._fn) {
       const comp = child;
-      comp._inSnapshotScope = false;
+      comp._config &= ~CONFIG_IN_SNAPSHOT_SCOPE;
       if (comp._flags & REACTIVE_SNAPSHOT_STALE) {
         comp._flags &= ~REACTIVE_SNAPSHOT_STALE;
         comp._flags |= REACTIVE_DIRTY;
@@ -1356,9 +1414,10 @@ function recompute(el, create = false) {
       clearSignals(el);
     }
   }
-  const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
+  let isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
   const hasOverride = el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING;
   const wasPending = !!(el._statusFlags & STATUS_PENDING);
+  const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
   const oldcontext = context;
   context = el;
   el._depsTail = null;
@@ -1377,9 +1436,25 @@ function recompute(el, create = false) {
   if (isOptimisticDirty) {
     const lane = resolveLane(el);
     if (lane) currentOptimisticLane = lane;
+  } else if (activeTransition && !create && activeTransition._optimisticNodes.length) {
+    for (let d = el._deps; d; d = d._nextDep) {
+      const dep = d._dep;
+      if (dep._flags & REACTIVE_OPTIMISTIC_DIRTY) {
+        const depLane = resolveLane(dep);
+        if (depLane) {
+          isOptimisticDirty = true;
+          currentOptimisticLane = depLane;
+          el._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+          assignOrMergeLane(el, depLane);
+          break;
+        }
+      }
+    }
   }
   try {
-    value = handleAsync(el, el._fn(value));
+    const prevInFlight = el._inFlight;
+    const fnResult = el._fn(value);
+    value = el._inFlight !== prevInFlight ? fnResult : handleAsync(el, fnResult);
     clearStatus(el, create);
     const resolvedLane = resolveLane(el);
     if (resolvedLane) {
@@ -1424,7 +1499,8 @@ function recompute(el, create = false) {
       : el._pendingValue === NOT_PENDING
         ? el._value
         : el._pendingValue;
-    const valueChanged = !el._equals || !el._equals(compareValue, value);
+    const valueChanged =
+      (!isEffect && wasUninitialized) || !el._equals || !el._equals(compareValue, value);
     if (valueChanged) {
       const prevVisible = hasOverride ? el._overrideValue : undefined;
       if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty) {
@@ -1477,22 +1553,25 @@ function updateIfNecessary(el) {
   }
   el._flags = el._flags & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
 }
-function computed(fn, initialValue, options) {
+function computed(fn, options) {
   const transparent = options?.transparent ?? false;
   const self = {
     id:
       options?.id ??
       (transparent ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
-    _transparent: transparent || undefined,
+    _config:
+      (transparent ? CONFIG_TRANSPARENT : 0) |
+      (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
+      (!context || options?.lazy ? CONFIG_AUTO_DISPOSE : 0) |
+      (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
     _equals: options?.equals != null ? options.equals : isEqual,
-    _pureWrite: !!options?.pureWrite,
     _unobserved: options?.unobserved,
     _disposal: null,
     _queue: context?._queue ?? globalQueue,
     _context: context?._context ?? defaultContext,
     _childCount: 0,
     _fn: fn,
-    _value: initialValue,
+    _value: undefined,
     _height: 0,
     _child: null,
     _nextHeap: undefined,
@@ -1516,10 +1595,16 @@ function computed(fn, initialValue, options) {
   self._name = options?.name ?? "computed";
   self._prevHeap = self;
   const parent = context?._root ? context._parentComputed : context;
-  if (context?._childrenForbidden) {
-    throw new Error(
-      "Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled"
-    );
+  if (context && context._config & CONFIG_CHILDREN_FORBIDDEN) {
+    emitDiagnostic({
+      code: "PRIMITIVE_IN_FORBIDDEN_SCOPE",
+      kind: "lifecycle",
+      severity: "error",
+      message: PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE,
+      ownerId: context.id,
+      ownerName: context._name
+    });
+    throw new Error(PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE);
   }
   if (context) {
     const lastChild = context._firstChild;
@@ -1532,9 +1617,8 @@ function computed(fn, initialValue, options) {
   }
   DEV$1.hooks.onOwner?.(self);
   if (parent) self._height = parent._height + 1;
-  if (snapshotCaptureActive && ownerInSnapshotScope(context)) self._inSnapshotScope = true;
   if (externalSourceConfig) {
-    const bridgeSignal = signal(undefined, { equals: false, pureWrite: true });
+    const bridgeSignal = signal(undefined, { equals: false, ownedWrite: true });
     const source = externalSourceConfig.factory(self._fn, () => {
       setSignal(bridgeSignal, undefined);
     });
@@ -1556,8 +1640,9 @@ function computed(fn, initialValue, options) {
 function signal(v, options, firewall = null) {
   const s = {
     _equals: options?.equals != null ? options.equals : isEqual,
-    _pureWrite: !!options?.pureWrite,
-    _noSnapshot: !!options?._noSnapshot,
+    _config:
+      (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
+      (options?._noSnapshot ? CONFIG_NO_SNAPSHOT : 0),
     _unobserved: options?.unobserved,
     _value: v,
     _subs: null,
@@ -1574,7 +1659,7 @@ function signal(v, options, firewall = null) {
   firewall && (firewall._child = s);
   if (
     snapshotCaptureActive &&
-    !s._noSnapshot &&
+    !(s._config & CONFIG_NO_SNAPSHOT) &&
     !((firewall?._statusFlags ?? 0) & STATUS_PENDING)
   ) {
     s._snapshotValue = v === undefined ? NO_SNAPSHOT : v;
@@ -1587,8 +1672,8 @@ function optimisticSignal(v, options) {
   s._overrideValue = NOT_PENDING;
   return s;
 }
-function optimisticComputed(fn, initialValue, options) {
-  const c = computed(fn, initialValue, options);
+function optimisticComputed(fn, options) {
+  const c = computed(fn, options);
   c._overrideValue = NOT_PENDING;
   return c;
 }
@@ -1668,15 +1753,21 @@ function read(el) {
   }
   let c = context;
   if (c?._root) c = c._parentComputed;
-  if (refreshing && el._fn) recompute(el);
-  if (el._flags & REACTIVE_LAZY) {
-    el._flags &= ~REACTIVE_LAZY;
-    recompute(el, true);
+  const computed = el;
+  if (typeof computed._fn === "function") {
+    const comp = el;
+    if (refreshing && !(comp._flags & REACTIVE_DISPOSED)) recompute(comp);
+    if (comp._flags & REACTIVE_LAZY) {
+      comp._flags &= ~REACTIVE_LAZY;
+      recompute(comp, true);
+    } else if (comp._flags & REACTIVE_DISPOSED) {
+      recompute(comp, true);
+    }
   }
   const owner = el._firewall || el;
   if (strictRead && owner._statusFlags & STATUS_PENDING) {
     const message =
-      `Reading a pending async value directly in ${strictRead}. ` +
+      `[PENDING_ASYNC_UNTRACKED_READ] Reading a pending async value directly in ${strictRead}. ` +
       `Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).`;
     emitDiagnostic({
       code: "PENDING_ASYNC_UNTRACKED_READ",
@@ -1691,7 +1782,6 @@ function read(el) {
     throw new Error(message);
   }
   if (c && tracking) {
-    if (el._fn && el._flags & REACTIVE_DISPOSED) recompute(el);
     link(el, c);
     if (owner._fn) {
       const isZombie = el._flags & REACTIVE_ZOMBIE;
@@ -1708,9 +1798,9 @@ function read(el) {
   }
   if (owner._statusFlags & STATUS_PENDING) {
     if (c && !(stale && owner._transition && activeTransition !== owner._transition)) {
-      if (c?._childrenForbidden) {
+      if (c && c._config & CONFIG_CHILDREN_FORBIDDEN) {
         const message =
-          "Reading a pending async value inside createTrackedEffect or onSettled will throw. " +
+          "[PENDING_ASYNC_FORBIDDEN_SCOPE] Reading a pending async value inside createTrackedEffect or onSettled will throw. " +
           "Use createEffect instead which supports async-aware reactivity.";
         emitDiagnostic({
           code: "PENDING_ASYNC_FORBIDDEN_SCOPE",
@@ -1747,7 +1837,7 @@ function read(el) {
       return read(el);
     } else throw el._error;
   }
-  if (snapshotCaptureActive && c && c._inSnapshotScope) {
+  if (snapshotCaptureActive && c && c._config & CONFIG_IN_SNAPSHOT_SCOPE) {
     const sv = el._snapshotValue;
     if (sv !== undefined) {
       const snapshot = sv === NO_SNAPSHOT ? undefined : sv;
@@ -1758,7 +1848,7 @@ function read(el) {
   }
   if (strictRead) {
     const message =
-      `Reactive value read directly in ${strictRead} will not update. ` +
+      `[STRICT_READ_UNTRACKED] Reactive value read directly in ${strictRead} will not update. ` +
       `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
     emitDiagnostic({
       code: "STRICT_READ_UNTRACKED",
@@ -1776,7 +1866,20 @@ function read(el) {
     if (c && stale && shouldReadStashedOptimisticValue(el)) return el._value;
     return el._overrideValue;
   }
-  return !c ||
+  if (
+    activeTransition !== null &&
+    currentOptimisticLane !== null &&
+    !latestReadActive &&
+    el._pendingValue !== NOT_PENDING &&
+    owner === el &&
+    !el._fn &&
+    c
+  ) {
+    activeTransition._gatedSubs.add(c);
+    return el._value;
+  }
+  const value =
+    !c ||
     (currentOptimisticLane !== null &&
       (el._overrideValue !== undefined ||
         el._optimisticLane ||
@@ -1784,14 +1887,30 @@ function read(el) {
         !!(owner._statusFlags & STATUS_PENDING))) ||
     el._pendingValue === NOT_PENDING ||
     (stale && el._transition && activeTransition !== el._transition)
-    ? el._value
-    : el._pendingValue;
+      ? el._value
+      : el._pendingValue;
+  if (
+    !c &&
+    owner === el &&
+    typeof computed._fn === "function" &&
+    el._config & CONFIG_AUTO_DISPOSE &&
+    !(owner._statusFlags & STATUS_PENDING) &&
+    !el._subs
+  ) {
+    unobserved(el);
+  }
+  return value;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && !context?._childrenForbidden && context && el._firewall !== context) {
+  if (
+    !(el._config & CONFIG_OWNED_WRITE) &&
+    !(context && context._config & CONFIG_CHILDREN_FORBIDDEN) &&
+    context &&
+    el._firewall !== context
+  ) {
     const message =
-      "Writing to a Signal inside an owned scope (component, computation) is not allowed. " +
-      "Move the write outside or set the `pureWrite` option if this is intentional.";
+      "[SIGNAL_WRITE_IN_OWNED_SCOPE] Writing to a Signal inside an owned scope (component, computation) is not allowed. " +
+      "Move the write outside or set the `ownedWrite` option if this is intentional.";
     emitDiagnostic({
       code: "SIGNAL_WRITE_IN_OWNED_SCOPE",
       kind: "write",
@@ -1851,7 +1970,7 @@ function setSignal(el, v) {
 function runWithOwner(owner, fn) {
   if (owner && owner._flags & REACTIVE_DISPOSED) {
     const message =
-      "runWithOwner called with a disposed owner. Children created inside will never be disposed.";
+      "[RUN_WITH_DISPOSED_OWNER] runWithOwner called with a disposed owner. Children created inside will never be disposed.";
     emitDiagnostic({
       code: "RUN_WITH_DISPOSED_OWNER",
       kind: "owner",
@@ -1875,7 +1994,7 @@ function runWithOwner(owner, fn) {
 }
 function getPendingSignal(el) {
   if (!el._pendingSignal) {
-    el._pendingSignal = optimisticSignal(false, { pureWrite: true });
+    el._pendingSignal = optimisticSignal(false, { ownedWrite: true });
     if (el._parentSource) {
       el._pendingSignal._parentSource = el;
     }
@@ -2018,26 +2137,24 @@ function hasContext(context, owner) {
 function isUndefined(value) {
   return typeof value === "undefined";
 }
-function effect(compute, effect, error, initialValue, options) {
+function effect(compute, effect, error, options) {
   let initialized = false;
-  const node = computed(
-    options?.render ? p => staleValues(() => compute(p)) : compute,
-    initialValue,
-    {
-      ...options,
-      equals: () => {
-        node._modified = !node._error;
-        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
-        return false;
-      },
-      lazy: true
-    }
-  );
-  node._prevValue = initialValue;
+  const isUser = !!options?.user;
+  const node = computed(isUser ? compute : p => staleValues(() => compute(p)), {
+    ...options,
+    equals: () => {
+      node._modified = !node._error;
+      if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
+      return false;
+    },
+    lazy: true
+  });
+  node._config &= ~CONFIG_AUTO_DISPOSE;
+  node._prevValue = undefined;
   node._effectFn = effect;
   node._errorFn = error;
   node._cleanup = undefined;
-  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
+  node._type = isUser ? EFFECT_USER : EFFECT_RENDER;
   node._notifyStatus = (status, error) => {
     const actualStatus = status !== undefined ? status : node._statusFlags;
     const actualError = error !== undefined ? error : node._error;
@@ -2061,28 +2178,32 @@ function effect(compute, effect, error, initialValue, options) {
       node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
       if (_hitUnhandledAsync) {
         resetUnhandledAsync();
-        const err = new Error("An async value must be rendered inside a Loading boundary.");
-        emitDiagnostic({
-          code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
-          kind: "async",
-          severity: "error",
-          message: err.message,
-          ownerId: node.id,
-          ownerName: node._name
-        });
-        if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+        if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
+          const message =
+            "[ASYNC_OUTSIDE_LOADING_BOUNDARY] An async value was read outside a Loading boundary. The root mount will be deferred until all pending async settles.";
+          emitDiagnostic({
+            code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
+            kind: "async",
+            severity: "warn",
+            message: message,
+            ownerId: node.id,
+            ownerName: node._name
+          });
+          console.warn(message);
+        }
       }
     }
   };
   recompute(node, true);
   !options?.defer &&
-    (node._type === EFFECT_USER
+    (node._type === EFFECT_USER || options?.schedule
       ? node._queue.enqueue(node._type, runEffect.bind(node))
       : runEffect.call(node));
   initialized = true;
   cleanup(() => node._cleanup?.());
   if (!node._parent) {
-    const message = "Effects created outside a reactive context will never be disposed";
+    const message =
+      "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";
     emitDiagnostic({
       code: "NO_OWNER_EFFECT",
       kind: "lifecycle",
@@ -2144,11 +2265,10 @@ function trackedEffect(fn, options) {
       }
       node._cleanup = cleanup;
     },
-    undefined,
     { ...options, lazy: true }
   );
   node._cleanup = undefined;
-  node._childrenForbidden = true;
+  node._config = (node._config & ~CONFIG_AUTO_DISPOSE) | CONFIG_CHILDREN_FORBIDDEN;
   node._modified = true;
   node._type = EFFECT_TRACKED;
   node._notifyStatus = (status, error) => {
@@ -2163,7 +2283,8 @@ function trackedEffect(fn, options) {
   node._queue.enqueue(EFFECT_USER, run);
   cleanup(() => node._cleanup?.());
   if (!node._parent) {
-    const message = "Effects created outside a reactive context will never be disposed";
+    const message =
+      "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";
     emitDiagnostic({
       code: "NO_OWNER_EFFECT",
       kind: "lifecycle",
@@ -2224,7 +2345,8 @@ function onCleanup(fn) {
   {
     const owner = getOwner();
     if (!owner) {
-      const message = "onCleanup called outside a reactive context will never be run";
+      const message =
+        "[NO_OWNER_CLEANUP] onCleanup called outside a reactive context will never be run";
       emitDiagnostic({
         code: "NO_OWNER_CLEANUP",
         kind: "lifecycle",
@@ -2232,9 +2354,9 @@ function onCleanup(fn) {
         message: message
       });
       console.warn(message);
-    } else if (owner._childrenForbidden) {
+    } else if (owner._config & CONFIG_CHILDREN_FORBIDDEN) {
       const message =
-        "Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead";
+        "[CLEANUP_IN_FORBIDDEN_SCOPE] Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead";
       emitDiagnostic({
         code: "CLEANUP_IN_FORBIDDEN_SCOPE",
         kind: "lifecycle",
@@ -2249,35 +2371,44 @@ function onCleanup(fn) {
   return cleanup(fn);
 }
 function accessor(node) {
-  const fn = read.bind(null, node);
-  fn.$r = true;
-  return fn;
+  return read.bind(null, node);
 }
-function createSignal(first, second, third) {
+function createSignal(first, second) {
   if (typeof first === "function") {
-    const node = computed(first, second, third);
+    const node = computed(first, second);
+    node._config &= ~CONFIG_AUTO_DISPOSE;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = signal(first, second);
   registerGraph(node, getOwner());
   return [accessor(node), setSignal.bind(null, node)];
 }
-function createMemo(compute, value, options) {
-  let node = computed(compute, value, options);
-  return accessor(node);
+function createMemo(compute, options) {
+  return accessor(computed(compute, options));
 }
-function createEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
-    ...options,
-    name: options?.name ?? "effect"
-  });
-}
-function createRenderEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn, undefined, value, {
-    render: true,
+function createEffect(compute, effectFn, options) {
+  if (effectFn === undefined) {
+    const message =
+      "[MISSING_EFFECT_FN] createEffect requires both a compute function and an effect function. " +
+      "Use `createEffect(() => signal(), value => doWork(value))`. " +
+      "If you want a derived value, use `createMemo`. " +
+      "If you want a one-shot side effect, just call the function directly.";
+    emitDiagnostic({
+      code: "MISSING_EFFECT_FN",
+      kind: "lifecycle",
+      severity: "error",
+      message: message
+    });
+    throw new Error(message);
+  }
+  effect(compute, effectFn.effect || effectFn, effectFn.error, {
+    user: true,
     ...{ ...options, name: options?.name ?? "effect" }
   });
 }
+function createRenderEffect(compute, effectFn, options) {
+  effect(compute, effectFn, undefined, { ...options, name: options?.name ?? "effect" });
+}
 function createTrackedEffect(compute, options) {
   trackedEffect(compute, { ...options, name: options?.name ?? "trackedEffect" });
 }
@@ -2301,8 +2432,11 @@ function createReaction(effectFn, options) {
           dispose(node);
         },
         effectFn.error,
-        undefined,
-        { defer: true, ...(true ? { ...options, name: options?.name ?? "effect" } : options) }
+        {
+          ...(true ? { ...options, name: options?.name ?? "effect" } : options),
+          user: true,
+          defer: true
+        }
       );
     });
   };
@@ -2327,9 +2461,10 @@ function resolve(fn) {
     });
   });
 }
-function createOptimistic(first, second, third) {
+function createOptimistic(first, second) {
   if (typeof first === "function") {
-    const node = optimisticComputed(first, second, third);
+    const node = optimisticComputed(first, second);
+    node._config &= ~CONFIG_AUTO_DISPOSE;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = optimisticSignal(first, second);
@@ -2338,7 +2473,7 @@ function createOptimistic(first, second, third) {
 }
 function onSettled(callback) {
   const owner = getOwner();
-  owner && !owner._childrenForbidden
+  owner && !(owner._config & CONFIG_CHILDREN_FORBIDDEN)
     ? createTrackedEffect(() => untrack(callback), { name: "onSettled" })
     : globalQueue.enqueue(EFFECT_USER, () => {
         const cleanup = callback();
@@ -2495,7 +2630,7 @@ function reconcile(value, key) {
     applyState(value, state, keyFn);
   };
 }
-function createProjectionInternal(fn, initialValue = {}, options) {
+function createProjectionInternal(fn, seed, options) {
   let node;
   const wrappedMap = new WeakMap();
   const wrapper = s => {
@@ -2515,31 +2650,39 @@ function createProjectionInternal(fn, initialValue = {}, options) {
     wrappedMap.set(source, wrapped);
     return wrapped;
   };
-  const wrappedStore = wrapProjection(initialValue);
-  node = computed(() => {
-    const owner = getOwner();
-    let settled = false;
-    let result;
-    const draft = new Proxy(
-      wrappedStore,
-      createWriteTraps(() => !settled || owner._inFlight === result)
-    );
-    storeSetter(draft, s => {
-      result = fn(s);
-      settled = true;
-      const value = handleAsync(owner, result, value => {
-        value !== s &&
-          value !== undefined &&
-          storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
-      });
-      value !== s && value !== undefined && reconcile(value, options?.key || "id")(wrappedStore);
-    });
-  });
-  node._preventAutoDisposal = true;
+  const wrappedStore = wrapProjection(seed);
+  node = computed(
+    () => {
+      if (!node) node = getOwner();
+      runProjectionComputed(wrappedStore, fn, options?.key || "id");
+    },
+    options?.name ? { name: options.name } : undefined
+  );
+  node._config &= ~CONFIG_AUTO_DISPOSE;
   return { store: wrappedStore, node: node };
 }
-function createProjection(fn, initialValue = {}, options) {
-  return createProjectionInternal(fn, initialValue, options).store;
+function createProjection(fn, seed, options) {
+  return createProjectionInternal(fn, seed, options).store;
+}
+function runProjectionComputed(wrappedStore, fn, key, wrapCommit) {
+  const owner = getOwner();
+  let settled = false;
+  let result;
+  const draft = new Proxy(
+    wrappedStore,
+    createWriteTraps(() => !settled || owner._inFlight === result)
+  );
+  storeSetter(draft, s => {
+    result = fn(s);
+    settled = true;
+    const commit = v => {
+      if (v === s || v === undefined) return;
+      const write = () => storeSetter(wrappedStore, reconcile(v, key));
+      wrapCommit ? wrapCommit(write) : write();
+    };
+    commit(handleAsync(owner, result, commit));
+  });
+  return owner;
 }
 function createWriteTraps(isActive) {
   const traps = {
@@ -2603,6 +2746,7 @@ const STORE_VALUE = "v",
   STORE_OPTIMISTIC_OVERRIDE = "x",
   STORE_NODE = "n",
   STORE_HAS = "h",
+  STORE_CUSTOM_PROTO = "c",
   STORE_WRAP = "w",
   STORE_LOOKUP = "l",
   STORE_FIREWALL = "f",
@@ -2613,6 +2757,7 @@ function createStoreProxy(value, traps = storeTraps, extend) {
     newTarget = [];
     newTarget.v = value;
   } else newTarget = { v: value };
+  newTarget[STORE_CUSTOM_PROTO] = hasCustomPrototype(unwrapStoreValue(value));
   extend && extend(newTarget);
   return (newTarget[$PROXY] = new Proxy(newTarget, traps));
 }
@@ -2638,6 +2783,23 @@ function setWriteOverride(value) {
 function writeOnly(proxy) {
   return writeOverride || !!Writing?.has(proxy);
 }
+function unwrapStoreValue(value) {
+  return value?.[$TARGET]?.[STORE_VALUE] ?? value;
+}
+function hasCustomPrototype(value) {
+  if (Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto !== null && proto !== Object.prototype;
+}
+function hasInheritedAccessor(source, property) {
+  let current = Object.getPrototypeOf(source);
+  while (current && current !== Object.prototype) {
+    const desc = Reflect.getOwnPropertyDescriptor(current, property);
+    if (desc) return !!desc.get;
+    current = Object.getPrototypeOf(current);
+  }
+  return false;
+}
 function getNodes(target, type) {
   let nodes = target[type];
   if (!nodes) target[type] = nodes = Object.create(null);
@@ -2650,7 +2812,7 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
     {
       equals: equals,
       unobserved() {
-        delete nodes[property];
+        if (nodes[property] === s) delete nodes[property];
       }
     },
     firewall
@@ -2690,12 +2852,87 @@ function getKeys(source, override, enumerable = true) {
   return Array.from(keys);
 }
 function getPropertyDescriptor(source, override, property) {
-  let value = source;
   if (override && property in override) {
-    if (value[property] === $DELETED) return void 0;
-    if (!(property in value)) value = override;
+    if (override[property] === $DELETED) return void 0;
+    const overrideDesc = Reflect.getOwnPropertyDescriptor(override, property);
+    if (overrideDesc?.get || overrideDesc?.set || !(property in source)) return overrideDesc;
   }
-  return Reflect.getOwnPropertyDescriptor(value, property);
+  return Reflect.getOwnPropertyDescriptor(source, property);
+}
+function prepareStoreWrite(target, store, property) {
+  if (target[STORE_OPTIMISTIC]) {
+    const firewall = target[STORE_FIREWALL];
+    if (firewall?._transition) {
+      globalQueue.initTransition(firewall._transition);
+    }
+  }
+  const state = target[STORE_VALUE];
+  const base = state[property];
+  if (
+    snapshotCaptureActive &&
+    typeof property !== "symbol" &&
+    !((target[STORE_FIREWALL]?._statusFlags ?? 0) & STATUS_PENDING)
+  ) {
+    if (!target[STORE_SNAPSHOT_PROPS]) {
+      target[STORE_SNAPSHOT_PROPS] = Object.create(null);
+      snapshotSources?.add(target);
+    }
+    if (!(property in target[STORE_SNAPSHOT_PROPS])) {
+      target[STORE_SNAPSHOT_PROPS][property] = base;
+    }
+  }
+  const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
+  const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+  if (useOptimistic) trackOptimisticStore(store);
+  return { base: base, overrideKey: overrideKey, state: state };
+}
+function upsertStoreNode(target, nodes, property, prev, snapshotProps) {
+  if (nodes[property]) return nodes[property];
+  const initial = isWrappable(prev) ? wrap(prev, target) : prev;
+  const node = getNode(
+    nodes,
+    property,
+    initial,
+    target[STORE_FIREWALL],
+    isEqual,
+    target[STORE_OPTIMISTIC],
+    snapshotProps
+  );
+  registerTransientStoreNode(node);
+  return node;
+}
+function notifyStoreProperty(target, property, mode, value, prev, prevHas) {
+  const skipUpsert = projectionWriteActive || target[STORE_OPTIMISTIC];
+  const newHas = mode !== "delete";
+  const existingHas = target[STORE_HAS]?.[property];
+  if (existingHas) {
+    setSignal(existingHas, newHas);
+  } else if (!skipUpsert && mode !== "invalidate" && prevHas !== newHas) {
+    const hasNode = upsertStoreNode(target, getNodes(target, STORE_HAS), property, prevHas);
+    setSignal(hasNode, newHas);
+  }
+  const nodes = getNodes(target, STORE_NODE);
+  if (mode === "set") {
+    if (nodes[property]) {
+      setSignal(nodes[property], () => (isWrappable(value) ? wrap(value, target) : value));
+    } else if (!skipUpsert) {
+      const node = upsertStoreNode(target, nodes, property, prev, target[STORE_SNAPSHOT_PROPS]);
+      setSignal(node, () => (isWrappable(value) ? wrap(value, target) : value));
+    }
+  } else if (mode === "invalidate") {
+    if (nodes[property]) {
+      setSignal(nodes[property], {});
+      delete nodes[property];
+    }
+  } else {
+    if (nodes[property]) {
+      setSignal(nodes[property], undefined);
+    } else if (!skipUpsert) {
+      const node = upsertStoreNode(target, nodes, property, prev, target[STORE_SNAPSHOT_PROPS]);
+      setSignal(node, undefined);
+    }
+  }
+  nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
 }
 let Writing = null;
 const storeTraps = {
@@ -2722,6 +2959,12 @@ const storeTraps = {
     if (!tracked) {
       const desc = Object.getOwnPropertyDescriptor(storeValue, property);
       if (desc && desc.get) return desc.get.call(receiver);
+      if (!desc && !overridden && target[STORE_CUSTOM_PROTO]) {
+        const source = unwrapStoreValue(storeValue);
+        if (hasInheritedAccessor(source, property)) {
+          return Reflect.get(storeValue, property, receiver);
+        }
+      }
     }
     if (writeOnly(receiver)) {
       let value =
@@ -2768,7 +3011,7 @@ const storeTraps = {
     }
     if (strictRead && typeof property === "string") {
       const message =
-        `Reactive value read directly in ${strictRead} will not update. ` +
+        `[STRICT_READ_UNTRACKED] Reactive value read directly in ${strictRead} will not update. ` +
         `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
       emitDiagnostic({
         code: "STRICT_READ_UNTRACKED",
@@ -2790,56 +3033,38 @@ const storeTraps = {
         : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
           ? target[STORE_OVERRIDE][property] !== $DELETED
           : property in target[STORE_VALUE];
-    if (!writeOnly(target[$PROXY])) {
-      getObserver() &&
-        read(
-          getNode(
-            getNodes(target, STORE_HAS),
-            property,
-            has,
-            target[STORE_FIREWALL],
-            isEqual,
-            target[STORE_OPTIMISTIC]
-          )
-        );
+    if (writeOnly(target[$PROXY])) return has;
+    const nodes = getNodes(target, STORE_HAS);
+    if (nodes[property]) return read(nodes[property]);
+    if (getObserver()) {
+      return read(
+        getNode(nodes, property, has, target[STORE_FIREWALL], isEqual, target[STORE_OPTIMISTIC])
+      );
     }
     return has;
   },
   set(target, property, rawValue) {
     const store = target[$PROXY];
     if (writeOnly(store)) {
-      if (target[STORE_OPTIMISTIC]) {
-        const firewall = target[STORE_FIREWALL];
-        if (firewall?._transition) {
-          globalQueue.initTransition(firewall._transition);
-        }
-      }
       untrack(() => {
-        const state = target[STORE_VALUE];
-        const base = state[property];
-        if (
-          snapshotCaptureActive &&
-          typeof property !== "symbol" &&
-          !((target[STORE_FIREWALL]?._statusFlags ?? 0) & STATUS_PENDING)
-        ) {
-          if (!target[STORE_SNAPSHOT_PROPS]) {
-            target[STORE_SNAPSHOT_PROPS] = Object.create(null);
-            snapshotSources?.add(target);
-          }
-          if (!(property in target[STORE_SNAPSHOT_PROPS])) {
-            target[STORE_SNAPSHOT_PROPS][property] = base;
-          }
-        }
-        const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
-        const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
-        if (useOptimistic) trackOptimisticStore(store);
+        const {
+          base: base,
+          overrideKey: overrideKey,
+          state: state
+        } = prepareStoreWrite(target, store, property);
         const prev =
           target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
             ? target[STORE_OPTIMISTIC_OVERRIDE][property]
             : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
               ? target[STORE_OVERRIDE][property]
               : base;
-        const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
+        const prevHas =
+          target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
+            ? target[STORE_OPTIMISTIC_OVERRIDE][property] !== $DELETED
+            : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+              ? target[STORE_OVERRIDE][property] !== $DELETED
+              : property in target[STORE_VALUE];
+        const value = unwrapStoreValue(rawValue);
         const isArrayIndexWrite = Array.isArray(state) && property !== "length";
         const nextIndex = isArrayIndexWrite ? parseInt(property) + 1 : 0;
         const len =
@@ -2858,21 +3083,53 @@ const storeTraps = {
           override[property] = value;
           if (nextLength !== undefined) override.length = nextLength;
         }
-        const wrappable = isWrappable(value);
-        target[STORE_HAS]?.[property] && setSignal(target[STORE_HAS][property], true);
-        const nodes = getNodes(target, STORE_NODE);
-        nodes[property] &&
-          setSignal(nodes[property], () => (wrappable ? wrap(value, target) : value));
-        if (Array.isArray(state)) {
-          const lengthValue = property === "length" ? value : nextLength;
-          lengthValue !== undefined && nodes.length && setSignal(nodes.length, lengthValue);
+        notifyStoreProperty(target, property, "set", value, prev, prevHas);
+        if (Array.isArray(state) && property !== "length" && nextLength !== undefined) {
+          const nodes = getNodes(target, STORE_NODE);
+          if (nodes.length) {
+            setSignal(nodes.length, nextLength);
+          } else if (!projectionWriteActive && !target[STORE_OPTIMISTIC]) {
+            const node = upsertStoreNode(
+              target,
+              nodes,
+              "length",
+              len,
+              target[STORE_SNAPSHOT_PROPS]
+            );
+            setSignal(node, nextLength);
+          }
         }
-        nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
         if (true) DEV$1.hooks.onStoreNodeUpdate?.(target[$PROXY], property, value, prev);
       });
     }
     return true;
   },
+  defineProperty(target, property, descriptor) {
+    const store = target[$PROXY];
+    if (writeOnly(store)) {
+      untrack(() => {
+        const { base: base, overrideKey: overrideKey } = prepareStoreWrite(target, store, property);
+        const normalizedDescriptor =
+          "value" in descriptor
+            ? { ...descriptor, value: unwrapStoreValue(descriptor.value) }
+            : descriptor;
+        Object.defineProperty(
+          target[overrideKey] || (target[overrideKey] = Object.create(null)),
+          property,
+          normalizedDescriptor
+        );
+        notifyStoreProperty(target, property, "invalidate");
+        if (true) {
+          const next =
+            "value" in normalizedDescriptor
+              ? normalizedDescriptor.value
+              : normalizedDescriptor.get?.call(store);
+          DEV$1.hooks.onStoreNodeUpdate?.(target[$PROXY], property, next, base);
+        }
+      });
+    }
+    return true;
+  },
   deleteProperty(target, property) {
     const optDeleted = target[STORE_OPTIMISTIC_OVERRIDE]?.[property] === $DELETED;
     const regDeleted = target[STORE_OVERRIDE]?.[property] === $DELETED;
@@ -2895,10 +3152,7 @@ const storeTraps = {
         } else if (target[overrideKey] && property in target[overrideKey]) {
           delete target[overrideKey][property];
         } else return true;
-        if (target[STORE_HAS]?.[property]) setSignal(target[STORE_HAS][property], false);
-        const nodes = getNodes(target, STORE_NODE);
-        nodes[property] && setSignal(nodes[property], undefined);
-        nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
+        notifyStoreProperty(target, property, "delete", undefined, prev, true);
       });
     }
     return true;
@@ -2920,6 +3174,8 @@ const storeTraps = {
     if (property === $PROXY) return { value: target[$PROXY], writable: true, configurable: true };
     if (target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]) {
       if (target[STORE_OPTIMISTIC_OVERRIDE][property] === $DELETED) return undefined;
+      const optDesc = Reflect.getOwnPropertyDescriptor(target[STORE_OPTIMISTIC_OVERRIDE], property);
+      if (optDesc?.get || optDesc?.set || !(property in target[STORE_VALUE])) return optDesc;
       const baseDesc = getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
       if (baseDesc) {
         return { ...baseDesc, value: target[STORE_OPTIMISTIC_OVERRIDE][property] };
@@ -2969,7 +3225,7 @@ function createStore(first, second, options) {
 function createOptimisticStore(first, second, options) {
   GlobalQueue._clearOptimisticStore ||= clearOptimisticStore;
   const derived = typeof first === "function";
-  const initialValue = (derived ? second : first) ?? {};
+  const initialValue = derived ? second : first;
   const fn = derived ? first : undefined;
   const { store: wrappedStore } = createOptimisticProjectionInternal(fn, initialValue, options);
   return [wrappedStore, fn => storeSetter(wrappedStore, fn)];
@@ -3003,7 +3259,7 @@ function clearOptimisticStore(store) {
   }
   delete target[STORE_OPTIMISTIC_OVERRIDE];
 }
-function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
+function createOptimisticProjectionInternal(fn, initialValue, options) {
   let node;
   const wrappedMap = new WeakMap();
   const wrapper = s => {
@@ -3026,42 +3282,33 @@ function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
   };
   const wrappedStore = wrapProjection(initialValue);
   if (fn) {
-    node = computed(() => {
-      const owner = getOwner();
-      let settled = false;
-      let result;
-      const draft = new Proxy(
-        wrappedStore,
-        createWriteTraps(() => !settled || owner._inFlight === result)
-      );
+    const wrapCommit = write => {
       setProjectionWriteActive(true);
       try {
-        storeSetter(draft, s => {
-          result = fn(s);
-          settled = true;
-          const value = handleAsync(owner, result, value => {
-            setProjectionWriteActive(true);
-            try {
-              value !== s &&
-                value !== undefined &&
-                storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
-            } finally {
-              setProjectionWriteActive(false);
-            }
-          });
-          value !== s &&
-            value !== undefined &&
-            reconcile(value, options?.key || "id")(wrappedStore);
-        });
+        write();
       } finally {
         setProjectionWriteActive(false);
       }
-    });
-    node._preventAutoDisposal = true;
+    };
+    node = computed(
+      () => {
+        setProjectionWriteActive(true);
+        try {
+          runProjectionComputed(wrappedStore, fn, options?.key || "id", wrapCommit);
+        } finally {
+          setProjectionWriteActive(false);
+        }
+      },
+      options?.name ? { name: options.name } : undefined
+    );
+    node._config &= ~CONFIG_AUTO_DISPOSE;
   }
   return { store: wrappedStore, node: node };
 }
 const DELETE = Symbol("STORE_PATH_DELETE");
+function isPrototypePollutionKey(part) {
+  return part === "__proto__" || part === "constructor" || part === "prototype";
+}
 function updatePath(current, args, i = 0) {
   let part,
     prev = current;
@@ -3069,6 +3316,7 @@ function updatePath(current, args, i = 0) {
     part = args[i];
     const partType = typeof part;
     const isArray = Array.isArray(current);
+    if (partType === "string" && isPrototypePollutionKey(part)) return;
     if (Array.isArray(part)) {
       for (let j = 0; j < part.length; j++) {
         args[i] = part[j];
@@ -3113,7 +3361,13 @@ function updatePath(current, args, i = 0) {
   ) {
     const target = part !== undefined ? current[part] : current;
     const keys = Object.keys(value);
-    for (let i = 0; i < keys.length; i++) target[keys[i]] = value[keys[i]];
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (isPrototypePollutionKey(key)) continue;
+      const desc = Object.getOwnPropertyDescriptor(value, key);
+      if (desc.get || desc.set) Object.defineProperty(target, key, desc);
+      else target[key] = desc.value;
+    }
   } else {
     current[part] = value;
   }
@@ -3329,23 +3583,25 @@ function mapArray(list, map, options) {
         }
       }
     : map;
-  return createMemo(
-    updateKeyedMap.bind({
-      _owner: createOwner(),
-      _len: 0,
-      _list: list,
-      _items: [],
-      _map: wrappedMap,
-      _mappings: [],
-      _nodes: [],
-      _key: keyFn,
-      _rows: keyFn || options?.keyed === false ? [] : undefined,
-      _indexes: indexes ? [] : undefined,
-      _fallback: options?.fallback
-    })
-  );
+  const data = {
+    _owner: createOwner(),
+    _len: 0,
+    _list: list,
+    _items: [],
+    _map: wrappedMap,
+    _mappings: [],
+    _nodes: [],
+    _key: keyFn,
+    _rows: keyFn || options?.keyed === false ? [] : undefined,
+    _indexes: indexes ? [] : undefined,
+    _fallback: options?.fallback
+  };
+  const node = computed(updateKeyedMap.bind(data));
+  data._owner._parentComputed = node;
+  node._config &= ~CONFIG_AUTO_DISPOSE;
+  return accessor(node);
 }
-const pureOptions = { pureWrite: true };
+const pureOptions = { ownedWrite: true };
 function updateKeyedMap() {
   const newItems = this._list() || [],
     newLen = newItems.length;
@@ -3482,17 +3738,21 @@ function repeat(count, map, options) {
         }
       }
     : map;
-  return updateRepeat.bind({
-    _owner: createOwner(),
-    _len: 0,
-    _offset: 0,
-    _count: count,
-    _map: wrappedMap,
-    _nodes: [],
-    _mappings: [],
-    _from: options?.from,
-    _fallback: options?.fallback
-  });
+  const node = computed(
+    updateRepeat.bind({
+      _owner: createOwner(),
+      _len: 0,
+      _offset: 0,
+      _count: count,
+      _map: wrappedMap,
+      _nodes: [],
+      _mappings: [],
+      _from: options?.from,
+      _fallback: options?.fallback
+    })
+  );
+  node._config &= ~CONFIG_AUTO_DISPOSE;
+  return accessor(node);
 }
 function updateRepeat() {
   const newLen = this._count();
@@ -3549,7 +3809,7 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 function boundaryComputed(fn, propagationMask) {
-  const node = computed(fn, undefined, { lazy: true });
+  const node = computed(fn, { lazy: true });
   node._notifyStatus = (status, error) => {
     const flags = status !== undefined ? status : node._statusFlags;
     const actualError = error !== undefined ? error : node._error;
@@ -3557,7 +3817,7 @@ function boundaryComputed(fn, propagationMask) {
     node._queue.notify(node, node._propagationMask, flags, actualError);
   };
   node._propagationMask = propagationMask;
-  node._preventAutoDisposal = true;
+  node._config &= ~CONFIG_AUTO_DISPOSE;
   recompute(node, true);
   return node;
 }
@@ -3574,12 +3834,16 @@ const ON_INIT = Symbol();
 const RevealControllerContext = createContext(null);
 let _revealUsed = false;
 const FALSE_ACCESSOR = () => false;
+const SEQUENTIAL_ACCESSOR = () => "sequential";
 function isRevealController(slot) {
   return slot instanceof RevealController;
 }
 function isSlotReady(slot) {
   return isRevealController(slot) ? slot.isReady() : slot._sources.size === 0 && !slot._pending;
 }
+function isSlotMinimallyReady(slot) {
+  return isRevealController(slot) ? slot.isMinimallyReady() : isSlotReady(slot);
+}
 function setSlotState(slot, controller, disabled, collapsed) {
   setSignal(slot._disabled, disabled);
   setSignal(slot._collapsed, collapsed);
@@ -3591,16 +3855,17 @@ function setSlotState(slot, controller, disabled, collapsed) {
     slot._revealController = undefined;
 }
 class RevealController {
-  _togetherAccessor;
+  _orderAccessor;
   _collapsedAccessor;
   _slots = [];
   _parentController;
-  _disabled = signal(false, { pureWrite: true, _noSnapshot: true });
-  _collapsed = signal(false, { pureWrite: true, _noSnapshot: true });
+  _disabled = signal(false, { ownedWrite: true, _noSnapshot: true });
+  _collapsed = signal(false, { ownedWrite: true, _noSnapshot: true });
   _ready = true;
+  _minimallyReady = true;
   _evaluating = false;
-  constructor(together, collapsed) {
-    this._togetherAccessor = together;
+  constructor(order, collapsed) {
+    this._orderAccessor = order;
     this._collapsedAccessor = collapsed;
   }
   _forEachOwnedSlot(fn) {
@@ -3615,12 +3880,37 @@ class RevealController {
   isReady() {
     return this._forEachOwnedSlot(isSlotReady);
   }
+  isMinimallyReady() {
+    const order = untrack(this._orderAccessor);
+    if (order === "together") return this.isReady();
+    if (order === "natural") {
+      let hasSlot = false;
+      let anyReady = false;
+      this._forEachOwnedSlot(slot => {
+        hasSlot = true;
+        if (isSlotMinimallyReady(slot)) {
+          anyReady = true;
+          return false;
+        }
+      });
+      return !hasSlot || anyReady;
+    }
+    let firstReady = true;
+    this._forEachOwnedSlot(slot => {
+      firstReady = isSlotMinimallyReady(slot);
+      return false;
+    });
+    return firstReady;
+  }
   register(slot) {
     if (this._slots.includes(slot)) return;
     this._slots.push(slot);
-    const together = !!untrack(this._togetherAccessor);
-    setSignal(slot._disabled, true),
-      setSignal(slot._collapsed, together ? false : !!untrack(this._collapsedAccessor));
+    const order = untrack(this._orderAccessor);
+    (setSignal(slot._disabled, true),
+      setSignal(
+        slot._collapsed,
+        order === "sequential" ? !!untrack(this._collapsedAccessor) : false
+      ));
     untrack(() => this.evaluate());
   }
   unregister(slot) {
@@ -3632,29 +3922,52 @@ class RevealController {
     if (this._evaluating) return;
     this._evaluating = true;
     const wasReady = this._ready;
+    const wasMinReady = this._minimallyReady;
     try {
       const disabled = disabledOverride ?? read(this._disabled),
-        collapseTail = !!untrack(this._collapsedAccessor),
+        order = untrack(this._orderAccessor),
+        collapseTail = order === "sequential" && !!untrack(this._collapsedAccessor),
         collapsed = collapsedOverride ?? collapseTail;
-      if (disabled && collapsed)
-        this._forEachOwnedSlot(slot => setSlotState(slot, this, true, true));
-      else if (!!untrack(this._togetherAccessor)) {
-        const ready = this.isReady();
-        this._forEachOwnedSlot(slot => setSlotState(slot, this, !ready, false));
+      if (disabled) {
+        this._forEachOwnedSlot(slot => setSlotState(slot, this, true, collapsed));
+      } else if (order === "natural") {
+        this._forEachOwnedSlot(slot => {
+          if (isRevealController(slot)) {
+            setSignal(slot._collapsed, false);
+            setSignal(slot._disabled, false);
+            slot.evaluate(false, false);
+          } else {
+            setSlotState(slot, this, !isSlotReady(slot), false);
+          }
+        });
+      } else if (order === "together") {
+        const minReady = this._forEachOwnedSlot(isSlotMinimallyReady);
+        this._forEachOwnedSlot(slot => setSlotState(slot, this, !minReady, false));
       } else {
         let pendingSeen = false;
         this._forEachOwnedSlot(slot => {
           if (pendingSeen) return setSlotState(slot, this, true, collapseTail);
           if (isSlotReady(slot)) return setSlotState(slot, this, false, false);
           pendingSeen = true;
-          setSlotState(slot, this, true, false);
+          if (isRevealController(slot)) {
+            setSignal(slot._collapsed, false);
+            setSignal(slot._disabled, false);
+            slot.evaluate(false, false);
+          } else {
+            setSlotState(slot, this, true, false);
+          }
         });
       }
     } finally {
       this._ready = this.isReady();
+      this._minimallyReady = this.isMinimallyReady();
       this._evaluating = false;
     }
-    if (this._parentController && wasReady !== this._ready) this._parentController.evaluate();
+    if (
+      this._parentController &&
+      (wasReady !== this._ready || wasMinReady !== this._minimallyReady)
+    )
+      this._parentController.evaluate();
   }
 }
 class CollectionQueue extends Queue {
@@ -3662,8 +3975,8 @@ class CollectionQueue extends Queue {
   _sources = new Set();
   _tree;
   _pending = true;
-  _disabled = signal(false, { pureWrite: true, _noSnapshot: true });
-  _collapsed = signal(false, { pureWrite: true, _noSnapshot: true });
+  _disabled = signal(false, { ownedWrite: true, _noSnapshot: true });
+  _collapsed = signal(false, { ownedWrite: true, _noSnapshot: true });
   _revealController;
   _initialized = false;
   _onFn;
@@ -3743,7 +4056,8 @@ class CollectionQueue extends Queue {
 }
 function createCollectionBoundary(type, fn, fallback, onFn) {
   if (!getOwner()) {
-    const message = "Boundaries created outside a reactive context will never be disposed.";
+    const message =
+      "[NO_OWNER_BOUNDARY] Boundaries created outside a reactive context will never be disposed.";
     emitDiagnostic({
       code: "NO_OWNER_BOUNDARY",
       kind: "lifecycle",
@@ -3776,15 +4090,16 @@ function createCollectionBoundary(type, fn, fallback, onFn) {
     controller.register(queue);
     cleanup(() => controller.unregister(queue));
   }
-  const decision = computed(() => {
-    if (!read(queue._disabled)) {
-      const resolved = read(tree);
-      if (!untrack(() => read(queue._disabled))) return (queue._initialized = true), resolved;
-    }
-    if (_revealUsed && read(queue._collapsed)) return undefined;
-    return fallback(queue);
-  });
-  return accessor(decision);
+  return accessor(
+    computed(() => {
+      if (!read(queue._disabled)) {
+        const resolved = read(tree);
+        if (!untrack(() => read(queue._disabled))) return ((queue._initialized = true), resolved);
+      }
+      if (_revealUsed && read(queue._collapsed)) return undefined;
+      return fallback(queue);
+    })
+  );
 }
 function createLoadingBoundary(fn, fallback, options) {
   return createCollectionBoundary(STATUS_PENDING, fn, () => fallback(), options?.on);
@@ -3803,14 +4118,14 @@ function createRevealOrder(fn, options) {
   _revealUsed = true;
   const owner = createOwner();
   const parentController = getContext(RevealControllerContext);
-  const together = options?.together || FALSE_ACCESSOR,
+  const order = options?.order || SEQUENTIAL_ACCESSOR,
     collapsed = options?.collapsed || FALSE_ACCESSOR;
-  const controller = new RevealController(together, collapsed);
+  const controller = new RevealController(order, collapsed);
   setContext(RevealControllerContext, controller, owner);
   return runWithOwner(owner, () => {
     const value = fn();
     computed(() => {
-      together();
+      order();
       collapsed();
       controller.evaluate();
     });