signalium 1.0.2 → 1.1.1

package/src/__tests__/gc.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { reactive, createContext, withContexts, watcher, state } from '../index.js';
+import { SignalScope, ROOT_SCOPE, forceGc, clearRootScope } from '../internals/contexts.js';
+import { nextTick, sleep } from './utils/async.js';
+
+// Helper to access private properties for testing
+const getSignalsMap = (scope: SignalScope) => {
+  return (scope as any).signals as Map<number, any>;
+};
+
+const getGCCandidates = (scope: SignalScope) => {
+  return (scope as any).gcCandidates as Set<any>;
+};
+
+describe('Garbage Collection', () => {
+  beforeEach(() => {
+    clearRootScope();
+  });
+
+  it('should automatically garbage collect unwatched signals', async () => {
+    const testSignal = reactive(() => 42);
+
+    const w = watcher(() => testSignal());
+
+    // Watch the signal
+    const unwatch = w.addListener(() => {
+      testSignal();
+    });
+
+    await nextTick();
+
+    // Signal should be in the scope
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+
+    // Unwatch the signal
+    unwatch();
+
+    await sleep(50);
+
+    // Signal should be garbage collected
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(0);
+  });
+
+  it('should not garbage collect signals with shouldGC returning false', async () => {
+    // Create a signal that should not be garbage collected
+    const persistentSignal = reactive(() => 'persist', {
+      shouldGC: () => false,
+    });
+
+    const w = watcher(() => persistentSignal());
+
+    // Watch the signal
+    const unwatch = w.addListener(() => {
+      persistentSignal();
+    });
+
+    await nextTick();
+
+    // Signal should be in the scope
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+
+    // Unwatch the signal
+    unwatch();
+
+    await sleep(50);
+
+    // Signal should still be in the scope
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+  });
+
+  it('should support conditional GC based on signal state', async () => {
+    // Create a signal with conditional GC
+    const shouldAllowGC = state(false);
+
+    const conditionalSignal = reactive(() => shouldAllowGC.get(), {
+      shouldGC: (signal, value) => {
+        // console.log('shouldGC', signal, value);
+        return value;
+      },
+    });
+
+    const w = watcher(() => conditionalSignal());
+
+    // Watch the signal
+    const unwatch = w.addListener(() => {
+      conditionalSignal();
+    });
+
+    await nextTick();
+
+    // Signal should be in the scope
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+
+    // Unwatch the signal
+    unwatch();
+
+    await sleep(50);
+
+    // Signal should still be in the scope because shouldGC returns false
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+
+    // Now allow GC
+    shouldAllowGC.set(true);
+
+    // Watch the signal
+    const unwatch2 = w.addListener(() => {
+      conditionalSignal();
+    });
+
+    await nextTick();
+
+    // Signal should be in GC candidates
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+
+    unwatch2();
+
+    await sleep(50);
+
+    // Signal should be garbage collected
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(0);
+  });
+
+  it('should support manual garbage collection', async () => {
+    let signalObj: object;
+
+    // Create multiple signals
+    const signal1 = reactive(() => 'signal1');
+    const signal2 = reactive(() => 'signal2', {
+      shouldGC: signal => {
+        signalObj = signal;
+        return false;
+      },
+    });
+
+    const w1 = watcher(() => signal1());
+    const w2 = watcher(() => signal2());
+
+    // Watch both signals
+    const unwatch1 = w1.addListener(() => {
+      signal1();
+    });
+    const unwatch2 = w2.addListener(() => {
+      signal2();
+    });
+
+    await nextTick();
+
+    // Both signals should be in the scope
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(2);
+
+    // Unwatch both signals
+    unwatch1();
+    unwatch2();
+
+    await sleep(50);
+
+    // Only signal1 should be garbage collected
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+
+    // The remaining signal should be signal2
+    const remainingSignal = Array.from(getSignalsMap(ROOT_SCOPE).values())[0];
+    expect(remainingSignal.get()).toBe('signal2');
+
+    forceGc(signalObj!);
+
+    await sleep(50);
+
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(0);
+  });
+
+  it('should not garbage collect signals that are still being watched', async () => {
+    // Create a signal
+    const watchedSignal = reactive(() => 'watched');
+
+    const w = watcher(() => watchedSignal());
+
+    // Watch the signal but don't unwatch
+    w.addListener(() => {
+      watchedSignal();
+    });
+
+    await nextTick();
+
+    // Signal should be in the scope
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+
+    await sleep(50);
+
+    // Signal should still be in the scope because it's being watched
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+  });
+
+  it('should handle context-scoped signals correctly', async () => {
+    // Create a context
+    const TestContext = createContext('test');
+
+    // Create signals in context
+    let contextSignal: any;
+
+    withContexts([[TestContext, 'value']], () => {
+      contextSignal = reactive(() => 'context-scoped');
+
+      const w = watcher(() => contextSignal());
+
+      // Watch and unwatch
+      const unwatch = w.addListener(() => {
+        contextSignal();
+      });
+
+      unwatch();
+    });
+
+    await nextTick();
+
+    // Get the context scope (this is a bit hacky for testing)
+    const contextScope = (ROOT_SCOPE as any).children.values().next().value;
+
+    await sleep(50);
+
+    // Signal should be garbage collected from the context scope
+    expect(getSignalsMap(contextScope).size).toBe(0);
+  });
+
+  it('should remove signal from GC candidates if watched again', async () => {
+    // Create a signal
+    const signal = reactive(() => 'rewatch');
+
+    const w = watcher(() => signal());
+
+    // Watch and unwatch
+    const unwatch = w.addListener(() => {
+      signal();
+    });
+
+    await nextTick();
+
+    // Signal should be in the scope
+    expect(getSignalsMap(ROOT_SCOPE).size).toBe(1);
+
+    unwatch();
+    await nextTick();
+
+    // Signal should be in GC candidates
+    expect(getGCCandidates(ROOT_SCOPE).size).toBe(1);
+
+    // Watch again
+    w.addListener(() => {
+      signal();
+    });
+
+    await nextTick();
+
+    // Signal should be removed from GC candidates
+    expect(getGCCandidates(ROOT_SCOPE).size).toBe(0);
+  });
+});

