mutts 1.0.8 → 1.0.10

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
 
@@ -76,3 +76,249 @@ result[cleanup]()
 | **Modify Item at `i`** | O(N) calls (entire reduction) | O(N-i) calls |
 | **Append Item** | O(N+1) calls | 1 call |
 | **Move Item** | O(N) calls | O(affected chain) |
+
+---
+
+# Lift
+
+The `lift` function transforms a callback that returns an array or object into a reactive array/object that automatically synchronizes with the source whenever dependencies change.
+
+## Overview
+
+`lift` is useful when you have a reactive computation that produces an array or object, and you want that result to be reactive itself. It efficiently syncs only the elements that differ from the previous result, minimizing DOM updates and downstream effects.
+
+## Basic Usage
+
+### Array Example
+
+```typescript
+import { reactive, lift } from 'mutts/reactive'
+
+const items = reactive([1, 2, 3])
+const doubled = lift(() => items.map(x => x * 2))
+
+console.log([...doubled]) // [2, 4, 6]
+
+items.push(4)
+console.log([...doubled]) // [2, 4, 6, 8]
+```
+
+### Object Example
+
+```typescript
+import { reactive, lift } from 'mutts/reactive'
+
+const user = reactive({ name: 'John', age: 30 })
+const profile = lift(() => ({
+  displayName: user.name.toUpperCase(),
+  isAdult: user.age >= 18,
+  description: `${user.name} is ${user.age} years old`
+}))
+
+console.log(profile.displayName) // JOHN
+console.log(profile.isAdult) // true
+
+user.name = 'Jane'
+console.log(profile.displayName) // JANE
+console.log(profile.description) // Jane is 30 years old
+```
+
+## How it Works
+
+`lift` creates a reactive array or object and sets up an effect that:
+1. Calls the provided callback to get the source array or object
+2. Compares the source with the current reactive result
+3. Updates only the elements/properties that have changed
+4. Adjusts the structure if needed (array length or object properties)
+
+For arrays, this approach preserves references to unchanged elements and triggers minimal reactive updates. For objects, it uses `Object.assign()` to merge changes and removes properties that no longer exist in the source.
+
+## API Reference
+
+```typescript
+function lift<Output extends (any[] | object)>(
+    cb: (access: EffectAccess) => Output
+): Output & { [cleanup]: ScopedCallback }
+```
+
+### Parameters
+- `cb`: A callback function that returns an array or object. The callback is tracked reactively, so accessing reactive values inside it will cause the result to update when those values change. The callback receives an `EffectAccess` parameter for advanced use cases.
+
+### Returns
+A reactive array or object that stays synchronized with the callback's result. The result includes a `[cleanup]` symbol that can be called to stop tracking.
+
+```typescript
+import { cleanup } from 'mutts/reactive'
+// ...
+doubled[cleanup]()
+profile[cleanup]()
+```
+
+## Use Cases
+
+### Dynamic Filtering (Arrays)
+
+```typescript
+const allItems = reactive([
+  { id: 1, active: true, name: 'Item 1' },
+  { id: 2, active: false, name: 'Item 2' },
+  { id: 3, active: true, name: 'Item 3' },
+])
+
+const activeItems = lift(() => allItems.filter(item => item.active))
+
+// activeItems automatically updates when items change or active status changes
+allItems[1].active = true
+console.log(activeItems.length) // 3
+```
+
+### Computed Transformations (Arrays)
+
+```typescript
+const numbers = reactive([1, 2, 3, 4, 5])
+const multiplier = reactive({ value: 2 })
+
+const scaled = lift(() => numbers.map(n => n * multiplier.value))
+
+multiplier.value = 3
+// scaled is now [3, 6, 9, 12, 15]
+```
+
+### Conditional Array Construction
+
+```typescript
+const showExtras = reactive({ value: false })
+const baseItems = reactive(['A', 'B', 'C'])
+
+const displayItems = lift(() => 
+  showExtras.value 
+    ? [...baseItems, 'Extra 1', 'Extra 2']
+    : baseItems
+)
+
+showExtras.value = true
+// displayItems is now ['A', 'B', 'C', 'Extra 1', 'Extra 2']
+```
+
+### Computed Object Properties
+
+```typescript
+const user = reactive({ firstName: 'John', lastName: 'Doe', age: 30 })
+const settings = reactive({ theme: 'dark', language: 'en' })
+
+const userProfile = lift(() => ({
+  fullName: `${user.firstName} ${user.lastName}`,
+  isMinor: user.age < 18,
+  displayTheme: settings.theme === 'dark' ? 'Dark Mode' : 'Light Mode',
+  locale: settings.language.toUpperCase()
+}))
+
+user.firstName = 'Jane'
+// userProfile.fullName is now 'Jane Doe'
+
+settings.theme = 'light'
+// userProfile.displayTheme is now 'Light Mode'
+```
+
+### Dynamic Object Composition
+
+```typescript
+const baseConfig = reactive({ api: 'https://api.example.com', timeout: 5000 })
+const userPrefs = reactive({ retries: 3, logging: false })
+const envVars = reactive({ debug: true, version: '1.0.0' })
+
+const fullConfig = lift(() => ({
+  ...baseConfig,
+  ...userPrefs,
+  environment: envVars.debug ? 'development' : 'production',
+  version: envVars.version,
+  logging: envVars.debug || userPrefs.logging
+}))
+
+envVars.debug = false
+// fullConfig.environment becomes 'production'
+
+userPrefs.logging = true
+// fullConfig.logging becomes true
+```
+
+### Conditional Object Properties
+
+```typescript
+const user = reactive({ role: 'admin', permissions: ['read', 'write'] })
+const showAdvanced = reactive({ value: true })
+
+const userInterface = lift(() => {
+  const base = {
+    canEdit: user.permissions.includes('write'),
+    userName: user.role
+  }
+  
+  return showAdvanced.value ? {
+    ...base,
+    isAdmin: user.role === 'admin',
+    permissionCount: user.permissions.length
+  } : base
+})
+
+showAdvanced.value = false
+// userInterface no longer has isAdmin and permissionCount properties
+```
+
+## Comparison with `scan`
+
+| Feature | `lift` | `scan` |
+| :--- | :--- | :--- |
+| **Purpose** | Synchronize with computed arrays/objects | Accumulate values with intermediates |
+| **Input** | Callback returning array/object | Source array + accumulator function |
+| **Output** | Reactive array/object | Reactive array of accumulated values |
+| **Optimization** | Element-wise/property-wise sync | Intermediate caching + move optimization |
+| **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
+- **Efficient Updates**: Only changed elements are updated, not the entire array
+- **Length Adjustments**: Array length changes are handled separately from element updates
+- **Reference Stability**: Unchanged elements maintain their references
+
+### Objects
+- **Property-wise Updates**: Only changed properties are updated using `Object.assign()`
+- **Property Addition/Removal**: Properties are added or removed as needed when the source object structure changes
+- **Reference Stability**: The reactive object maintains its identity while properties are updated
+
+### General
+- **Cleanup**: Remember to call the cleanup function when the lifted array/object is no longer needed to prevent memory leaks
+- **Type Consistency**: The callback must return the same type (array or object) on subsequent calls

package/docs/reactive.md

@@ -11,10 +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`)
 *   **[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/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/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/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.