mutts 1.0.9 → 1.0.10

package/docs/reactive/debugging.md

@@ -40,15 +40,40 @@ You can control how cycles are handled via `reactiveOptions.cycleHandling`:
 - **`'debug'`**: Full diagnostic mode with transitive closures and topological sorting. Provides detailed cycle path reporting.
 
 ### Topological vs. Flat Mode Detection
+- **Detection**: Cycles are detected when the execution depth exceeds `maxEffectChain` (default 100).
+- **Diagnostics**: The resulting `ReactiveError` includes a `trace` property (the recent execution sequence) and attempts to identify a repeating `cycle`.
+- **Recommendation**: Use this mode only for production to minimize performance overhead.
 
-| Mode | `cycleHandling` | Detection Method | Error Code |
-| :--- | :--- | :--- | :--- |
-| **Debug** | `'debug'` or `'development'` | **Mathematical**: Analyzes the dependency graph. | `CYCLE_DETECTED` |
-| **Production** | `'production'` (Default) | **Heuristic**: Counts executions per batch. | `MAX_REACTION_EXCEEDED` |
+### Cycle Handling Modes
 
-In **Topological mode**, the system maintains a transitive closure of all effects, allowing it to know instantly if an effect is its own cause. In **Flat mode**, the system is "blind" to the graph and relies on the execution threshold (`maxTriggerPerBatch`) to interrupt infinite loops.
+You can configure how the system handles cycles via `reactiveOptions.cycleHandling`:
 
-## Memoization Discrepancy Detection
+| Mode | Detection Timing | Cycle Information | Performance |
+|------|-----------------|-------------------|-------------|
+| `'production'` | Late (Heuristic) | Trace of last N effects | Fastest |
+| `'development'` | Eager (On edge) | Exact path (DFS) | Moderate |
+| `'debug'` | Structural | Transitive closures | Slowest |
+
+#### Finding Cycle Information
+
+When a cycle is detected, a `ReactiveError` is thrown. You can find detailed path information in the error object:
+
+```typescript
+try {
+    atom(() => { /* cycle logic */ });
+} catch (error) {
+    if (error.code === 'Cycle detected') {
+        console.log('Cycle Path:', error.cycle.join(' → '));
+        console.log('Trigger Chain:', error.causalChain);
+    }
+}
+```
+
+- **`error.cycle`**: An array of effect names forming the cycle.
+- **`error.causalChain`**: The sequence of triggers that led to the current effect.
+- **`error.lineage`**: The creation stack of the effect (available in `development` or `debug` modes).
+
+### Memoization Discrepancy Detection
 
 The most powerful debugging tool in `mutts` is the **Discrepancy Detector**. It helps identify "missing dependencies"—reactive values used inside a computation that the system isn't tracking.
 