package/src/__tests__/utils/instrumented-hooks.ts

@@ -9,7 +9,7 @@ import {
 } from '../../index.js';
 import { ReactiveTask, ReactiveValue, SignalOptionsWithInit, SignalSubscription } from '../../types.js';
 import { Context, ContextImpl, getCurrentScope, ROOT_SCOPE, SignalScope } from '../../internals/contexts.js';
-import { createDerivedSignal, DerivedSignal } from '../../internals/derived.js';
+import { DerivedSignal } from '../../internals/derived.js';
 import { ReactivePromise } from '../../internals/async.js';
 import { hashValue } from '../../internals/utils/hash.js';
 
@@ -71,10 +71,10 @@ const WATCHERS = new WeakMap<Function, DerivedSignal<unknown, unknown[]>>();
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 function getWatcherForHook(hook: Function) {
-  let watcher = WATCHERS.get(hook);
+  let w = WATCHERS.get(hook);
 
-  if (!watcher) {
-    watcher = createDerivedSignal(
+  if (!w) {
+    w = watcher(
       () => {
         let result = hook();
 
@@ -84,18 +84,15 @@ function getWatcherForHook(hook: Function) {
 
         return result;
       },
-      undefined,
-      undefined,
-      undefined,
       { desc: 'test' + TEST_ID++ },
-    );
+    ) as DerivedSignal<unknown, unknown[]>;
 
-    unsubs.push(watcher.addListener(() => {}));
+    unsubs.push(w.addListener(() => {}));
 
-    WATCHERS.set(hook, watcher);
+    WATCHERS.set(hook, w);
   }
 
-  return watcher;
+  return w;
 }
 
 function toHaveSignalValue(

package/src/config.ts

@@ -14,7 +14,7 @@ interface SignalHooksConfig {
   runBatch: BatchFn;
   getFrameworkScope: () => SignalScope | undefined;
   useStateSignal: <T>(signal: StateSignal<T>) => T;
-  useDerivedSignal: <T>(signal: DerivedSignal<T, unknown[]>) => ReactiveValue<T>;
+  useDerivedSignal: <T, Args extends unknown[]>(signal: DerivedSignal<T, Args>) => ReactiveValue<T>;
 }
 
 export let scheduleFlush: FlushFn = flushWatchers => {
@@ -28,9 +28,11 @@ export let runBatch: BatchFn = fn => fn();
 export let getFrameworkScope: () => SignalScope | undefined = () => undefined;
 
 let useFrameworkStateSignal: <T>(signal: StateSignal<T>) => T = signal => signal.get();
-let useFrameworkDerivedSignal: <T>(signal: DerivedSignal<T, unknown[]>) => ReactiveValue<T> = signal => signal.get();
+let useFrameworkDerivedSignal: <T, Args extends unknown[]>(
+  signal: DerivedSignal<T, Args>,
+) => ReactiveValue<T> = signal => signal.get();
 
-export function useDerivedSignal<T>(signal: DerivedSignal<T, any[]>): ReactiveValue<T> {
+export function useDerivedSignal<T, Args extends unknown[]>(signal: DerivedSignal<T, Args>): ReactiveValue<T> {
   if (CURRENT_CONSUMER !== undefined) {
     return signal.get();
   } else {

package/src/hooks.ts

@@ -11,9 +11,10 @@ import {
 import { useDerivedSignal } from './config.js';
 import { getCurrentScope, SignalScope } from './internals/contexts.js';
 import { createStateSignal } from './internals/state.js';
-import { createDerivedSignal } from './internals/derived.js';
+import { createDerivedSignal, DerivedSignalDefinition } from './internals/derived.js';
 import { ReactivePromise } from './internals/async.js';
 import { Tracer } from './trace.js';
+import { equalsFrom } from './internals/utils/equals.js';
 
 export const state = createStateSignal;
 
@@ -29,9 +30,16 @@ export function reactive<T, Args extends unknown[]>(
   fn: (...args: Args) => T,
   opts?: Partial<SignalOptionsWithInit<T, Args>>,
 ): (...args: Args) => ReactiveValue<T> {
+  const def: DerivedSignalDefinition<T, Args> = {
+    compute: fn,
+    equals: equalsFrom(opts?.equals),
+    shouldGC: opts?.shouldGC,
+    isSubscription: false,
+  };
+
   return (...args) => {
     const scope = getCurrentScope();
-    const signal = scope.get(fn as any, args, opts);
+    const signal = scope.get(def, args, opts);
 
     return useDerivedSignal(signal)!;
   };
@@ -64,5 +72,11 @@ export function watcher<T>(
   fn: () => T,
   opts?: SignalOptions<T, unknown[]> & { scope?: SignalScope; tracer?: Tracer },
 ): Signal<ReactiveValue<T>> {
-  return createDerivedSignal(fn, undefined, undefined, opts?.scope, opts);
+  const def: DerivedSignalDefinition<T, unknown[]> = {
+    compute: fn,
+    equals: equalsFrom(opts?.equals),
+    isSubscription: false,
+  };
+
+  return createDerivedSignal(def, undefined, undefined, opts?.scope, opts);
 }

package/src/index.ts

@@ -6,7 +6,14 @@ export { isReactivePromise, isReactiveTask, isReactiveSubscription } from './int
 
 export { callback } from './internals/get.js';
 
-export { createContext, useContext, withContexts, SignalScope, CONTEXT_KEY } from './internals/contexts.js';
+export {
+  createContext,
+  useContext,
+  withContexts,
+  setRootContexts,
+  SignalScope,
+  CONTEXT_KEY,
+} from './internals/contexts.js';
 
 export { setConfig } from './config.js';
 

package/src/internals/async.ts

@@ -8,7 +8,7 @@ import {
   SignalSubscribe,
   SignalSubscription,
 } from '../types.js';
-import { createDerivedSignal, DerivedSignal, SignalState } from './derived.js';
+import { createDerivedSignal, DerivedSignal, DerivedSignalDefinition, SignalState } from './derived.js';
 import { CURRENT_CONSUMER, generatorResultToPromise, getSignal } from './get.js';
 import { dirtySignal, dirtySignalConsumers } from './dirty.js';
 import { scheduleAsyncPull, schedulePull, setResolved } from './scheduling.js';
@@ -17,7 +17,7 @@ import { getCurrentScope, ROOT_SCOPE, SignalScope, withScope } from './contexts.
 import { createStateSignal } from './state.js';
 import { useStateSignal } from '../config.js';
 import { isGeneratorResult, isPromise } from './utils/type-utils.js';
-import { equalsFrom } from './utils/equals.js';
+import { DEFAULT_EQUALS, equalsFrom, FALSE_EQUALS } from './utils/equals.js';
 
 const enum AsyncFlags {
   // ======= Notifiers ========
@@ -72,10 +72,10 @@ export class ReactivePromise<T, Args extends unknown[] = unknown[]> implements B
   private _boundRun: ((...args: Args) => ReactivePromise<T, Args>) | undefined;
 
   static createPromise<T>(promise: Promise<T>, signal?: DerivedSignal<T, unknown[]>, initValue?: T | undefined) {
-    const p = new ReactivePromise();
+    const p = new ReactivePromise<T>();
 
     p._signal = signal;
-    p._equals = signal?.equals ?? ((a, b) => a === b);
+    p._equals = signal?.def.equals ?? DEFAULT_EQUALS;
 
     p._initFlags(AsyncFlags.Pending, initValue);
 
@@ -130,8 +130,8 @@ export class ReactivePromise<T, Args extends unknown[] = unknown[]> implements B
       },
     };
 
-    p._signal = createDerivedSignal(
-      () => {
+    const def: DerivedSignalDefinition<() => void, unknown[]> = {
+      compute: () => {
         if (active === false) {
           currentSub = subscribe(state);
           active = true;
@@ -144,11 +144,16 @@ export class ReactivePromise<T, Args extends unknown[] = unknown[]> implements B
 
         return unsubscribe;
       },
+      equals: DEFAULT_EQUALS,
+      isSubscription: true,
+    };
+
+    p._signal = createDerivedSignal<() => void, unknown[]>(
+      def,
       [],
       undefined,
       scope,
-      opts as Omit<SignalOptionsWithInit<T, unknown[]>, 'equals' | 'initValue' | 'paramKey'>,
-      true,
+      opts as Omit<SignalOptionsWithInit<T, unknown[]>, 'equals' | 'initValue' | 'paramKey' | 'shouldGC'>,
     );
 
     p._equals = equalsFrom(opts?.equals);

package/src/internals/connect.ts

@@ -10,6 +10,9 @@ export function watchSignal(signal: DerivedSignal<any, any>): void {
   // If > 0, already watching, return
   if (watchCount > 0) return;
 
+  // If signal is being watched again, remove from GC candidates
+  signal.scope?.removeFromGc(signal);
+
   for (const dep of signal.deps.keys()) {
     watchSignal(dep);
   }
@@ -38,4 +41,9 @@ export function unwatchSignal(signal: DerivedSignal<any, any>, count = 1) {
     // teardown the subscription
     signal.value?.();
   }
+
+  // If watchCount is now zero, mark the signal for GC
+  if (newWatchCount === 0 && signal.scope) {
+    signal.scope.markForGc(signal);
+  }
 }

package/src/internals/contexts.ts

@@ -1,8 +1,9 @@
 import { getFrameworkScope } from '../config.js';
 import { SignalOptionsWithInit } from '../types.js';
-import { DerivedSignal, createDerivedSignal } from './derived.js';
+import { DerivedSignal, DerivedSignalDefinition, createDerivedSignal } from './derived.js';
 import { CURRENT_CONSUMER } from './get.js';
 import { hashReactiveFn, hashValue } from './utils/hash.js';
+import { scheduleGcSweep } from './scheduling.js';
 
 export const CONTEXT_KEY = Symbol('signalium:context');
 
@@ -46,7 +47,8 @@ export class SignalScope {
   private parentScope?: SignalScope = undefined;
   private contexts: Record<symbol, unknown>;
   private children = new Map<number, SignalScope>();
-  private signals = new Map<number, DerivedSignal<any, any[]>>();
+  private signals = new Map<number, DerivedSignal<any, any>>();
+  private gcCandidates = new Set<DerivedSignal<any, any>>();
 
   getChild(contexts: [ContextImpl<unknown>, unknown][]) {
     const key = hashValue(contexts);
@@ -68,25 +70,58 @@ export class SignalScope {
   }
 
   get<T, Args extends unknown[]>(
-    fn: (...args: Args) => T,
+    def: DerivedSignalDefinition<T, Args>,
     args: Args,
     opts?: Partial<SignalOptionsWithInit<T, Args>>,
   ): DerivedSignal<T, Args> {
     const paramKey = opts?.paramKey?.(...args);
-    const key = hashReactiveFn(fn, paramKey ? [paramKey] : args);
+    const key = hashReactiveFn(def.compute, paramKey ? [paramKey] : args);
     let signal = this.signals.get(key) as DerivedSignal<T, Args> | undefined;
 
     if (signal === undefined) {
-      signal = createDerivedSignal(fn, args, key, this, opts);
+      signal = createDerivedSignal(def, args, key, this, opts);
       this.signals.set(key, signal);
     }
 
     return signal;
   }
+
+  markForGc(signal: DerivedSignal<any, any>) {
+    if (!this.gcCandidates.has(signal)) {
+      this.gcCandidates.add(signal);
+      scheduleGcSweep(this);
+    }
+  }
+
+  removeFromGc(signal: DerivedSignal<any, any>) {
+    this.gcCandidates.delete(signal);
+  }
+
+  forceGc(signal: DerivedSignal<any, any>) {
+    this.signals.delete(signal.key!);
+  }
+
+  sweepGc() {
+    for (const signal of this.gcCandidates) {
+      if (signal.watchCount === 0) {
+        const { shouldGC } = signal.def;
+
+        if (!shouldGC || shouldGC(signal, signal.value, signal.args)) {
+          this.signals.delete(signal.key!);
+        }
+      }
+    }
+
+    this.gcCandidates = new Set();
+  }
 }
 
 export let ROOT_SCOPE = new SignalScope([]);
 
+export function setRootContexts<C extends unknown[], U>(contexts: [...ContextPair<C>]): void {
+  ROOT_SCOPE = new SignalScope(contexts as [ContextImpl<unknown>, unknown][], ROOT_SCOPE);
+}
+
 export const clearRootScope = () => {
   ROOT_SCOPE = new SignalScope([]);
 };
@@ -131,3 +166,8 @@ export const useContext = <T>(context: Context<T>): T => {
 
   return scope.getContext(context) ?? (context as unknown as ContextImpl<T>).defaultValue;
 };
+
+export function forceGc(_signal: object) {
+  const signal = _signal as DerivedSignal<any, any>;
+  signal.scope?.forceGc(signal);
+}

package/src/internals/derived.ts

@@ -3,12 +3,11 @@ import { Tracer, TRACER, TracerMeta } from '../trace.js';
 import { ReactiveValue, Signal, SignalEquals, SignalListener, SignalOptionsWithInit } from '../types.js';
 import { getUnknownSignalFnName } from './utils/debug-name.js';
 import { SignalScope } from './contexts.js';
-import { checkAndRunListeners, getSignal } from './get.js';
-import { Edge, EdgeType, SignalEdge } from './edge.js';
+import { getSignal } from './get.js';
+import { Edge } from './edge.js';
 import { schedulePull, scheduleUnwatch } from './scheduling.js';
 import { hashValue } from './utils/hash.js';
 import { stringifyValue } from './utils/stringify.js';
-import { equalsFrom } from './utils/equals.js';
 
 /**
  * This file contains computed signal base types and struct definitions.
@@ -52,6 +51,17 @@ interface ListenerMeta {
   cachedBoundAdd: (listener: SignalListener) => () => void;
 }
 
+/**
+ * Shared definition for derived signals to reduce memory usage.
+ * Contains configuration that's common across all instances of a reactive function.
+ */
+export interface DerivedSignalDefinition<T, Args extends unknown[]> {
+  compute: (...args: Args) => T;
+  equals: SignalEquals<T>;
+  shouldGC?: (signal: object, value: T, args: Args) => boolean;
+  isSubscription: boolean;
+}
+
 export class DerivedSignal<T, Args extends unknown[]> implements Signal<ReactiveValue<T>> {
   // Bitmask containing state in the first 2 bits and boolean properties in the remaining bits
   private flags: number;
@@ -62,7 +72,6 @@ export class DerivedSignal<T, Args extends unknown[]> implements Signal<Reactive
 
   ref: WeakRef<DerivedSignal<T, Args>> = new WeakRef(this);
 
-  equals: SignalEquals<any>;
   dirtyHead: Edge | undefined = undefined;
 
   updatedCount: number = 0;
@@ -72,32 +81,33 @@ export class DerivedSignal<T, Args extends unknown[]> implements Signal<Reactive
 
   _listeners: ListenerMeta | null = null;
 
-  compute: (...args: Args) => T;
+  key: SignalId | undefined;
   args: Args;
   value: ReactiveValue<T> | undefined;
 
   tracerMeta?: TracerMeta;
 
+  // Reference to the shared definition
+  def: DerivedSignalDefinition<T, Args>;
+
   constructor(
-    isSubscription: boolean,
-    compute: (...args: Args) => T,
+    definition: DerivedSignalDefinition<T, Args>,
     args: Args,
     key?: SignalId,
     scope?: SignalScope,
     opts?: Partial<SignalOptionsWithInit<T, Args>> & { tracer?: Tracer },
   ) {
-    this.flags = (isSubscription ? SignalFlags.isSubscription : 0) | SignalState.Dirty;
+    this.flags = (definition.isSubscription ? SignalFlags.isSubscription : 0) | SignalState.Dirty;
     this.scope = scope;
-    this.compute = compute;
+    this.key = key;
     this.args = args;
-
-    this.equals = equalsFrom(opts?.equals);
+    this.def = definition;
     this.value = opts?.initValue as ReactiveValue<T>;
 
     if (TRACER) {
       this.tracerMeta = {
-        id: opts?.id ?? key ?? hashValue([compute, ID++]),
-        desc: opts?.desc ?? compute.name ?? getUnknownSignalFnName(compute),
+        id: opts?.id ?? key ?? hashValue([definition.compute, ID++]),
+        desc: opts?.desc ?? definition.compute.name ?? getUnknownSignalFnName(definition.compute),
         params: args.map(arg => stringifyValue(arg)).join(', '),
         tracer: opts?.tracer,
       };
@@ -197,12 +207,11 @@ export const isSubscription = (signal: unknown): boolean => {
 };
 
 export function createDerivedSignal<T, Args extends unknown[]>(
-  compute: (...args: Args) => T,
+  def: DerivedSignalDefinition<T, Args>,
   args: Args = [] as any,
   key?: SignalId,
   scope?: SignalScope,
   opts?: Partial<SignalOptionsWithInit<T, Args>> & { tracer?: Tracer },
-  isSubscription: boolean = false,
 ): DerivedSignal<T, Args> {
-  return new DerivedSignal(isSubscription, compute, args, key, scope, opts);
+  return new DerivedSignal(def, args, key, scope, opts);
 }

package/src/internals/get.ts

@@ -128,7 +128,7 @@ export function runSignal(signal: DerivedSignal<any, any[]>) {
 
     const initialized = updatedCount !== 0;
     const prevValue = signal.value;
-    let nextValue = signal.compute(...signal.args);
+    let nextValue = signal.def.compute(...signal.args);
     let valueIsPromise = false;
 
     if (nextValue !== null && typeof nextValue === 'object') {
@@ -177,7 +177,7 @@ export function runSignal(signal: DerivedSignal<any, any[]>) {
         signal.value = ReactivePromise.createPromise(nextValue, signal, initValue);
         signal.updatedCount = updatedCount + 1;
       }
-    } else if (!initialized || !signal.equals(prevValue!, nextValue)) {
+    } else if (!initialized || !signal.def.equals(prevValue!, nextValue)) {
       signal.value = nextValue;
       signal.updatedCount = updatedCount + 1;
     }