feat!: reconcile abort-signal with type-safety and efficiency refactors

Layers minimal refactors on top of the abort-signal feature commits:

- Add normalizeError helper (lib/misc.js) and use it in all 5 fillQueue /
  fail-fast catch sites
- Extract isValueObject helper in lib/type-checks.js (DRY for isIterable /
  isAsyncIterable)
- Add bounds check to ordered-insertion while loop in fillQueue so the
  BufferPromise type cast is honest past array end
- Inline null-safety on the IteratorResult shape check
  (`!result || typeof result !== 'object'`); typeof null === 'object' would
  have let null through to the next-line property accesses

Drops the larger-scope tweaks from the harden / efficiency branches that
weren't earning their keep:

- @voxpelli/typed-utils runtime dep (kept the lib zero-dep; the only
  material correctness win — null check on IteratorResult — is inlined)
- yieldArrayWithItem generator (replaces a 1-element array allocation in
  the common case with a generator allocation; not a measurable win and
  less readable than the spread)
- guardedArrayIncludes (the type cast in isPartOfArray is honest enough)

BREAKING CHANGE: engine requirement bumped from >=18.6.0 to >=22.0.0 (native
Symbol.asyncDispose is required). Callback signature widened from
`(item)` to `(item, { signal })`; existing one-arg callbacks keep working
since JS ignores extra args, but TypeScript consumers that pass a callback
type with a strict single-parameter signature may need to update the type.

Author: claude

index.js

@@ -6,8 +6,8 @@
 // TODO: THERE'S ACTUALLY A "throw" method MENTION IN https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation: "NOTE: Exceptions from the inner iterator throw method are propagated. Normal completions from an inner throw method are processed similarly to an inner next." THOUGH NOT SURE HOW TO TRIGGER IT IN PRACTICE, SEE yield.spec.js
 
 import { findLeastTargeted } from './lib/find-least-targeted.js';
-import { arrayDeleteInPlace, makeIterableAsync } from './lib/misc.js';
-import { isAsyncIterable, isIterable, isPartOfArray } from './lib/type-checks.js';
+import { arrayDeleteInPlace, makeIterableAsync, normalizeError } from './lib/misc.js';
+import { isAsyncIterable, isIterable, isObject, isPartOfArray } from './lib/type-checks.js';
 
 /**
  * @template T
@@ -159,10 +159,10 @@ export function bufferedAsyncMap (input, callback, options) {
     const bufferPromise = currentSubIterator
       ? Promise.resolve(currentSubIterator.next())
         .catch(err => ({
-          err: err instanceof Error ? err : new Error('Unknown subiterator error'),
+          err: normalizeError(err, 'Unknown subiterator error'),
         }))
         .then(async result => {
-          if (typeof result !== 'object') {
+          if (!isObject(result)) {
             throw new TypeError('Expected an object value');
           }
           if ('err' in result || result.done) {
@@ -184,10 +184,10 @@ export function bufferedAsyncMap (input, callback, options) {
         })
       : Promise.resolve(asyncIterator.next())
         .catch(err => ({
-          err: err instanceof Error ? err : new Error('Unknown iterator error'),
+          err: normalizeError(err, 'Unknown iterator error'),
         }))
         .then(async result => {
-          if (typeof result !== 'object') {
+          if (!isObject(result)) {
             throw new TypeError('Expected an object value');
           }
           if ('err' in result || result.done) {
@@ -221,7 +221,7 @@ export function bufferedAsyncMap (input, callback, options) {
             promiseValue = {
               bufferPromise,
               done: true,
-              err: err instanceof Error ? err : new Error('Unknown callback error'),
+              err: normalizeError(err, 'Unknown callback error'),
               value: undefined,
             };
           }
@@ -234,7 +234,7 @@ export function bufferedAsyncMap (input, callback, options) {
     if (ordered && currentSubIterator) {
       let i = 0;
 
-      while (promisesToSourceIteratorMap.get(/** @type {BufferPromise} */ (bufferedPromises[i])) === currentSubIterator) {
+      while (i < bufferedPromises.length && promisesToSourceIteratorMap.get(/** @type {BufferPromise} */ (bufferedPromises[i])) === currentSubIterator) {
         i += 1;
       }
 
@@ -319,7 +319,7 @@ export function bufferedAsyncMap (input, callback, options) {
       return { done: true, value: undefined };
     } else if (err || done) {
       if (err) {
-        const normalisedErr = err instanceof Error ? err : new Error('Unknown error');
+        const normalisedErr = normalizeError(err, 'Unknown error');
 
         // In fail-fast mode the first captured error short-circuits iteration:
         // route it through the same abort machinery so the next .next() rejects

lib/misc.js

@@ -22,3 +22,12 @@ export function arrayDeleteInPlace (list, value) {
     list.splice(index, 1);
   }
 }
+
+/**
+ * @param {unknown} err
+ * @param {string} defaultMessage
+ * @returns {Error}
+ */
+export function normalizeError (err, defaultMessage) {
+  return err instanceof Error ? err : new Error(defaultMessage);
+}

lib/type-checks.js

@@ -1,14 +1,20 @@
+/**
+ * @param {unknown} value
+ * @returns {value is object}
+ */
+export const isObject = (value) => Boolean(value && typeof value === 'object');
+
 /**
  * @param {unknown} value
  * @returns {value is Iterable<unknown>}
  */
-export const isIterable = (value) => Boolean(value && typeof value === 'object' && Symbol.iterator in value);
+export const isIterable = (value) => isObject(value) && Symbol.iterator in value;
 
 /**
  * @param {unknown} value
  * @returns {value is AsyncIterable<unknown>}
  */
-export const isAsyncIterable = (value) => Boolean(value && typeof value === 'object' && Symbol.asyncIterator in value);
+export const isAsyncIterable = (value) => isObject(value) && Symbol.asyncIterator in value;
 
 /**
  * @template Values