chore: migrate to Ultracite

.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

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.

biome.jsonc

@@ -0,0 +1,4 @@
+{
+  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
+  "extends": ["ultracite/biome/core"]
+}

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>;

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);
+    },
+  });
 }

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)
+);