From 20431a12d822e11995af9fa93c914c58b4c8ba13 Mon Sep 17 00:00:00 2001
From: Mark Stuart <mstuart@users.noreply.github.com>
Date: Sun, 9 Aug 2026 19:43:55 -0700
Subject: [PATCH 1/2] chore: migrate to ultracite

---
 biome.jsonc  | 4 ++++
 package.json | 7 +++++--
 2 files changed, 9 insertions(+), 2 deletions(-)
 create mode 100644 biome.jsonc

diff --git a/biome.jsonc b/biome.jsonc
new file mode 100644
index 0000000..a39804b
--- /dev/null
+++ b/biome.jsonc
@@ -0,0 +1,4 @@
+{
+  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
+  "extends": ["ultracite/biome/core"]
+}
diff --git a/package.json b/package.json
index 279a663..42ee80f 100644
--- a/package.json
+++ b/package.json
@@ -21,7 +21,9 @@
 		"node": ">=22"
 	},
 	"scripts": {
-		"test": "xo && ava && tsd"
+		"test": "ava && tsd",
+		"check": "ultracite check",
+		"fix": "ultracite fix"
 	},
 	"files": [
 		"index.js",
@@ -39,8 +41,9 @@
 		"functional"
 	],
 	"devDependencies": {
+		"@biomejs/biome": "2.5.6",
 		"ava": "^8",
 		"tsd": "^0.33",
-		"xo": "^4.0"
+		"ultracite": "7.10.2"
 	}
 }

From 19d1201c30c6e8924adb052871069d1761418398 Mon Sep 17 00:00:00 2001
From: Mark Stuart <mstuart@users.noreply.github.com>
Date: Sun, 9 Aug 2026 21:07:23 -0700
Subject: [PATCH 2/2] chore: enforce ultracite

