@solidjs/signals 0.13.11 → 0.13.13

package/dist/dev.js

@@ -145,21 +145,53 @@ function adjustHeight(el, heap) {
   }
 }
 const hooks = {};
-const DEV = {
+const diagnosticListeners = new Set();
+const diagnosticCaptures = new Set();
+let diagnosticSequence = 0;
+const diagnostics = {
+  subscribe(listener) {
+    diagnosticListeners.add(listener);
+    return () => diagnosticListeners.delete(listener);
+  },
+  capture() {
+    const events = [];
+    diagnosticCaptures.add(events);
+    return {
+      get events() {
+        return events;
+      },
+      clear() {
+        events.length = 0;
+      },
+      stop() {
+        diagnosticCaptures.delete(events);
+        return [...events];
+      }
+    };
+  }
+};
+const DEV$1 = {
   hooks: hooks,
+  diagnostics: diagnostics,
   getChildren: getChildren,
   getSignals: getSignals,
   getParent: getParent,
   getSources: getSources,
   getObservers: getObservers
 };
+function emitDiagnostic(event) {
+  const entry = { sequence: ++diagnosticSequence, ...event };
+  for (const listener of diagnosticListeners) listener(entry);
+  for (const capture of diagnosticCaptures) capture.push(entry);
+  return entry;
+}
 function registerGraph(value, owner) {
   value._owner = owner;
   if (owner) {
     if (!owner._signals) owner._signals = [];
     owner._signals.push(value);
   }
-  DEV.hooks.onGraph?.(value, owner);
+  DEV$1.hooks.onGraph?.(value, owner);
 }
 function clearSignals(node) {
   node._signals = undefined;
@@ -252,13 +284,13 @@ function setTrackedQueueCallback(value) {
 function mergeTransitionState(target, outgoing) {
   outgoing._done = target;
   target._actions.push(...outgoing._actions);
-  for (const lane of activeLanes) {
-    if (lane._transition === outgoing) lane._transition = target;
-  }
+  for (const lane of activeLanes) if (lane._transition === outgoing) lane._transition = target;
   target._optimisticNodes.push(...outgoing._optimisticNodes);
   for (const store of outgoing._optimisticStores) target._optimisticStores.add(store);
-  for (const node of outgoing._asyncNodes) {
-    if (!target._asyncNodes.includes(node)) target._asyncNodes.push(node);
+  for (const [source, reporters] of outgoing._asyncReporters) {
+    let targetReporters = target._asyncReporters.get(source);
+    if (!targetReporters) target._asyncReporters.set(source, (targetReporters = new Set()));
+    for (const reporter of reporters) targetReporters.add(reporter);
   }
 }
 function resolveOptimisticNodes(nodes) {
@@ -424,7 +456,7 @@ class GlobalQueue extends Queue {
       this.run(EFFECT_RENDER);
       runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
-      if (true) DEV.hooks.onUpdate?.();
+      if (true) DEV$1.hooks.onUpdate?.();
     } finally {
       this._running = false;
     }
@@ -435,10 +467,11 @@ class GlobalQueue extends Queue {
         const actualError = error !== undefined ? error : node._error;
         if (activeTransition && actualError) {
           const source = actualError.source;
-          if (!activeTransition._asyncNodes.includes(source)) {
-            activeTransition._asyncNodes.push(source);
-            schedule();
-          }
+          let reporters = activeTransition._asyncReporters.get(source);
+          if (!reporters) activeTransition._asyncReporters.set(source, (reporters = new Set()));
+          const prevSize = reporters.size;
+          reporters.add(node);
+          if (reporters.size !== prevSize) schedule();
         }
         if (_enforceLoadingBoundary) _hitUnhandledAsync = true;
       }
@@ -454,7 +487,7 @@ class GlobalQueue extends Queue {
       activeTransition = transition ?? {
         _time: clock,
         _pendingNodes: [],
-        _asyncNodes: [],
+        _asyncReporters: new Map(),
         _optimisticNodes: [],
         _optimisticStores: new Set(),
         _actions: [],
@@ -593,13 +626,37 @@ function flush() {
 function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++) queue[i](type);
 }
+function reporterBlocksSource(reporter, source) {
+  if (reporter._flags & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+  if (reporter._pendingSource === source || reporter._pendingSources?.has(source)) return true;
+  for (let dep = reporter._deps; dep; dep = dep._nextDep) {
+    let current = dep._dep;
+    while (current) {
+      if (current === source || current._firewall === source) return true;
+      current = current._parentSource;
+    }
+  }
+  return !!(
+    reporter._statusFlags & STATUS_PENDING &&
+    reporter._error instanceof NotReadyError &&
+    reporter._error.source === source
+  );
+}
 function transitionComplete(transition) {
   if (transition._done) return true;
   if (transition._actions.length) return false;
   let done = true;
-  for (let i = 0; i < transition._asyncNodes.length; i++) {
-    const node = transition._asyncNodes[i];
-    if (node._statusFlags & STATUS_PENDING && node._error?.source === node) {
+  for (const [source, reporters] of transition._asyncReporters) {
+    let hasLive = false;
+    for (const reporter of reporters) {
+      if (reporterBlocksSource(reporter, source)) {
+        hasLive = true;
+        break;
+      }
+      reporters.delete(reporter);
+    }
+    if (!hasLive) transition._asyncReporters.delete(source);
+    else if (source._statusFlags & STATUS_PENDING && source._error?.source === source) {
       done = false;
       break;
     }
@@ -907,7 +964,7 @@ function createOwner(options) {
       parent._firstChild = owner;
     }
   }
-  DEV.hooks.onOwner?.(owner);
+  DEV$1.hooks.onOwner?.(owner);
   return owner;
 }
 function createRoot(init, options) {
@@ -1024,6 +1081,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);
@@ -1037,9 +1095,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) {
@@ -1302,6 +1361,7 @@ function recompute(el, create = false) {
   const 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;
@@ -1367,7 +1427,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) {
@@ -1473,7 +1534,7 @@ function computed(fn, initialValue, options) {
       context._firstChild = self;
     }
   }
-  DEV.hooks.onOwner?.(self);
+  DEV$1.hooks.onOwner?.(self);
   if (parent) self._height = parent._height + 1;
   if (snapshotCaptureActive && ownerInSnapshotScope(context)) self._inSnapshotScope = true;
   if (externalSourceConfig) {
@@ -1618,10 +1679,20 @@ function read(el) {
   }
   const owner = el._firewall || el;
   if (strictRead && owner._statusFlags & STATUS_PENDING) {
-    throw new Error(
+    const message =
       `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).`
-    );
+      `Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).`;
+    emitDiagnostic({
+      code: "PENDING_ASYNC_UNTRACKED_READ",
+      kind: "async",
+      severity: "error",
+      message: message,
+      ownerId: c?.id,
+      ownerName: c?._name,
+      nodeName: owner?._name,
+      data: { strictRead: strictRead }
+    });
+    throw new Error(message);
   }
   if (c && tracking) {
     if (el._fn && el._flags & REACTIVE_DISPOSED) recompute(el);
@@ -1642,10 +1713,19 @@ function read(el) {
   if (owner._statusFlags & STATUS_PENDING) {
     if (c && !(stale && owner._transition && activeTransition !== owner._transition)) {
       if (c?._childrenForbidden) {
-        console.warn(
+        const message =
           "Reading a pending async value inside createTrackedEffect or onSettled will throw. " +
-            "Use createEffect instead which supports async-aware reactivity."
-        );
+          "Use createEffect instead which supports async-aware reactivity.";
+        emitDiagnostic({
+          code: "PENDING_ASYNC_FORBIDDEN_SCOPE",
+          kind: "async",
+          severity: "warn",
+          message: message,
+          ownerId: c.id,
+          ownerName: c._name,
+          nodeName: owner?._name
+        });
+        console.warn(message);
       }
       if (currentOptimisticLane) {
         const pendingLane = owner._optimisticLane;
@@ -1680,11 +1760,22 @@ function read(el) {
       return snapshot;
     }
   }
-  if (strictRead)
-    console.warn(
+  if (strictRead) {
+    const message =
       `Reactive value read directly in ${strictRead} will not update. ` +
-        `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`
-    );
+      `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
+    emitDiagnostic({
+      code: "STRICT_READ_UNTRACKED",
+      kind: "strict-read",
+      severity: "warn",
+      message: message,
+      ownerId: c?.id,
+      ownerName: c?._name,
+      nodeName: owner?._name,
+      data: { strictRead: strictRead }
+    });
+    console.warn(message);
+  }
   if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
     if (c && stale && shouldReadStashedOptimisticValue(el)) return el._value;
     return el._overrideValue;
@@ -1701,8 +1792,21 @@ function read(el) {
     : el._pendingValue;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && !context?._childrenForbidden && context && el._firewall !== context)
-    console.warn("A Signal was written to in an owned scope.");
+  if (!el._pureWrite && !context?._childrenForbidden && 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.";
+    emitDiagnostic({
+      code: "SIGNAL_WRITE_IN_OWNED_SCOPE",
+      kind: "write",
+      severity: "error",
+      message: message,
+      ownerId: context.id,
+      ownerName: context._name,
+      nodeName: el._name
+    });
+    throw new Error(message);
+  }
   if (el._transition && activeTransition !== el._transition)
     globalQueue.initTransition(el._transition);
   const isOptimistic = el._overrideValue !== undefined && !projectionWriteActive;
@@ -1749,10 +1853,19 @@ function setSignal(el, v) {
   return v;
 }
 function runWithOwner(owner, fn) {
-  if (owner && owner._flags & REACTIVE_DISPOSED)
-    console.warn(
-      "runWithOwner called with a disposed owner. Children created inside will never be disposed."
-    );
+  if (owner && owner._flags & REACTIVE_DISPOSED) {
+    const message =
+      "runWithOwner called with a disposed owner. Children created inside will never be disposed.";
+    emitDiagnostic({
+      code: "RUN_WITH_DISPOSED_OWNER",
+      kind: "owner",
+      severity: "warn",
+      message: message,
+      ownerId: owner.id,
+      ownerName: owner._name
+    });
+    console.warn(message);
+  }
   const oldContext = context;
   const prevTracking = tracking;
   context = owner;
@@ -1953,6 +2066,14 @@ function effect(compute, effect, error, initialValue, options) {
       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;
       }
     }
@@ -1964,8 +2085,19 @@ function effect(compute, effect, error, initialValue, options) {
       : runEffect.call(node));
   initialized = true;
   cleanup(() => node._cleanup?.());
-  if (!node._parent)
-    console.warn("Effects created outside a reactive context will never be disposed");
+  if (!node._parent) {
+    const message = "Effects created outside a reactive context will never be disposed";
+    emitDiagnostic({
+      code: "NO_OWNER_EFFECT",
+      kind: "lifecycle",
+      severity: "warn",
+      message: message,
+      ownerId: node.id,
+      ownerName: node._name,
+      data: { effectType: "effect" }
+    });
+    console.warn(message);
+  }
 }
 function runEffect() {
   if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
@@ -2034,8 +2166,19 @@ function trackedEffect(fn, options) {
   node._run = run;
   node._queue.enqueue(EFFECT_USER, run);
   cleanup(() => node._cleanup?.());
-  if (!node._parent)
-    console.warn("Effects created outside a reactive context will never be disposed");
+  if (!node._parent) {
+    const message = "Effects created outside a reactive context will never be disposed";
+    emitDiagnostic({
+      code: "NO_OWNER_EFFECT",
+      kind: "lifecycle",
+      severity: "warn",
+      message: message,
+      ownerId: node.id,
+      ownerName: node._name,
+      data: { effectType: "trackedEffect" }
+    });
+    console.warn(message);
+  }
 }
 function restoreTransition(transition, fn) {
   globalQueue.initTransition(transition);
@@ -2084,11 +2227,28 @@ function action(genFn) {
 function onCleanup(fn) {
   {
     const owner = getOwner();
-    if (!owner) console.warn("onCleanup called outside a reactive context will never be run");
-    else if (owner._childrenForbidden)
-      throw new Error(
-        "Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead"
-      );
+    if (!owner) {
+      const message = "onCleanup called outside a reactive context will never be run";
+      emitDiagnostic({
+        code: "NO_OWNER_CLEANUP",
+        kind: "lifecycle",
+        severity: "warn",
+        message: message
+      });
+      console.warn(message);
+    } else if (owner._childrenForbidden) {
+      const message =
+        "Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead";
+      emitDiagnostic({
+        code: "CLEANUP_IN_FORBIDDEN_SCOPE",
+        kind: "lifecycle",
+        severity: "error",
+        message: message,
+        ownerId: owner.id,
+        ownerName: owner._name
+      });
+      throw new Error(message);
+    }
   }
   return cleanup(fn);
 }
@@ -2534,12 +2694,55 @@ 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 notifyStoreProperty(target, property, mode, value) {
+  if (target[STORE_HAS]?.[property]) setSignal(target[STORE_HAS][property], mode !== "delete");
+  const nodes = getNodes(target, STORE_NODE);
+  if (mode === "set") {
+    nodes[property] &&
+      setSignal(nodes[property], () => (isWrappable(value) ? wrap(value, target) : value));
+  } else if (mode === "invalidate") {
+    if (nodes[property]) {
+      setSignal(nodes[property], {});
+      delete nodes[property];
+    }
+  } else {
+    nodes[property] && setSignal(nodes[property], undefined);
+  }
+  nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
 }
 let Writing = null;
 const storeTraps = {
@@ -2610,11 +2813,20 @@ const storeTraps = {
         );
       }
     }
-    if (strictRead && typeof property === "string")
-      console.warn(
+    if (strictRead && typeof property === "string") {
+      const message =
         `Reactive value read directly in ${strictRead} will not update. ` +
-          `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`
-      );
+        `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
+      emitDiagnostic({
+        code: "STRICT_READ_UNTRACKED",
+        kind: "strict-read",
+        severity: "warn",
+        message: message,
+        nodeName: String(property),
+        data: { strictRead: strictRead, property: String(property), source: "store" }
+      });
+      console.warn(message);
+    }
     return isWrappable(value) ? wrap(value, target) : value;
   },
   has(target, property) {
@@ -2643,31 +2855,12 @@ const storeTraps = {
   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]
@@ -2693,17 +2886,42 @@ 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));
+        notifyStoreProperty(target, property, "set", value);
         if (Array.isArray(state)) {
+          const nodes = getNodes(target, STORE_NODE);
           const lengthValue = property === "length" ? value : nextLength;
           lengthValue !== undefined && nodes.length && setSignal(nodes.length, lengthValue);
         }
-        nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
-        if (true) DEV.hooks.onStoreNodeUpdate?.(target[$PROXY], property, value, prev);
+        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: descriptor.value?.[$TARGET]?.[STORE_VALUE] ?? 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;
@@ -2730,10 +2948,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");
       });
     }
     return true;
@@ -2755,6 +2970,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] };
@@ -2948,7 +3165,12 @@ 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];
+      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;
   }
@@ -3577,8 +3799,17 @@ class CollectionQueue extends Queue {
   }
 }
 function createCollectionBoundary(type, fn, fallback, onFn) {
-  if (!getOwner())
-    console.warn("Boundaries created outside a reactive context will never be disposed.");
+  if (!getOwner()) {
+    const message = "Boundaries created outside a reactive context will never be disposed.";
+    emitDiagnostic({
+      code: "NO_OWNER_BOUNDARY",
+      kind: "lifecycle",
+      severity: "warn",
+      message: message,
+      data: { boundaryType: type === STATUS_PENDING ? "loading" : "error" }
+    });
+    console.warn(message);
+  }
   const owner = createOwner();
   if (_revealUsed) setContext(RevealControllerContext, null, owner);
   const queue = new CollectionQueue(type);
@@ -3704,6 +3935,7 @@ function flattenArray(children, results = [], options) {
   if (notReady) throw notReady;
   return needsUnwrap;
 }
+const DEV = DEV$1;
 export {
   $PROXY,
   $REFRESH,