mutts 1.0.8 → 1.0.9

package/docs/std-decorators.md

@@ -189,13 +189,13 @@ When the decorator is applied to a non-getter method:
 3. **Memory overhead**: Cached values are stored indefinitely
 4. **Getter-only**: Can only be applied to getter methods, not setters or regular methods
 
-## Describe
+## Descriptor
 
-The `describe` decorator provides a clean, reusable way to configure property descriptors (enumerable, configurable, writable) for class properties. This decorator uses a functional approach that makes it easy to create reusable descriptor configurations.
+The `descriptor` decorator provides a clean, reusable way to configure property descriptors (enumerable, configurable, writable) for class properties. This decorator uses a functional approach that makes it easy to create reusable descriptor configurations.
 
 ## API Reference
 
-### `describe(descriptor: PropertyDescriptor): <T>(...properties: (keyof T)[]) => GenericClassDecorator<T>`
+### `descriptor(descriptor: PropertyDescriptor): <T>(...properties: (keyof T)[]) => GenericClassDecorator<T>`
 
 A function that creates a decorator to configure property descriptors for specified properties.
 
@@ -207,29 +207,68 @@ A function that creates a decorator to configure property descriptors for specif
 
 **Returns:** A function that takes property names and returns a class decorator
 
+**Flavors:**
+The `descriptor` function is flavored with the following chainable properties:
+- `.enumerable` - Sets enumerable to true
+- `.hidden` - Sets enumerable to false
+- `.configurable` - Sets configurable to true
+- `.frozen` - Sets configurable to false
+- `.writable` - Sets writable to true
+- `.readonly` - Sets writable to false
+
 **Usage Pattern:**
 ```typescript
-const readonly = describe({ writable: false })
-const hidden = describe({ enumerable: false })
-const locked = describe({ configurable: false })
+// Using flavors for single properties
+@descriptor.readonly('id', 'createdAt')
+@descriptor.hidden('_private')
+class MyClass { }
 
-@readonly('id', 'createdAt')
-@hidden('_private')
-@locked('critical')
+// For multiple descriptor properties on the same property, use object syntax
+@descriptor({ writable: false, enumerable: false, configurable: false })('secret')
 class MyClass { }
+
+// Note: Stacking multiple flavored decorators on the same property is not recommended
+// as each decorator creates a new subclass and only the last applied takes effect
 ```
 
 ## Usage Examples
 
+### Using Flavors
+
+```typescript
+import { descriptor } from 'mutts/std-decorators'
+
+// Use flavors directly for cleaner syntax
+@descriptor.readonly('id', 'createdAt')
+@descriptor.hidden('_private', '_cache')
+@descriptor.frozen('critical')
+class User {
+  id: string = 'user-123'
+  name: string = 'John'
+  _private: string = 'secret'
+  _cache: Map<string, any> = new Map()
+  createdAt: Date = new Date()
+  critical: string = 'locked'
+  
+  constructor(name: string) {
+    this.name = name
+  }
+}
+
+const user = new User('Alice')
+console.log(Object.keys(user)) // ['name', 'createdAt'] - only enumerable properties
+// user.id = 'new-id' // TypeError: Cannot assign to read only property 'id'
+```
+
 ### Creating Reusable Decorators
 
 ```typescript
-import { describe } from 'mutts/std-decorators'
+import { descriptor } from 'mutts/std-decorators'
 
 // Create reusable descriptor configurations
-const readonly = describe({ writable: false })
-const hidden = describe({ enumerable: false })
-const locked = describe({ configurable: false })
+const readonly = descriptor.readonly
+const hidden = descriptor.hidden
+const locked = descriptor.frozen
 
 // Use them on classes
 @readonly('id', 'createdAt')
@@ -255,11 +294,10 @@ console.log(Object.keys(user)) // ['id', 'name', 'createdAt', 'critical'] - only
 ### Making Properties Non-Enumerable
 
 ```typescript
-import { describe } from 'mutts/std-decorators'
+import { descriptor } from 'mutts/std-decorators'
 
