signalium 2.2.3 → 2.3.1

package/dist/esm/development/{debug-BfudYKc4.js → debug-B6Cqxyzi.js}

@@ -1,5 +1,6 @@
 import { s as scheduleFlush$1, r as runBatch } from "./config-CPQL7hX-.js";
 class WeakRefPolyfill {
+  value;
   constructor(value) {
     this.value = value;
   }
@@ -22,7 +23,8 @@ let TRACER;
 const getTracerProxy = () => {
   return TRACER;
 };
-var TracerEventType = /* @__PURE__ */ ((TracerEventType2) => {
+var TracerEventType;
+(function(TracerEventType2) {
   TracerEventType2["StartUpdate"] = "StartUpdate";
   TracerEventType2["EndUpdate"] = "EndUpdate";
   TracerEventType2["StartLoading"] = "StartLoading";
@@ -30,15 +32,31 @@ var TracerEventType = /* @__PURE__ */ ((TracerEventType2) => {
   TracerEventType2["Connected"] = "Connected";
   TracerEventType2["Disconnected"] = "Disconnected";
   TracerEventType2["ConsumeState"] = "ConsumeState";
-  return TracerEventType2;
-})(TracerEventType || {});
-var SignalType = /* @__PURE__ */ ((SignalType2) => {
+})(TracerEventType || (TracerEventType = {}));
+var SignalType;
+(function(SignalType2) {
   SignalType2["State"] = "state";
   SignalType2["Reactive"] = "reactive";
   SignalType2["Watcher"] = "watcher";
-  return SignalType2;
-})(SignalType || {});
+})(SignalType || (SignalType = {}));
 class VisualizerNode {
+  tracer;
+  depth;
+  type;
+  id;
+  value;
+  name;
+  params;
+  _setValue;
+  subscribers = [];
+  nextStateChildren = [];
+  stateChildren = [];
+  children = [];
+  updating = true;
+  loading = false;
+  version = 0;
+  updatingVersion = 0;
+  didConnect = false;
   constructor(tracer, depth, type, id, value, name, params, _setValue) {
     this.tracer = tracer;
     this.depth = depth;
@@ -50,15 +68,6 @@ class VisualizerNode {
     this._setValue = _setValue;
     this.tracer.maxDepth = Math.max(this.tracer.maxDepth, this.depth);
   }
-  subscribers = [];
-  nextStateChildren = [];
-  stateChildren = [];
-  children = [];
-  updating = true;
-  loading = false;
-  version = 0;
-  updatingVersion = 0;
-  didConnect = false;
   get showParams() {
     return this.tracer.showParams;
   }
@@ -69,16 +78,14 @@ class VisualizerNode {
     return this.tracer.interactive;
   }
   setValue(value) {
-    if (this.type !== "state") {
+    if (this.type !== SignalType.State) {
       throw new Error("setValue is only allowed on state nodes");
     }
     this._setValue?.(value);
     this.notify();
   }
   connectChild(child) {
-    let childLink = this.children.find(
-      (link) => link.node.id === child.id || link.node.name === child.name && link.version !== this.updatingVersion
-    );
+    let childLink = this.children.find((link) => link.node.id === child.id || link.node.name === child.name && link.version !== this.updatingVersion);
     let shouldSkip = false;
     if (childLink) {
       if (!child.didConnect) {
@@ -141,16 +148,7 @@ class VisualizerNode {
       this.nextStateChildren.push(existing);
       existing.notify();
     } else {
-      const node = new VisualizerNode(
-        this.tracer,
-        this.depth + 1,
-        "state",
-        id,
-        value,
-        name,
-        void 0,
-        setValue
-      );
+      const node = new VisualizerNode(this.tracer, this.depth + 1, SignalType.State, id, value, name, void 0, setValue);
       node.updating = false;
       this.nextStateChildren.push(node);
     }
@@ -195,39 +193,39 @@ class TraceFlush {
   }
 }
 class Tracer {
+  showParams;
+  showValue;
+  interactive;
+  nodeMap = /* @__PURE__ */ new Map();
+  delay = 200;
+  maxDepth = 0;
+  initialized = false;
   constructor(id, immediate = false, showParams = true, showValue = true, interactive = true) {
     this.showParams = showParams;
     this.showValue = showValue;
     this.interactive = interactive;
     this.initialized = !immediate;
-    const node = new VisualizerNode(this, 0, "watcher", id, "");
+    const node = new VisualizerNode(this, 0, SignalType.Watcher, id, "");
     this.rootNode = node;
     this.nodeMap.set(id, node);
   }
-  nodeMap = /* @__PURE__ */ new Map();
-  delay = 200;
-  maxDepth = 0;
-  initialized = false;
   rootNode;
   eventQueue = [];
   currentFlush;
   emit(event) {
-    if (event.type === "Connected" || event.type === "ConsumeState") {
+    if (event.type === TracerEventType.Connected || event.type === TracerEventType.ConsumeState) {
       const node = this.nodeMap.get(event.id);
-      if (!node || event.type === "Connected" && !event.name) {
+      if (!node || event.type === TracerEventType.Connected && !event.name) {
         return;
       }
       if (!this.nodeMap.has(event.childId)) {
-        const name = event.type === "Connected" ? event.name : void 0;
-        const params = event.type === "Connected" ? event.params : void 0;
-        const nodeType = event.type === "Connected" ? event.nodeType : "state";
-        this.nodeMap.set(
-          event.childId,
-          new VisualizerNode(this, node.depth + 1, nodeType, event.childId, "", name, params)
-        );
+        const name = event.type === TracerEventType.Connected ? event.name : void 0;
+        const params = event.type === TracerEventType.Connected ? event.params : void 0;
+        const nodeType = event.type === TracerEventType.Connected ? event.nodeType : SignalType.State;
+        this.nodeMap.set(event.childId, new VisualizerNode(this, node.depth + 1, nodeType, event.childId, "", name, params));
       }
     }
-    if (event.type === "StartLoading" || event.type === "EndLoading") {
+    if (event.type === TracerEventType.StartLoading || event.type === TracerEventType.EndLoading) {
       scheduleTracer(this);
     }
     if (this.initialized) {
@@ -241,28 +239,28 @@ class Tracer {
     if (!node) {
       return true;
     }
-    let skipDelay = nextEvent?.type === "StartLoading";
-    if (event.type === "Connected") {
+    let skipDelay = nextEvent?.type === TracerEventType.StartLoading;
+    if (event.type === TracerEventType.Connected) {
       let child = this.nodeMap.get(event.childId);
       if (!child) {
         throw new Error(`Child node ${event.childId} not found`);
       }
       skipDelay = node.connectChild(child);
-    } else if (event.type === "Disconnected") {
+    } else if (event.type === TracerEventType.Disconnected) {
       node.disconnectChild(event.childId);
-    } else if (event.type === "StartUpdate") {
+    } else if (event.type === TracerEventType.StartUpdate) {
       node.startUpdate();
-      if (nextEvent && nextEvent.id === event.id && (nextEvent.type === "EndUpdate" || nextEvent.type === "StartLoading")) {
+      if (nextEvent && nextEvent.id === event.id && (nextEvent.type === TracerEventType.EndUpdate || nextEvent.type === TracerEventType.StartLoading)) {
         skipDelay = true;
       }
-    } else if (event.type === "EndUpdate") {
+    } else if (event.type === TracerEventType.EndUpdate) {
       node.endUpdate(event.value, event.preserveChildren);
-    } else if (event.type === "StartLoading") {
+    } else if (event.type === TracerEventType.StartLoading) {
       node.startLoading();
       skipDelay = true;
-    } else if (event.type === "EndLoading") {
+    } else if (event.type === TracerEventType.EndLoading) {
       node.endLoading(event.value);
-    } else if (event.type === "ConsumeState") {
+    } else if (event.type === TracerEventType.ConsumeState) {
       node.consumeState(event.childId, event.name, event.value, event.setValue);
     }
     return skipDelay;
@@ -328,8 +326,21 @@ const setCurrentConsumer = (consumer) => {
 const getCurrentConsumer = () => {
   return CURRENT_CONSUMER;
 };
+const DEFAULT_EQUALS = (a, b) => a === b;
+const FALSE_EQUALS = () => false;
+const equalsFrom = (equals) => {
+  if (equals === false) {
+    return FALSE_EQUALS;
+  }
+  return equals ?? DEFAULT_EQUALS;
+};
 let STATE_ID = 0;
+const SIGNAL_BRAND = /* @__PURE__ */ Symbol.for("signalium.signal");
+function isSignal(value) {
+  return typeof value === "object" && value !== null && value[SIGNAL_BRAND] === true;
+}
 class StateSignal {
+  [SIGNAL_BRAND] = true;
   _value;
   _equals;
   _subs = /* @__PURE__ */ new Map();
@@ -339,8 +350,10 @@ class StateSignal {
   constructor(value, equals = (a, b) => a === b, desc = "signal") {
     this._value = value;
     this._equals = equals;
-    this._id = STATE_ID++;
-    this._desc = desc;
+    {
+      this._id = STATE_ID++;
+      this._desc = desc;
+    }
   }
   get value() {
     this.consume();
@@ -384,7 +397,7 @@ class StateSignal {
       }
       dirtySignal(sub);
     }
-    this._subs = /* @__PURE__ */ new Map();
+    this._subs.clear();
     scheduleListeners(this);
   }
   addListener(listener) {
@@ -405,13 +418,12 @@ function runListeners$1(signal2) {
     listener();
   }
 }
-const FALSE_EQUALS$1 = () => false;
 function signal(initialValue, opts) {
-  const equals = opts?.equals === false ? FALSE_EQUALS$1 : opts?.equals ?? ((a, b) => a === b);
+  const equals = opts?.equals === false ? FALSE_EQUALS : opts?.equals ?? ((a, b) => a === b);
   return new StateSignal(initialValue, equals, opts?.desc);
 }
 const notifier = (opts) => {
-  return new StateSignal(void 0, FALSE_EQUALS$1, opts?.desc);
+  return new StateSignal(void 0, FALSE_EQUALS, opts?.desc);
 };
 function watchSignal(signal2, parentIsSuspended) {
   if (parentIsSuspended) {
@@ -535,7 +547,8 @@ let PENDING_GC = /* @__PURE__ */ new Set();
 const microtask = () => Promise.resolve();
 let currentFlush = null;
 const scheduleFlush = (fn) => {
-  if (currentFlush) return;
+  if (currentFlush)
+    return;
   let resolve;
   const promise = new Promise((r) => resolve = r);
   currentFlush = { promise, resolve };
@@ -572,7 +585,8 @@ const scheduleTracer = (tracer) => {
 };
 const scheduleGcSweep = (scope) => {
   PENDING_GC.add(scope);
-  if (PENDING_GC.size > 1) return;
+  if (PENDING_GC.size > 1)
+    return;
   scheduleIdleCallback(() => {
     for (const scope2 of PENDING_GC) {
       scope2.sweepGc();
@@ -582,6 +596,8 @@ const scheduleGcSweep = (scope) => {
 };
 const flushWatchers = async () => {
   const flush = currentFlush;
+  if (!flush)
+    return;
   while (PENDING_ASYNC_PULLS.length > 0 || PENDING_PULLS.size > 0) {
     const asyncPulls = PENDING_ASYNC_PULLS;
     PENDING_ASYNC_PULLS = [];
@@ -625,19 +641,17 @@ const settled = async () => {
 };
 function dirtySignal(signal2) {
   const prevState = signal2._state;
-  if (prevState === ReactiveFnState.Dirty) {
+  if (prevState === 2) {
     return;
   }
-  signal2._state = ReactiveFnState.Dirty;
-  if (prevState < ReactiveFnState.MaybeDirty) {
+  signal2._state = 2;
+  if (prevState < 3) {
     propagateDirty(signal2);
   }
 }
 function propagateDirty(signal2) {
   if (getCurrentConsumer() === signal2) {
-    throw new Error(
-      "A signal was dirtied after it was consumed by the current function. This can cause race conditions and infinite rerenders and is not allowed."
-    );
+    throw new Error("A signal was dirtied after it was consumed by the current function. This can cause race conditions and infinite rerenders and is not allowed.");
   }
   if (isRelay(signal2)) {
     if (signal2.watchCount > 0) {
@@ -648,31 +662,32 @@ function propagateDirty(signal2) {
       schedulePull(signal2);
     }
     dirtySignalConsumers(signal2.subs);
-    signal2.subs = /* @__PURE__ */ new Map();
+    signal2.subs.clear();
   }
 }
 function dirtySignalConsumers(map) {
   for (const [subRef, edge] of map) {
     const sub = subRef.deref();
-    if (sub === void 0 || sub.computedCount !== edge.consumedAt) continue;
+    if (sub === void 0 || sub.computedCount !== edge.consumedAt)
+      continue;
     const dirtyState = sub._state;
     switch (dirtyState) {
-      case ReactiveFnState.Clean:
-        sub._state = ReactiveFnState.MaybeDirty;
+      case 0:
+        sub._state = 3;
         sub.dirtyHead = edge;
         edge.nextDirty = void 0;
         propagateDirty(sub);
         break;
-      case ReactiveFnState.Pending:
-      case ReactiveFnState.MaybeDirty:
-      case ReactiveFnState.PendingDirty: {
+      case 1:
+      case 3:
+      case 4: {
         let subEdge = sub.dirtyHead;
         const ord = edge.ord;
         if (subEdge.ord > ord) {
           sub.dirtyHead = edge;
           edge.nextDirty = subEdge;
-          if (dirtyState === ReactiveFnState.Pending || dirtyState === ReactiveFnState.PendingDirty) {
-            sub._state = ReactiveFnState.MaybeDirty;
+          if (dirtyState === 1 || dirtyState === 4) {
+            sub._state = 3;
             propagateDirty(sub);
           }
         } else {
@@ -693,21 +708,25 @@ function dirtySignalConsumers(map) {
   }
 }
 let CURRENT_ORD = 0;
-var EdgeType = /* @__PURE__ */ ((EdgeType2) => {
-  EdgeType2[EdgeType2["Signal"] = 0] = "Signal";
-  EdgeType2[EdgeType2["Promise"] = 1] = "Promise";
-  return EdgeType2;
-})(EdgeType || {});
+class EdgeBase {
+  type;
+  dep;
+  ord;
+  updatedAt;
+  consumedAt;
+  nextDirty;
+  constructor(type, dep, updatedAt, consumedAt) {
+    this.type = type;
+    this.dep = dep;
+    this.ord = CURRENT_ORD++;
+    this.updatedAt = updatedAt;
+    this.consumedAt = consumedAt;
+    this.nextDirty = void 0;
+  }
+}
 function createEdge(prevEdge, type, dep, updatedAt, consumedAt) {
   if (prevEdge === void 0) {
-    return {
-      type,
-      dep,
-      ord: CURRENT_ORD++,
-      updatedAt,
-      consumedAt,
-      nextDirty: void 0
-    };
+    return new EdgeBase(type, dep, updatedAt, consumedAt);
   }
   prevEdge.ord = CURRENT_ORD++;
   prevEdge.updatedAt = updatedAt;
@@ -735,14 +754,6 @@ function findAndRemoveDirty(sub, dep) {
   }
   return void 0;
 }
-const DEFAULT_EQUALS = (a, b) => a === b;
-const FALSE_EQUALS = () => false;
-const equalsFrom = (equals) => {
-  if (equals === false) {
-    return FALSE_EQUALS;
-  }
-  return equals ?? DEFAULT_EQUALS;
-};
 const GeneratorResultConstructor = (function* () {
 })().constructor;
 function isGeneratorResult(value) {
@@ -869,6 +880,9 @@ function callback(fn, idx, deps) {
   }
   return callback2.fn;
 }
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
 const arrayFrom = Array.from;
 function isThenable(v) {
   return v !== null && typeof v === "object" && typeof v.then === "function";
@@ -931,12 +945,15 @@ class ReactivePromiseImpl {
     let remaining = len;
     let rejected = false;
     const onFulfillAt = (i) => (v) => {
-      if (rejected) return;
+      if (rejected)
+        return;
       results[i] = v;
-      if (--remaining === 0) p._setValue(results);
+      if (--remaining === 0)
+        p._setValue(results);
     };
     const onReject = (r) => {
-      if (rejected) return;
+      if (rejected)
+        return;
       rejected = true;
       p._setError(r);
     };
@@ -949,15 +966,18 @@ class ReactivePromiseImpl {
     const p = new ReactivePromiseImpl();
     const arr = arrayFrom(values);
     const len = arr.length;
-    if (len === 0) return p;
+    if (len === 0)
+      return p;
     let settled2 = false;
     const onFulfill = (v) => {
-      if (settled2) return;
+      if (settled2)
+        return;
       settled2 = true;
       p._setValue(v);
     };
     const onReject = (r) => {
-      if (settled2) return;
+      if (settled2)
+        return;
       settled2 = true;
       p._setError(r);
     };
@@ -978,12 +998,14 @@ class ReactivePromiseImpl {
     const errors = new Array(len);
     let fulfilled = false;
     const onFulfill = (value) => {
-      if (fulfilled) return;
+      if (fulfilled)
+        return;
       fulfilled = true;
       p._setValue(value);
     };
     const onRejectAt = (index) => (reason) => {
-      if (fulfilled) return;
+      if (fulfilled)
+        return;
       errors[index] = reason;
       if (--pending === 0) {
         p._setError(new AggregateError(errors, "All promises were rejected in ReactivePromise.any"));
@@ -1006,11 +1028,13 @@ class ReactivePromiseImpl {
     let remaining = len;
     const onFulfillAt = (index) => (value) => {
       results[index] = { status: "fulfilled", value };
-      if (--remaining === 0) p._setValue(results);
+      if (--remaining === 0)
+        p._setValue(results);
     };
     const onRejectAt = (index) => (reason) => {
       results[index] = { status: "rejected", reason };
-      if (--remaining === 0) p._setValue(results);
+      if (--remaining === 0)
+        p._setValue(results);
     };
     for (let i = 0; i < len; i++) {
       thenLoop(arr[i], onFulfillAt(i), onRejectAt(i));
@@ -1018,7 +1042,8 @@ class ReactivePromiseImpl {
     return p;
   }
   static resolve(value) {
-    if (value instanceof ReactivePromiseImpl) return value;
+    if (value instanceof ReactivePromiseImpl)
+      return value;
     return new ReactivePromiseImpl((resolve) => resolve(value));
   }
   static reject(reason) {
@@ -1029,7 +1054,7 @@ class ReactivePromiseImpl {
     p._equals = DEFAULT_EQUALS;
     p._initFlags(
       1
-      /* Pending */
+      /* AsyncFlags.Pending */
     );
     const resolve = (value) => {
       if (value && typeof value.then === "function") {
@@ -1057,7 +1082,8 @@ class ReactivePromiseImpl {
   }
   _consumeFlags(flags) {
     const currentConsumer = getCurrentConsumer();
-    if (currentConsumer === void 0) return;
+    if (currentConsumer === void 0)
+      return;
     if ((this._flags & 128) !== 0) {
       this._connect();
     }
@@ -1069,11 +1095,13 @@ class ReactivePromiseImpl {
   _connect() {
     const signal2 = this._signal;
     const currentConsumer = getCurrentConsumer();
+    if (currentConsumer === signal2)
+      return;
     if (currentConsumer?.watchCount === 0) {
       const { ref, computedCount, deps } = currentConsumer;
       const prevEdge = deps.get(signal2);
       if (prevEdge?.consumedAt !== computedCount) {
-        const newEdge = createEdge(prevEdge, EdgeType.Signal, signal2, signal2.updatedCount, computedCount);
+        const newEdge = createEdge(prevEdge, 0, signal2, signal2.updatedCount, computedCount);
         signal2.subs.set(ref, newEdge);
         deps.set(signal2, newEdge);
       }
@@ -1130,7 +1158,7 @@ class ReactivePromiseImpl {
     }
     this._setFlags(
       1
-      /* Pending */
+      /* AsyncFlags.Pending */
     );
     dirtySignalConsumers(this._awaitSubs);
     return this._awaitSubs = /* @__PURE__ */ new Map();
@@ -1193,6 +1221,10 @@ class ReactivePromiseImpl {
     }
   }
   _setError(nextError, awaitSubs = this._awaitSubs) {
+    if (nextError !== this._error && !isAbortError(nextError)) {
+      const desc = this._signal?.desc ?? this._signal?.tracerMeta?.desc;
+      console.error(`[signalium] Unhandled async error${desc ? ` in "${desc}"` : ""}:`, nextError);
+    }
     let error = this._error;
     let notifyFlags = 0;
     if (error !== nextError) {
@@ -1222,7 +1254,7 @@ class ReactivePromiseImpl {
     }
   }
   _scheduleSubs(awaitSubs, dirty) {
-    const newState = dirty ? ReactiveFnState.Dirty : ReactiveFnState.PendingDirty;
+    const newState = dirty ? 2 : 4;
     for (const ref of awaitSubs.keys()) {
       const signal2 = ref.deref();
       if (signal2 === void 0) {
@@ -1235,49 +1267,49 @@ class ReactivePromiseImpl {
   get value() {
     this._consumeFlags(
       16
-      /* Value */
+      /* AsyncFlags.Value */
     );
     return this._value;
   }
   get error() {
     this._consumeFlags(
       32
-      /* Error */
+      /* AsyncFlags.Error */
     );
     return this._error;
   }
   get isPending() {
     this._consumeFlags(
       1
-      /* Pending */
+      /* AsyncFlags.Pending */
     );
     return (this._flags & 1) !== 0;
   }
   get isRejected() {
     this._consumeFlags(
       2
-      /* Rejected */
+      /* AsyncFlags.Rejected */
     );
     return (this._flags & 2) !== 0;
   }
   get isResolved() {
     this._consumeFlags(
       4
-      /* Resolved */
+      /* AsyncFlags.Resolved */
     );
     return (this._flags & 4) !== 0;
   }
   get isReady() {
     this._consumeFlags(
       8
-      /* Ready */
+      /* AsyncFlags.Ready */
     );
     return (this._flags & 8) !== 0;
   }
   get isSettled() {
     this._consumeFlags(
       6
-      /* Settled */
+      /* AsyncFlags.Settled */
     );
     return (this._flags & 6) !== 0;
   }
@@ -1293,13 +1325,7 @@ class ReactivePromiseImpl {
         }
         ref = currentConsumer.ref;
         const prevEdge = this._awaitSubs.get(ref) ?? findAndRemoveDirty(currentConsumer, this);
-        edge = createEdge(
-          prevEdge,
-          EdgeType.Promise,
-          this,
-          this._updatedCount,
-          currentConsumer.computedCount
-        );
+        edge = createEdge(prevEdge, 1, this, this._updatedCount, currentConsumer.computedCount);
       }
       const wrappedFulfilled = onfulfilled ? (value) => {
         try {
@@ -1335,16 +1361,13 @@ class ReactivePromiseImpl {
     return this.then(null, onrejected);
   }
   finally(onfinally) {
-    return this.then(
-      (value) => {
-        onfinally?.();
-        return value;
-      },
-      (reason) => {
-        onfinally?.();
-        throw reason;
-      }
-    );
+    return this.then((value) => {
+      onfinally?.();
+      return value;
+    }, (reason) => {
+      onfinally?.();
+      throw reason;
+    });
   }
   get [Symbol.toStringTag]() {
     return `ReactivePromise`;
@@ -1366,7 +1389,7 @@ function createPromise(promise, signal2) {
   p["_equals"] = signal2.def.equals;
   p["_initFlags"](
     1
-    /* Pending */
+    /* AsyncFlags.Pending */
   );
   p["_setPromise"](promise);
   return p;
@@ -1383,7 +1406,7 @@ function createRelay(activate, scope, opts) {
     }
     const signal2 = p["_signal"];
     signal2.subs = /* @__PURE__ */ new Map();
-    signal2._state = ReactiveFnState.Dirty;
+    signal2._state = 2;
     active = false;
     currentSub = void 0;
   };
@@ -1428,7 +1451,7 @@ function createRelay(activate, scope, opts) {
   p["_equals"] = equalsFrom(opts?.equals);
   p["_initFlags"](
     128 | 1
-    /* Pending */
+    /* AsyncFlags.Pending */
   );
   return p;
 }
@@ -1438,7 +1461,7 @@ function createTask(task, scope, opts) {
   p["_equals"] = equalsFrom(opts?.equals);
   p["_initFlags"](
     64
-    /* isRunnable */
+    /* AsyncFlags.isRunnable */
   );
   const throwIfRunning = opts?.throwIfRunning === true;
   p["run"] = ((...args) => {
@@ -1474,7 +1497,7 @@ function getSignal(signal2) {
         }
       }
       const updatedAt = checkSignal(signal2);
-      const newEdge = createEdge(prevEdge, EdgeType.Signal, signal2, updatedAt, computedCount);
+      const newEdge = createEdge(prevEdge, 0, signal2, updatedAt, computedCount);
       signal2.subs.set(ref, newEdge);
       deps.set(signal2, newEdge);
     } else {
@@ -1490,26 +1513,26 @@ function getSignal(signal2) {
 }
 function checkSignal(signal2) {
   const { ref, _state: state } = signal2;
-  if (state < ReactiveFnState.Dirty) {
+  if (state < 2) {
     return signal2.updatedCount;
   }
-  if (state >= ReactiveFnState.MaybeDirty) {
+  if (state >= 3) {
     let edge = signal2.dirtyHead;
     while (edge !== void 0) {
-      if (edge.type === EdgeType.Promise) {
+      if (edge.type === 1) {
         const dep2 = edge.dep;
         if (dep2._getPending()) {
           const value = signal2._value;
           dep2["_awaitSubs"].set(ref, edge);
           value._setPending();
-          signal2._state = ReactiveFnState.Pending;
+          signal2._state = 1;
           signal2.dirtyHead = edge;
           return signal2.updatedCount;
         } else if (edge.updatedAt === edge.dep._updatedCount) {
           dep2["_awaitSubs"].set(ref, edge);
         } else {
           signal2.dirtyHead = edge.nextDirty;
-          signal2._state = ReactiveFnState.Dirty;
+          signal2._state = 2;
           break;
         }
         edge = edge.nextDirty;
@@ -1520,23 +1543,23 @@ function checkSignal(signal2) {
       dep.subs.set(ref, edge);
       if (edge.updatedAt !== updatedAt) {
         signal2.dirtyHead = edge.nextDirty;
-        signal2._state = ReactiveFnState.Dirty;
+        signal2._state = 2;
         break;
       }
       edge = edge.nextDirty;
     }
   }
   const newState = signal2._state;
-  if (newState === ReactiveFnState.Dirty) {
+  if (newState === 2) {
     if (signal2._isLazy) {
       signal2.updatedCount++;
     } else {
       runSignal(signal2);
     }
-  } else if (newState === ReactiveFnState.PendingDirty) {
+  } else if (newState === 4) {
     signal2._value._clearPending();
   }
-  signal2._state = ReactiveFnState.Clean;
+  signal2._state = 0;
   signal2.dirtyHead = void 0;
   if (getTracerProxy() !== void 0 && signal2.tracerMeta?.tracer) {
     scheduleTracer(signal2.tracerMeta.tracer);
@@ -1723,56 +1746,56 @@ function hashDate(date, _seen) {
   return hashNumber(
     date.getTime(),
     14
-    /* DATE */
+    /* HashType.DATE */
   );
 }
 function hashRegExp(regexp, _seen) {
   const h = hashStr(
     regexp.source + regexp.flags,
     15
-    /* REGEXP */
+    /* HashType.REGEXP */
   );
   return (h ^ regexp.lastIndex) >>> 0;
 }
 const UNDEFINED = hashStr(
   "undefined",
   0
-  /* UNDEFINED */
+  /* HashType.UNDEFINED */
 );
 const NULL = hashStr(
   "null",
   1
-  /* NULL */
+  /* HashType.NULL */
 );
 const TRUE = hashStr(
   "true",
   2
-  /* TRUE */
+  /* HashType.TRUE */
 );
 const FALSE = hashStr(
   "false",
   3
-  /* FALSE */
+  /* HashType.FALSE */
 );
 const ARRAY = hashStr(
   "array",
   7
-  /* ARRAY */
+  /* HashType.ARRAY */
 );
 const OBJECT = hashStr(
   "object",
   8
-  /* OBJECT */
+  /* HashType.OBJECT */
 );
 const SET = hashStr(
   "set",
   13
-  /* SET */
+  /* HashType.SET */
 );
 const MAP = hashStr(
   "map",
   12
-  /* MAP */
+  /* HashType.MAP */
 );
 const getObjectProto = Object.getPrototypeOf;
 const PROTO_TO_HASH = /* @__PURE__ */ new Map([
@@ -1796,19 +1819,19 @@ function hashValue(node, seen = []) {
       return hashStr(
         String(node),
         4
-        /* NUMBER */
+        /* HashType.NUMBER */
       );
     case "string":
       return hashStr(
         node,
         5
-        /* STRING */
+        /* HashType.STRING */
       );
     case "bigint":
       return hashStr(
         node.toString(),
         6
-        /* BIGINT */
+        /* HashType.BIGINT */
       );
     case "object": {
       if (node === null) {
@@ -1819,7 +1842,7 @@ function hashValue(node, seen = []) {
         return hashStr(
           String(index),
           11
-          /* CYCLE */
+          /* HashType.CYCLE */
         );
       }
       const hashFn = PROTO_TO_HASH.get(getObjectProto(node));
@@ -1837,7 +1860,7 @@ function hashValue(node, seen = []) {
       return hashStr(
         node.toString(),
         10
-        /* SYMBOL */
+        /* HashType.SYMBOL */
       );
   }
 }
@@ -1849,7 +1872,7 @@ function getObjectHash(obj) {
     id = hashNumber(
       nextHashMapId++,
       9
-      /* REFERENCE */
+      /* HashType.REFERENCE */
     );
     objectToHashMap.set(obj, id);
   }
@@ -1883,8 +1906,10 @@ function isPlainArray(arr) {
   return Array.isArray(arr);
 }
 function stringifyValue(value) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
+  if (value === null)
+    return "null";
+  if (value === void 0)
+    return "undefined";
   switch (typeof value) {
     case "number":
     case "boolean":
@@ -1916,25 +1941,21 @@ function stringifyValue(value) {
       return getObjectId(value);
   }
 }
-var ReactiveFnState = /* @__PURE__ */ ((ReactiveFnState2) => {
-  ReactiveFnState2[ReactiveFnState2["Clean"] = 0] = "Clean";
-  ReactiveFnState2[ReactiveFnState2["Pending"] = 1] = "Pending";
-  ReactiveFnState2[ReactiveFnState2["Dirty"] = 2] = "Dirty";
-  ReactiveFnState2[ReactiveFnState2["MaybeDirty"] = 3] = "MaybeDirty";
-  ReactiveFnState2[ReactiveFnState2["PendingDirty"] = 4] = "PendingDirty";
-  return ReactiveFnState2;
-})(ReactiveFnState || {});
 let ID = 0;
 function createReactiveDefinition(id, desc, compute, equals, isRelay2, paramKey, tracer) {
-  return {
-    id,
-    desc,
+  const def = {
     compute,
     equals: equalsFrom(equals),
     isRelay: isRelay2,
     paramKey,
-    tracer
+    tracer: void 0
   };
+  {
+    def.id = id;
+    def.desc = desc;
+    def.tracer = tracer;
+  }
+  return def;
 }
 class ReactiveSignal {
   // Bitmask containing state in the first 2 bits and boolean properties in the remaining bits
@@ -1955,6 +1976,7 @@ class ReactiveSignal {
   _listeners = null;
   _value = void 0;
   tracerMeta;
+  desc;
   // Reference to the shared definition
   def;
   constructor(def, args, key, scope) {
@@ -1963,6 +1985,7 @@ class ReactiveSignal {
     this.key = key;
     this.args = args;
     this.def = def;
+    this.desc = def.desc;
     {
       this.tracerMeta = {
         id: def.id ?? key ?? hashValue([def.compute, ID++]),
@@ -2106,13 +2129,14 @@ function createReactiveSignal(def, args = [], key, scope) {
 }
 let CONTEXT_ID = 0;
 class ContextImpl {
+  defaultValue;
+  _key;
+  _description;
   constructor(defaultValue, desc) {
     this.defaultValue = defaultValue;
     this._description = desc ?? `context:${CONTEXT_ID++}`;
     this._key = Symbol(this._description);
   }
-  _key;
-  _description;
 }
 const context = (initialValue, description) => {
   return new ContextImpl(initialValue, description);
@@ -2130,9 +2154,7 @@ function withContexts(contexts, fn) {
 const getContext = (context2) => {
   const scope = CURRENT_SCOPE ?? getCurrentConsumer()?.scope;
   if (scope === void 0) {
-    throw new Error(
-      "getContext must be used within a reactive function, a withContext, or within a framework-specific context provider."
-    );
+    throw new Error("getContext must be used within a reactive function, a withContext, or within a framework-specific context provider.");
   }
   return scope.getContext(context2) ?? context2.defaultValue;
 };
@@ -2250,16 +2272,17 @@ const getScopeOwner = (obj) => {
   return scope;
 };
 export {
-  clearGlobalContexts as A,
-  setScopeOwner as B,
-  setTracing as C,
-  createTracer as D,
-  createTracerFromId as E,
-  removeTracer as F,
-  Tracer as G,
-  SignalType as H,
-  getTracerProxy as I,
-  scheduleTracer as J,
+  setGlobalContexts as A,
+  clearGlobalContexts as B,
+  setScopeOwner as C,
+  setTracing as D,
+  createTracer as E,
+  createTracerFromId as F,
+  removeTracer as G,
+  Tracer as H,
+  SignalType as I,
+  getTracerProxy as J,
+  scheduleTracer as K,
   ReactivePromise as R,
   SignalScope as S,
   TracerEventType as T,
@@ -2272,23 +2295,23 @@ export {
   getCurrentConsumer as f,
   getCurrentScope as g,
   getGlobalScope as h,
-  hashValue as i,
-  isReactivePromise as j,
+  isReactivePromise as i,
+  hashValue as j,
   isRelay$1 as k,
   getSignal as l,
   isPromise as m,
   registerCustomHash as n,
   setReactivePromise as o,
   notifier as p,
-  callback as q,
+  isSignal as q,
   runSignal as r,
   signal as s,
-  settled as t,
+  callback as t,
   unwatchSignal as u,
-  context as v,
+  settled as v,
   watchSignal as w,
-  getContext as x,
-  withContexts as y,
-  setGlobalContexts as z
+  context as x,
+  getContext as y,
+  withContexts as z
 };
-//# sourceMappingURL=debug-BfudYKc4.js.map
+//# sourceMappingURL=debug-B6Cqxyzi.js.map