feat: Add image compression support and parallel file processing

.Jules/palette.md

@@ -0,0 +1,3 @@
+## 2025-12-30 - Sidebar Toggle Accessibility
+**Learning:** `aria-pressed` is for toggle buttons (like Bold/Italic), while `aria-expanded` is for disclosing content (like Menus/Sidebars). Screen readers treat them differently.
+**Action:** Always check if a toggle button controls a region (`aria-expanded`) or changes a state (`aria-pressed`).

.changeset/feat-image-support.md

@@ -0,0 +1,20 @@
+---
+"@node-minify/sharp": minor
+"@node-minify/svgo": minor
+"@node-minify/imagemin": minor
+"@node-minify/utils": patch
+"@node-minify/types": patch
+"@node-minify/core": patch
+---
+
+feat: Add image compression support
+
+New packages:
+- `@node-minify/sharp`: Convert and compress images to WebP, AVIF, PNG, JPEG using sharp
+- `@node-minify/svgo`: Optimize SVG files using SVGO
+- `@node-minify/imagemin`: Compress PNG, JPEG, GIF images using imagemin
+
+Core changes:
+- Support for binary (Buffer) content in compressors
+- Multi-format output support (e.g., convert PNG to both WebP and AVIF)
+- New `buffer` and `outputs` fields in CompressorResult type

.github/workflows/codeql.yml

@@ -28,11 +28,13 @@ jobs:
 
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.5"
 
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
-          node-version: '22'
+          node-version: "22"
 
       - name: Install dependencies
         run: bun install --frozen-lockfile

.github/workflows/publish.yml

@@ -47,7 +47,31 @@ jobs:
         with:
           publish: bun run changeset:release
           version: bun run changeset:version
-          createGithubReleases: true
+          createGithubReleases: false
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_CONFIG_PROVENANCE: true
+
+      - name: 📦 Create Aggregated GitHub Release
+        if: steps.changesets.outputs.published == 'true'
+        run: |
+          VERSION=$(jq -r '.version' packages/core/package.json)
+          PACKAGES='${{ steps.changesets.outputs.publishedPackages }}'
+
+          # Format package list as markdown
+          PACKAGE_LIST=$(echo "$PACKAGES" | jq -r '.[] | "- `\(.name)@\(.version)`"')
+
+          # Create release notes
+          cat > /tmp/release-notes.md << 'EOF'
+          ## Published Packages
+
+          EOF
+          echo "$PACKAGE_LIST" >> /tmp/release-notes.md
+          echo "" >> /tmp/release-notes.md
+          echo "See individual package CHANGELOGs for details." >> /tmp/release-notes.md
+
+          gh release create "v${VERSION}" \
+            --title "v${VERSION}" \
+            --notes-file /tmp/release-notes.md
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -1,6 +1,16 @@
 name: Test
 
-on: [push]
+permissions:
+  contents: read
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+
+concurrency:
+  group: test-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
   test:
@@ -15,20 +25,22 @@ jobs:
 
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.5"
 
       - name: Set up JDK 11
         uses: actions/setup-java@v5
         with:
           java-version: '11'
-          distribution: 'adopt'
+          distribution: 'temurin'
 
       - name: Use Node.js ${{ matrix.node-version }} on ${{ matrix.os }}
         uses: actions/setup-node@v6
         with:
           node-version: ${{ matrix.node-version }}
 
       - name: Install dependencies
-        run: bun install
+        run: bun install --frozen-lockfile
 
       - name: Run tests
         run: bun run ci

.gitignore

@@ -14,3 +14,4 @@ tests/tmp
 *.tsbuildinfo
 examples/public/**/*-dist
 examples/public/**/*.min.html
+packages/utils/__tests__/temp_perf/

.jules/bolt.md

@@ -0,0 +1 @@
+# Bolt's Journal

AGENTS.md