---
 .github/workflows/main.yml |   2 +
 AGENTS.md                  | 123 +++++++++++++
 docs/assets/logo.svg       |  58 ++++++-
 index.d.ts                 |  12 +-
 index.js                   |  90 +++++-----
 index.test-d.ts            |  28 +--
 package.json               |  94 +++++-----
 renovate.json              |  25 +--
 test.js                    | 341 ++++++++++++++++++++++---------------
 9 files changed, 510 insertions(+), 263 deletions(-)
 create mode 100644 AGENTS.md

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 55dfe24..8222449 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -18,4 +18,6 @@ jobs:
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm install
+      - name: Ultracite check
+        run: npm run check
       - run: npm test
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..28d2de8
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,123 @@
+# Ultracite Code Standards
+
+This project uses **Ultracite**, a zero-config preset that enforces strict code quality standards through automated formatting and linting.
+
+## Quick Reference
+
+- **Format code**: `npm exec -- ultracite fix`
+- **Check for issues**: `npm exec -- ultracite check`
+- **Diagnose setup**: `npm exec -- ultracite doctor`
+
+Biome (the underlying engine) provides robust linting and formatting. Most issues are automatically fixable.
+
+---
+
+## Core Principles
+
+Write code that is **accessible, performant, type-safe, and maintainable**. Focus on clarity and explicit intent over brevity.
+
+### Type Safety & Explicitness
+
+- Use explicit types for function parameters and return values when they enhance clarity
+- Prefer `unknown` over `any` when the type is genuinely unknown
+- Use const assertions (`as const`) for immutable values and literal types
+- Leverage TypeScript's type narrowing instead of type assertions
+- Use meaningful variable names instead of magic numbers - extract constants with descriptive names
+
+### Modern JavaScript/TypeScript
+
+- Use arrow functions for callbacks and short functions
+- Prefer `for...of` loops over `.forEach()` and indexed `for` loops
+- Use optional chaining (`?.`) and nullish coalescing (`??`) for safer property access
+- Prefer template literals over string concatenation
+- Use destructuring for object and array assignments
+- Use `const` by default, `let` only when reassignment is needed, never `var`
+
+### Async & Promises
+
+- Always `await` promises in async functions - don't forget to use the return value
+- Use `async/await` syntax instead of promise chains for better readability
+- Handle errors appropriately in async code with try-catch blocks
+- Don't use async functions as Promise executors
+
+### React & JSX
+
+- Use function components over class components
+- Call hooks at the top level only, never conditionally
+- Specify all dependencies in hook dependency arrays correctly
+- Use the `key` prop for elements in iterables (prefer unique IDs over array indices)
+- Nest children between opening and closing tags instead of passing as props
+- Don't define components inside other components
+- Use semantic HTML and ARIA attributes for accessibility:
+  - Provide meaningful alt text for images
+  - Use proper heading hierarchy
+  - Add labels for form inputs
+  - Include keyboard event handlers alongside mouse events
+  - Use semantic elements (`<button>`, `<nav>`, etc.) instead of divs with roles
+
+### Error Handling & Debugging
+
+- Remove `console.log`, `debugger`, and `alert` statements from production code
+- Throw `Error` objects with descriptive messages, not strings or other values
+- Use `try-catch` blocks meaningfully - don't catch errors just to rethrow them
+- Prefer early returns over nested conditionals for error cases
+
+### Code Organization
+
+- Keep functions focused and under reasonable cognitive complexity limits
+- Extract complex conditions into well-named boolean variables
+- Use early returns to reduce nesting
+- Prefer simple conditionals over nested ternary operators
+- Group related code together and separate concerns
+
+### Security
+
+- Add `rel="noopener"` when using `target="_blank"` on links
+- Avoid `dangerouslySetInnerHTML` unless absolutely necessary
+- Don't use `eval()` or assign directly to `document.cookie`
+- Validate and sanitize user input
+
+### Performance
+
+- Avoid spread syntax in accumulators within loops
+- Use top-level regex literals instead of creating them in loops
+- Prefer specific imports over namespace imports
+- Avoid barrel files (index files that re-export everything)
+- Use proper image components (e.g., Next.js `<Image>`) over `<img>` tags
+
+### Framework-Specific Guidance
+
+**Next.js:**
+- Use Next.js `<Image>` component for images
+- Use `next/head` or App Router metadata API for head elements
+- Use Server Components for async data fetching instead of async Client Components
+
+**React 19+:**
+- Use ref as a prop instead of `React.forwardRef`
+
+**Solid/Svelte/Vue/Qwik:**
+- Use `class` and `for` attributes (not `className` or `htmlFor`)
+
+---
+
+## Testing
+
+- Write assertions inside `it()` or `test()` blocks
+- Avoid done callbacks in async tests - use async/await instead
+- Don't use `.only` or `.skip` in committed code
+- Keep test suites reasonably flat - avoid excessive `describe` nesting
+
+## When Biome Can't Help
+
+Biome's linter will catch most issues automatically. Focus your attention on:
+
+1. **Business logic correctness** - Biome can't validate your algorithms
+2. **Meaningful naming** - Use descriptive names for functions, variables, and types
+3. **Architecture decisions** - Component structure, data flow, and API design
+4. **Edge cases** - Handle boundary conditions and error states
+5. **User experience** - Accessibility, performance, and usability considerations
+6. **Documentation** - Add comments for complex logic, but prefer self-documenting code
+
+---
+
+Most formatting and common issues are automatically fixed by Biome. Run `npm exec -- ultracite fix` before committing to ensure compliance.
diff --git a/docs/assets/logo.svg b/docs/assets/logo.svg
index ab95c3b..624bf40 100644
--- a/docs/assets/logo.svg
+++ b/docs/assets/logo.svg
@@ -1,12 +1,54 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="800" height="200" viewBox="0 0 800 200" font-family="ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif">
-  <rect width="800" height="200" rx="16" fill="#0d1117"/>
-  <rect x="0.5" y="0.5" width="799" height="199" rx="16" fill="none" stroke="#30363d"/>
+<svg
+  font-family="ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif"
+  height="200"
+  viewBox="0 0 800 200"
+  width="800"
+  xmlns="http://www.w3.org/2000/svg"
+>
+  <title>web-stream-transform</title>
+  <rect fill="#0d1117" height="200" rx="16" width="800" />
+  <rect
+    fill="none"
+    height="199"
+    rx="16"
+    stroke="#30363d"
+    width="799"
+    x="0.5"
+    y="0.5"
+  />
   <g transform="translate(140,38)">
