New 1.1.3

src/docs/api/ignore.md

@@ -0,0 +1,75 @@
+# 🛑 Untracking: `$.ignore( )`
+
+The `$.ignore` function allows you to read a signal's value inside an effect or a computed signal **without** creating a dependency. 
+
+## 🛠 Function Signature
+
+```typescript
+$.ignore(callback: Function): any
+```
+
+| Parameter | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| **`callback`** | `Function` | Yes | A function where signals can be read "silently". |
+
+**Returns:** Whatever the callback function returns.
+
+---
+
+## 📖 Usage Patterns
+
+### 1. Preventing Dependency Tracking
+Normally, reading a signal inside `$.effect` makes the effect re-run when that signal changes. `$.ignore` breaks this link.
+
+```javascript
+const count = $(0);
+const logLabel = $("System Log");
+
+$.effect(() => {
+  // This effect tracks 'count'...
+  const currentCount = count();
+  
+  // ...but NOT 'logLabel'. 
+  // Changing 'logLabel' will NOT re-run this effect.
+  const label = $.ignore(() => logLabel());
+  
+  console.log(`${label}: ${currentCount}`);
+});
+
+count(1);     // Console: "System Log: 1" (Triggers re-run)
+logLabel("UI"); // Nothing happens in console (Ignored)
+```
+
+### 2. Reading State in Event Handlers
+Inside complex UI logic, you might want to take a "snapshot" of a signal without triggering a reactive chain.
+
+```javascript
+const handleClick = () => {
+  // Accessing state without letting the caller know we touched it
+  const data = $.ignore(() => mySignal());
+  process(data);
+};
+```
+
+### 3. Avoiding Infinite Loops
+If you need to **write** to a signal based on its own value inside an effect (and you aren't using the functional updater), `$.ignore` prevents the effect from triggering itself.
+
+```javascript
+$.effect(() => {
+  const value = someSignal();
+  
+  if (value > 100) {
+    // We update the signal, but we ignore the read to avoid a loop
+    $.ignore(() => someSignal(0));
+  }
+});
+```
+
+---
+
+## 💡 Why use it?
+
+* **Performance:** Prevents expensive effects from running when non-essential data changes.
+* **Logic Control:** Allows "sampling" a signal at a specific point in time.
+* **Safety:** Essential for complex state orchestrations where circular dependencies might occur.
+