• Provides wrappers/enhancements for functions

• Key capabilities:

  • Logging, timing, retry, caching
  • Control execution (debounce, throttle, lock, once)
  • Transform input/output
  • Error handling and safety
  • Composition and chaining

A. Logging & Monitoring

• log(fn) → logs calls and results
• time(fn) → measures execution time
• profile(fn) → detailed table of duration
• changelog(fn) → logs changes in object outputs
• stats(fn) → tracks number of calls, avg time
• watch(fn) → subscribe to outputs
• feedback(fn, logger) → logs input/output

B. Execution Control

• once(fn) → runs only once
• after(fn, n) → runs after n calls
• before(fn, n) → runs at most n times
• limit(fn, max) → limits number of calls
• lock(fn) → prevents concurrent execution
• oncePerArgs(fn) → runs once per argument combo
• queue(fn) → sequential execution
• delayFn(fn, delay) → delay execution
• delayResult(fn, ms) → delay return value
• delayEach(fn, delayMs) → sequential with delay
• afterIdle(fn, timeout) → browser idle execution
• smartIdle(fn, options) → idle execution with cancel

C. Error Handling & Safety

• catch(fn, onError, fallback) → error catch
• sandbox(fn, timeout) → safe execution with error handling
• safeJson(fn) → catches JSON parsing errors
• timeLimit(fn, timeout) → rejects after timeout
• cancelable(fn) → cancel in-flight promise

D. Input/Output Transformation

• validate(fn, validator) → validate arguments
• mask(fn, masker) → transform arguments
• restrict(fn, isAllowed) → allow/disallow call
• tap(fn, tapFn) → side effect without affecting return
• transformOutput(fn, transformer) → change output
• locale(fn, formatter) → format input/output
• unit(fn, unit) → wraps output with value/unit/timestamp

E. Caching & Memoization

• memo(fn) → caches results
• replay(fn) → returns cached result for identical args

F. Functional Composition

• pipe(...fns) → left-to-right composition
• chainable(fn) → chain calls, collect results

G. Retry & Simulation

• retry(fn, retries, delayMs) → retry failing fn
• simulate(fn, options) → simulate failure/delay/corruption
• randomBehavior(fn, behaviors) → random behavior
• randomizeArgs(fn) → shuffle arguments

H. Undo & History

• undoable(fn, inverseFn) → supports undo
• history(fn) → tracks args/results

I. Conditional Execution

• ensure(fn, validator) → ensures output passes
• filterArgs(fn, filterFn) → executes only if condition passes
• delayIf(fn, condition, delayMs) → delays conditionally
• alertOn(fn, condition) → logs alerts if condition true
• warnOnArgs(fn, warningFn) → warns on suspicious input
• predict(fn, modelFn) → adds prediction based on output
• eventual(fn, checkFn, interval) → polls until condition true

J. Repeat & Batch

• repeat(fn, n) → repeat function n times
• batch(fn, chunkSize, cb) → executes in chunks

K. Miscellaneous

• hook(fn, {before, after}) → pre/post hooks
• evolve(fn, evolver) → mutate or extend output

FunctionWrapper
│
├─ Logging & Monitoring
│   ├─ log()
│   ├─ time()
│   ├─ profile()
│   ├─ changelog()
│   ├─ stats()
│   ├─ watch()
│   └─ feedback()
│
├─ Execution Control
│   ├─ once()
│   ├─ after()
│   ├─ before()
│   ├─ limit()
│   ├─ lock()
│   ├─ oncePerArgs()
│   ├─ queue()
│   ├─ delayFn()
│   ├─ delayResult()
│   ├─ delayEach()
│   ├─ afterIdle()
│   └─ smartIdle()
│
├─ Error Handling & Safety
│   ├─ catch()
│   ├─ sandbox()
│   ├─ safeJson()
│   ├─ timeLimit()
│   └─ cancelable()
│
├─ Input/Output Transformation
│   ├─ validate()
│   ├─ mask()
│   ├─ restrict()
│   ├─ tap()
│   ├─ transformOutput()
│   ├─ locale()
│   └─ unit()
│
├─ Caching & Memoization
│   ├─ memo()
│   └─ replay()
│
├─ Functional Composition
│   ├─ pipe()
│   └─ chainable()
│
├─ Retry & Simulation
│   ├─ retry()
│   ├─ simulate()
│   ├─ randomBehavior()
│   └─ randomizeArgs()
│
├─ Undo & History
│   ├─ undoable()
│   └─ history()
│
├─ Conditional Execution
│   ├─ ensure()
│   ├─ filterArgs()
│   ├─ delayIf()
│   ├─ alertOn()
│   ├─ warnOnArgs()
│   ├─ predict()
│   └─ eventual()
│
├─ Repeat & Batch
│   ├─ repeat()
│   └─ batch()
│
└─ Miscellaneous
    ├─ hook()
    └─ evolve()

FunctionWrapper
├─ Logging & Monitoring
│  ├─ log(fn)
│  ├─ time(fn)
│  ├─ profile(fn)
│  ├─ changelog(fn)
│  ├─ feedback(fn, logger)
│  └─ watch(fn)
│
├─ Execution Control
│  ├─ once(fn)
│  ├─ after(fn, n)
│  ├─ before(fn, n)
│  ├─ lock(fn)
│  ├─ queue(fn)
│  ├─ repeat(fn, n)
│  ├─ delayFn(fn, delay)
│  ├─ timeLimit(fn, timeout)
│  ├─ sandbox(fn, timeout)
│  ├─ afterIdle(fn, timeout)
│  └─ smartIdle(fn, options)
│
├─ Error Handling & Safety
│  ├─ catch(fn, onError, fallback)
│  ├─ safeJson(fn)
│  ├─ undoable(fn, inverseFn)
│  ├─ cancelable(fn)
│  ├─ ensure(fn, validator)
│  └─ restrict(fn, isAllowed)
│
├─ Input/Output Transformation
│  ├─ tap(fn, tapFn)
│  ├─ mask(fn, masker)
│  ├─ transformOutput(fn, transformer)
│  ├─ evolve(fn, evolver)
│  ├─ locale(fn, formatter)
│  ├─ randomizeArgs(fn)
│  ├─ randomBehavior(fn, behaviors)
│  └─ predict(fn, modelFn)
│
├─ Caching & Memoization
│  ├─ memo(fn)
│  ├─ replay(fn)
│  └─ oncePerArgs(fn)
│
├─ Functional Composition
│  ├─ chainable(fn)
│  ├─ pipe(...fns)
│  └─ hook(fn, {before, after})
│
├─ Retry & Simulation
│  ├─ retry(fn, retries, delayMs)
│  └─ simulate(fn, {failRate, corrupt, delay})
│
├─ Conditional Execution
│  ├─ delayIf(fn, condition, delayMs)
│  ├─ eventual(fn, checkFn, interval)
│  ├─ filterArgs(fn, filterFn)
│  ├─ warnOnArgs(fn, warningFn)
│  └─ alertOn(fn, condition)
│
├─ Repeat & Batch
│  ├─ batch(fn, chunkSize, cb)
│  └─ delayEach(fn, delayMs)
│
└─ Unit & Stats
   ├─ unit(fn, unit)
   └─ stats(fn)