-    <rect width="96" height="96" rx="24" fill="#db6d28"/>
-    <g transform="translate(48,48) scale(0.52)" stroke="#ffffff" stroke-width="10" stroke-linecap="round" stroke-linejoin="round" fill="none">
-      <path d="M0 -44 L52 -16 L0 12 L-52 -16 Z"/><path d="M-52 14 L0 42 L52 14"/>
+    <rect fill="#db6d28" height="96" rx="24" width="96" />
+    <g
+      fill="none"
+      stroke="#ffffff"
+      stroke-linecap="round"
+      stroke-linejoin="round"
+      stroke-width="10"
+      transform="translate(48,48) scale(0.52)"
+    >
+      <path d="M0 -44 L52 -16 L0 12 L-52 -16 Z" />
+      <path d="M-52 14 L0 42 L52 14" />
     </g>
   </g>
-  <text x="266" y="100" fill="#e6edf3" font-size="38" font-weight="800" letter-spacing="-1">web-stream-transform</text>
-  <text x="400" y="154" text-anchor="middle" fill="#8b949e" font-size="16" font-weight="500">Functional transform helpers for Web Streams — map, filter, take, batch, and…</text>
+  <text
+    fill="#e6edf3"
+    font-size="38"
+    font-weight="800"
+    letter-spacing="-1"
+    x="266"
+    y="100"
+  >
+    web-stream-transform
+  </text>
+  <text
+    fill="#8b949e"
+    font-size="16"
+    font-weight="500"
+    text-anchor="middle"
+    x="400"
+    y="154"
+  >
+    Functional transform helpers for Web Streams — map, filter, take, batch,
+    and…
+  </text>
 </svg>
diff --git a/index.d.ts b/index.d.ts
index 4342adf..3235242 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -11,7 +11,9 @@ import {mapStream} from 'web-stream-transform';
 const doubled = ReadableStream.from([1, 2, 3]).pipeThrough(mapStream(x => x * 2));
 ```
 */
-export function mapStream<I, O>(function_: (chunk: I) => O | Promise<O>): TransformStream<I, O>;
+export function mapStream<I, O>(
+  function_: (chunk: I) => O | Promise<O>
+): TransformStream<I, O>;
 
 /**
 Create a TransformStream that filters chunks based on a predicate function.
@@ -26,7 +28,9 @@ import {filterStream} from 'web-stream-transform';
 const evens = ReadableStream.from([1, 2, 3, 4]).pipeThrough(filterStream(x => x % 2 === 0));
 ```
 */
-export function filterStream<T>(function_: (chunk: T) => boolean | Promise<boolean>): TransformStream<T, T>;
+export function filterStream<T>(
+  function_: (chunk: T) => boolean | Promise<boolean>
+): TransformStream<T, T>;
 
 /**
 Create a TransformStream that passes only the first `count` chunks.
@@ -72,4 +76,6 @@ import {tapStream} from 'web-stream-transform';
 const logged = ReadableStream.from([1, 2, 3]).pipeThrough(tapStream(x => console.log(x)));
 ```
 */