-const hidden = describe({ enumerable: false })
-
-@hidden('_internal', '_cache', 'debug')
+// Use the hidden flavor directly
+@descriptor.hidden('_internal', '_cache', 'debug')
 class CacheManager {
   public data: any[] = []
   _internal: Map<string, any> = new Map()
@@ -280,13 +318,10 @@ console.log(Object.getOwnPropertyNames(cache)) // ['data', '_internal', '_cache'
 ### Read-Only Properties
 
 ```typescript
-import { describe } from 'mutts/std-decorators'
-
-const readonly = describe({ writable: false })
-const readonlyLocked = describe({ writable: false, configurable: false })
+import { descriptor } from 'mutts/std-decorators'
 
-@readonly('createdAt', 'version')
-@readonlyLocked('id')
+// Use flavors for read-only properties
+@descriptor.readonly('createdAt', 'version')
 class Document {
   id: string
   title: string
@@ -306,25 +341,41 @@ class Document {
 }
 
 const doc = new Document('doc-1', 'My Document')
-// doc.id = 'new-id' // TypeError: Cannot assign to read only property 'id'
 // doc.createdAt = new Date() // TypeError: Cannot assign to read only property 'createdAt'
+// doc.version = 2 // TypeError: Cannot assign to read only property 'version'
 doc.updateTitle('Updated Title') // This works
 ```
 
-### Configuration Control
+### Combining Multiple Flavors
 
 ```typescript
-import { describe } from 'mutts/std-decorators'
+import { descriptor } from 'mutts/std-decorators'
 
-const locked = describe({ configurable: false })
-const frozen = describe({ configurable: false, writable: false })
+// Stack multiple flavored decorators
+@descriptor.readonly('secret')
+@descriptor.hidden('secret')
+@descriptor.frozen('secret')
+class SecureData {
+  public info: string = 'public'
+  secret: string = 'top secret'
+}
 
-@locked('_sealed')
-@frozen('_frozen')
+const data = new SecureData()
+// data.secret = 'leaked' // TypeError: Cannot assign to read only property 'secret'
+console.log(Object.keys(data)) // ['info'] - secret is not enumerable
+// Object.defineProperty(data, 'secret', { value: 'new' }) // TypeError: Cannot redefine property
+```
+
+### Configuration Control
+
+```typescript
+import { descriptor } from 'mutts/std-decorators'
+
+// Use flavors for configuration control
+@descriptor.frozen('_sealed')
 class SecureObject {
   public data: any
   _sealed: string = 'cannot be reconfigured'
-  _frozen: string = 'cannot be changed or reconfigured'
   
   constructor(data: any) {
     this.data = data
@@ -333,41 +384,41 @@ class SecureObject {
 
 const obj = new SecureObject({ key: 'value' })
 // Object.defineProperty(obj, '_sealed', { value: 'new' }) // TypeError: Cannot redefine property
-// Object.defineProperty(obj, '_frozen', { value: 'new' }) // TypeError: Cannot redefine property
 ```
 
 ## Implementation Details
 
 ### Functional Approach
 
-The `describe` decorator uses a functional approach that separates descriptor configuration from property selection:
+The `descriptor` function uses a flavored approach that provides direct access to common configurations:
 
 ```typescript
-// Create reusable configurations once
-const readonly = describe({ writable: false })
-const hidden = describe({ enumerable: false })
-
-// Apply to multiple classes with different properties
-@readonly('id', 'createdAt')
+// Use flavors directly for cleaner syntax
+@descriptor.readonly('id', 'createdAt')
+@descriptor.hidden('internal')
 class User { }
 
+// Or create reusable aliases
+const readonly = descriptor.readonly
+const hidden = descriptor.hidden
+
 @readonly('version', 'buildDate')  
 class Package { }
 ```
 
 ### Common Decorator Patterns
 
-The functional approach makes it easy to create common decorator patterns:
+The flavored approach makes it easy to create common decorator patterns:
 
 ```typescript
-import { describe } from './std-decorators'
+import { descriptor } from './std-decorators'
 
-// Common reusable decorators
-export const readonly = describe({ writable: false })
-export const hidden = describe({ enumerable: false })
-export const locked = describe({ configurable: false })
-export const frozen = describe({ writable: false, configurable: false })
-export const private = describe({ enumerable: false, configurable: false })
+// Common reusable decorators using flavors
+export const readonly = descriptor.readonly
+export const hidden = descriptor.hidden
+export const locked = descriptor.frozen
+export const frozen = (() => descriptor.readonly.frozen)()
+export const private = (() => descriptor.hidden.frozen)()
 
 // Usage examples
 @readonly('id', 'createdAt')
@@ -389,7 +440,7 @@ The decorator merges the provided descriptor configuration with the existing pro
 
 ```typescript
 // Original property might have { enumerable: true, writable: true, configurable: true }
-// After @readonly('prop') where readonly = describe({ writable: false })
+// After @descriptor.readonly('prop')
 // Final descriptor: { enumerable: true, writable: false, configurable: true }
 ```
 
@@ -399,9 +450,9 @@ The property descriptor configuration is applied in the constructor after callin
 
 ## Best Practices
 
-1. **Create reusable configurations**: Define descriptor configurations once and reuse them
-2. **Use descriptive names**: Name your descriptor configurations clearly (`readonly`, `hidden`, `locked`)
-3. **Combine multiple decorators**: Stack multiple `describe` decorators for complex configurations
+1. **Use flavors directly**: Prefer `descriptor.readonly` over creating aliases for simple cases
+2. **Create reusable aliases**: For complex or frequently used combinations, create aliases
+3. **Combine multiple decorators**: Stack multiple flavored decorators for complex configurations
 4. **Use for encapsulation**: Hide internal properties from enumeration
 5. **Control immutability**: Make critical properties read-only
 6. **Prevent reconfiguration**: Lock important properties from being modified

package/docs/zone.md

@@ -21,20 +21,17 @@ console.log(myZone.active); // undefined
 
 ## Async Propagation
 
-By default, zones are lost when an async operation yields control (e.g., after `await`). To fix this, `mutts` provides `configureAsyncZone()`.
+By default, zones are lost when an async operation yields control (e.g., after `await`). To fix this, register zones in `asyncZone` — the global `ZoneAggregator` — which automatically preserves context across async boundaries via `asyncHooks`.
 
 ```typescript
-import { configureAsyncZone, asyncZone, Zone } from 'mutts/zone';
+import { asyncZone, Zone } from 'mutts/zone';
 
 const requestId = new Zone<string>();
 
 // 1. Tell the global aggregator to track this zone
 asyncZone.add(requestId);
 
-// 2. Patch global async primitives (once per app)
-configureAsyncZone();
-
-// 3. Usage
+// 2. Usage
 requestId.with("req-123", async () => {
     await somePromise();
     // Context is automatically preserved across await!
@@ -43,7 +40,6 @@ requestId.with("req-123", async () => {
 ```
 
 > [!WARNING]
-> TODO
 > **Browser Limitations**: In browser environments (where `AsyncLocalStorage` is unavailable), `mutts` relies on monkey-patching global async primitives (Promise, setTimeout, etc.) to propagate zones. This is generally less robust than Node.js's `async_hooks` and may fail to track context across:
 > *   Native `async/await` boundaries in some modern browsers if not transpiled.
 > *   Concurrent modifications to global prototypes by other libraries.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mutts",
   "description": "Modern UTility TS: A collection of TypeScript utilities",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "main": "dist/browser.cjs",
   "module": "dist/browser.esm.js",
   "types": "dist/browser.d.ts",
@@ -51,6 +51,11 @@
     "./src/node": {
       "types": "./src/entry-node.ts",
       "import": "./src/entry-node.ts"
+    },
+    "./debug": {
+      "types": "./dist/debug.d.ts",
+      "import": "./dist/debug.esm.js",
+      "require": "./dist/debug.cjs"
     }
   },
   "files": [

package/src/async/browser.ts

@@ -1,29 +1,21 @@
-import { Hook, Restorer, asyncHooks } from '.'
+import { asyncHooks, hooks, type Restorer } from '.'
 
-const hooks = new Set<Hook>()
 const promiseContexts = new WeakMap<Promise<any>, Set<Restorer>>()
 
-asyncHooks.addHook = function (hook: Hook) {
-	hooks.add(hook)
-	return () => {
-		hooks.delete(hook)
-	}
-}
-
 // [HACK]: Sanitization
 // If a Promise is created inside the zone, it carries the "Sticky" zone context.
 // If returned to the outer scope, that context leaks. We wrap it in a new Promise
 // created here (in the outer scope) to break the chain and sanitize the return value.
 // See BROWSER_ASYNC_POLYFILL.md for full details.
 asyncHooks.sanitizePromise = (res: any) => {
-    if (res && typeof (res as any).then === 'function') {
-        return new Promise((resolve, reject) => {
-            setTimeout(() => {
-                (res as any).then(resolve, reject)
-            }, 0)
-        })
-    }
-    return res
+	if (res && typeof (res as any).then === 'function') {
+		return new Promise((resolve, reject) => {
+			setTimeout(() => {
+				;(res as any).then(resolve, reject)
+			}, 0)
+		})
+	}
+	return res
 }
 
 function captureRestorers() {
@@ -35,7 +27,10 @@ function captureRestorers() {
 	return restorers
 }
 
-function wrap<Args extends any[], R>(fn: ((...args: Args) => R) | null | undefined, capturedRestorers?: Set<Restorer>) {
+function wrap<Args extends any[], R>(
+	fn: ((...args: Args) => R) | null | undefined,
+	capturedRestorers?: Set<Restorer>
+) {
 	if (typeof fn !== 'function') return fn
 	const restorers = capturedRestorers || captureRestorers()
 	return function (this: any, ...args: Args) {
@@ -88,7 +83,7 @@ function patchEventTarget(proto: any) {
 			wrapped = wrap(listener)
 			listeners.set(listener, wrapped)
 		}
-		
+
 		return nativeAdd.call(this, type, wrapped, options)
 	}
 
@@ -107,7 +102,7 @@ function patchEventTarget(proto: any) {
 				}
 			}
 		}
-		
+
 		return nativeRemove.call(this, type, listener, options)
 	}
 }
@@ -123,7 +118,7 @@ function patchOnProperties(proto: any) {
 					...desc,
 					set: function (this: any, fn: any) {
 						nativeSet.call(this, wrap(fn))
-					}
+					},
 				})
 			}
 		}
@@ -154,35 +149,35 @@ for (const proto of prototypesToPatch) {
 	}
 }
 
-const GLOBAL_ORIGINALS = Symbol.for('mutts.originals');
-const GLOBAL_PROMISE = Symbol.for('mutts.OriginalPromise');
+const GLOBAL_ORIGINALS = Symbol.for('mutts.originals')
+const GLOBAL_PROMISE = Symbol.for('mutts.OriginalPromise')
 
-let originals: any;
-let OriginalPromise: any;
+let originals: any
+let OriginalPromise: any
 
 if ((globalThis as any)[GLOBAL_ORIGINALS]) {
-    originals = (globalThis as any)[GLOBAL_ORIGINALS];
-    OriginalPromise = (globalThis as any)[GLOBAL_PROMISE];
+	originals = (globalThis as any)[GLOBAL_ORIGINALS]
+	OriginalPromise = (globalThis as any)[GLOBAL_PROMISE]
 } else {
-    OriginalPromise = globalThis.Promise;
-    originals = {
-        then: OriginalPromise.prototype.then,
-        catch: OriginalPromise.prototype.catch,
-        finally: OriginalPromise.prototype.finally,
-        resolve: OriginalPromise.resolve,
-        reject: OriginalPromise.reject,
-        all: OriginalPromise.all,
-        allSettled: (OriginalPromise as any).allSettled,
-        race: OriginalPromise.race,
-        any: (OriginalPromise as any).any,
-        setTimeout: globalThis.setTimeout,
-        setInterval: globalThis.setInterval,
-        setImmediate: (globalThis as any).setImmediate,
-        requestAnimationFrame: (globalThis as any).requestAnimationFrame,
-        queueMicrotask: globalThis.queueMicrotask,
-    };
-    (globalThis as any)[GLOBAL_ORIGINALS] = originals;
-    (globalThis as any)[GLOBAL_PROMISE] = OriginalPromise;
+	OriginalPromise = globalThis.Promise
+	originals = {
+		then: OriginalPromise.prototype.then,
+		catch: OriginalPromise.prototype.catch,
+		finally: OriginalPromise.prototype.finally,
+		resolve: OriginalPromise.resolve,
+		reject: OriginalPromise.reject,
+		all: OriginalPromise.all,
+		allSettled: (OriginalPromise as any).allSettled,
+		race: OriginalPromise.race,
+		any: (OriginalPromise as any).any,
+		setTimeout: globalThis.setTimeout,
+		setInterval: globalThis.setInterval,
+		setImmediate: (globalThis as any).setImmediate,
+		requestAnimationFrame: (globalThis as any).requestAnimationFrame,
+		queueMicrotask: globalThis.queueMicrotask,
+	}
+	;(globalThis as any)[GLOBAL_ORIGINALS] = originals
+	;(globalThis as any)[GLOBAL_PROMISE] = OriginalPromise
 }
 
 // Ensure modern statics are captured even if originals was cached from an older version
@@ -192,7 +187,11 @@ if (!originals.race) originals.race = OriginalPromise.race
 
 function patchedThen(this: any, onFulfilled: any, onRejected: any) {
 	const context = promiseContexts.get(this) || captureRestorers()
-	const nextPromise = originals.then.call(this, wrap(onFulfilled, context), wrap(onRejected, context))
+	const nextPromise = originals.then.call(
+		this,
+		wrap(onFulfilled, context),
+		wrap(onRejected, context)
+	)
 	if (context.size > 0) promiseContexts.set(nextPromise, context)
 	return nextPromise
 }
@@ -211,82 +210,87 @@ function patchedFinally(this: any, onFinally: any) {
 	return nextPromise
 }
 
-function PatchedPromise<T>(this: any, executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) {
-    if (typeof executor === 'function') {
-        const p = new OriginalPromise((resolve, reject) => {
-            const wrappedResolve = wrap(resolve)
-            const wrappedReject = wrap(reject)
-            executor(wrappedResolve, wrappedReject)
-        })
-        const context = captureRestorers()
-        promiseContexts.set(p, context) // Always set, even if empty (Sticky Root)
-        return p
-    }
-    return new OriginalPromise(executor)
+function PatchedPromise<T>(
+	this: any,
+	executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void
+) {
+	if (typeof executor === 'function') {
+		const p = new OriginalPromise((resolve, reject) => {
+			const wrappedResolve = wrap(resolve)
+			const wrappedReject = wrap(reject)
+			executor(wrappedResolve, wrappedReject)
+		})
+		const context = captureRestorers()
+		promiseContexts.set(p, context) // Always set, even if empty (Sticky Root)
+		return p
+	}
+	return new OriginalPromise(executor)
 }
 
 // Copy statics
-Object.assign(PatchedPromise, (OriginalPromise as any))
+Object.assign(PatchedPromise, OriginalPromise as any)
 
 // Inherit prototype for instanceof checks
 PatchedPromise.prototype = OriginalPromise.prototype
 
-PatchedPromise.resolve = function<T>(value?: T | PromiseLike<T>): Promise<T> {
-    const p = originals.resolve.call(OriginalPromise, value) as Promise<T>
-    const context = captureRestorers()
-    // Ensure we don't overwrite if it already has context (e.g. from constructor)
-    if (context.size > 0 && !promiseContexts.has(p)) promiseContexts.set(p, context)
-    return p
-} as any
-
-PatchedPromise.reject = function<T = never>(reason?: any): Promise<T> {
-    const p = originals.reject.call(OriginalPromise, reason) as Promise<T>
-    const context = captureRestorers()
-    if (context.size > 0) promiseContexts.set(p, context)
-    return p
-} as any
-
-PatchedPromise.all = function<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]> {
-    const p = originals.all.call(OriginalPromise, values) as Promise<Awaited<T>[]>
-    const context = captureRestorers()
-    if (context.size > 0) promiseContexts.set(p, context)
-    return p
-} as any
-
-PatchedPromise.allSettled = function<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]> {
-    const p = (originals.allSettled as any).call(OriginalPromise, values)
-    const context = captureRestorers()
-    if (context.size > 0) promiseContexts.set(p, context)
-    return p
-} as any
-
-PatchedPromise.race = function<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>> {
-    const p = originals.race.call(OriginalPromise, values) as Promise<Awaited<T>>
-    const context = captureRestorers()
-    if (context.size > 0) promiseContexts.set(p, context)
-    return p
-} as any
-
-PatchedPromise.any = function<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>> {
-    const p = (originals.any as any).call(OriginalPromise, values)
-    const context = captureRestorers()
-    if (context.size > 0) promiseContexts.set(p, context)
-    return p
-} as any
+PatchedPromise.resolve = (<T>(value?: T | PromiseLike<T>): Promise<T> => {
+	const p = originals.resolve.call(OriginalPromise, value) as Promise<T>
+	const context = captureRestorers()
+	// Ensure we don't overwrite if it already has context (e.g. from constructor)
+	if (context.size > 0 && !promiseContexts.has(p)) promiseContexts.set(p, context)
+	return p
+}) as any
+
+PatchedPromise.reject = (<T = never>(reason?: any): Promise<T> => {
+	const p = originals.reject.call(OriginalPromise, reason) as Promise<T>
+	const context = captureRestorers()
+	if (context.size > 0) promiseContexts.set(p, context)
+	return p
+}) as any
+
+PatchedPromise.all = (<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]> => {
+	const p = originals.all.call(OriginalPromise, values) as Promise<Awaited<T>[]>
+	const context = captureRestorers()
+	if (context.size > 0) promiseContexts.set(p, context)
+	return p
+}) as any
+
+PatchedPromise.allSettled = (<T>(
+	values: Iterable<T | PromiseLike<T>>
+): Promise<PromiseSettledResult<Awaited<T>>[]> => {
+	const p = (originals.allSettled as any).call(OriginalPromise, values)
+	const context = captureRestorers()
+	if (context.size > 0) promiseContexts.set(p, context)
+	return p
+}) as any
+
+PatchedPromise.race = (<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>> => {
+	const p = originals.race.call(OriginalPromise, values) as Promise<Awaited<T>>
+	const context = captureRestorers()
+	if (context.size > 0) promiseContexts.set(p, context)
+	return p
+}) as any
+
+PatchedPromise.any = (<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>> => {
+	const p = (originals.any as any).call(OriginalPromise, values)
+	const context = captureRestorers()
+	if (context.size > 0) promiseContexts.set(p, context)
+	return p
+}) as any
 
 // Only apply patches if not already applied (or re-apply safely)
 // Note: OriginalPromise.prototype might be shared if we used the global one.
 // We must ensure we don't patch it twice if it's the SAME object.
 if (OriginalPromise.prototype.then !== patchedThen) {
-    OriginalPromise.prototype.then = patchedThen as any
-    OriginalPromise.prototype.catch = patchedCatch as any
-    OriginalPromise.prototype.finally = patchedFinally as any
+	OriginalPromise.prototype.then = patchedThen as any
+	OriginalPromise.prototype.catch = patchedCatch as any
+	OriginalPromise.prototype.finally = patchedFinally as any
 }
 
 try {
 	Object.defineProperty(OriginalPromise, Symbol.species, {
 		get: () => PatchedPromise,
-		configurable: true
+		configurable: true,
 	})
 } catch (e) {}
 

package/src/async/index.ts

@@ -1,18 +1,22 @@
 export type Restorer = () => () => void
 export type Hook = () => Restorer
 
+// Queue for hooks registered before the environment is ready (circular dependency fix)
+export const hooks = new Set<Hook>()
+
 export const asyncHooks = {
-	addHook(_hook: Hook): () => void {
-		throw 'One must import the library from the server or the client side'
+	addHook(hook: Hook): () => void {
+		hooks.add(hook)
+		return () => hooks.delete(hook)
+	},
+	/**
+	 * [Hack] Sanitize a promise (or value) to prevent context leaks.
+	 * Default: Identity function.
+	 * Browser: Uses Macrotask wrapping to break microtask chains.
+	 */
+	sanitizePromise(p: any): any {
+		return p
 	},
-    /** 
-     * [Hack] Sanitize a promise (or value) to prevent context leaks. 
-     * Default: Identity function.
-     * Browser: Uses Macrotask wrapping to break microtask chains.
-     */
-    sanitizePromise(p: any): any {
-        return p
-    }
 }
 
 /**
@@ -20,4 +24,4 @@ export const asyncHooks = {
  * The hook should return a restorer function which will be called just before the async callback runs.
  * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
  */
-export const asyncHook = (hook: Hook) => asyncHooks.addHook(hook)
+export const asyncHook = (hook: Hook) => asyncHooks.addHook(hook)