Adds untracked.

This allows signal reads which are not tracked by any active consumers/effects/etc.

```typescript
const foo = signal('foo');
const bar = signal('bar');

// Re-runs when `foo` changes, but not when `bar` changes because it is untracked.
host.effect(() => {
  const f = foo();
  const b = untracked(() => bar());
  console.log(`${f} - ${b}`);
});
```

src/signals/graph.test.ts

@@ -1,4 +1,4 @@
-import { bindProducer, Consumer, observe, Producer } from './graph.js';
+import { bindProducer, Consumer, observe, Producer, untracked } from './graph.js';
 import { signal } from './signal.js';
 
 describe('graph', () => {
@@ -73,6 +73,62 @@ describe('graph', () => {
     });
   });
 
+  describe('untracked', () => {
+    it('ignores producer reads inside the callback', () => {
+      const consumer = Consumer.from();
+
+      const listener = jasmine.createSpy<() => void>('listener');
+      consumer.listen(listener);
+
+      const foo = signal('foo');
+      const bar = signal('bar');
+      consumer.record(() => `${untracked(() => foo())} - ${bar()}`);
+
+      expect(listener).not.toHaveBeenCalled();
+      foo.set('foo2');
+      expect(listener).not.toHaveBeenCalled();
+      bar.set('bar2');
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      consumer.destroy();
+    });
+
+    it('propagates errors', () => {
+      const err = new Error('Untrack this!');
+
+      expect(() => untracked(() => { throw err; })).toThrow(err);
+    });
+
+    it('resets the consumer on error', () => {
+      const consumer = Consumer.from();
+
+      const listener = jasmine.createSpy<() => void>('listener');
+      consumer.listen(listener);
+
+      const foo = signal('foo');
+      const bar = signal('bar');
+      consumer.record(() => {
+        try {
+          untracked(() => {
+            foo(); // `foo` still untracked.
+            throw new Error('Untrack this!');
+          });
+        } catch {}
+
+        // `bar` should not be affected by above error.
+        return bar();
+      });
+
+      expect(listener).not.toHaveBeenCalled();
+      foo.set('foo2');
+      expect(listener).not.toHaveBeenCalled();
+      bar.set('bar2');
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      consumer.destroy();
+    });
+  });
+
   describe('Producer', () => {
     describe('poll', () => {
       it('invokes the constructor parameter', () => {

src/signals/graph.ts

@@ -44,6 +44,36 @@ export function observe<Value>(consumer: Consumer, cb: () => Value): Value {
   }
 }
 
+/**
+ * Immediately invokes the given callback in an "untracked" state, meaning any
+ * currently active {@link Consumer} objects will *not* observe signal reads.
+ *
+ * For example, the following effect will rerun whenever `foo` changes, but will
+ * *not* rerun when `bar` changes because it is untracked.
+ *
+ * ```typescript
+ * const foo = signal('foo');
+ * const bar = signal('bar');
+ *
+ * host.effect(() => {
+ *   const f = foo();
+ *   const b = untracked(() => bar());
+ *   console.log(`${f} - ${b}`);
+ * });
+ * ```
+ *
+ * @param cb The callback to invoke in an untracked state.
+ * @returns The result of the callback.
+ */
+export function untracked<Value>(cb: () => Value): Value {
+  const stack = consumerStack.splice(0, consumerStack.length);
+  try {
+    return cb();
+  } finally {
+    consumerStack.push(...stack);
+  }
+}
+
 /**
  * Binds the provided {@link Producer} to the currently observing
  * {@link Consumer}, if present. This will configure the {@link Producer} to

src/signals/index.ts

@@ -1,5 +1,6 @@
 export { cached } from './cached.js';
 export { effect } from './effect.js';
+export { untracked } from './graph.js';
 export { type ReactiveRoot } from './reactive-root.js';
 export { type Equals, signal } from './signal.js';
 export { MacrotaskScheduler } from './schedulers/macrotask-scheduler.js';