-export function tapStream<T>(function_: (chunk: T) => void | Promise<void>): TransformStream<T, T>;
+export function tapStream<T>(
+  function_: (chunk: T) => void | Promise<void>
+): TransformStream<T, T>;
diff --git a/index.js b/index.js
index dfe0cbb..e455c0d 100644
--- a/index.js
+++ b/index.js
@@ -5,11 +5,11 @@ Create a TransformStream that applies an async function to each chunk.
 @returns {TransformStream} A TransformStream that maps each chunk.
 */
 export function mapStream(function_) {
-	return new TransformStream({
-		async transform(chunk, controller) {
-			controller.enqueue(await function_(chunk));
-		},
-	});
+  return new TransformStream({
+    async transform(chunk, controller) {
+      controller.enqueue(await function_(chunk));
+    },
+  });
 }
 
 /**
@@ -19,13 +19,13 @@ Create a TransformStream that filters chunks based on a predicate function.
 @returns {TransformStream} A TransformStream that filters chunks.
 */
 export function filterStream(function_) {
-	return new TransformStream({
-		async transform(chunk, controller) {
-			if (await function_(chunk)) {
-				controller.enqueue(chunk);
-			}
-		},
-	});
+  return new TransformStream({
+    async transform(chunk, controller) {
+      if (await function_(chunk)) {
+        controller.enqueue(chunk);
+      }
+    },
+  });
 }
 
 /**
@@ -35,19 +35,19 @@ Create a TransformStream that passes only the first `count` chunks.
 @returns {TransformStream} A TransformStream that limits chunks.
 */
 export function takeStream(count) {
-	let taken = 0;
-	return new TransformStream({
-		transform(chunk, controller) {
-			if (taken < count) {
-				taken++;
-				controller.enqueue(chunk);
-			}
+  let taken = 0;
+  return new TransformStream({
+    transform(chunk, controller) {
+      if (taken < count) {
+        taken += 1;
+        controller.enqueue(chunk);
+      }
 
-			if (taken >= count) {
-				controller.terminate();
-			}
-		},
-	});
+      if (taken >= count) {
+        controller.terminate();
+      }
+    },
+  });
 }
 
 /**
@@ -57,21 +57,21 @@ Create a TransformStream that collects chunks into arrays of a given size.
 @returns {TransformStream} A TransformStream that batches chunks.
 */
 export function batchStream(size) {
-	let buffer = [];
-	return new TransformStream({
-		transform(chunk, controller) {
-			buffer.push(chunk);
-			if (buffer.length >= size) {
-				controller.enqueue(buffer);
-				buffer = [];
-			}
-		},
-		flush(controller) {
-			if (buffer.length > 0) {
-				controller.enqueue(buffer);
-			}
-		},
-	});
+  let buffer = [];
+  return new TransformStream({
+    flush(controller) {
+      if (buffer.length > 0) {
+        controller.enqueue(buffer);
+      }
+    },
+    transform(chunk, controller) {
+      buffer.push(chunk);
+      if (buffer.length >= size) {
+        controller.enqueue(buffer);
+        buffer = [];
+      }
+    },
+  });
 }
 
 /**
@@ -81,10 +81,10 @@ Create a TransformStream that calls a function for side effects but passes chunk
 @returns {TransformStream} A TransformStream that taps into the stream.
 */
 export function tapStream(function_) {
-	return new TransformStream({
-		async transform(chunk, controller) {
-			await function_(chunk);
-			controller.enqueue(chunk);
-		},
-	});
+  return new TransformStream({
+    async transform(chunk, controller) {
+      await function_(chunk);
+      controller.enqueue(chunk);
+    },
+  });
 }
diff --git a/index.test-d.ts b/index.test-d.ts
index 844c165..fb948b7 100644
--- a/index.test-d.ts
+++ b/index.test-d.ts
@@ -1,18 +1,24 @@
-import {expectType} from 'tsd';
+import { expectType } from "tsd";
 import {
-	mapStream,
-	filterStream,
-	takeStream,
-	batchStream,
-	tapStream,
-} from './index.js';
+  batchStream,
+  filterStream,
+  mapStream,
+  takeStream,
+  tapStream,
+} from "./index.js";
 
 expectType<TransformStream<number, string>>(mapStream<number, string>(String));
-expectType<TransformStream<number, number>>(filterStream<number>(x => x > 0));
+expectType<TransformStream<number, number>>(filterStream<number>((x) => x > 0));
 expectType<TransformStream<number, number>>(takeStream<number>(5));
 expectType<TransformStream<number, number[]>>(batchStream<number>(3));
-expectType<TransformStream<string, string>>(tapStream<string>(x => console.log(x)));
+expectType<TransformStream<string, string>>(
+  tapStream<string>((x) => console.log(x))
+);
 
 // Async functions should also work