@@ -0,0 +1,232 @@
+# AGENTS.md
+
+This file provides guidance to AI coding assistants when working with code in this repository.
+
+## Requirements
+- **Node.js**: >=20.0.0
+- **Bun**: 1.3.5+
+
+## Package Manager
+
+This branch (`main`) uses **Bun** as the package manager and runtime.
+
+## Commands
+- **Install**: `bun install`
+- **Build**: `bun run build`
+- **Lint**: `bun run lint` | **Format**: `bun run format`
+- **Test all**: `bun run test`
+- **Test single package**: `bun run test packages/<name>` (e.g., `bun run test packages/core`)
+- **Test single file**: `bun run test packages/core/__tests__/core.test.ts`
+- **Typecheck**: `bun run typecheck`
+- **CI (full)**: `bun run ci`
+
+## Code Style (Biome)
+- **Indent**: 4 spaces | **Quotes**: double | **Semicolons**: always | **Trailing commas**: ES5
+- **Imports**: Use `type` keyword for type-only imports. Use `node:` prefix for Node.js built-ins (e.g., `node:child_process`)
+- **File extensions**: Include `.ts` in local imports (e.g., `./setup.ts`)
+- **Naming**: camelCase for functions/variables, PascalCase for types/interfaces
+- **Tests**: Vitest with `describe`/`test`/`expect`. Files in `packages/*/__tests__/*.test.ts`
+- **Error handling**: Use `try/catch` with `if (err instanceof Error)` checks
+- **Source files**: Include copyright header: `/*! node-minify ... MIT Licensed */`
+
+### Linter Rules (from biome.json)
+- `noForEach`: off (forEach allowed)
+- `noParameterAssign`: off (parameter reassignment allowed)
+- `noExplicitAny`: off (but prefer proper types when possible)
+- Organize imports automatically on save
+
+## Architecture
+
+This is a Bun monorepo for compressing JavaScript, CSS, and HTML files using various backends.
+
+### Package Structure
+
+**Core packages** (in `/packages`):
+- `core` - Main `minify()` function, orchestrates compression
+- `utils` - Shared utilities (file operations, gzip sizing)
+- `run` - Command execution wrapper for external tools
+- `types` - TypeScript type definitions (not compiled)
+- `cli` - Command-line interface
+
+**Compressor packages** - Each wraps a specific minification library:
+- JS: `esbuild`, `google-closure-compiler`, `oxc`, `swc`, `terser`, `uglify-js`
+- CSS: `clean-css`, `cssnano`, `csso`, `esbuild`, `lightningcss`
+- HTML: `html-minifier`
+- Other: `jsonminify`, `no-compress` (passthrough)
+
+**Deprecated** (still available but unmaintained upstream):
+- `babel-minify` - Babel 6 only, use `terser` instead
+- `uglify-es` - Unmaintained, use `terser` instead
+- `yui` - Java-based, use modern alternatives instead
+- `crass` - Unmaintained, use `lightningcss` or `clean-css` instead
+- `sqwish` - Unmaintained, use `lightningcss` or `clean-css` instead
+
+### Dependencies
+
+`core` depends on `utils` and `run`. All compressor packages depend on `core`. The build command (`bun run build`) builds `utils` and `run` first, then all other packages.
+
+### Package Pattern
+
+All packages follow the same structure:
+```text
+packages/<name>/
+├── src/index.ts      # Main export
+├── __tests__/        # Vitest tests
+├── package.json
+└── tsconfig.json
+```
+
+Build: `tsdown` (configured via `tsdown.config.ts`)
+
+## Changesets
+
+This project uses [Changesets](https://github.com/changesets/changesets) for versioning.
+- **Add changeset**: `bun run changeset` (interactive prompt)
+- **Version packages**: `bun run changeset:version`
+- Required for any user-facing changes (features, fixes, breaking changes)
+
+## Adding a New Compressor
+
+1. Create `packages/<name>/` with standard structure
+2. Export async function matching `Compressor` type from `@node-minify/types`
+3. Function receives `{ settings, content }`, returns `{ code, map? }`
+4. Add tests using shared helpers from `tests/fixtures.ts`
+
+Example compressor signature:
+```ts
+import type { CompressorResult, MinifierOptions } from "@node-minify/types";
+
+export async function myCompressor({
+    settings,
+    content,
+}: MinifierOptions): Promise<CompressorResult> {
+    // ... minification logic
+    return { code: minifiedCode, map: sourceMap };
+}
+```
+
+## Testing
+
+Tests use shared fixtures from `tests/fixtures.ts`:
+- `runOneTest({ options, compressorLabel, compressor })` - Run a single test case
+- `tests` object contains test suites: `commonjs`, `commoncss`, `commonhtml`, `uglifyjs`, etc.
+
+Types are in `packages/types/src/types.d.ts` (not `index.ts`).
+
+## Key Types
+
+From `@node-minify/types`:
+- `Settings` - User-facing options for `minify()` function
+- `MinifierOptions` - What compressors receive (`{ settings, content }`)
+- `CompressorResult` - What compressors return (`{ code, map? }`)
+- `Compressor` - Function type: `(args: MinifierOptions) => Promise<CompressorResult>`
+
+## Common Patterns
+
+### File Operations (from @node-minify/utils)
+```ts
+import { readFile, writeFile, getFilesizeInBytes } from "@node-minify/utils";
+
+const content = await readFile("src/app.js");
+await writeFile({ file: "dist/app.min.js", content, index: 0 });
+const size = await getFilesizeInBytes("dist/app.min.js");
+```
+
+### Deprecation Warnings
+```ts
+import { warnDeprecation } from "@node-minify/utils";
+
+warnDeprecation("@node-minify/old-package", "Use @node-minify/new-package instead");
+```
+
+### Async / Parallel Patterns
+
+The codebase uses async functions for file operations and parallel compression.
+
+#### Async File Operations
+```ts
+import {
+    getContentFromFilesAsync,
+    isValidFileAsync,
+} from "@node-minify/utils";
+
+// Async file reading (preferred for non-blocking IO)
+const content = await getContentFromFilesAsync("src/app.js");
+const contents = await getContentFromFilesAsync(["src/a.js", "src/b.js"]);
+
+// Async file validation
+if (await isValidFileAsync("src/app.js")) {
+    // file exists and is readable
+}
+```
+
+#### Parallel Compression (Array Inputs)
+
+The core `minify()` function automatically processes array inputs in parallel:
+```ts
+// Core handles parallelization internally via Promise.all
+await minify({
+    compressor: terser,
+    input: ["src/a.js", "src/b.js", "src/c.js"],
+    output: ["dist/a.min.js", "dist/b.min.js", "dist/c.min.js"],
+});
+```
+
+#### Custom Parallel Processing
+
+For custom parallel operations:
+```ts
+// Basic parallel execution
+const results = await Promise.all(
+    files.map(async (file, index) => {
+        const content = await getContentFromFilesAsync(file);
+        return run({ settings, content, index });
+    })
+);
+
+// With error handling per item (use allSettled)
+const results = await Promise.allSettled(
+    files.map(file => compressSingleFile({ ...settings, input: file }))
+);
+// Map results back to inputs
+results.forEach((result, i) => {
+    if (result.status === "fulfilled") {
+        console.log(`${files[i]}: success`);
+    } else {
+        console.error(`${files[i]}: ${result.reason}`);
+    }
+});
+```
+
+#### Concurrency Limits
+
+For large arrays, limit concurrent operations to avoid resource exhaustion:
+```ts
+// Using p-limit (install: bun add p-limit)
+import pLimit from "p-limit";
+
+const limit = pLimit(5); // max 5 concurrent
+const results = await Promise.all(
+    files.map(file => limit(() => compressSingleFile({ ...settings, input: file })))
+);
+
+// Or batch processing
+async function processBatches<T>(items: T[], batchSize: number, fn: (item: T) => Promise<unknown>) {
+    for (let i = 0; i < items.length; i += batchSize) {
+        await Promise.all(items.slice(i, i + batchSize).map(fn));
+    }
+}
+```
+
+**Guidelines:**
+- Use `Promise.all` when all operations must succeed (fail-fast)
+- Use `Promise.allSettled` when you need results for all items regardless of individual failures
+- Limit concurrency to 5-10 for file operations, 2-4 for CPU-intensive compressions
+- Always maintain 1:1 mapping between inputs and outputs for traceability
+
+## Troubleshooting
+
+- **Build fails**: Run `bun run build:deps` first to build `utils` and `run`
+- **Type errors**: Ensure `bun run build` completed; types come from compiled `dist/`
+- **Test isolation**: Tests use `tests/tmp/` for output files (gitignored)
+- **Clean rebuild**: `bun run clean && bun run build`