measure-fn 3.1.0 → 3.2.1

package/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+
+name: CI
+
+on:
+  push:
+    branches: [master, main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+      
+      - run: bun install
+      - run: bun test
+      - run: bun run example.ts

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 7flash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,23 +1,30 @@
 # measure-fn
 
+![CI](https://github.com/7flash/ments-utils/actions/workflows/ci.yml/badge.svg)
+
 **Stop writing blind code.** Every function you write either succeeds or fails, takes some amount of time, and lives inside a larger flow. `measure-fn` makes all of that visible — automatically, hierarchically.
 
 ```
-[18:25:55.816] [a] ✓ Load config 0.10ms → {"env":"prod","port":3000}
-[18:25:55.818] [b] = App ready
-[18:25:55.819] [f] ... Parallel Fetch
-[18:25:55.819] [f-a] ... Fetch User (userId=1)
-[18:25:55.820] [f-b] ... Fetch User (userId=2)
-[18:25:55.913] [f-b] ✓ Fetch User 93.94ms → {"id":2,"name":"User 2"}
-[18:25:55.914] [f-a] ✓ Fetch User 94.30ms → {"id":1,"name":"User 1"}
-[18:25:55.914] [f] ✓ Parallel Fetch 94.46ms
-[18:25:56.051] [api:a] ... GET /users
-[18:25:56.051] [db:a] ... SELECT users
-[18:25:56.095] [db:a] ✓ SELECT users 44.32ms → [{"id":1},{"id":2}]
-[18:25:56.096] [api:a] ✓ GET /users 44.65ms → [{"id":1},{"id":2}]
+[18:50:04.893] [a] ✓ Load config 0.09ms → {"env":"prod","port":3000}
+[18:50:04.894] [b] = App ready
+[18:50:04.895] [e] ... Parallel Fetch
+[18:50:04.895] [e-a] ... Fetch User (userId=1)
+[18:50:04.895] [e-b] ... Fetch User (userId=2)
+[18:50:04.950] [e-b] ✓ Fetch User 55.58ms → {"id":2,"name":"User 2"}
+[18:50:04.981] [e-a] ✓ Fetch User 85.93ms → {"id":1,"name":"User 1"}
+[18:50:04.981] [e] ✓ Parallel Fetch 86.08ms
+[18:50:05.072] [f] ✓ DB query 91.12ms → {"rows":42} ⚠ OVER BUDGET (30.00ms)
+[18:50:05.775] [m] ... Fetch all users (20 items)
+[18:50:06.179] [m] = 5/20 (0.4s, 12/s)
+[18:50:07.450] [m] ✓ Fetch all users (20 items) 1.7s → "20/20 ok"
+[18:50:07.450] [api:a] ... GET /users
+[18:50:07.450] [db:a] ... SELECT users
+[18:50:07.493] [db:a] ✓ SELECT users 43.07ms → [{"id":1},{"id":2}]
+[18:50:07.493] [api:a] ✓ GET /users 43.32ms → [{"id":1},{"id":2}]
+[18:50:08.721] [o] ✓ Slow op 1.2s → "slow"
 ```
 
-No setup. No dashboards. Just wrap your functions. Return values auto-print, parallel ops interleave naturally, hierarchical IDs tell you what belongs where.
+No setup. No dashboards. Just wrap your functions.
 
 ## Install
 
@@ -30,16 +37,16 @@ bun add measure-fn
 ```typescript
 import { measure, measureSync } from 'measure-fn';
 
-// Sync leaf — single line with result
-const config = measureSync('Parse config', () => JSON.parse(configStr));
+// Sync leaf — single line with auto-printed result
+const config = measureSync('Parse config', () => JSON.parse(str));
 // → [a] ✓ Parse config 0.20ms → {"port":3000}
 
 // Async — start + end
-await measure('Fetch data', async () => {
-  return await fetch('https://api.example.com/data').then(r => r.json());
+const data = await measure('Fetch data', async () => {
+  return await fetch(url).then(r => r.json());
 });
 // → [b] ... Fetch data
-// → [b] ✓ Fetch data 245.12ms → [{"id":1},{"id":2}]
+// → [b] ✓ Fetch data 245.12ms → [{"id":1}]
 ```
 
 ## Output Format
@@ -51,62 +58,75 @@ await measure('Fetch data', async () => {
 | `[id] ✗ label Nms (err)` | Error | `[a] ✗ Fetch 2ms (timeout)` |
 | `[id] = label` | Annotation | `[a] = checkpoint` |
 
-**No indentation, no colors.** IDs encode hierarchy: `[a]` → `[a-a]` → `[a-b-c]`. After `z`: `aa`, `ab`...
+**No indentation, no colors.** IDs encode hierarchy. Return values auto-print. Circular refs → `[Circular]`, long values truncated.
 
-Return values auto-print with safe stringify (circular refs → `[Circular]`, long values truncated at 80 chars).
+**Smart duration**: `0.10ms` → `1.2s` → `2m 5s`
 
 ## API
 
 ### `measure(label, fn?)` — async
 
 ```typescript
-const user = await measure('Fetch user', async () => fetchUser(1));
+// Simple
+const user = await measure('Fetch user', () => fetchUser(1));
 
-// Nested
+// Nested + parallel
 await measure('Pipeline', async (m) => {
-  const user = await m('Get user', () => fetchUser(1));
-  if (!user) return;
-
   await Promise.all([
-    m('Get posts', () => fetchPosts(user.id)),
-    m('Get friends', () => fetchFriends(user.id)),
+    m({ label: 'Fetch', userId: 1 }, () => fetchUser(1)),
+    m({ label: 'Fetch', userId: 2 }, () => fetchUser(2)),
   ]);
 });
 
 // Annotation
-await measure('checkpoint reached');
+await measure('checkpoint');
 ```
 
 ### `measureSync(label, fn?)` — synchronous
 
 ```typescript
-// Leaf (no m) — single line
-const result = measureSync('Compute hash', () => computeHash(data));
+// Leaf — single line
+const hash = measureSync('Hash', () => computeHash(data));
 
 // With children — start + end
-measureSync('Build report', (m) => {
-  const data = m('Parse CSV', () => parseCSV(raw));
+measureSync('Report', (m) => {
+  const data = m('Parse', () => parse(raw));
   return m('Summarize', () => summarize(data));
 });
 ```
 
-### `measure.timed(label, fn?)` — get timing programmatically
+### `measure.wrap(label, fn)` — decorator
+
+Wrap a function once, every call is measured:
+
+```typescript
+const getUser = measure.wrap('Get user', fetchUser);
+await getUser(1); // → [a] ... Get user → [a] ✓ Get user 82ms → {...}
+await getUser(2); // → [b] ... Get user → [b] ✓ Get user 75ms → {...}
+```
+
+### `measure.batch(label, items, fn, opts?)` — array processing with progress
 
 ```typescript
-const { result, duration } = await measure.timed('Fetch users', () => fetchUsers());
-console.log(`Got ${result.length} users in ${duration.toFixed(1)}ms`);
+const results = await measure.batch('Process users', userIds, async (id) => {
+  return await processUser(id);
+}, { every: 100 }); // log progress every 100 items
+```
+Output:
+```
+[a] ... Process users (500 items)
+[a] = 100/500 (1.2s, 83/s)
+[a] = 200/500 (2.1s, 95/s)
+[a] ✓ Process users (500 items) 5.3s → "500/500 ok"
 ```
 
 ### `measure.retry(label, opts, fn)` — retry with backoff
 
 ```typescript
 const result = await measure.retry('Flaky API', {
-  attempts: 3,
-  delay: 1000,     // ms between retries
-  backoff: 2,      // multiplier per retry
+  attempts: 3, delay: 1000, backoff: 2
 }, () => fetchFlakyApi());
 ```
-Output:
 ```
 [a] ... Flaky API [1/3]
 [a] ✗ Flaky API [1/3] 102ms (timeout)
@@ -116,69 +136,68 @@ Output:
 
 ### `measure.assert(label, fn)` — throw if null
 
-Type-narrowing variant that re-throws on error instead of returning `null`:
-
 ```typescript
 const user = await measure.assert('Get user', () => fetchUser(1));
-// user is guaranteed non-null, or it throws
+// guaranteed non-null, or throws
 ```
 
-### `createMeasure(prefix)` — scoped instances
-
-Separate namespace and counter, avoids ID collisions across modules:
+### Budget — warn on slow operations
 
 ```typescript
-import { createMeasure } from 'measure-fn';
+await measure({ label: 'DB query', budget: 100 }, async () => {
+  return await db.query('SELECT * FROM users');
+});
+// → [a] ✓ DB query 245ms → [...] ⚠ OVER BUDGET (100ms)
+```
+
+### `createMeasure(prefix)` — scoped instances
 
+```typescript
 const api = createMeasure('api');
 const db = createMeasure('db');
 
 await api.measure('GET /users', async () => {
-  return await db.measure('SELECT users', () => query('SELECT * FROM users'));
+  return await db.measure('SELECT', () => query('...'));
 });
 // → [api:a] ... GET /users
-// → [db:a] ... SELECT users
-// → [db:a] ✓ SELECT users 44ms → [...]
+// → [db:a] ✓ SELECT 44ms → [...]
 // → [api:a] ✓ GET /users 45ms → [...]
 ```
 
-### `configure(opts)` — runtime configuration
+### `configure(opts)` — runtime config
 
 ```typescript
-import { configure } from 'measure-fn';
-
 configure({
   silent: true,            // suppress all output
   timestamps: true,        // prepend [HH:MM:SS.mmm]
-  maxResultLength: 200,    // truncate results at N chars (default: 80)
+  maxResultLength: 200,    // truncate results (default: 80)
   logger: (event) => {     // custom event handler
-    // event: { type, id, label, depth, duration?, result?, error?, meta? }
-    myTelemetryService.track(event);
+    myTelemetry.track(event);
   }
 });
 ```
 
-**Environment variables**: `MEASURE_SILENT=1`, `MEASURE_TIMESTAMPS=1`
-
-### `resetCounter()`
+Env: `MEASURE_SILENT=1`, `MEASURE_TIMESTAMPS=1`
 
-Reset global ID counter for deterministic tests:
+### `measure.timed(label, fn?)` — programmatic timing
 
 ```typescript
-import { resetCounter, configure } from 'measure-fn';
-beforeEach(() => {
-  resetCounter();
-  configure({ silent: false, logger: null, timestamps: false });
-});
+const { result, duration } = await measure.timed('Fetch', () => fetchUsers());
 ```
 
-## Error Handling
+### Utilities
 
-**measure never throws** (except `.assert()`). On error: logs `✗` with message, logs stack trace to stderr, returns `null`.
+```typescript
+import { safeStringify, formatDuration, resetCounter } from 'measure-fn';
 
+safeStringify({ circular: self }); // handles circular refs, truncates
+formatDuration(91234);              // "1m 31s"
+resetCounter();                     // reset ID counter for tests
 ```
-[a-a] ✗ Get user 2.31ms (User not found)
-```
+
+## Error Handling
+
+**measure never throws** (except `.assert()`). On error: logs `✗`, returns `null`, prints stack to stderr.
 
 ## Types
 
@@ -186,11 +205,12 @@ beforeEach(() => {
 export type MeasureEvent = {
   type: 'start' | 'success' | 'error' | 'annotation';
   id: string; label: string; depth: number;
-  duration?: number; result?: unknown;
-  error?: unknown; meta?: Record<string, unknown>;
+  duration?: number; result?: unknown; error?: unknown;
+  meta?: Record<string, unknown>; budget?: number;
 };
 export type TimedResult<T> = { result: T | null; duration: number };
 export type RetryOpts = { attempts?: number; delay?: number; backoff?: number };
+export type BatchOpts = { every?: number };
 ```
 
 ## Zero Dependencies

package/SKILL.md

@@ -5,7 +5,7 @@ description: Zero-dependency function performance measurement with hierarchical
 
 # measure-fn — Structured Program Measurement
 
-**Every program you write should be observable from day one.** `measure-fn` wraps any function — async or sync — with automatic performance timing, hierarchical structured logging, and graceful error isolation.
+**Every program you write should be observable from day one.**
 
 ## Installation
 
@@ -16,80 +16,74 @@ bun add measure-fn
 ## Output Format
 
 ```
-[id] ... label          — async start / sync with children
+[id] ... label          — start (async / sync with children)
 [id] ✓ label Nms → val  — success with auto-printed result
 [id] ✗ label Nms (err)  — error
-[id] = label            — annotation
+[id] = label            — annotation / progress
 ```
 
-No indentation, no colors. IDs encode hierarchy. Return values auto-print. Circular refs → `[Circular]`, long values truncated.
+No indentation, no colors. IDs encode hierarchy. Smart duration: `0.10ms` → `1.2s` → `2m 5s`.
 
-## Core Patterns
-
-### Label First, Function Second
+## Core API
 
 ```typescript
-import { measure, measureSync } from 'measure-fn';
+import { measure, measureSync, createMeasure, configure } from 'measure-fn';
 
+// Async
 const users = await measure('Fetch users', () => fetchUsers());
-const config = measureSync('Load config', () => loadConfig());
-```
 
-### Nested Trees + Parallel
+// Sync (leaf = single line)
+const config = measureSync('Load config', () => loadConfig());
 
-```typescript
+// Nested + parallel
 await measure('Pipeline', async (m) => {
   await Promise.all([
     m({ label: 'Fetch', userId: 1 }, () => fetchUser(1)),
     m({ label: 'Fetch', userId: 2 }, () => fetchUser(2)),
   ]);
 });
-```
 
-### Error Isolation
+// Wrap: decorator pattern — wrap once, measure every call
+const getUser = measure.wrap('Get user', fetchUser);
+await getUser(1);
+await getUser(2);
 
-measure never throws (except `.assert()`). Returns `null` on error.
+// Batch: process array with progress logging
+await measure.batch('Process', items, async (item) => transform(item), { every: 100 });
 
-### Retry with Backoff
+// Retry: automatic retry with backoff
+await measure.retry('Flaky', { attempts: 3, delay: 1000, backoff: 2 }, () => flakyApi());
 
-```typescript
-await measure.retry('Flaky API', { attempts: 3, delay: 1000, backoff: 2 }, () => fetch(url));
-```
+// Assert: throws if null (type-narrowing)
+const user = await measure.assert('Get user', () => fetchUser(1));
 
-### Assert (Type-Narrowing)
+// Budget: warn when operation exceeds time limit
+await measure({ label: 'DB query', budget: 100 }, () => query());
 
-```typescript
-const user = await measure.assert('Get user', () => fetchUser(1)); // throws if null
-```
-
-### Scoped Instances
-
-```typescript
-import { createMeasure } from 'measure-fn';
+// Scoped: separate namespace and counter
 const api = createMeasure('api');  // → [api:a], [api:b], ...
 const db = createMeasure('db');    // → [db:a], [db:b], ...
 ```
 
-### Timed (Programmatic Duration)
+## Configuration
 
 ```typescript
-const { result, duration } = await measure.timed('Op', () => doWork());
+configure({
+  silent: true,            // suppress output
+  timestamps: true,        // [HH:MM:SS.mmm] prefix
+  maxResultLength: 200,    // result truncation (default: 80)
+  logger: (event) => ...,  // custom event handler
+});
 ```
 
-### Configuration
+Env: `MEASURE_SILENT=1`, `MEASURE_TIMESTAMPS=1`
+
+## Utilities
 
 ```typescript
-import { configure } from 'measure-fn';
-configure({
-  silent: true,           // suppress output
-  timestamps: true,       // [HH:MM:SS.mmm] prefix
-  maxResultLength: 200,   // result truncation (default: 80)
-  logger: (event) => ..., // custom event handler
-});
+import { safeStringify, formatDuration, resetCounter } from 'measure-fn';
 ```
 
-Env vars: `MEASURE_SILENT=1`, `MEASURE_TIMESTAMPS=1`
-
 ## API Reference
 
 | Export | Description |
@@ -98,12 +92,15 @@ Env vars: `MEASURE_SILENT=1`, `MEASURE_TIMESTAMPS=1`
 | `measure.timed(label, fn?)` | Returns `{ result, duration }` |
 | `measure.retry(label, opts, fn)` | Retry with backoff |
 | `measure.assert(label, fn)` | Throws if null |
+| `measure.wrap(label, fn)` | Returns measured version of fn |
+| `measure.batch(label, items, fn, opts?)` | Array processing with progress |
 | `measureSync(label, fn?)` | Sync measurement |
-| `measureSync.timed(label, fn?)` | Sync `{ result, duration }` |
-| `measureSync.assert(label, fn)` | Sync throws if null |
-| `createMeasure(prefix)` | Scoped instance with own counter |
-| `configure(opts)` | Set silent/timestamps/logger/maxResultLength |
+| `measureSync.timed/assert/wrap` | Sync variants |
+| `createMeasure(prefix)` | Scoped instance |
+| `configure(opts)` | Runtime configuration |
 | `resetCounter()` | Reset global ID counter |
+| `safeStringify(value)` | Safe JSON with circular ref handling |
+| `formatDuration(ms)` | Smart duration formatting |
 
 ## Testing
 

package/bench.ts

@@ -0,0 +1,54 @@
+
+import { measure, measureSync, configure } from "./index.ts";
+
+const ITERATIONS = 100_000;
+
+function noop() { }
+
+async function run() {
+    console.log(`Running benchmark with ${ITERATIONS.toLocaleString()} iterations...`);
+    configure({ silent: true }); // Disable logging to measure pure overhead
+
+    // Baseline
+    const startBase = performance.now();
+    for (let i = 0; i < ITERATIONS; i++) {
+        noop();
+    }
+    const timeBase = performance.now() - startBase;
+    const perOpBase = timeBase / ITERATIONS;
+    console.log(`Baseline (noop): ${(timeBase).toFixed(2)}ms total, ${perOpBase.toFixed(6)}ms/op`);
+
+    // measureSync overhead
+    const startSync = performance.now();
+    for (let i = 0; i < ITERATIONS; i++) {
+        measureSync('test', noop);
+    }
+    const timeSync = performance.now() - startSync;
+    const overheadSync = (timeSync - timeBase) / ITERATIONS;
+    console.log(`measureSync:     ${(timeSync).toFixed(2)}ms total, ${overheadSync.toFixed(6)}ms overhead/op`);
+
+    // measure (async) overhead
+    const startAsync = performance.now();
+    for (let i = 0; i < ITERATIONS; i++) {
+        await measure('test', async () => { });
+    }
+    const timeAsync = performance.now() - startAsync;
+    const overheadAsync = (timeAsync - timeBase) / ITERATIONS;
+    console.log(`measure (async): ${(timeAsync).toFixed(2)}ms total, ${overheadAsync.toFixed(6)}ms overhead/op`);
+
+    // Nested overhead (depth 3)
+    const startNested = performance.now();
+    for (let i = 0; i < ITERATIONS / 10; i++) { // reduce iterations
+        measureSync('root', (m) => {
+            m('child', (m2) => {
+                m2('leaf', noop);
+            });
+        });
+    }
+    const timeNested = performance.now() - startNested;
+    // 3 measurements per iteration
+    const perOpNested = timeNested / (ITERATIONS / 10);
+    console.log(`Nested (depth 3): ${(timeNested).toFixed(2)}ms total, ${perOpNested.toFixed(6)}ms per tree (3 ops)`);
+}
+
+run();

package/example.ts

@@ -1,4 +1,4 @@
-import { measure, measureSync, configure, createMeasure, type MeasureFn } from "./index.ts";
+import { measure, measureSync, configure, createMeasure, safeStringify, type MeasureFn } from "./index.ts";
 
 const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
@@ -11,14 +11,13 @@ async function fetchUser(userId: number) {
 async function flakyApi() {
   await sleep(30);
   if (Math.random() < 0.6) throw new Error('Service unavailable');
-  return { status: 'ok', data: [1, 2, 3] };
+  return { status: 'ok' };
 }
 
 async function main() {
-  // Enable timestamps for production-style output
   configure({ timestamps: true });
 
-  // ─── Sync leaf: single line + result ────────────────────────────
+  // ─── Sync leaf: single line + auto-printed result ──────────────
   measureSync('Load config', () => ({ env: 'prod', port: 3000 }));
 
   // ─── Annotation ────────────────────────────────────────────────
@@ -31,17 +30,14 @@ async function main() {
     return { rows, count: rows?.length ?? 0 };
   });
 
-  // ─── Circular reference (safe stringify handles it) ────────────
+  // ─── Circular ref (safe stringify) ─────────────────────────────
   measureSync('Circular ref', () => {
     const obj: any = { name: 'root' };
     obj.self = obj;
     return obj;
   });
 
-  // ─── Long result (auto-truncated) ──────────────────────────────
-  measureSync('Long result', () => ({ data: 'x'.repeat(200) }));
-
-  // ─── Parallel async (interleaved output) ───────────────────────
+  // ─── Parallel async (interleaved) ──────────────────────────────
   await measure('Parallel Fetch', async (m) => {
     await Promise.all([
       m({ label: 'Fetch User', userId: 1 }, () => fetchUser(1)),
@@ -50,18 +46,31 @@ async function main() {
     ]);
   });
 
-  // ─── assert: throws if null ────────────────────────────────────
-  try {
-    const user = await measure.assert('Assert user', () => fetchUser(1));
-    console.log(`Asserted user: ${user.name}`); // guaranteed non-null
-  } catch (e) {
-    console.log('Assert caught:', e);
-  }
+  // ─── Budget: warn when operation exceeds time limit ────────────
+  await measure({ label: 'DB query', budget: 30 }, async () => {
+    await sleep(80); // intentionally slow
+    return { rows: 42 };
+  });
 
-  // ─── retry: automatic retry with backoff ───────────────────────
+  // ─── Retry with backoff ────────────────────────────────────────
   await measure.retry('Flaky API', { attempts: 3, delay: 100, backoff: 2 }, flakyApi);
 
-  // ─── Scoped instances: separate namespaces ─────────────────────
+  // ─── Assert: throws if null ────────────────────────────────────
+  const user = await measure.assert('Assert user', () => fetchUser(1));
+  console.log(`Asserted: ${user.name}`);
+
+  // ─── Wrap: decorator pattern ───────────────────────────────────
+  const getUser = measure.wrap('Get user', fetchUser);
+  await getUser(1);
+  await getUser(2);
+
+  // ─── Batch: process array with progress ────────────────────────
+  const userIds = Array.from({ length: 20 }, (_, i) => i + 1);
+  await measure.batch('Fetch all users', userIds, async (id) => {
+    return await fetchUser(id);
+  }, { every: 5 });
+
+  // ─── Scoped instances ──────────────────────────────────────────
   const api = createMeasure('api');
   const db = createMeasure('db');
 
@@ -72,9 +81,21 @@ async function main() {
     });
   });
 
-  // ─── Timed: get duration programmatically ──────────────────────
-  const { result, duration } = await measure.timed('Timed op', () => fetchUser(1));
-  console.log(`Result: ${result?.name}, Duration: ${duration.toFixed(1)}ms`);
+  // ─── safeStringify utility ─────────────────────────────────────
+  const circular: any = { a: 1 };
+  circular.self = circular;
+  console.log(`safeStringify: ${safeStringify(circular)}`);
+
+  // ─── Smart duration formatting (simulated long op) ─────────────
+  await measure('Quick op', async () => {
+    await sleep(5);
+    return 'fast';
+  });
+
+  await measure('Slow op', async () => {
+    await sleep(1200);
+    return 'slow';
+  });
 }
 
 main().then(() => console.log('\n✅ Done.'));