-expectType<TransformStream<number, string>>(mapStream<number, string>(async x => String(x)));
-expectType<TransformStream<number, number>>(filterStream<number>(async x => x > 0));
+expectType<TransformStream<number, string>>(
+  mapStream<number, string>(async (x) => String(x))
+);
+expectType<TransformStream<number, number>>(
+  filterStream<number>(async (x) => x > 0)
+);
diff --git a/package.json b/package.json
index 42ee80f..5a74fa1 100644
--- a/package.json
+++ b/package.json
@@ -1,49 +1,49 @@
 {
-	"name": "web-stream-transform",
-	"version": "1.0.0",
-	"description": "Functional transform helpers for Web Streams — map, filter, take, batch, and tap",
-	"license": "MIT",
-	"repository": "mstuart/web-stream-transform",
-	"author": {
-		"name": "Mark Stuart",
-		"email": "mstuart@users.noreply.github.com",
-		"url": "https://github.com/mstuart"
-	},
-	"type": "module",
-	"exports": {
-		".": {
-			"types": "./index.d.ts",
-			"default": "./index.js"
-		}
-	},
-	"sideEffects": false,
-	"engines": {
-		"node": ">=22"
-	},
-	"scripts": {
-		"test": "ava && tsd",
-		"check": "ultracite check",
-		"fix": "ultracite fix"
-	},
-	"files": [
-		"index.js",
-		"index.d.ts"
-	],
-	"keywords": [
-		"stream",
-		"transform",
-		"web",
-		"readablestream",
-		"transformstream",
-		"map",
-		"filter",
-		"pipe",
-		"functional"
-	],
-	"devDependencies": {
-		"@biomejs/biome": "2.5.6",
-		"ava": "^8",
-		"tsd": "^0.33",
-		"ultracite": "7.10.2"
-	}
+  "name": "web-stream-transform",
+  "version": "1.0.0",
+  "description": "Functional transform helpers for Web Streams — map, filter, take, batch, and tap",
+  "keywords": [
+    "stream",
+    "transform",
+    "web",
+    "readablestream",
+    "transformstream",
+    "map",
+    "filter",
+    "pipe",
+    "functional"
+  ],
+  "repository": "mstuart/web-stream-transform",
+  "license": "MIT",
+  "author": {
+    "name": "Mark Stuart",
+    "email": "mstuart@users.noreply.github.com",
+    "url": "https://github.com/mstuart"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "check": "ultracite check",
+    "fix": "ultracite fix",
+    "test": "ava && tsd"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.6",
+    "ava": "^8",
+    "tsd": "^0.33",
+    "ultracite": "7.10.2"
+  },
+  "engines": {
+    "node": ">=22"
+  }
 }
diff --git a/renovate.json b/renovate.json
index 3e0220c..5c0a90d 100644
--- a/renovate.json
+++ b/renovate.json
@@ -1,18 +1,11 @@
 {
-	"$schema": "https://docs.renovatebot.com/renovate-schema.json",
-	"extends": [
-		"config:recommended"
-	],
-	"packageRules": [
-		{
-			"matchUpdateTypes": [
-				"patch",
-				"minor"
-			],
-			"matchDepTypes": [
-				"devDependencies"
-			],
-			"automerge": true
-		}
-	]
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": ["config:recommended"],
+  "packageRules": [
+    {
+      "matchUpdateTypes": ["patch", "minor"],
+      "matchDepTypes": ["devDependencies"],
+      "automerge": true
+    }
+  ]
 }
diff --git a/test.js b/test.js
index 9b0b772..890f046 100644
--- a/test.js
+++ b/test.js
@@ -1,200 +1,275 @@
-import test from 'ava';
+import test from "ava";
 import {
-	mapStream,
-	filterStream,
-	takeStream,
-	batchStream,
-	tapStream,
-} from './index.js';
+  batchStream,
+  filterStream,
+  mapStream,
+  takeStream,
+  tapStream,
+} from "./index.js";
 
 async function collectStream(readable) {
-	const results = [];
-	const reader = readable.getReader();
-	for (;;) {
-		const {done, value} = await reader.read(); // eslint-disable-line no-await-in-loop
-		if (done) {
-			break;
-		}
-
-		results.push(value);
-	}
-
-	return results;
+  const results = [];
+  const reader = readable.getReader();
+  for (;;) {
+    // biome-ignore lint/performance/noAwaitInLoops: Stream reads are inherently sequential.
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+
+    results.push(value);
+  }
+
+  return results;
 }
 
 function createReadable(items) {
-	return new ReadableStream({
-		start(controller) {
-			for (const item of items) {
-				controller.enqueue(item);
-			}
-
-			controller.close();
-		},
-	});
+  return new ReadableStream({
+    start(controller) {
+      for (const item of items) {
+        controller.enqueue(item);
+      }
+
+      controller.close();
+    },
+  });
 }
 
 // MapStream tests
 