@@ -125,10 +150,12 @@ When the reactive system encounters a critical failure (like a cycle or max dept
 ### `ReactiveErrorCode`
 
 Always check `error.debugInfo.code` to identify the failure type:
-- `CYCLE_DETECTED`: A circular dependency was found.
-- `MAX_DEPTH_EXCEEDED`: The synchronous effect chain reached `maxEffectChain`.
-- `MAX_REACTION_EXCEEDED`: An effect was triggered too many times in a single batch.
-- `WRITE_IN_COMPUTED`: An attempt was made to modify reactive state inside a `memoize` or `derived` function.
+- `Cycle detected`: A circular dependency was found.
+- `Max depth exceeded`: The synchronous effect chain reached `maxEffectChain`.
+- `Max reaction exceeded`: An effect was triggered too many times in a single batch.
+- `Write in computed`: An attempt was made to modify reactive state inside a `memoize` function.
+- `Tracking error`: Internal inconsistency detected in the active dependency stack.
+- `Broken effects`: The system has entered an unrecoverable "broken" state after a root-level panic. Call `reset()` to recover.
 
 ### Rich Debug Info
 
@@ -136,6 +163,7 @@ The `debugInfo` property on `ReactiveError` includes:
 - **`causalChain`**: A string array describing the logical path of modifications leading to the error.
 - **`creationStack`**: The stack trace of where the effect was originally created, helping you locate the source in your code.
 - **`cycle`**: (For `CYCLE_DETECTED`) The names of the effects that form the loop.
+- **`lineage`**: Detailed source-to-sink dependency traces for debugging (requires `lineages` introspection).
 
 ## Best Practices for Debugging
 
@@ -147,8 +175,15 @@ Always provide a name for your effects to make debug logs and error messages rea
 effect(() => {
     // ...
 }, { name: 'UpdateSidebarCounter' });
+
+// Or
+
+effect.named('UpdateSidebarCounter')(() => {
+    // ...
+});
 ```
 
+
 ### Activation & Deactivation
 
 Since these are runtime options, you can toggle them based on your environment:
@@ -164,3 +199,75 @@ if (process.env.NODE_ENV === 'development') {
     reactiveOptions.cycleHandling = 'production';
 }
 ```
+
+## Advanced Debugging (`mutts/debug`)
+
+For a deeper look into the reactivity graph and execution flow, you can import the `mutts/debug` module. Simply importing it enables several background tracking features.
+
+```typescript
+import 'mutts/debug';
+```
+
+### Reaction Reasons (`CleanupReason`)
+
+When an effect or watcher re-runs, it receives a `reaction` property (in `EffectAccess`) that describes *why* it was triggered. This is also passed to the `cleanup` function.
+
+```typescript
+effect(({ reaction }) => {
+    if (reaction && typeof reaction === 'object') {
+        if (reaction.type === 'propChange') {
+            console.log('Triggered by:', reaction.triggers.map(t => t.evolution.prop));
+        }
+    }
+    
+    return (reason) => {
+        // reason is also a CleanupReason
+        if (reason?.type === 'stopped') console.log('Effect manually stopped');
+    };
+});
+```
+
+#### `formatCleanupReason`
+
+A built-in utility to turn a `CleanupReason` into an inspectable console log array.
+
+```typescript
+import { formatCleanupReason } from 'mutts';
+
+effect(()=> {
+    ...
+    return (reason)=> {
+        if (reason) console.log(...formatCleanupReason(reason));
+    }
+});
+```
+
+### Lineage Tracking
+
+Lineage tracking allows you to see the "causal path" of an effect—not just the current stack trace, but the stack traces of all parent effects that created the current execution.
+
+When an effect is created, it is assigned a `lineage` property that contains the stack traces of all parent effects that lead to its creation.
+
+- **`logLineage()`**: Prints a formatted, interactive tree of the current effect's lineage to the console.
+- **`captureLineage()`**: Captures the current lineage as a structured object.
+
+#### Lineage Options
+
+You can control how lineages are captured via `reactiveOptions.introspection.gatherReasons.lineages`:
+- `'none'`: Disable lineage capture.
+- `'touch'`: Capture lineage when a property is accessed (default).
+- `'dependency'`: Capture lineage when a dependency is recorded.
+- `'both'`: Capture both.
+
+### The `__MUTTS_DEBUG__` Global
+
+When `mutts/debug` is active (or after calling `enableDevTools()`), a global `__MUTTS_DEBUG__` object is exposed in the environment (Node.js `global` or Browser `window`).
+
+This object provides low-level access to the graph, lineage capture, and renaming utilities:
+- `__MUTTS_DEBUG__.getGraph()`: Returns the full reactivity graph.
+- `__MUTTS_DEBUG__.logLineage()`: logs the current lineage.
+- `__MUTTS_DEBUG__.browserLineage`: captures lineage for the DevTools panel.
+
+### Custom DevTools Formatters
+
+`mutts/debug` automatically registers [Custom Formatters](https://bit.ly/chrome-extension-custom-formatters) in Chrome. This makes lineage objects and reactive proxies appear as clean, structured trees in the console instead of opaque Proxy objects.

package/docs/reactive/error-handling.md

@@ -1,18 +1,18 @@
 # Effect Error Handling
 
-The `onEffectThrow` function allows you to catch and handle errors within reactive effects.
+The `caught` function allows you to catch and handle errors within reactive effects.
 
 ## Basic Usage
 
-Register an error handler inside an effect using `onEffectThrow`:
+Register an error handler inside an effect using `caught`:
 
 ```typescript
-import { effect, onEffectThrow, reactive } from 'mutts'
+import { effect, caught, reactive } from 'mutts'
 
 const state = reactive({ value: 0 })
 
 effect(() => {
-  onEffectThrow((error) => {
+  caught((error) => {
     console.error('Effect failed:', error)
   })
 
@@ -28,7 +28,7 @@ You can register multiple handlers. They are tried in order until one succeeds:
 ```typescript
 effect(() => {
   // First handler - try to recover
-  onEffectThrow((error) => {
+  caught((error) => {
     if (error.message === 'Retryable') {
       retryOperation()
       return  // Success - stops here
@@ -37,7 +37,7 @@ effect(() => {
   })
 
   // Second handler - log and continue
-  onEffectThrow((error) => {
+  caught((error) => {
     console.log('Operation failed:', error)
   })
 })
@@ -50,7 +50,7 @@ Errors in child effects propagate to parent effects:
 ```typescript
 effect(() => {
   // Parent catches child's error
-  onEffectThrow((error) => {
+  caught((error) => {
     console.log('Child failed:', error.message)
   })
 
@@ -69,7 +69,7 @@ Handlers can return cleanup functions:
 
 ```typescript
 effect(() => {
-  onEffectThrow((error) => {
+  caught((error) => {
     console.log('Handling error:', error)
     
     return () => {
@@ -82,7 +82,7 @@ effect(() => {
 
 ## API
 
-### `onEffectThrow(handler)`
+### `caught(handler)`
 
 Registers an error handler for the current effect.
 
@@ -118,4 +118,4 @@ Parent's handlers try
 
 - Handlers must be registered **before** the code that might throw
 - Handlers are cleared on each effect re-run (re-register if needed)
-- Errors in async effects (Promises) are not caught by `onEffectThrow` - use `.catch()` on the Promise
+- Errors in async effects (Promises) are not caught by `caught` - use `.catch()` on the Promise

package/docs/reactive/resource.md

@@ -0,0 +1,125 @@
+# Reactive Resource (`resource`)
+
+The `resource` utility creates a reactive object that automatically tracks the state of an asynchronous operation (loading, value, error). It is designed to simplify data fetching and async state management in a reactive environment.
+
+## Overview
+
+`resource` wraps an async function (the "fetcher") and returns a reactive object that:
+-   **Tracks dependencies**: Automatically re-runs the fetcher when reactive dependencies accessed within it change.
+-   **Manages state**: Provides `loading`, `value`, `error`, and `latest` properties that update automatically.
+-   **Handles race conditions**: Ensures that only the result of the latest fetch is applied, discarding results from stale requests.
+-   **Supports manual reload**: Exposes a `reload()` method to force a refresh.
+
+## API
+
+```typescript
+function resource<T>(
+    fetcher: (dep: EffectAccess) => Promise<T> | T,
+    options?: { initialValue?: T }
+): Resource<T>
+
+interface Resource<T> {
+    value: T | undefined  // The current successful value
+    loading: boolean      // True if a fetch is in progress
+    error: any            // Error from the last failed fetch
+    latest: T | undefined // The latest successful value (preserved during loading)
+    reload: () => void    // Function to manually trigger a re-fetch
+}
+```
+
+### Parameters
+
+-   **`fetcher`**: A function that returns a value `T` or a `Promise<T>`. It receives an `EffectAccess` object, allowing for dependency tracking control (e.g., `dep.tracked()`). Reactive properties accessed synchronously or within tracked scopes are dependencies.
+-   **`options`**: Optional configuration object.
+    -   `initialValue`: Initial value for `value` and `latest` before the first fetch completes (or if the first fetch is async).
+
+### Returns
+
+A reactive object implementing the `Resource<T>` interface.
+
+## Usage
+
+### Basic Async Fetch
+
+```typescript
+import { reactive, resource } from 'mutts/reactive'
+
+// ID usually comes from another reactive source
+const state = reactive({ userId: 1 })
+
+// Create a resource that fetches user data based on state.userId
+const user = resource(async () => {
+    const response = await fetch(`/api/users/${state.userId}`)
+    return response.json()
+})
+
+// Use the resource in your view
+effect(() => {
+    if (user.loading) {
+        console.log('Loading...')
+    } else if (user.error) {
+        console.error('Error:', user.error)
+    } else {
+        console.log('User:', user.value)
+    }
+})
+
+// Changing state.userId automatically triggers a new fetch
+state.userId = 2
+```
+
+### Handling Race Conditions
+
+`resource` automatically handles race conditions. If `state.userId` changes quickly from 1 to 2, and the request for user 1 takes longer than user 2, the result for user 1 will be ignored when it arrives, preventing inconsistent state.
+
+### Using `latest` for Smooth Transitions
+
+The `value` property becomes `undefined` (or `initialValue`) when a new fetch starts if the previous value is not preserved (current implementation resets `value` only on success? No, `value` is kept from previous success? - *Clarification: In the implementation, `value` is NOT reset to undefined on new fetch start, it retains the old value until new value arrives, unless `initialValue` was used? Let's check implementation behavior.*)
+
+*Correction based on implementation:*
+The current implementation:
+```typescript
+state.loading = true
+state.error = undefined
+// ... fetcher executes ...
+// on success:
+state.value = val
+state.latest = val
+state.loading = false
+```
+It does **NOT** reset `value` to `undefined` when a new fetch starts. So `value` acts like `latest`. The distinction is primarily semantic or for future behavior where `value` might be reset. Currently `value` and `latest` behave similarly regarding preservation of old data during loading.
+
+```typescript
+effect(() => {
+    // Show old data while loading new data
+    if (user.loading) {
+        console.log('Reloading... showing cached version:', user.latest)
+    } else {
+        console.log('Current:', user.value)
+    }
+})
+```
+
+### Manual Reload
+
+You can trigger a re-fetch without changing dependencies:
+
+```typescript
+// Refresh the data (e.g., user clicked a "Refresh" button)
+user.reload()
+```
+
+### Synchronous Resources
+
+`resource` can also wrap synchronous calculations, essentially behaving like a computed property but with the `Resource` interface structure.
+
+```typescript
+const count = reactive({ value: 1 })
+
+const doubled = resource(() => {
+    return count.value * 2
+})
+
+console.log(doubled.value) // 2
+console.log(doubled.loading) // false
+```

package/docs/reactive/scan.md

@@ -42,7 +42,7 @@ The implementation consists of:
 2. **Intermediates**: Class instances that link `val` and `prev`. They expose an `acc` getter decorated with `@memoize`.
 3. **Index Sync Effects**: Granular effects (one per result index) that subscribe to `indexToIntermediate[i].acc`.
 
-This "Project-like" architecture ensures that the main loop only does structural work, while the actual logic propagation is handled by the dependency chain of the intermediates.
+This "Morph-like" architecture ensures that the main loop only does structural work, while the actual logic propagation is handled by the dependency chain of the intermediates.
 
 ## API Reference
 
@@ -276,6 +276,37 @@ showAdvanced.value = false
 | **Use Case** | Derived arrays/objects (map, filter, computed properties) | Cumulative operations (sum, reduce) |
 | **Data Types** | Arrays and objects | Arrays only (object items required) |
 
+## Comparison with Recursive Touching (Deep Touch)
+
+When you assign a new array/object to a reactive property (`state.items = newArray`), the reactive system performs a **recursive touch** — it diffs old vs new element-by-element and fires per-index notifications on the *same proxy*. This raises the question: is `lift` redundant?
+
+| | Recursive Touching | `lift` |
+| :--- | :--- | :--- |
+| **Trigger** | Direct assignment to a reactive property | Any reactive dependency change inside the callback |
+| **Scope** | Same-shape replacement of one value | Arbitrary computation → stable reactive output |
+| **Identity** | Same proxy, same object | Returns a **new persistent proxy** that outlives re-evaluations |
+| **Use case** | `state.user = fetchedUser` — fine-grained diff on assignment | `lift(() => items.filter(x => x.active))` — derived collection |
+
+Deep touching makes `lift` unnecessary for **replacement** patterns (`state.items = newItems`). `lift` remains essential for **derived collections** where the result is a transformation (filter, map, reshape) rather than a direct assignment — there is no single property to assign to, and the whole output is recomputed from scratch each time.
+
+## Comparison with `memoize`
+
+Both `lift` and `memoize` compute derived values from reactive dependencies, but they differ in evaluation strategy and output type.
+
+| | `memoize` | `lift` |
+| :--- | :--- | :--- |
+| **Evaluation** | Lazy — invalidates on dep change, recomputes on next read | Eager — recomputes immediately on dep change |
+| **Return type** | The raw return value of the function | A **stable reactive proxy** (array or object) |
+| **Downstream reactivity** | Consumers get a new value each time (identity changes) | Consumers see per-property/per-index diffs on the *same* proxy |
+| **Arguments** | Keyed by object args (WeakMap cache tree) | No args — closure over reactive deps |
+| **Decorator** | Yes (`@memoize` on getters/methods) | No |
+| **Cleanup** | Automatic (WeakMap GC) | Explicit `result[cleanup]()` |
+
+**When to use which:**
+- **`lift`** for derived collections where downstream consumers (e.g., `morph()`, effects) benefit from per-element diffing on a stable proxy.
+- **`memoize`** for parameterized caching (`memoize((user) => expensiveCompute(user))`) or lazy evaluation where recomputation should only happen on access.
+- For a scalar result read in one place, they are nearly interchangeable — prefer `memoize` for its laziness and automatic cleanup.
+
 ## Performance Considerations
 
 ### Arrays

package/docs/reactive.md

@@ -11,12 +11,13 @@ The Mutts Reactive System documentation has been split into focused sections for
 *   **[Reactive Collections](./reactive/collections.md#collections)**: Map, Set, WeakMap, WeakSet
 *   **[Reactive Arrays](./reactive/collections.md#reactivearray)**: Full array method support
 *   **[Register](./reactive/collections.md#register)**: ID-keyed ordered collections
-*   **[Projections](./reactive/collections.md#projection)**: `project`, `organized`
+*   **[Morphing](./reactive/collections.md#morph)**: `morph`, `organized`
 *   **[Attend](./reactive/attend.md)**: Reactive enumeration (`attend`)
-*   **[Describe](./reactive/describe.md)**: Reactive property definition (`describe`)
 *   **[Scan](./reactive/scan.md)**: Reactive scan and accumulation
+*   **[Resource](./reactive/resource.md)**: Async state tracking (`resource`)
 
 ## [Advanced Topics](./reactive/advanced.md)
+*   **[Choosing the Right Primitive](./reactive/advanced.md#choosing-the-right-reactive-primitive)**: Comparison table of effect-value functions (memoize, lift, project, scan, etc.)
 *   **[Atomic Operations](./reactive/advanced.md#atomic-operations)**: Batching and Bidirectional binding
 *   **[Evolution Tracking](./reactive/advanced.md#evolution-tracking)**: History introspection
 *   **[Prototype Chains](./reactive/advanced.md#prototype-chains-and-pure-objects)**: Advanced inheritance patterns

package/docs/utils.md

@@ -0,0 +1,70 @@
+# Utilities
+
+Mutts provides a collection of lightweight, high-performance utility functions. These are used extensively within the reactive engine but are also exported for general application logic.
+
+## Collection Utilities
+
+### `zip(...arrays)`
+
+A generator that yields tuples containing elements from each input array. It continues until the **longest** array is exhausted (returning `undefined` for shorter arrays).
+
+```typescript
+import { zip } from 'mutts';
+
+const names = ['Alice', 'Bob'];
+const scores = [100, 95, 80];
+
+for (const [name, score] of zip(names, scores)) {
+    console.log(`${name}: ${score}`);
+}
+// Alice: 100
+// Bob: 95
+// undefined: 80
+```
+
+> [!NOTE]
+> `zip` is implemented as a generator for memory efficiency. If you need a plain array, spread the result: `[...zip(a, b)]`.
+
+
+### `deepCompare(a, b)`
+
+A robust deep comparison utility that handles circular references and various built-in types.
+
+- **Supported Types**: Objects, Arrays, `Set`, `Map`, `Date`, `RegExp`.
+- **Circular References**: Safely handled via internal tracking.
+- **Prototypes**: Objects must have matching prototypes to be considered equal.
+
+```typescript
+import { deepCompare } from 'mutts';
+
+const obj1 = { date: new Date(0), map: new Map([['a', 1]]) };
+const obj2 = { date: new Date(0), map: new Map([['a', 1]]) };
+
+deepCompare(obj1, obj2); // true
+```
+
+## Type Reflection
+
+### `isConstructor(fn)` / `isObject(value)`
+
+Utilities for robust type checking without the pitfalls of `typeof`.
+
+- `isConstructor`: Returns `true` if the function is a `class` or a native constructor (like `Array`).
+- `isObject`: Returns `true` for plain objects. Returns `false` for `null`, `Array`, `Date`, `Map`, etc.
+
+## Debugging & Metadata
+
+### `tag(name, obj)`
+
+Applies a debugging "tag" to an object. It sets `Symbol.toStringTag` and overrides `toString()` so the object appears clearly in logs and DevTools.
+
+### `named(name, fn)`
+
+Renames a function for better stack traces. If the function already has a name, it appends the new name using `::` as a separator (e.g., `original::new`).
+
+```typescript
+const myFn = named('Enhanced', () => {});
+console.log(myFn.name); // "Enhanced"
+```
+
+---

package/package.json

@@ -1,56 +1,86 @@
 {
   "name": "mutts",
   "description": "Modern UTility TS: A collection of TypeScript utilities",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "main": "dist/browser.cjs",
   "module": "dist/browser.esm.js",
-  "types": "dist/browser.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "test-node": {
-        "import": "./src/entry-node.ts"
-      },
-      "test-browser": {
-        "import": "./src/entry-browser.ts"
-      },
       "node": {
         "types": "./dist/node.d.ts",
-        "import": "./dist/node.esm.js",
-        "require": "./dist/node.cjs"
+        "development": {
+          "import": "./dist/node.dev.esm.js",
+          "require": "./dist/node.dev.cjs"
+        },
+        "default": {
+          "import": "./dist/node.esm.js",
+          "require": "./dist/node.cjs"
+        }
       },
       "default": {
         "types": "./dist/browser.d.ts",
-        "import": "./dist/browser.esm.js",
-        "require": "./dist/browser.cjs"
+        "development": {
+          "import": "./dist/browser.dev.esm.js",
+          "require": "./dist/browser.dev.cjs"
+        },
+        "default": {
+          "import": "./dist/browser.esm.js",
+          "require": "./dist/browser.cjs"
+        }
       }
     },
     "./browser": {
       "types": "./dist/browser.d.ts",
-      "import": "./dist/browser.esm.js",
-      "require": "./dist/browser.cjs"
+      "development": {
+        "import": "./dist/browser.dev.esm.js",
+        "require": "./dist/browser.dev.cjs"
+      },
+      "default": {
+        "import": "./dist/browser.esm.js",
+        "require": "./dist/browser.cjs"
+      }
     },
     "./node": {
       "types": "./dist/node.d.ts",
-      "import": "./dist/node.esm.js",
-      "require": "./dist/node.cjs"
-    },
-    "./src": {
-      "node": {
-        "types": "./src/entry-node.ts",
-        "import": "./src/entry-node.ts"
+      "development": {
+        "import": "./dist/node.dev.esm.js",
+        "require": "./dist/node.dev.cjs"
       },
       "default": {
-        "types": "./src/entry-browser.ts",
-        "import": "./src/entry-browser.ts"
+        "import": "./dist/node.esm.js",
+        "require": "./dist/node.cjs"
       }
     },
-    "./src/browser": {
-      "types": "./src/entry-browser.ts",
-      "import": "./src/entry-browser.ts"
+    "./dev": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.dev.esm.js",
+      "require": "./dist/browser.dev.cjs"
     },
-    "./src/node": {
-      "types": "./src/entry-node.ts",
-      "import": "./src/entry-node.ts"
+    "./prod": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.esm.js",
+      "require": "./dist/browser.cjs"
+    },
+    "./browser/dev": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.dev.esm.js",
+      "require": "./dist/browser.dev.cjs"
+    },
+    "./browser/prod": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.esm.js",
+      "require": "./dist/browser.cjs"
+    },
+    "./node/dev": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.dev.esm.js",
+      "require": "./dist/node.dev.cjs"
+    },
+    "./node/prod": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.esm.js",
+      "require": "./dist/node.cjs"
     },
     "./debug": {
       "types": "./dist/debug.d.ts",
@@ -60,7 +90,6 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "docs"
   ],