diff --git a/.prettierignore b/.prettierignore
index aae8f9d..a31190c 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -4,3 +4,4 @@ temp
 *.md
 coverage
 .angular
+tests
diff --git a/package.json b/package.json
index 65081aa..d8f25ee 100644
--- a/package.json
+++ b/package.json
@@ -25,9 +25,16 @@
   "main": "./dist/package/index.cjs",
   "module": "./dist/package/index.js",
   "exports": {
-    "types": "./dist/package/index.d.ts",
-    "require": "./dist/package/index.cjs",
-    "default": "./dist/package/index.js"
+    ".": {
+      "types": "./dist/package/index.d.ts",
+      "require": "./dist/package/index.cjs",
+      "default": "./dist/package/index.js"
+    },
+    "./polyfill": {
+      "types": "./dist/package/wrapper.d.ts",
+      "require": "./dist/package/wrapper.cjs",
+      "default": "./dist/package/wrapper.js"
+    }
   },
   "license": "MIT",
   "repository": {
diff --git a/rollup.config.mjs b/rollup.config.mjs
index ab99715..619898f 100644
--- a/rollup.config.mjs
+++ b/rollup.config.mjs
@@ -13,16 +13,20 @@ export default defineConfig({
   output: [
     {
       format: 'cjs',
-      file: './dist/package/index.cjs',
+      dir: './dist/package',
+      entryFileNames: (chunk) => `${chunk.name}.cjs`,
     },
     {
       format: 'es',
-      file: './dist/package/index.js',
+      dir: './dist/package',
+      entryFileNames: (chunk) => `${chunk.name}.js`,
     },
   ],
-  input: './src/index.ts',
+  input: { index: './src/index.ts', wrapper: './src/wrapper.ts' },
   plugins: [
-    typescript(),
+    typescript({
+      tsconfig: 'tsconfig.d.json',
+    }),
     {
       name: 'package',
       async buildStart() {
@@ -36,9 +40,11 @@ export default defineConfig({
         pkg.typings = removeDistPackage(pkg.typings);
         pkg.main = removeDistPackage(pkg.main);
         pkg.module = removeDistPackage(pkg.module);
-        pkg.exports.types = removeDistPackage(pkg.exports.types);
-        pkg.exports.require = removeDistPackage(pkg.exports.require);
-        pkg.exports.default = removeDistPackage(pkg.exports.default);
+        for (const entryPoint of Object.values(pkg.exports)) {
+          entryPoint.types = removeDistPackage(entryPoint.types);
+          entryPoint.require = removeDistPackage(entryPoint.require);
+          entryPoint.default = removeDistPackage(entryPoint.default);
+        }
         this.emitFile({ type: 'asset', fileName: 'package.json', source: JSON.stringify(pkg) });
         this.emitFile({
           type: 'asset',
diff --git a/src/internal/store.ts b/src/internal/store.ts
index 1d65ddc..0cc1169 100644
--- a/src/internal/store.ts
+++ b/src/internal/store.ts
@@ -2,6 +2,7 @@ import type { SignalStore, SubscribableStore } from '../types';
 
 export interface Consumer {
   markDirty(): void;
+  wrapper?: any;
 }
 
 export const enum RawStoreFlags {
@@ -13,6 +14,7 @@ export const enum RawStoreFlags {
   // the following flags are used in RawStoreComputedOrDerived and derived classes
   COMPUTING = 1 << 3,
   DIRTY = 1 << 4,
+  COMPUTED_WITH_ONUSE = 1 << 5,
 }
 
 export interface BaseLink<T> {
@@ -30,6 +32,7 @@ export interface RawStore<T, Link extends BaseLink<T> = BaseLink<T>>
   updateValue(): void;
   isLinkUpToDate(link: Link): boolean;
   updateLink(link: Link): T;
+  wrapper?: any;
 }
 
 export const updateLinkProducerValue = <T>(link: BaseLink<T>): void => {
diff --git a/src/internal/storeComputed.ts b/src/internal/storeComputed.ts
index 1bc94f9..f3563a6 100644
--- a/src/internal/storeComputed.ts
+++ b/src/internal/storeComputed.ts
@@ -13,7 +13,7 @@ export class RawStoreComputed<T>
   implements Consumer, ActiveConsumer
 {
   private producerIndex = 0;
-  private producerLinks: BaseLink<any>[] = [];
+  public producerLinks: BaseLink<any>[] = [];
   private epoch = -1;
 
   constructor(private readonly computeFn: () => T) {
@@ -59,7 +59,10 @@ export class RawStoreComputed<T>
     producerLinks[producerIndex] = link;
     this.producerIndex = producerIndex + 1;
     updateLinkProducerValue(link);
-    if (producer.flags & RawStoreFlags.HAS_VISIBLE_ONUSE) {
+    if (
+      !(this.flags & RawStoreFlags.COMPUTED_WITH_ONUSE) &&
+      producer.flags & RawStoreFlags.HAS_VISIBLE_ONUSE
+    ) {
       this.flags |= RawStoreFlags.HAS_VISIBLE_ONUSE;
     }
     return producer.updateLink(link);
@@ -72,6 +75,7 @@ export class RawStoreComputed<T>
       link.producer.registerConsumer(link);
     }
     this.flags |= RawStoreFlags.DIRTY;
+    super.startUse();
   }
 
   override endUse(): void {
@@ -80,6 +84,7 @@ export class RawStoreComputed<T>
       const link = producerLinks[i];
       link.producer.unregisterConsumer(link);
     }
+    super.endUse();
   }
 
   override areProducersUpToDate(): boolean {
@@ -103,9 +108,10 @@ export class RawStoreComputed<T>
     const prevActiveConsumer = setActiveConsumer(this);
     try {
       this.producerIndex = 0;
-      this.flags &= ~RawStoreFlags.HAS_VISIBLE_ONUSE;
-      const computeFn = this.computeFn;
-      value = computeFn();
+      if (!(this.flags & RawStoreFlags.COMPUTED_WITH_ONUSE)) {
+        this.flags &= ~RawStoreFlags.HAS_VISIBLE_ONUSE;
+      }
+      value = this.computeFn.call(this.wrapper);
       this.error = null;
     } catch (error) {
       value = COMPUTED_ERRORED;
diff --git a/src/internal/storeDerived.ts b/src/internal/storeDerived.ts
index 18e414a..8bf8eea 100644
--- a/src/internal/storeDerived.ts
+++ b/src/internal/storeDerived.ts
@@ -51,6 +51,7 @@ abstract class RawStoreDerived<T, S extends StoresInput>
       producer.registerConsumer(producer.newLink(this))
     );
     this.flags |= RawStoreFlags.DIRTY;
+    super.startUse();
   }
 
   override endUse(): void {
@@ -63,6 +64,7 @@ abstract class RawStoreDerived<T, S extends StoresInput>
         link.producer.unregisterConsumer(link);
       }
     }
+    super.endUse();
   }
 
   override areProducersUpToDate(): boolean {
diff --git a/src/internal/storeSubscribable.ts b/src/internal/storeSubscribable.ts
index 67a8534..ac7f6ea 100644
--- a/src/internal/storeSubscribable.ts
+++ b/src/internal/storeSubscribable.ts
@@ -29,6 +29,7 @@ export class RawSubscribableWrapper<T> extends RawStoreTrackingUsage<T> {
 
   override startUse(): void {
     this.unsubscribe = normalizeUnsubscribe(this.subscribable.subscribe(this.subscriber));
+    super.startUse();
   }
 
   override endUse(): void {
@@ -37,5 +38,6 @@ export class RawSubscribableWrapper<T> extends RawStoreTrackingUsage<T> {
       this.unsubscribe = null;
       unsubscribe();
     }
+    super.endUse();
   }
 }
diff --git a/src/internal/storeTrackingUsage.ts b/src/internal/storeTrackingUsage.ts
index 6495145..f0a1c48 100644
--- a/src/internal/storeTrackingUsage.ts
+++ b/src/internal/storeTrackingUsage.ts
@@ -28,12 +28,19 @@ export const flushUnused = (): void => {
   }
 };
 
-export abstract class RawStoreTrackingUsage<T> extends RawStoreWritable<T> {
+export class RawStoreTrackingUsage<T> extends RawStoreWritable<T> {
   private extraUsages = 0;
-  abstract startUse(): void;
-  abstract endUse(): void;
+  startUseFn?: () => void;
+  endUseFn?: () => void;
 
-  override updateValue(): void {
+  startUse(): void {
+    this.startUseFn?.call(this.wrapper);
+  }
+  endUse(): void {
+    this.endUseFn?.call(this.wrapper);
+  }
+
+  private callOnUse(): boolean {
     const flags = this.flags;
     if (!(flags & RawStoreFlags.START_USE_CALLED)) {
       // Ignoring coverage for the following lines because, unless there is a bug in tansu (which would have to be fixed!)
@@ -44,7 +51,17 @@ export abstract class RawStoreTrackingUsage<T> extends RawStoreWritable<T> {
       }
       this.flags |= RawStoreFlags.START_USE_CALLED;
       untrack(() => this.startUse());
+      return true;
     }
+    return false;
+  }
+
+  override updateValue(): void {
+    this.callOnUse();
+  }
+
+  isUsed(): boolean {
+    return this.extraUsages > 0 || (this.consumerLinks?.length ?? 0) > 0;
   }
 
   override checkUnused(): void {
diff --git a/src/internal/storeWithOnUse.ts b/src/internal/storeWithOnUse.ts
index 81f63d4..0a0a8a9 100644
--- a/src/internal/storeWithOnUse.ts
+++ b/src/internal/storeWithOnUse.ts
@@ -16,6 +16,7 @@ export class RawStoreWithOnUse<T> extends RawStoreTrackingUsage<T> {
 
   override startUse(): void {
     this.cleanUpFn = normalizeUnsubscribe(this.onUseFn());
+    super.startUse();
   }
 
   override endUse(): void {
@@ -24,5 +25,6 @@ export class RawStoreWithOnUse<T> extends RawStoreTrackingUsage<T> {
       this.cleanUpFn = null;
       cleanUpFn();
     }
+    super.endUse();
   }
 }
diff --git a/src/internal/storeWritable.ts b/src/internal/storeWritable.ts
index 9b0644c..ccd2efb 100644
--- a/src/internal/storeWritable.ts
+++ b/src/internal/storeWritable.ts
@@ -32,6 +32,7 @@ export class RawStoreWritable<T> implements RawStore<T, ProducerConsumerLink<T>>
   equalFn = equal<T>;
   private equalCache: Record<number, boolean> | null = null;
   consumerLinks: ProducerConsumerLink<T>[] = [];
+  wrapper?: any;
 
   newLink(consumer: Consumer): ProducerConsumerLink<T> {
     return {
@@ -102,8 +103,7 @@ export class RawStoreWritable<T> implements RawStore<T, ProducerConsumerLink<T>>
   updateValue(): void {}
 
   protected equal(a: T, b: T): boolean {
-    const equalFn = this.equalFn;
-    return equalFn(a, b);
+    return this.equalFn.call(this.wrapper, a, b);
   }
 
   protected increaseEpoch(): void {
diff --git a/src/internal/untrack.ts b/src/internal/untrack.ts
index be236a0..faa0d45 100644
--- a/src/internal/untrack.ts
+++ b/src/internal/untrack.ts
@@ -2,6 +2,7 @@ import type { BaseLink, RawStore } from './store';
 
 export interface ActiveConsumer {
   addProducer: <T, L extends BaseLink<T>>(store: RawStore<T, L>) => T;
+  wrapper?: any;
 }
 
 export let activeConsumer: ActiveConsumer | null = null;
diff --git a/src/internal/watcher.ts b/src/internal/watcher.ts
new file mode 100644
index 0000000..c401f80
--- /dev/null
+++ b/src/internal/watcher.ts
@@ -0,0 +1,44 @@
+import { updateLinkProducerValue, type BaseLink, type Consumer, type RawStore } from './store';
+
+export class RawWatcher implements Consumer {
+  producerLinks: BaseLink<any>[] = [];
+  dirty = false;
+  wrapper?: any;
+
+  constructor(public notifyFn: () => void) {}
+
+  markDirty(): void {
+    if (!this.dirty) {
+      this.dirty = true;
+      this.notifyFn.call(this.wrapper);
+    }
+  }
+
+  update(): void {
+    try {
+      this.dirty = true;
+      this.producerLinks.forEach(updateLinkProducerValue);
+    } finally {
+      this.dirty = false;
+    }
+  }
+
+  addProducer(producer: RawStore<any>): void {
+    const link = producer.newLink(this);
+    this.producerLinks.push(link);
+    producer.registerConsumer(link);
+  }
+
+  removeProducer(producer: RawStore<any>): void {
+    const producerLinks = this.producerLinks;
+    const index = producerLinks.findIndex((link) => link.producer === producer);
+    if (index > -1) {
+      const link = producerLinks[index];
+      const lastItem = producerLinks.pop()!;
+      if (link !== lastItem) {
+        producerLinks[index] = lastItem;
+      }
+      producer.unregisterConsumer(link);
+    }
+  }
+}
diff --git a/src/wrapper.ts b/src/wrapper.ts
new file mode 100644
index 0000000..5431a17
--- /dev/null
+++ b/src/wrapper.ts
@@ -0,0 +1,252 @@
+/**
+ * @license
+ * Copyright 2024 Bloomberg Finance L.P.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { RawStoreFlags } from './internal/store';
+import { RawStoreComputed } from './internal/storeComputed';
+import { RawStoreTrackingUsage } from './internal/storeTrackingUsage';
+import { RawStoreWritable } from './internal/storeWritable';
+import { activeConsumer, untrack as rawUntrack } from './internal/untrack';
+import { RawWatcher } from './internal/watcher';
+
+const NODE: unique symbol = Symbol('node');
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace Signal {
+  export let isState: (s: any) => boolean,
+    isComputed: (s: any) => boolean,
+    isWatcher: (s: any) => boolean;
+
+  // A read-write Signal
+  export class State<T> {
+    readonly [NODE]: RawStoreWritable<T>;
+    #brand() {}
+
+    static {
+      isState = (s) => #brand in s;
+    }
+
+    constructor(initialValue: T, options: Signal.Options<T> = {}) {
+      let node;
+      const startUseFn = options[Signal.subtle.watched];
+      const endUseFn = options[Signal.subtle.unwatched];
+      if (startUseFn || endUseFn) {
+        node = new RawStoreTrackingUsage(initialValue);
+        node.startUseFn = startUseFn;
+        node.endUseFn = endUseFn;
+        node.flags = RawStoreFlags.HAS_VISIBLE_ONUSE;
+      } else {
+        node = new RawStoreWritable(initialValue);
+      }
+      this[NODE] = node;
+      node.wrapper = this;
+      const equals = options.equals;
+      if (equals) {
+        node.equalFn = equals;
+      }
+    }
+
+    public get(): T {
+      if (!isState(this)) throw new TypeError('Wrong receiver type for Signal.State.prototype.get');
+      return this[NODE].get();
+    }
+
+    public set(newValue: T): void {
+      if (!isState(this)) throw new TypeError('Wrong receiver type for Signal.State.prototype.set');
+      this[NODE].set(newValue);
+    }
+  }
+
+  // A Signal which is a formula based on other Signals
+  export class Computed<T> {
+    readonly [NODE]: RawStoreComputed<T>;
+
+    #brand() {}
+
+    static {
+      isComputed = (c: any) => #brand in c;
+    }
+
+    // Create a Signal which evaluates to the value returned by the callback.
+    // Callback is called with this signal as the parameter.
+    constructor(computation: () => T, options?: Signal.Options<T>) {
+      const node = new RawStoreComputed<T>(computation);
+      this[NODE] = node;
+      node.wrapper = this;
+      if (options) {
+        const equals = options.equals;
+        if (equals) {
+          node.equalFn = equals;
+        }
+        const startUseFn = options[Signal.subtle.watched];
+        const endUseFn = options[Signal.subtle.unwatched];
+        if (startUseFn || endUseFn) {
+          node.startUseFn = startUseFn;
+          node.endUseFn = endUseFn;
+          node.flags = RawStoreFlags.HAS_VISIBLE_ONUSE | RawStoreFlags.COMPUTED_WITH_ONUSE;
+        }
+      }
+    }
+
+    get(): T {
+      if (!isComputed(this))
+        throw new TypeError('Wrong receiver type for Signal.Computed.prototype.get');
+      return this[NODE].get();
+    }
+  }
+
+  type AnySignal<T = any> = State<T> | Computed<T>;
+  type AnySink = Computed<any> | subtle.Watcher;
+
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  export namespace subtle {
+    // Run a callback with all tracking disabled (even for nested computed).
+    export const untrack = rawUntrack;
+
+    // Returns ordered list of all signals which this one referenced
+    // during the last time it was evaluated
+    export function introspectSources(sink: AnySink): AnySignal[] {
+      if (!isComputed(sink) && !isWatcher(sink)) {
+        throw new TypeError('Called introspectSources without a Computed or Watcher argument');
+      }
+      return sink[NODE].producerLinks?.map((n) => n.producer.wrapper) ?? [];
+    }
+
+    // Returns the subset of signal sinks which recursively
+    // lead to an Effect which has not been disposed
+    // Note: Only watched Computed signals will be in this list.
+    export function introspectSinks(signal: AnySignal): AnySink[] {
+      if (!isComputed(signal) && !isState(signal)) {
+        throw new TypeError('Called introspectSinks without a Signal argument');
+      }
+      return (
+        signal[NODE].consumerLinks
+          ?.filter((n) => (n.consumer instanceof RawStoreComputed ? n.consumer.isUsed() : true))
+          .map((n) => n.consumer.wrapper) ?? []
+      );
+    }
+
+    // True iff introspectSinks() is non-empty
+    export function hasSinks(signal: AnySignal): boolean {
+      if (!isComputed(signal) && !isState(signal)) {
+        throw new TypeError('Called hasSinks without a Signal argument');
+      }
+      const liveConsumerNode = signal[NODE].consumerLinks;
+      if (!liveConsumerNode) return false;
+      return liveConsumerNode.some((n) =>
+        n.consumer instanceof RawStoreComputed ? n.consumer.isUsed() : true
+      );
+    }
+
+    // True iff introspectSources() is non-empty
+    export function hasSources(signal: AnySink): boolean {
+      if (!isComputed(signal) && !isWatcher(signal)) {
+        throw new TypeError('Called hasSources without a Computed or Watcher argument');
+      }
+      const producerNode = signal[NODE].producerLinks;
+      if (!producerNode) return false;
+      return producerNode.length > 0;
+    }
+
+    export class Watcher {
+      readonly [NODE]: RawWatcher;
+
+      #brand() {}
+      static {
+        isWatcher = (w: any): w is Watcher => #brand in w;
+      }
+
+      // When a (recursive) source of Watcher is written to, call this callback,
+      // if it hasn't already been called since the last `watch` call.
+      // No signals may be read or written during the notify.
+      constructor(notify: (this: Watcher) => void) {
+        const watcher = new RawWatcher(notify);
+        this[NODE] = watcher;
+        watcher.wrapper = this;
+      }
+
+      #assertSignals(signals: AnySignal[]): void {
+        for (const signal of signals) {
+          if (!isComputed(signal) && !isState(signal)) {
+            throw new TypeError('Called watch/unwatch without a Computed or State argument');
+          }
+        }
+      }
+
+      // Add these signals to the Watcher's set, and set the watcher to run its
+      // notify callback next time any signal in the set (or one of its dependencies) changes.
+      // Can be called with no arguments just to reset the "notified" state, so that
+      // the notify callback will be invoked again.
+      watch(...signals: AnySignal[]): void {
+        if (!isWatcher(this)) {
+          throw new TypeError('Called unwatch without Watcher receiver');
+        }
+        this.#assertSignals(signals);
+
+        const node = this[NODE];
+        for (const signal of signals) {
+          node.addProducer(signal[NODE]);
+        }
+        node.update(); // update signals and mark non-dirty
+      }
+
+      // Remove these signals from the watched set (e.g., for an effect which is disposed)
+      unwatch(...signals: AnySignal[]): void {
+        if (!isWatcher(this)) {
+          throw new TypeError('Called unwatch without Watcher receiver');
+        }
+        this.#assertSignals(signals);
+
+        const node = this[NODE];
+        for (const signal of signals) {
+          node.removeProducer(signal[NODE]);
+        }
+      }
+
+      // Returns the set of computeds in the Watcher's set which are still yet
+      // to be re-evaluated
+      getPending(): Computed<any>[] {
+        if (!isWatcher(this)) {
+          throw new TypeError('Called getPending without Watcher receiver');
+        }
+        const node = this[NODE];
+        return node
+          .producerLinks!.filter((n) => n.producer.flags & RawStoreFlags.DIRTY)
+          .map((n) => n.producer.wrapper);
+      }
+    }
+
+    export function currentComputed(): Computed<any> | undefined {
+      return activeConsumer?.wrapper;
+    }
+
+    // Hooks to observe being watched or no longer watched
+    export const watched = Symbol('watched');
+    export const unwatched = Symbol('unwatched');
+  }
+
+  export interface Options<T> {
+    // Custom comparison function between old and new value. Default: Object.is.
+    // The signal is passed in as an optionally-used third parameter for context.
+    equals?: (this: AnySignal<T>, t: T, t2: T) => boolean;
+
+    // Callback called when hasSinks becomes true, if it was previously false
+    [Signal.subtle.watched]?: (this: AnySignal<T>) => void;
+
+    // Callback called whenever hasSinks becomes false, if it was previously true
+    [Signal.subtle.unwatched]?: (this: AnySignal<T>) => void;
+  }
+}
diff --git a/tests/Signal/computed.test.ts b/tests/Signal/computed.test.ts
new file mode 100644
index 0000000..4048a77
--- /dev/null
+++ b/tests/Signal/computed.test.ts
@@ -0,0 +1,127 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Computed', () => {
+  it('should work', () => {
+    const stateSignal = new Signal.State(1);
+
+    const computedSignal = new Signal.Computed(() => {
+      const f = stateSignal.get() * 2;
+      return f;
+    });
+
+    expect(computedSignal.get()).toEqual(2);
+
+    stateSignal.set(5);
+
+    expect(stateSignal.get()).toEqual(5);
+    expect(computedSignal.get()).toEqual(10);
+  });
+
+  describe('Comparison semantics', () => {
+    it('should track Computed by Object.is', () => {
+      const state = new Signal.State(1);
+      let value = 5;
+      let calls = 0;
+      const computed = new Signal.Computed(() => (state.get(), value));
+      const c2 = new Signal.Computed(() => (calls++, computed.get()));
+
+      expect(calls).toBe(0);
+      expect(c2.get()).toBe(5);
+      expect(calls).toBe(1);
+      state.set(2);
+      expect(c2.get()).toBe(5);
+      expect(calls).toBe(1);
+      value = NaN;
+      expect(c2.get()).toBe(5);
+      expect(calls).toBe(1);
+      state.set(3);
+      expect(c2.get()).toBe(NaN);
+      expect(calls).toBe(2);
+      state.set(4);
+      expect(c2.get()).toBe(NaN);
+      expect(calls).toBe(2);
+    });
+
+    it('applies custom equality in Computed', () => {
+      const s = new Signal.State(5);
+      let ecalls = 0;
+      const c1 = new Signal.Computed(() => (s.get(), 1), {
+        equals() {
+          ecalls++;
+          return false;
+        },
+      });
+      let calls = 0;
+      const c2 = new Signal.Computed(() => {
+        calls++;
+        return c1.get();
+      });
+
+      expect(calls).toBe(0);
+      expect(ecalls).toBe(0);
+
+      expect(c2.get()).toBe(1);
+      expect(ecalls).toBe(0);
+      expect(calls).toBe(1);
+
+      s.set(10);
+      expect(c2.get()).toBe(1);
+      expect(ecalls).toBe(1);
+      expect(calls).toBe(2);
+    });
+  });
+
+  it('should work to change a dependent signal in a computed', () => {
+    const s = new Signal.State(0);
+    const c = new Signal.Computed(() => {
+      const value = s.get();
+      if (value < 10) {
+        s.set(value + 1);
+      }
+      return value;
+    });
+    const d = new Signal.Computed(() => {
+      const value = s.get();
+      if (value < 10) {
+        s.set(value + 1);
+      }
+      return value;
+    });
+    expect(c.get()).toBe(10);
+    expect(d.get()).toBe(10);
+    expect(c.get()).toBe(10);
+    expect(d.get()).toBe(10);
+  });
+
+  it('should not recompute when the dependent values go back to the ones used for last computation', () => {
+    const s = new Signal.State(0);
+    let n = 0;
+    const c = new Signal.Computed(() => (n++, s.get()));
+    expect(n).toBe(0);
+    expect(c.get()).toBe(0);
+    expect(n).toBe(1);
+    s.set(1);
+    expect(n).toBe(1);
+    s.set(0);
+    expect(n).toBe(1);
+    expect(c.get()).toBe(0); // the last time c was computed was with s = 0, no need to recompute
+    expect(n).toBe(1);
+  });
+
+  it('should not recompute when the dependent values go back to the ones used for last computation (with extra computed)', () => {
+    const s = new Signal.State(0);
+    let n = 0;
+    const extra = new Signal.Computed(() => s.get());
+    const c = new Signal.Computed(() => (n++, extra.get()));
+    expect(n).toBe(0);
+    expect(c.get()).toBe(0);
+    expect(n).toBe(1);
+    s.set(1);
+    expect(n).toBe(1);
+    s.set(0);
+    expect(n).toBe(1);
+    expect(c.get()).toBe(0); // the last time c was computed was with s = 0, no need to recompute
+    expect(n).toBe(1);
+  });
+});
diff --git a/tests/Signal/state.test.ts b/tests/Signal/state.test.ts
new file mode 100644
index 0000000..067830a
--- /dev/null
+++ b/tests/Signal/state.test.ts
@@ -0,0 +1,57 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Signal.State', () => {
+  it('should work', () => {
+    const stateSignal = new Signal.State(0);
+    expect(stateSignal.get()).toEqual(0);
+
+    stateSignal.set(10);
+
+    expect(stateSignal.get()).toEqual(10);
+  });
+
+  describe('Comparison semantics', () => {
+    it('should cache State by Object.is', () => {
+      const state = new Signal.State(NaN);
+      let calls = 0;
+      const computed = new Signal.Computed(() => {
+        calls++;
+        return state.get();
+      });
+      expect(calls).toBe(0);
+      expect(computed.get()).toBe(NaN);
+      expect(calls).toBe(1);
+      state.set(NaN);
+      expect(computed.get()).toBe(NaN);
+      expect(calls).toBe(1);
+    });
+
+    it('applies custom equality in State', () => {
+      let ecalls = 0;
+      const state = new Signal.State(1, {
+        equals() {
+          ecalls++;
+          return false;
+        },
+      });
+      let calls = 0;
+      const computed = new Signal.Computed(() => {
+        calls++;
+        return state.get();
+      });
+
+      expect(calls).toBe(0);
+      expect(ecalls).toBe(0);
+
+      expect(computed.get()).toBe(1);
+      expect(ecalls).toBe(0);
+      expect(calls).toBe(1);
+
+      state.set(1);
+      expect(computed.get()).toBe(1);
+      expect(ecalls).toBe(1);
+      expect(calls).toBe(2);
+    });
+  });
+});
diff --git a/tests/Signal/subtle/currentComputed.test.ts b/tests/Signal/subtle/currentComputed.test.ts
new file mode 100644
index 0000000..a21c26d
--- /dev/null
+++ b/tests/Signal/subtle/currentComputed.test.ts
@@ -0,0 +1,12 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../../src/wrapper.js';
+
+describe('currentComputed', () => {
+  it('works', () => {
+    expect(Signal.subtle.currentComputed()).toBe(undefined);
+    let context;
+    let c = new Signal.Computed(() => (context = Signal.subtle.currentComputed()));
+    c.get();
+    expect(c).toBe(context);
+  });
+});
diff --git a/tests/Signal/subtle/untrack.test.ts b/tests/Signal/subtle/untrack.test.ts
new file mode 100644
index 0000000..5e06be7
--- /dev/null
+++ b/tests/Signal/subtle/untrack.test.ts
@@ -0,0 +1,20 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../../src/wrapper.js';
+
+describe('Untrack', () => {
+  it('works', () => {
+    const state = new Signal.State(1);
+    const computed = new Signal.Computed(() => Signal.subtle.untrack(() => state.get()));
+    expect(computed.get()).toBe(1);
+    state.set(2);
+    expect(computed.get()).toBe(1);
+  });
+
+  it('works differently without untrack', () => {
+    const state = new Signal.State(1);
+    const computed = new Signal.Computed(() => state.get());
+    expect(computed.get()).toBe(1);
+    state.set(2);
+    expect(computed.get()).toBe(2);
+  });
+});
diff --git a/tests/Signal/subtle/watch-unwatch.test.ts b/tests/Signal/subtle/watch-unwatch.test.ts
new file mode 100644
index 0000000..a633c26
--- /dev/null
+++ b/tests/Signal/subtle/watch-unwatch.test.ts
@@ -0,0 +1,192 @@
+import {describe, expect, it, vi} from 'vitest';
+import {Signal} from '../../../src/wrapper.js';
+
+describe('watch and unwatch', () => {
+  it('handles multiple watchers well', () => {
+    const s = new Signal.State(1);
+    const s2 = new Signal.State(2);
+    let n = 0;
+    const w = new Signal.subtle.Watcher(() => n++);
+    w.watch(s, s2);
+
+    s.set(4);
+    expect(n).toBe(1);
+    expect(w.getPending()).toStrictEqual([]);
+
+    w.watch();
+    s2.set(8);
+    expect(n).toBe(2);
+
+    w.unwatch(s);
+    s.set(3);
+    expect(n).toBe(2);
+
+    w.watch();
+    s2.set(3);
+    expect(n).toBe(3);
+
+    w.watch();
+    s.set(2);
+    expect(n).toBe(3);
+  });
+  it('understands dynamic dependency sets', () => {
+    let w1 = 0,
+      u1 = 0,
+      w2 = 0,
+      u2 = 0,
+      n = 0,
+      d = 0;
+    let s1 = new Signal.State(1, {
+      [Signal.subtle.watched]() {
+        w1++;
+      },
+      [Signal.subtle.unwatched]() {
+        u1++;
+      },
+    });
+    let s2 = new Signal.State(2, {
+      [Signal.subtle.watched]() {
+        w2++;
+      },
+      [Signal.subtle.unwatched]() {
+        u2++;
+      },
+    });
+    let which: {get(): number} = s1;
+    let c = new Signal.Computed(() => (d++, which.get()));
+    let w = new Signal.subtle.Watcher(() => n++);
+
+    expect(w1 + w2 + u1 + u2 + n + d).toBe(0);
+    expect(Signal.subtle.hasSinks(s1)).toBe(false);
+    expect(Signal.subtle.hasSinks(s2)).toBe(false);
+    w.watch(c); // watch triggers the evaluation of c
+
+    expect(c.get()).toBe(1);
+    expect(w1).toBe(1);
+    expect(u1).toBe(0);
+    expect(w2).toBe(0);
+    expect(u2).toBe(0);
+    expect(n).toBe(0);
+    expect(Signal.subtle.hasSinks(s1)).toBe(true);
+    expect(Signal.subtle.hasSinks(s2)).toBe(false);
+    expect(w.getPending()).toStrictEqual([]);
+    expect(d).toBe(1);
+
+    s1.set(3);
+    expect(w1).toBe(1);
+    expect(u1).toBe(0);
+    expect(w2).toBe(0);
+    expect(u2).toBe(0);
+    expect(n).toBe(1);
+    expect(Signal.subtle.hasSinks(s1)).toBe(true);
+    expect(Signal.subtle.hasSinks(s2)).toBe(false);
+    expect(w.getPending()).toStrictEqual([c]);
+    expect(d).toBe(1);
+
+    expect(c.get()).toBe(3);
+    expect(w1).toBe(1);
+    expect(u1).toBe(0);
+    expect(w2).toBe(0);
+    expect(u2).toBe(0);
+    expect(n).toBe(1);
+    expect(Signal.subtle.hasSinks(s1)).toBe(true);
+    expect(Signal.subtle.hasSinks(s2)).toBe(false);
+    expect(w.getPending()).toStrictEqual([]);
+    expect(d).toBe(2);
+
+    which = s2;
+    w.watch();
+    s1.set(4);
+    expect(w1).toBe(1);
+    expect(u1).toBe(0);
+    expect(w2).toBe(0);
+    expect(u2).toBe(0);
+    expect(n).toBe(2);
+    expect(Signal.subtle.hasSinks(s1)).toBe(true);
+    expect(Signal.subtle.hasSinks(s2)).toBe(false);
+    expect(w.getPending()).toStrictEqual([c]);
+    expect(d).toBe(2);
+
+    expect(c.get()).toBe(2);
+    expect(w1).toBe(1);
+    expect(u1).toBe(1);
+    expect(w2).toBe(1);
+    expect(u2).toBe(0);
+    expect(n).toBe(2);
+    expect(Signal.subtle.hasSinks(s1)).toBe(false);
+    expect(Signal.subtle.hasSinks(s2)).toBe(true);
+    expect(w.getPending()).toStrictEqual([]);
+    expect(d).toBe(3);
+
+    w.watch();
+    which = {
+      get() {
+        return 10;
+      },
+    };
+    s1.set(5);
+    expect(c.get()).toBe(2);
+    expect(w1).toBe(1);
+    expect(u1).toBe(1);
+    expect(w2).toBe(1);
+    expect(u2).toBe(0);
+    expect(n).toBe(2);
+    expect(Signal.subtle.hasSinks(s1)).toBe(false);
+    expect(Signal.subtle.hasSinks(s2)).toBe(true);
+    expect(w.getPending()).toStrictEqual([]);
+    expect(d).toBe(3);
+
+    w.watch();
+    s2.set(0);
+    expect(w1).toBe(1);
+    expect(u1).toBe(1);
+    expect(w2).toBe(1);
+    expect(u2).toBe(0);
+    expect(n).toBe(3);
+    expect(Signal.subtle.hasSinks(s1)).toBe(false);
+    expect(Signal.subtle.hasSinks(s2)).toBe(true);
+    expect(w.getPending()).toStrictEqual([c]);
+    expect(d).toBe(3);
+
+    expect(c.get()).toBe(10);
+    expect(w1).toBe(1);
+    expect(u1).toBe(1);
+    expect(w2).toBe(1);
+    expect(u2).toBe(1);
+    expect(n).toBe(3);
+    expect(Signal.subtle.hasSinks(s1)).toBe(false);
+    expect(Signal.subtle.hasSinks(s2)).toBe(false);
+    expect(w.getPending()).toStrictEqual([]);
+    expect(d).toBe(4);
+  });
+  it('can unwatch multiple signals', async () => {
+    const signals = [...Array(7)].map((_, i) => new Signal.State(i));
+    const notify = vi.fn();
+    const watcher = new Signal.subtle.Watcher(notify);
+    const expectSources = (expected: typeof signals) => {
+      const sources = Signal.subtle.introspectSources(watcher) as typeof signals;
+      sources.sort((a, b) => signals.indexOf(a) - signals.indexOf(b));
+      expected.sort((a, b) => signals.indexOf(a) - signals.indexOf(b));
+      return expect(sources).toEqual(expected);
+    };
+
+    watcher.watch(...signals);
+    expectSources(signals);
+
+    const unwatched = [0, 3, 4, 6].map((i) => signals[i]);
+    const watched = signals.filter((s) => !unwatched.includes(s));
+
+    watcher.unwatch(...unwatched);
+    expectSources(watched);
+
+    let expectedNotifyCalls = 0;
+    for (const signal of signals) {
+      signal.set(signal.get() + 1);
+      if (watched.includes(signal)) ++expectedNotifyCalls;
+
+      expect(notify).toHaveBeenCalledTimes(expectedNotifyCalls);
+
+      watcher.watch();
+    }
+  });
+});
diff --git a/tests/Signal/subtle/watcher.test.ts b/tests/Signal/subtle/watcher.test.ts
new file mode 100644
index 0000000..8eada4f
--- /dev/null
+++ b/tests/Signal/subtle/watcher.test.ts
@@ -0,0 +1,193 @@
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import {Signal} from '../../../src/wrapper.js';
+
+describe('Watcher', () => {
+  type Destructor = () => void;
+  const notifySpy = vi.fn();
+
+  const watcher = new Signal.subtle.Watcher(() => {
+    notifySpy();
+  });
+
+  function effect(cb: () => Destructor | void): () => void {
+    let destructor: Destructor | void;
+    const c = new Signal.Computed(() => (destructor = cb()));
+    watcher.watch(c);
+    c.get();
+    return () => {
+      destructor?.();
+      watcher.unwatch(c);
+    };
+  }
+
+  function flushPending() {
+    for (const signal of watcher.getPending()) {
+      signal.get();
+    }
+    expect(watcher.getPending()).toStrictEqual([]);
+  }
+
+  afterEach(() => watcher.unwatch(...Signal.subtle.introspectSources(watcher)));
+
+  it('should work', () => {
+    const watchedSpy = vi.fn();
+    const unwatchedSpy = vi.fn();
+    const stateSignal = new Signal.State(1, {
+      [Signal.subtle.watched]: watchedSpy,
+      [Signal.subtle.unwatched]: unwatchedSpy,
+    });
+
+    stateSignal.set(100);
+    stateSignal.set(5);
+
+    const computedSignal = new Signal.Computed(() => stateSignal.get() * 2);
+
+    let calls = 0;
+    let output = 0;
+    let computedOutput = 0;
+
+    // Ensure the call backs are not called yet
+    expect(watchedSpy).not.toHaveBeenCalled();
+    expect(unwatchedSpy).not.toHaveBeenCalled();
+
+    // Expect the watcher to not have any sources as nothing has been connected yet
+    expect(Signal.subtle.introspectSources(watcher)).toHaveLength(0);
+    expect(Signal.subtle.introspectSinks(computedSignal)).toHaveLength(0);
+    expect(Signal.subtle.introspectSinks(stateSignal)).toHaveLength(0);
+
+    expect(Signal.subtle.hasSinks(stateSignal)).toEqual(false);
+
+    const destructor = effect(() => {
+      output = stateSignal.get();
+      computedOutput = computedSignal.get();
+      calls++;
+      return () => {};
+    });
+
+    // The signal is now watched
+    expect(Signal.subtle.hasSinks(stateSignal)).toEqual(true);
+
+    // Now that the effect is created, there will be a source
+    expect(Signal.subtle.introspectSources(watcher)).toHaveLength(1);
+    expect(Signal.subtle.introspectSinks(computedSignal)).toHaveLength(1);
+
+    // Note: stateSignal has more sinks because one is for the computed signal and one is the effect.
+    expect(Signal.subtle.introspectSinks(stateSignal)).toHaveLength(2);
+
+    // Now the watched callback should be called
+    expect(watchedSpy).toHaveBeenCalled();
+    expect(unwatchedSpy).not.toHaveBeenCalled();
+
+    // It should not have notified yet
+    expect(notifySpy).not.toHaveBeenCalled();
+
+    stateSignal.set(10);
+
+    // After a signal has been set, it should notify
+    expect(notifySpy).toHaveBeenCalled();
+
+    // Initially, the effect should not have run
+    expect(calls).toEqual(1);
+    expect(output).toEqual(5);
+    expect(computedOutput).toEqual(10);
+
+    flushPending();
+
+    // The effect should run, and thus increment the value
+    expect(calls).toEqual(2);
+    expect(output).toEqual(10);
+    expect(computedOutput).toEqual(20);
+
+    // Kicking it off again, the effect should run again
+    watcher.watch();
+    stateSignal.set(20);
+    expect(watcher.getPending()).toHaveLength(1);
+    flushPending();
+
+    // After a signal has been set, it should notify again
+    expect(notifySpy).toHaveBeenCalledTimes(2);
+
+    expect(calls).toEqual(3);
+    expect(output).toEqual(20);
+    expect(computedOutput).toEqual(40);
+
+    Signal.subtle.untrack(() => {
+      // Untrack doesn't affect set, only get
+      stateSignal.set(999);
+      expect(calls).toEqual(3);
+      flushPending();
+      expect(calls).toEqual(4);
+    });
+
+    // Destroy and un-subscribe
+    destructor();
+
+    // Since now it is un-subscribed, it should now be called
+    expect(unwatchedSpy).toHaveBeenCalled();
+    // We can confirm that it is un-watched by checking it
+    expect(Signal.subtle.hasSinks(stateSignal)).toEqual(false);
+
+    // Since now it is un-subscribed, this should have no effect now
+    stateSignal.set(200);
+    flushPending();
+
+    // Make sure that effect is no longer running
+    // Everything should stay the same
+    expect(calls).toEqual(4);
+    expect(output).toEqual(999);
+    expect(computedOutput).toEqual(1998);
+
+    expect(watcher.getPending()).toHaveLength(0);
+
+    // Adding any other effect after an unwatch should work as expected
+    const destructor2 = effect(() => {
+      output = stateSignal.get();
+      return () => {};
+    });
+
+    stateSignal.set(300);
+    flushPending();
+  });
+
+  it('provides `this` to notify as normal function', () => {
+    const mockGetPending = vi.fn();
+
+    const watcher = new Signal.subtle.Watcher(function () {
+      this.getPending();
+    });
+    watcher.getPending = mockGetPending;
+
+    const signal = new Signal.State<number>(0);
+    watcher.watch(signal);
+
+    signal.set(1);
+    expect(mockGetPending).toBeCalled();
+  });
+
+  it('can be closed in if needed in notify as an arrow function', () => {
+    const mockGetPending = vi.fn();
+
+    const watcher = new Signal.subtle.Watcher(() => {
+      watcher.getPending();
+    });
+    watcher.getPending = mockGetPending;
+
+    const signal = new Signal.State<number>(0);
+    watcher.watch(signal);
+
+    signal.set(1);
+    expect(mockGetPending).toBeCalled();
+  });
+
+  it('should not break a computed signal to watch it before getting its value', () => {
+    const signal = new Signal.State(0);
+    const computedSignal = new Signal.Computed(() => signal.get());
+    const watcher = new Signal.subtle.Watcher(() => {});
+    expect(computedSignal.get()).toBe(0);
+    signal.set(1);
+    watcher.watch(computedSignal);
+    expect(computedSignal.get()).toBe(1);
+    watcher.unwatch(computedSignal);
+    expect(computedSignal.get()).toBe(1);
+  });
+});
diff --git a/tests/behaviors/custom-equality.test.ts b/tests/behaviors/custom-equality.test.ts
new file mode 100644
index 0000000..3ccd5a0
--- /dev/null
+++ b/tests/behaviors/custom-equality.test.ts
@@ -0,0 +1,147 @@
+import {describe, expect, it, vi} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Custom equality', () => {
+  it('works for State', () => {
+    let answer = true;
+    const s = new Signal.State(1, {
+      equals() {
+        return answer;
+      },
+    });
+    let n = 0;
+    const c = new Signal.Computed(() => (n++, s.get()));
+
+    expect(c.get()).toBe(1);
+    expect(n).toBe(1);
+
+    s.set(2);
+    expect(s.get()).toBe(1);
+    expect(c.get()).toBe(1);
+    expect(n).toBe(1);
+
+    answer = false;
+    s.set(2);
+    expect(s.get()).toBe(2);
+    expect(c.get()).toBe(2);
+    expect(n).toBe(2);
+
+    s.set(2);
+    expect(s.get()).toBe(2);
+    expect(c.get()).toBe(2);
+    expect(n).toBe(3);
+  });
+  it('works for Computed', () => {
+    let answer = true;
+    let value = 1;
+    const u = new Signal.State(1);
+    const s = new Signal.Computed(() => (u.get(), value), {
+      equals() {
+        return answer;
+      },
+    });
+    let n = 0;
+    const c = new Signal.Computed(() => (n++, s.get()));
+
+    expect(c.get()).toBe(1);
+    expect(n).toBe(1);
+
+    u.set(2);
+    value = 2;
+    expect(s.get()).toBe(1);
+    expect(c.get()).toBe(1);
+    expect(n).toBe(1);
+
+    answer = false;
+    u.set(3);
+    expect(s.get()).toBe(2);
+    expect(c.get()).toBe(2);
+    expect(n).toBe(2);
+
+    u.set(4);
+    expect(s.get()).toBe(2);
+    expect(c.get()).toBe(2);
+    expect(n).toBe(3);
+  });
+  // FIXME: the validity of this test is questionable
+  // why should a computed signal be recomputed if the equality function depends on a signal that changed?
+  it.skip('does not leak tracking information', () => {
+    const exact = new Signal.State(1);
+    const epsilon = new Signal.State(0.1);
+    const counter = new Signal.State(1);
+
+    const cutoff = vi.fn((a, b) => Math.abs(a - b) < epsilon.get());
+    const innerFn = vi.fn(() => exact.get());
+    const inner = new Signal.Computed(innerFn, {
+      equals: cutoff,
+    });
+
+    const outerFn = vi.fn(() => {
+      counter.get();
+      return inner.get();
+    });
+    const outer = new Signal.Computed(outerFn);
+
+    outer.get();
+
+    // Everything runs the first time.
+    expect(innerFn).toBeCalledTimes(1);
+    expect(outerFn).toBeCalledTimes(1);
+
+    exact.set(2);
+    counter.set(2);
+    outer.get();
+
+    // `outer` reruns because `counter` changed, `inner` reruns when called by
+    // `outer`, and `cutoff` is called for the first time.
+    expect(innerFn).toBeCalledTimes(2);
+    expect(outerFn).toBeCalledTimes(2);
+    expect(cutoff).toBeCalledTimes(1);
+
+    epsilon.set(0.2);
+    outer.get();
+
+    // Changing something `cutoff` depends on makes `inner` need to rerun, but
+    // (since the new and old values are equal) not `outer`.
+    expect(innerFn).toBeCalledTimes(3);
+    expect(outerFn).toBeCalledTimes(2);
+    expect(cutoff).toBeCalledTimes(2);
+  });
+
+  it('should not call equal multiple times for the same comparison', () => {
+    let equalCalls: [number, number][] = [];
+    const equals = (a: number, b: number) => {
+      equalCalls.push([a, b]);
+      return a === b;
+    };
+    const s = new Signal.State<number>(0, {equals});
+    let n1 = 0;
+    let n2 = 0;
+    const c1 = new Signal.Computed(() => (n1++, s.get()));
+    const c2 = new Signal.Computed(() => (n2++, s.get()));
+    expect(equalCalls).toEqual([]);
+    expect(n1).toBe(0);
+    expect(c1.get()).toBe(0);
+    expect(n1).toBe(1);
+    expect(n2).toBe(0);
+    expect(c2.get()).toBe(0);
+    expect(n2).toBe(1);
+    s.set(1);
+    expect(equalCalls).toEqual([[0, 1]]);
+    equalCalls = [];
+    expect(n1).toBe(1);
+    expect(n2).toBe(1);
+    s.set(0);
+    expect(equalCalls).toEqual([[1, 0]]);
+    equalCalls = [];
+    expect(n1).toBe(1);
+    expect(n2).toBe(1);
+    expect(c1.get()).toBe(0); // the last time c1 was computed was with s = 0, no need to recompute
+    expect(equalCalls).toEqual([[0, 0]]); // equal should have been called
+    equalCalls = [];
+    expect(c2.get()).toBe(0); // the last time c2 was computed was with s = 0, no need to recompute
+    expect(equalCalls).toEqual([]); // equal should not have been called again
+    expect(n1).toBe(1);
+    expect(n2).toBe(1);
+  });
+});
diff --git a/tests/behaviors/cycles.test.ts b/tests/behaviors/cycles.test.ts
new file mode 100644
index 0000000..5ebb7a4
--- /dev/null
+++ b/tests/behaviors/cycles.test.ts
@@ -0,0 +1,16 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Cycles', () => {
+  it('detects trivial cycles', () => {
+    const c = new Signal.Computed(() => c.get());
+    expect(() => c.get()).toThrow();
+  });
+
+  it('detects slightly larger cycles', () => {
+    const c = new Signal.Computed(() => c2.get());
+    const c2 = new Signal.Computed(() => c.get());
+    const c3 = new Signal.Computed(() => c2.get());
+    expect(() => c3.get()).toThrow();
+  });
+});
diff --git a/tests/behaviors/dynamic-dependencies.test.ts b/tests/behaviors/dynamic-dependencies.test.ts
new file mode 100644
index 0000000..fbe404e
--- /dev/null
+++ b/tests/behaviors/dynamic-dependencies.test.ts
@@ -0,0 +1,30 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Dynamic dependencies', () => {
+  function run(live) {
+    const states = Array.from('abcdefgh').map((s) => new Signal.State(s));
+    const sources = new Signal.State(states);
+    const computed = new Signal.Computed(() => {
+      let str = '';
+      for (const state of sources.get()) str += state.get();
+      return str;
+    });
+    if (live) {
+      const w = new Signal.subtle.Watcher(() => {});
+      w.watch(computed);
+    }
+    expect(computed.get()).toBe('abcdefgh');
+    expect(Signal.subtle.introspectSources(computed).slice(1)).toStrictEqual(states);
+
+    sources.set(states.slice(0, 5));
+    expect(computed.get()).toBe('abcde');
+    expect(Signal.subtle.introspectSources(computed).slice(1)).toStrictEqual(states.slice(0, 5));
+
+    sources.set(states.slice(3));
+    expect(computed.get()).toBe('defgh');
+    expect(Signal.subtle.introspectSources(computed).slice(1)).toStrictEqual(states.slice(3));
+  }
+  it('works live', () => run(true));
+  it('works not live', () => run(false));
+});
diff --git a/tests/behaviors/errors.test.ts b/tests/behaviors/errors.test.ts
new file mode 100644
index 0000000..4fb58f4
--- /dev/null
+++ b/tests/behaviors/errors.test.ts
@@ -0,0 +1,78 @@
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Errors', () => {
+  it('are cached by computed signals', () => {
+    const s = new Signal.State('first');
+    let n = 0;
+    const c = new Signal.Computed(() => {
+      n++;
+      throw s.get();
+    });
+    let n2 = 0;
+    const c2 = new Signal.Computed(() => {
+      n2++;
+      return c.get();
+    });
+    expect(n).toBe(0);
+    expect(() => c.get()).toThrowError('first');
+    expect(() => c2.get()).toThrowError('first');
+    expect(n).toBe(1);
+    expect(n2).toBe(1);
+    expect(() => c.get()).toThrowError('first');
+    expect(() => c2.get()).toThrowError('first');
+    expect(n).toBe(1);
+    expect(n2).toBe(1);
+    s.set('second');
+    expect(() => c.get()).toThrowError('second');
+    expect(() => c2.get()).toThrowError('second');
+    expect(n).toBe(2);
+    expect(n2).toBe(2);
+
+    // Doesn't retrigger on setting state to the same value
+    s.set('second');
+    expect(n).toBe(2);
+  });
+  it('are cached by computed signals when watched', () => {
+    const s = new Signal.State('first');
+    let n = 0;
+    const c = new Signal.Computed<unknown>(() => {
+      n++;
+      throw s.get();
+    });
+    const w = new Signal.subtle.Watcher(() => {});
+
+    expect(n).toBe(0);
+    w.watch(c); // watch triggers the evaluation of c
+    expect(n).toBe(1);
+    expect(() => c.get()).toThrowError('first');
+    expect(n).toBe(1);
+    expect(() => c.get()).toThrowError('first');
+    expect(n).toBe(1);
+    s.set('second');
+    expect(() => c.get()).toThrowError('second');
+    expect(n).toBe(2);
+
+    s.set('second');
+    expect(n).toBe(2);
+  });
+  // FIXME: equals should not throw, but if it does, why should it be cached as the value of the computed?
+  it.skip('are cached by computed signals when equals throws', () => {
+    const s = new Signal.State(0);
+    const cSpy = vi.fn(() => s.get());
+    const c = new Signal.Computed(cSpy, {
+      equals() {
+        throw new Error('equals');
+      },
+    });
+
+    c.get();
+    s.set(1);
+
+    // Error is cached; c throws again without needing to rerun.
+    expect(() => c.get()).toThrowError('equals');
+    expect(cSpy).toBeCalledTimes(2);
+    expect(() => c.get()).toThrowError('equals');
+    expect(cSpy).toBeCalledTimes(2);
+  });
+});
diff --git a/tests/behaviors/liveness.test.ts b/tests/behaviors/liveness.test.ts
new file mode 100644
index 0000000..d13ad7d
--- /dev/null
+++ b/tests/behaviors/liveness.test.ts
@@ -0,0 +1,111 @@
+import {describe, expect, it, vi} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('liveness', () => {
+  it('only changes on first and last descendant', () => {
+    const watchedSpy = vi.fn();
+    const unwatchedSpy = vi.fn();
+    const state = new Signal.State(1, {
+      [Signal.subtle.watched]: watchedSpy,
+      [Signal.subtle.unwatched]: unwatchedSpy,
+    });
+    const computed = new Signal.Computed(() => state.get());
+    computed.get(); // reading a computed is considered watching and unwatching it
+    expect(watchedSpy).toHaveBeenCalledTimes(1);
+    expect(unwatchedSpy).toHaveBeenCalledTimes(1);
+    watchedSpy.mockClear();
+    unwatchedSpy.mockClear();
+
+    const w = new Signal.subtle.Watcher(() => {});
+    const w2 = new Signal.subtle.Watcher(() => {});
+
+    w.watch(computed);
+    expect(watchedSpy).toBeCalledTimes(1);
+    expect(unwatchedSpy).not.toBeCalled();
+
+    w2.watch(computed);
+    expect(watchedSpy).toBeCalledTimes(1);
+    expect(unwatchedSpy).not.toBeCalled();
+
+    w2.unwatch(computed);
+    expect(watchedSpy).toBeCalledTimes(1);
+    expect(unwatchedSpy).not.toBeCalled();
+
+    w.unwatch(computed);
+    expect(watchedSpy).toBeCalledTimes(1);
+    expect(unwatchedSpy).toBeCalledTimes(1);
+  });
+
+  it('is tracked well on computed signals', () => {
+    const watchedSpy = vi.fn();
+    const unwatchedSpy = vi.fn();
+    const s = new Signal.State(1);
+    const c = new Signal.Computed(() => s.get(), {
+      [Signal.subtle.watched]: watchedSpy,
+      [Signal.subtle.unwatched]: unwatchedSpy,
+    });
+
+    c.get(); // reading a computed is considered watching and unwatching it
+    expect(watchedSpy).toHaveBeenCalledTimes(1);
+    expect(unwatchedSpy).toHaveBeenCalledTimes(1);
+    watchedSpy.mockClear();
+    unwatchedSpy.mockClear();
+
+    const w = new Signal.subtle.Watcher(() => {});
+    w.watch(c);
+    expect(watchedSpy).toBeCalledTimes(1);
+    expect(unwatchedSpy).not.toBeCalled();
+
+    w.unwatch(c);
+    expect(watchedSpy).toBeCalledTimes(1);
+    expect(unwatchedSpy).toBeCalledTimes(1);
+  });
+
+  it('is possible to update a signal in the watch callback', () => {
+    const logs: string[] = [];
+    let indent = '';
+    const logFn = (msg: string) => () => {
+      logs.push(`${indent}${msg}`);
+    };
+    const wrapFn =
+      <T>(logMsg: string, fn: () => T) =>
+      (): T => {
+        logs.push(`${indent}start ${logMsg}`);
+        const prevIndent = indent;
+        indent += '  ';
+        const res = fn();
+        indent = prevIndent;
+        logs.push(`${indent}end ${logMsg} returning ${res}`);
+        return res;
+      };
+    const wrapComputed = <T>(logMsg: string, fn: () => T) =>
+      new Signal.Computed(wrapFn(`${logMsg} computing`, fn), {
+        [Signal.subtle.watched]: logFn(`${logMsg} watched`),
+        [Signal.subtle.unwatched]: logFn(`${logMsg} unwatched`),
+      });
+    let counter = 0;
+    const signal = new Signal.State(0, {
+      [Signal.subtle.watched]: wrapFn('signal watched', () => {
+        counter++;
+        const value = counter;
+        logs.push(`${indent}signal.set(${value})`);
+        signal.set(value);
+      }),
+      [Signal.subtle.unwatched]: logFn('signal unwatched'),
+    });
+    const dep1 = wrapComputed('dep1', () => `${signal.get()},${signal.get()}`);
+    const dep2 = wrapComputed('dep2', () => `${signal.get()},${signal.get()}`);
+    const dep3 = wrapComputed('result', () => `${dep1.get()},${dep2.get()}`);
+
+    expect(wrapFn('signal.get 1', () => signal.get())()).toBe(1);
+    expect(wrapFn('signal.get 2', () => signal.get())()).toBe(2);
+    expect(wrapFn('dep1.get', () => dep1.get())()).toBe('3,3');
+    expect(wrapFn('dep1.get', () => dep1.get())()).toBe('4,4');
+    expect(wrapFn('dep2.get', () => dep2.get())()).toBe('5,5');
+    expect(wrapFn('dep2.get', () => dep2.get())()).toBe('6,6');
+    expect(wrapFn('dep3.get', () => dep3.get())()).toBe('7,7,7,7');
+    expect(wrapFn('dep3.get', () => dep3.get())()).toBe('8,8,8,8');
+    console.log(logs);
+    // expect(logs).toMatchInlineSnapshot();
+  });
+});
diff --git a/tests/behaviors/prohibited-contexts.test.ts b/tests/behaviors/prohibited-contexts.test.ts
new file mode 100644
index 0000000..961b60e
--- /dev/null
+++ b/tests/behaviors/prohibited-contexts.test.ts
@@ -0,0 +1,39 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Prohibited contexts', () => {
+  it('allows writes during computed', () => {
+    const s = new Signal.State(1);
+    const c = new Signal.Computed(() => (Signal.subtle.untrack(() => s.set(s.get() + 1)), s.get()));
+    expect(c.get()).toBe(2);
+    expect(s.get()).toBe(2);
+
+    // Note: c is marked clean in this case, even though re-evaluating it
+    // would cause it to change value (due to the set inside of it).
+    expect(c.get()).toBe(2);
+    expect(s.get()).toBe(2);
+
+    s.set(3);
+
+    expect(c.get()).toBe(4);
+    expect(s.get()).toBe(4);
+  });
+  it('disallows reads and writes during watcher notify', () => {
+    const s = new Signal.State(1);
+    const w = new Signal.subtle.Watcher(() => {
+      s.get();
+    });
+    w.watch(s);
+    expect(() => s.set(2)).toThrow();
+    w.unwatch(s);
+    expect(() => s.set(3)).not.toThrow();
+
+    const w2 = new Signal.subtle.Watcher(() => {
+      s.set(4);
+    });
+    w2.watch(s);
+    expect(() => s.set(5)).toThrow();
+    w2.unwatch(s);
+    expect(() => s.set(3)).not.toThrow();
+  });
+});
diff --git a/tests/behaviors/pruning.test.ts b/tests/behaviors/pruning.test.ts
new file mode 100644
index 0000000..342c658
--- /dev/null
+++ b/tests/behaviors/pruning.test.ts
@@ -0,0 +1,67 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Pruning', () => {
+  it('only recalculates until things are equal', () => {
+    const s = new Signal.State(0);
+    let n = 0;
+    const c = new Signal.Computed(() => (n++, s.get()));
+    let n2 = 0;
+    const c2 = new Signal.Computed(() => (n2++, c.get(), 5));
+    let n3 = 0;
+    const c3 = new Signal.Computed(() => (n3++, c2.get()));
+
+    expect(n).toBe(0);
+    expect(n2).toBe(0);
+    expect(n3).toBe(0);
+
+    expect(c3.get()).toBe(5);
+    expect(n).toBe(1);
+    expect(n2).toBe(1);
+    expect(n3).toBe(1);
+
+    s.set(1);
+    expect(n).toBe(1);
+    expect(n2).toBe(1);
+    expect(n3).toBe(1);
+
+    expect(c3.get()).toBe(5);
+    expect(n).toBe(2);
+    expect(n2).toBe(2);
+    expect(n3).toBe(1);
+  });
+  it('does similar pruning for live signals', () => {
+    const s = new Signal.State(0);
+    let n = 0;
+    const c = new Signal.Computed(() => (n++, s.get()));
+    let n2 = 0;
+    const c2 = new Signal.Computed(() => (n2++, c.get(), 5));
+    let n3 = 0;
+    const c3 = new Signal.Computed(() => (n3++, c2.get()));
+    const w = new Signal.subtle.Watcher(() => {});
+
+    w.watch(c3); // watch triggers the evaluation of c3
+    expect(n).toBe(1);
+    expect(n2).toBe(1);
+    expect(n3).toBe(1);
+
+    expect(c3.get()).toBe(5);
+    expect(n).toBe(1);
+    expect(n2).toBe(1);
+    expect(n3).toBe(1);
+
+    s.set(1);
+    expect(n).toBe(1);
+    expect(n2).toBe(1);
+    expect(n3).toBe(1);
+
+    expect(w.getPending().length).toBe(1);
+
+    expect(c3.get()).toBe(5);
+    expect(n).toBe(2);
+    expect(n2).toBe(2);
+    expect(n3).toBe(1);
+
+    expect(w.getPending().length).toBe(0);
+  });
+});
diff --git a/tests/behaviors/receivers.test.ts b/tests/behaviors/receivers.test.ts
new file mode 100644
index 0000000..abd6683
--- /dev/null
+++ b/tests/behaviors/receivers.test.ts
@@ -0,0 +1,50 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Receivers', () => {
+  it('is this for computed', () => {
+    let receiver;
+    const c = new Signal.Computed(function () {
+      receiver = this;
+    });
+    expect(c.get()).toBe(undefined);
+    expect(receiver).toBe(c);
+  });
+  it('is this for watched/unwatched', () => {
+    let r1, r2;
+    const s = new Signal.State(1, {
+      [Signal.subtle.watched]() {
+        r1 = this;
+      },
+      [Signal.subtle.unwatched]() {
+        r2 = this;
+      },
+    });
+    expect(r1).toBe(undefined);
+    expect(r2).toBe(undefined);
+    const w = new Signal.subtle.Watcher(() => {});
+    w.watch(s);
+    expect(r1).toBe(s);
+    expect(r2).toBe(undefined);
+    w.unwatch(s);
+    expect(r2).toBe(s);
+  });
+  it('is this for equals', () => {
+    let receiver;
+    const options = {
+      equals() {
+        receiver = this;
+        return false;
+      },
+    };
+    const s = new Signal.State(1, options);
+    s.set(2);
+    expect(receiver).toBe(s);
+
+    const c = new Signal.Computed(() => s.get(), options);
+    expect(c.get()).toBe(2);
+    s.set(4);
+    expect(c.get()).toBe(4);
+    expect(receiver).toBe(c);
+  });
+});
diff --git a/tests/behaviors/type-checking.test.ts b/tests/behaviors/type-checking.test.ts
new file mode 100644
index 0000000..b66fefd
--- /dev/null
+++ b/tests/behaviors/type-checking.test.ts
@@ -0,0 +1,75 @@
+import {describe, expect, it} from 'vitest';
+import {Signal} from '../../src/wrapper.js';
+
+describe('Expected class shape', () => {
+  it('should be on the prototype', () => {
+    expect(typeof Signal.State.prototype.get).toBe('function');
+    expect(typeof Signal.State.prototype.set).toBe('function');
+    expect(typeof Signal.Computed.prototype.get).toBe('function');
+    expect(typeof Signal.subtle.Watcher.prototype.watch).toBe('function');
+    expect(typeof Signal.subtle.Watcher.prototype.unwatch).toBe('function');
+    expect(typeof Signal.subtle.Watcher.prototype.getPending).toBe('function');
+  });
+});
+
+describe('type checks', () => {
+  it('checks types in methods', () => {
+    let x = {};
+    let s = new Signal.State(1);
+    let c = new Signal.Computed(() => {});
+    let w = new Signal.subtle.Watcher(() => {});
+
+    expect(() => Signal.State.prototype.get.call(x)).toThrowError(TypeError);
+    expect(Signal.State.prototype.get.call(s)).toBe(1);
+    expect(() => Signal.State.prototype.get.call(c)).toThrowError(TypeError);
+    expect(() => Signal.State.prototype.get.call(w)).toThrowError(TypeError);
+
+    expect(() => Signal.State.prototype.set.call(x, 2)).toThrowError(TypeError);
+    expect(Signal.State.prototype.set.call(s, 2)).toBe(undefined);
+    expect(() => Signal.State.prototype.set.call(c, 2)).toThrowError(TypeError);
+    expect(() => Signal.State.prototype.set.call(w, 2)).toThrowError(TypeError);
+
+    expect(() => Signal.Computed.prototype.get.call(x)).toThrowError(TypeError);
+    expect(() => Signal.Computed.prototype.get.call(s)).toThrowError(TypeError);
+    expect(Signal.Computed.prototype.get.call(c)).toBe(undefined);
+    expect(() => Signal.Computed.prototype.get.call(w)).toThrowError(TypeError);
+
+    expect(() => Signal.subtle.Watcher.prototype.watch.call(x, s)).toThrowError(TypeError);
+    expect(() => Signal.subtle.Watcher.prototype.watch.call(s, s)).toThrowError(TypeError);
+    expect(() => Signal.subtle.Watcher.prototype.watch.call(c, s)).toThrowError(TypeError);
+    expect(Signal.subtle.Watcher.prototype.watch.call(w, s)).toBe(undefined);
+    expect(() => Signal.subtle.Watcher.prototype.watch.call(w, w)).toThrowError(TypeError);
+
+    expect(() => Signal.subtle.Watcher.prototype.unwatch.call(x, s)).toThrowError(TypeError);
+    expect(() => Signal.subtle.Watcher.prototype.unwatch.call(s, s)).toThrowError(TypeError);
+    expect(() => Signal.subtle.Watcher.prototype.unwatch.call(c, s)).toThrowError(TypeError);
+    expect(Signal.subtle.Watcher.prototype.unwatch.call(w, s)).toBe(undefined);
+    expect(() => Signal.subtle.Watcher.prototype.unwatch.call(w, w)).toThrowError(TypeError);
+
+    expect(() => Signal.subtle.Watcher.prototype.getPending.call(x, s)).toThrowError(TypeError);
+    expect(() => Signal.subtle.Watcher.prototype.getPending.call(s, s)).toThrowError(TypeError);
+    expect(() => Signal.subtle.Watcher.prototype.getPending.call(c, s)).toThrowError(TypeError);
+    expect(Signal.subtle.Watcher.prototype.getPending.call(w, s)).toStrictEqual([]);
+
+    // @ts-expect-error
+    expect(() => Signal.subtle.introspectSources(x)).toThrowError(TypeError);
+    // @ts-expect-error
+    expect(() => Signal.subtle.introspectSources(s)).toThrowError(TypeError);
+    expect(Signal.subtle.introspectSources(c)).toStrictEqual([]);
+    expect(Signal.subtle.introspectSources(w)).toStrictEqual([]);
+
+    // @ts-expect-error
+    expect(() => Signal.subtle.hasSinks(x)).toThrowError(TypeError);
+    expect(Signal.subtle.hasSinks(s)).toBe(false);
+    expect(Signal.subtle.hasSinks(c)).toBe(false);
+    // @ts-expect-error
+    expect(() => Signal.subtle.hasSinks(w)).toThrowError(TypeError);
+
+    // @ts-expect-error
+    expect(() => Signal.subtle.introspectSinks(x)).toThrowError(TypeError);
+    expect(Signal.subtle.introspectSinks(s)).toStrictEqual([]);
+    expect(Signal.subtle.introspectSinks(c)).toStrictEqual([]);
+    // @ts-expect-error
+    expect(() => Signal.subtle.introspectSinks(w)).toThrowError(TypeError);
+  });
+});
diff --git a/tsconfig.d.json b/tsconfig.d.json
index e1eba92..b1efce2 100644
--- a/tsconfig.d.json
+++ b/tsconfig.d.json
@@ -5,5 +5,5 @@
     "declaration": true,
     "emitDeclarationOnly": true
   },
-  "files": ["src/index.ts"]
+  "files": ["src/index.ts", "src/wrapper.ts"]
 }
diff --git a/vitest.config.ts b/vitest.config.ts
index 99d199b..601e33e 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -6,7 +6,7 @@ process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --expose-gc`;
 export default defineConfig({
   test: {
     setupFiles: ['test.ts'],
-    include: ['src/**/*.spec.ts'],
+    include: ['src/**/*.spec.ts', 'tests/**/*.test.ts'],
     environment: 'happy-dom',
     coverage: {
       provider: 'v8',