-test('mapStream transforms each chunk', async t => {
-	const result = await collectStream(createReadable([1, 2, 3]).pipeThrough(mapStream(x => x * 2)));
-	t.deepEqual(result, [2, 4, 6]);
+test("mapStream transforms each chunk", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3]).pipeThrough(mapStream((x) => x * 2))
+  );
+  t.deepEqual(result, [2, 4, 6]);
 });
 
-test('mapStream works with async functions', async t => {
-	const result = await collectStream(createReadable(['a', 'b']).pipeThrough(mapStream(async x => x.toUpperCase())));
-	t.deepEqual(result, ['A', 'B']);
+test("mapStream works with async functions", async (t) => {
+  const result = await collectStream(
+    createReadable(["a", "b"]).pipeThrough(
+      mapStream(async (x) => x.toUpperCase())
+    )
+  );
+  t.deepEqual(result, ["A", "B"]);
 });
 
-test('mapStream handles empty stream', async t => {
-	const result = await collectStream(createReadable([]).pipeThrough(mapStream(x => x * 2)));
-	t.deepEqual(result, []);
+test("mapStream handles empty stream", async (t) => {
+  const result = await collectStream(
+    createReadable([]).pipeThrough(mapStream((x) => x * 2))
+  );
+  t.deepEqual(result, []);
 });
 
-test('mapStream transforms to different types', async t => {
-	const result = await collectStream(createReadable([1, 2, 3]).pipeThrough(mapStream(String)));
-	t.deepEqual(result, ['1', '2', '3']);
+test("mapStream transforms to different types", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3]).pipeThrough(mapStream(String))
+  );
+  t.deepEqual(result, ["1", "2", "3"]);
 });
 
 // FilterStream tests
 
-test('filterStream keeps matching chunks', async t => {
-	const result = await collectStream(createReadable([1, 2, 3, 4, 5]).pipeThrough(filterStream(x => x % 2 === 0)));
-	t.deepEqual(result, [2, 4]);
+test("filterStream keeps matching chunks", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3, 4, 5]).pipeThrough(
+      filterStream((x) => x % 2 === 0)
+    )
+  );
+  t.deepEqual(result, [2, 4]);
 });
 
-test('filterStream removes all when none match', async t => {
-	const result = await collectStream(createReadable([1, 3, 5]).pipeThrough(filterStream(x => x % 2 === 0)));
-	t.deepEqual(result, []);
+test("filterStream removes all when none match", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 3, 5]).pipeThrough(filterStream((x) => x % 2 === 0))
+  );
+  t.deepEqual(result, []);
 });
 
-test('filterStream keeps all when all match', async t => {
-	const result = await collectStream(createReadable([2, 4, 6]).pipeThrough(filterStream(x => x % 2 === 0)));
-	t.deepEqual(result, [2, 4, 6]);
+test("filterStream keeps all when all match", async (t) => {
+  const result = await collectStream(
+    createReadable([2, 4, 6]).pipeThrough(filterStream((x) => x % 2 === 0))
+  );
+  t.deepEqual(result, [2, 4, 6]);
 });
 
-test('filterStream works with async predicate', async t => {
-	const result = await collectStream(createReadable([1, 2, 3]).pipeThrough(filterStream(async x => x > 1)));
-	t.deepEqual(result, [2, 3]);
+test("filterStream works with async predicate", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3]).pipeThrough(filterStream(async (x) => x > 1))
+  );
+  t.deepEqual(result, [2, 3]);
 });
 
-test('filterStream handles empty stream', async t => {
-	const result = await collectStream(createReadable([]).pipeThrough(filterStream(() => true)));
-	t.deepEqual(result, []);
+test("filterStream handles empty stream", async (t) => {
+  const result = await collectStream(
+    createReadable([]).pipeThrough(filterStream(() => true))
+  );
+  t.deepEqual(result, []);
 });
 
 // TakeStream tests
 
-test('takeStream limits output to count', async t => {
-	const result = await collectStream(createReadable([1, 2, 3, 4, 5]).pipeThrough(takeStream(3)));
-	t.deepEqual(result, [1, 2, 3]);
+test("takeStream limits output to count", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3, 4, 5]).pipeThrough(takeStream(3))
+  );
+  t.deepEqual(result, [1, 2, 3]);
 });
 
