feat(result): make AsyncResult.all short-circuit on first Fail

- Implement sequential evaluation with early exit to avoid waiting on later items when a failure is encountered\n- Add test verifying early return behavior (does not wait for slow item)\n- Document semantics in method JSDoc

Author: CharlieHelps

src/result/async-result.all.spec.ts

@@ -0,0 +1,21 @@
+import { AsyncResult } from './async-result'
+
+describe('AsyncResult.all (short-circuit)', () => {
+  it('should short-circuit and not wait for later items after a failure', async () => {
+    const a = AsyncResult.ok<number, string>(1)
+    const bad = AsyncResult.fail<number, string>('boom')
+
+    const slow = AsyncResult.fromPromise<number, string>(
+      new Promise<number>(resolve => setTimeout(() => resolve(99), 200))
+    )
+
+    const start = Date.now()
+    const res = await AsyncResult.all([a, bad, slow]).toPromise()
+    const elapsed = Date.now() - start
+
+    expect(res.isFail()).toBe(true)
+    expect(res.unwrapFail()).toBe('boom')
+    // Should return well before the slow item resolves (200ms). Allow a generous margin.
+    expect(elapsed).toBeLessThan(150)
+  })
+})

src/result/async-result.ts

@@ -36,8 +36,22 @@ export class AsyncResult<TOk, TFail> {
     return new AsyncResult<TOk, TFail>(Result.fromPromise<TOk, TFail>(promise))
   }
 
+  /**
+   * Aggregate a list of AsyncResult values, short-circuiting on the first Fail.
+   * Note: evaluation is sequential to enable early exit; this method does not
+   * guarantee concurrent execution of inputs. If all are Ok, returns Ok of the
+   * collected values preserving order; otherwise returns the first Fail seen.
+   */
   static all<T, E>(items: ReadonlyArray<AsyncResult<T, E>>): AsyncResult<ReadonlyArray<T>, E> {
-    const p = Promise.all(items.map(i => i.promise)).then(results => Result.sequence(results))
+    const p = (async () => {
+      const acc: T[] = []
+      for (const ar of items) {
+        const r = await ar.toPromise()
+        if (r.isFail()) return Result.fail<ReadonlyArray<T>, E>(r.unwrapFail())
+        acc.push(r.unwrap())
+      }
+      return Result.ok<ReadonlyArray<T>, E>(acc)
+    })()
     return new AsyncResult<ReadonlyArray<T>, E>(p)
   }