-test('takeStream returns all when count exceeds length', async t => {
-	const result = await collectStream(createReadable([1, 2]).pipeThrough(takeStream(5)));
-	t.deepEqual(result, [1, 2]);
+test("takeStream returns all when count exceeds length", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2]).pipeThrough(takeStream(5))
+  );
+  t.deepEqual(result, [1, 2]);
 });
 
-test('takeStream returns empty for count 0', async t => {
-	const result = await collectStream(createReadable([1, 2, 3]).pipeThrough(takeStream(0)));
-	t.deepEqual(result, []);
+test("takeStream returns empty for count 0", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3]).pipeThrough(takeStream(0))
+  );
+  t.deepEqual(result, []);
 });
 
-test('takeStream takes exactly 1', async t => {
-	const result = await collectStream(createReadable([10, 20, 30]).pipeThrough(takeStream(1)));
-	t.deepEqual(result, [10]);
+test("takeStream takes exactly 1", async (t) => {
+  const result = await collectStream(
+    createReadable([10, 20, 30]).pipeThrough(takeStream(1))
+  );
+  t.deepEqual(result, [10]);
 });
 
 // BatchStream tests
 
-test('batchStream groups chunks into arrays', async t => {
-	const result = await collectStream(createReadable([1, 2, 3, 4]).pipeThrough(batchStream(2)));
-	t.deepEqual(result, [[1, 2], [3, 4]]);
+test("batchStream groups chunks into arrays", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3, 4]).pipeThrough(batchStream(2))
+  );
+  t.deepEqual(result, [
+    [1, 2],
+    [3, 4],
+  ]);
 });
 
-test('batchStream flushes remainder', async t => {
-	const result = await collectStream(createReadable([1, 2, 3, 4, 5]).pipeThrough(batchStream(2)));
-	t.deepEqual(result, [[1, 2], [3, 4], [5]]);
+test("batchStream flushes remainder", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3, 4, 5]).pipeThrough(batchStream(2))
+  );
+  t.deepEqual(result, [[1, 2], [3, 4], [5]]);
 });
 
-test('batchStream with size 1 wraps each chunk', async t => {
-	const result = await collectStream(createReadable([1, 2, 3]).pipeThrough(batchStream(1)));
-	t.deepEqual(result, [[1], [2], [3]]);
+test("batchStream with size 1 wraps each chunk", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3]).pipeThrough(batchStream(1))
+  );
+  t.deepEqual(result, [[1], [2], [3]]);
 });
 
-test('batchStream handles empty stream', async t => {
-	const result = await collectStream(createReadable([]).pipeThrough(batchStream(3)));
-	t.deepEqual(result, []);
+test("batchStream handles empty stream", async (t) => {
+  const result = await collectStream(
+    createReadable([]).pipeThrough(batchStream(3))
+  );
+  t.deepEqual(result, []);
 });
 
-test('batchStream with size larger than input', async t => {
-	const result = await collectStream(createReadable([1, 2]).pipeThrough(batchStream(5)));
-	t.deepEqual(result, [[1, 2]]);
+test("batchStream with size larger than input", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2]).pipeThrough(batchStream(5))
+  );
+  t.deepEqual(result, [[1, 2]]);
 });
 
-test('batchStream exact multiple', async t => {
-	const result = await collectStream(createReadable([1, 2, 3, 4, 5, 6]).pipeThrough(batchStream(3)));
-	t.deepEqual(result, [[1, 2, 3], [4, 5, 6]]);
+test("batchStream exact multiple", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3, 4, 5, 6]).pipeThrough(batchStream(3))
+  );
+  t.deepEqual(result, [
+    [1, 2, 3],
+    [4, 5, 6],
+  ]);
 });
 
 // TapStream tests
 
-test('tapStream passes chunks through unchanged', async t => {
-	const result = await collectStream(createReadable([1, 2, 3]).pipeThrough(tapStream(() => {})));
-	t.deepEqual(result, [1, 2, 3]);
+test("tapStream passes chunks through unchanged", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3]).pipeThrough(tapStream(() => undefined))
+  );
+  t.deepEqual(result, [1, 2, 3]);
 });
 
-test('tapStream calls function for side effects', async t => {
-	const seen = [];
-	const result = await collectStream(createReadable([1, 2, 3]).pipeThrough(tapStream(x => {
-		seen.push(x);
-	})));
-	t.deepEqual(result, [1, 2, 3]);
-	t.deepEqual(seen, [1, 2, 3]);
+test("tapStream calls function for side effects", async (t) => {
+  const seen = [];
+  const result = await collectStream(
+    createReadable([1, 2, 3]).pipeThrough(
+      tapStream((x) => {
+        seen.push(x);
+      })
+    )
+  );
+  t.deepEqual(result, [1, 2, 3]);
+  t.deepEqual(seen, [1, 2, 3]);
 });
 
-test('tapStream works with async side effects', async t => {
-	const seen = [];
-	const result = await collectStream(createReadable(['a', 'b']).pipeThrough(tapStream(async x => {
-		seen.push(x);
-	})));
-	t.deepEqual(result, ['a', 'b']);
-	t.deepEqual(seen, ['a', 'b']);
+test("tapStream works with async side effects", async (t) => {
+  const seen = [];
+  const result = await collectStream(
+    createReadable(["a", "b"]).pipeThrough(
+      tapStream(async (x) => {
+        await Promise.resolve();
+        seen.push(x);
+      })
+    )
+  );
+  t.deepEqual(result, ["a", "b"]);
+  t.deepEqual(seen, ["a", "b"]);
 });
 
-test('tapStream handles empty stream', async t => {
-	const seen = [];
-	const result = await collectStream(createReadable([]).pipeThrough(tapStream(x => {
-		seen.push(x);
-	})));
-	t.deepEqual(result, []);
-	t.deepEqual(seen, []);
+test("tapStream handles empty stream", async (t) => {
+  const seen = [];
+  const result = await collectStream(
+    createReadable([]).pipeThrough(
+      tapStream((x) => {
+        seen.push(x);
+      })
+    )
+  );
+  t.deepEqual(result, []);
+  t.deepEqual(seen, []);
 });
 
 // Chaining tests
 
-test('chaining multiple transforms with pipeThrough', async t => {
-	const result = await collectStream(createReadable([1, 2, 3, 4, 5, 6])
-		.pipeThrough(filterStream(x => x % 2 === 0))
-		.pipeThrough(mapStream(x => x * 10))
-		.pipeThrough(takeStream(2)));
-	t.deepEqual(result, [20, 40]);
-});
-
-test('chaining filter then batch', async t => {
-	const result = await collectStream(createReadable([1, 2, 3, 4, 5, 6, 7, 8])
-		.pipeThrough(filterStream(x => x > 2))
-		.pipeThrough(batchStream(3)));
-	t.deepEqual(result, [[3, 4, 5], [6, 7, 8]]);
-});
-
-test('chaining tap then map', async t => {
-	const seen = [];
-	const result = await collectStream(createReadable([1, 2, 3])
-		.pipeThrough(tapStream(x => {
-			seen.push(x);
-		}))
-		.pipeThrough(mapStream(x => x + 100)));
-	t.deepEqual(seen, [1, 2, 3]);
-	t.deepEqual(result, [101, 102, 103]);
+test("chaining multiple transforms with pipeThrough", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3, 4, 5, 6])
+      .pipeThrough(filterStream((x) => x % 2 === 0))
+      .pipeThrough(mapStream((x) => x * 10))
+      .pipeThrough(takeStream(2))
+  );
+  t.deepEqual(result, [20, 40]);
+});
+
+test("chaining filter then batch", async (t) => {
+  const result = await collectStream(
+    createReadable([1, 2, 3, 4, 5, 6, 7, 8])
+      .pipeThrough(filterStream((x) => x > 2))
+      .pipeThrough(batchStream(3))
+  );
+  t.deepEqual(result, [
+    [3, 4, 5],
+    [6, 7, 8],
+  ]);
+});
+
+test("chaining tap then map", async (t) => {
+  const seen = [];
+  const result = await collectStream(
+    createReadable([1, 2, 3])
+      .pipeThrough(
+        tapStream((x) => {
+          seen.push(x);
+        })
+      )
+      .pipeThrough(mapStream((x) => x + 100))
+  );
+  t.deepEqual(seen, [1, 2, 3]);
+  t.deepEqual(result, [101, 102, 103]);
 });