fix: resolve CI test failures and formatting issues

- Add CI environment detection to benchmark tests with lower thresholds
- Fix unused variable warnings in benchmark files
- Fix prettier formatting issues across benchmark and test files
- Update version to 1.0.0-beta.1 with matching optional dependencies
- Add API performance guide documentation

Author: richiemcilroy

benches/api/async_bench.ts

@@ -105,7 +105,7 @@ function median(arr: number[]): number {
   return percentile(arr, 50)
 }
 
-function forceGC() {
+function _forceGC() {
   if (global.gc) {
     global.gc()
   }
@@ -163,7 +163,7 @@ async function runAsyncBenchmark(
   // Check result consistency (use sets for comparison)
   const globSet = new Set(globResults)
   const globlinSet = new Set(globlinResults)
-  const resultMatch = globSet.size === globlinSet.size && [...globSet].every((r) => globlinSet.has(r))
+  const resultMatch = globSet.size === globlinSet.size && [...globSet].every(r => globlinSet.has(r))
 
   const fixtureLabel = cwd.includes('small')
     ? 'small'
@@ -218,21 +218,37 @@ async function runConcurrencyBenchmark(
   const fgOptions = { cwd }
 
   // Warmup
-  await Promise.all([ogGlob(pattern, ogOptions), glob(pattern, globlinOptions), fg(pattern, fgOptions)])
+  await Promise.all([
+    ogGlob(pattern, ogOptions),
+    glob(pattern, globlinOptions),
+    fg(pattern, fgOptions),
+  ])
 
   // Benchmark glob - concurrent operations
   const globStart = performance.now()
-  await Promise.all(Array(concurrency).fill(0).map(() => ogGlob(pattern, ogOptions)))
+  await Promise.all(
+    Array(concurrency)
+      .fill(0)
+      .map(() => ogGlob(pattern, ogOptions))
+  )
   const globTotal = performance.now() - globStart
 
   // Benchmark globlin - concurrent operations
   const globlinStart = performance.now()
-  await Promise.all(Array(concurrency).fill(0).map(() => glob(pattern, globlinOptions)))
+  await Promise.all(
+    Array(concurrency)
+      .fill(0)
+      .map(() => glob(pattern, globlinOptions))
+  )
   const globlinTotal = performance.now() - globlinStart
 
   // Benchmark fast-glob - concurrent operations
   const fgStart = performance.now()
-  await Promise.all(Array(concurrency).fill(0).map(() => fg(pattern, fgOptions)))
+  await Promise.all(
+    Array(concurrency)
+      .fill(0)
+      .map(() => fg(pattern, fgOptions))
+  )
   const fgTotal = performance.now() - fgStart
 
   const fixtureLabel = cwd.includes('small')
@@ -325,19 +341,20 @@ async function measureEventLoopLatency(
     while (running) {
       const expected = intervalMs
       const start = performance.now()
-      await new Promise((resolve) => setTimeout(resolve, intervalMs))
+      await new Promise(resolve => setTimeout(resolve, intervalMs))
       const actual = performance.now() - start
       latencies.push(actual - expected)
     }
   }
 
-  const monitorPromise = monitor()
+  // Start monitor (intentionally not awaited to run concurrently)
+  void monitor()
 
   // Run the glob operation
   await glob(pattern, { cwd })
 
   running = false
-  await new Promise((resolve) => setTimeout(resolve, 20)) // Allow monitor to exit
+  await new Promise(resolve => setTimeout(resolve, 20)) // Allow monitor to exit
 
   return {
     avgLatency: latencies.length > 0 ? latencies.reduce((a, b) => a + b, 0) / latencies.length : 0,
@@ -586,7 +603,12 @@ async function main() {
   console.log('-'.repeat(80))
 
   console.log('\nMeasuring event loop latency during async glob operations...\n')
-  console.log('Pattern'.padEnd(25) + 'Avg Latency'.padStart(15) + 'Max Latency'.padStart(15) + 'Samples'.padStart(10))
+  console.log(
+    'Pattern'.padEnd(25) +
+      'Avg Latency'.padStart(15) +
+      'Max Latency'.padStart(15) +
+      'Samples'.padStart(10)
+  )
   console.log('-'.repeat(65))
 
   const eventLoopPatterns = ['**/*.js', '**/*']
@@ -606,7 +628,13 @@ async function main() {
   console.log('-'.repeat(80))
 
   const percentilePatterns = ['**/*.js', '*.js', 'level0/**/*.js']
-  console.log('\nPattern'.padEnd(25) + 'Median'.padStart(10) + 'P95'.padStart(10) + 'P99'.padStart(10) + 'Max'.padStart(10))
+  console.log(
+    '\nPattern'.padEnd(25) +
+      'Median'.padStart(10) +
+      'P95'.padStart(10) +
+      'P99'.padStart(10) +
+      'Max'.padStart(10)
+  )
   console.log('-'.repeat(65))
 
   for (const pattern of percentilePatterns) {
@@ -628,7 +656,12 @@ async function main() {
   // Import sync version for comparison
   const { globSync } = await import('../../js/index.js')
 
-  console.log('\n[Globlin] Pattern'.padEnd(25) + 'Sync (ms)'.padStart(12) + 'Async (ms)'.padStart(12) + 'Overhead'.padStart(12))
+  console.log(
+    '\n[Globlin] Pattern'.padEnd(25) +
+      'Sync (ms)'.padStart(12) +
+      'Async (ms)'.padStart(12) +
+      'Overhead'.padStart(12)
+  )
   console.log('-'.repeat(61))
 
   for (const pattern of ['**/*.js', '*.js', 'level0/**/*.js']) {
@@ -674,13 +707,18 @@ async function main() {
   }
 
   console.log('\nAggregate by fixture:')
-  console.log('Fixture'.padEnd(10) + 'Avg vs Glob'.padStart(15) + 'Avg vs FG'.padStart(15) + 'Faster than Glob'.padStart(20))
+  console.log(
+    'Fixture'.padEnd(10) +
+      'Avg vs Glob'.padStart(15) +
+      'Avg vs FG'.padStart(15) +
+      'Faster than Glob'.padStart(20)
+  )
   console.log('-'.repeat(60))
 
   for (const [fixture, results] of Object.entries(byFixture)) {
     const avgVsGlob = results.reduce((sum, r) => sum + r.speedupVsGlob, 0) / results.length
     const avgVsFg = results.reduce((sum, r) => sum + r.speedupVsFg, 0) / results.length
-    const fasterCount = results.filter((r) => r.speedupVsGlob > 1).length
+    const fasterCount = results.filter(r => r.speedupVsGlob > 1).length
     console.log(
       fixture.padEnd(10) +
         `${avgVsGlob.toFixed(2)}x`.padStart(15) +
@@ -690,18 +728,21 @@ async function main() {
   }
 
   // Result accuracy
-  const totalMatches = allResults.filter((r) => r.resultMatch).length
+  const totalMatches = allResults.filter(r => r.resultMatch).length
   console.log(`\nResult accuracy: ${totalMatches}/${allResults.length} patterns match glob results`)
 
   // Concurrency summary
   console.log('\nConcurrency scaling (medium fixture, **/*.js):')
-  const mediumConcurrency = concurrencyResults.filter((r) => r.fixture === 'medium')
+  const mediumConcurrency = concurrencyResults.filter(r => r.fixture === 'medium')
   for (const r of mediumConcurrency) {
-    console.log(`  ${r.concurrency.toString().padEnd(3)} concurrent: ${r.speedupVsGlob.toFixed(2)}x vs glob, throughput ${r.globlin.throughput.toFixed(0)}/s`)
+    console.log(
+      `  ${r.concurrency.toString().padEnd(3)} concurrent: ${r.speedupVsGlob.toFixed(2)}x vs glob, throughput ${r.globlin.throughput.toFixed(0)}/s`
+    )
   }
 
   // AbortSignal overhead summary
-  const avgAbortOverhead = abortResults.reduce((sum, r) => sum + r.overheadPercent, 0) / abortResults.length
+  const avgAbortOverhead =
+    abortResults.reduce((sum, r) => sum + r.overheadPercent, 0) / abortResults.length
   console.log(`\nAbortSignal average overhead: ${avgAbortOverhead.toFixed(1)}%`)
 
   // Best and worst patterns

benches/api/async_bottleneck_analysis.ts

@@ -25,14 +25,14 @@ function median(arr: number[]): number {
   return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2
 }
 
-function percentile(arr: number[], p: number): number {
+function _percentile(arr: number[], p: number): number {
   const sorted = [...arr].sort((a, b) => a - b)
   const idx = Math.ceil((p / 100) * sorted.length) - 1
   return sorted[Math.max(0, idx)]
 }
 
 async function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
+  return new Promise(resolve => setTimeout(resolve, ms))
 }
 
 // ============================================================
@@ -163,12 +163,12 @@ async function measureEventLoopBlocking(
   let running = true
   let expectedTime = 0
 
-  // Monitor event loop in a separate task
-  const monitorPromise = (async () => {
+  // Monitor event loop in a separate task (intentionally not awaited to run concurrently)
+  void (async () => {
     while (running) {
       const before = performance.now()
       expectedTime = sampleIntervalMs
-      await new Promise((resolve) => setTimeout(resolve, sampleIntervalMs))
+      await new Promise(resolve => setTimeout(resolve, sampleIntervalMs))
       const after = performance.now()
       const actualTime = after - before
       const blockTime = actualTime - expectedTime
@@ -302,7 +302,11 @@ interface TokioAnalysisResult {
   napiPercent: number
 }
 
-async function analyzeTokioRuntime(pattern: string, cwd: string, runs = 15): Promise<TokioAnalysisResult> {
+async function analyzeTokioRuntime(
+  pattern: string,
+  cwd: string,
+  runs = 15
+): Promise<TokioAnalysisResult> {
   const opts = { cwd }
 
   // Warmup
@@ -376,7 +380,11 @@ interface AsyncComparisonResult {
   fgAsyncOverhead: number
 }
 
-async function compareAsyncImplementations(pattern: string, cwd: string, runs = 10): Promise<AsyncComparisonResult> {
+async function compareAsyncImplementations(
+  pattern: string,
+  cwd: string,
+  runs = 10
+): Promise<AsyncComparisonResult> {
   const opts = { cwd }
   const fgOpts = { cwd }
 
@@ -509,15 +517,19 @@ async function main() {
           result.syncTime.toFixed(2).padStart(12) +
           result.asyncTime.toFixed(2).padStart(12) +
           `${result.overhead >= 0 ? '+' : ''}${result.overhead.toFixed(2)}ms`.padStart(12) +
-          `${result.overheadPercent >= 0 ? '+' : ''}${result.overheadPercent.toFixed(1)}%`.padStart(8)
+          `${result.overheadPercent >= 0 ? '+' : ''}${result.overheadPercent.toFixed(1)}%`.padStart(
+            8
+          )
       )
     }
   }
 
   // Promise creation and scheduling overhead
   console.log('\nPromise/Scheduling Micro-benchmarks:')
   const sampleOverhead = overheadResults[0]
-  console.log(`  Promise.resolve() creation: ~${(sampleOverhead.promiseCreationTime * 1000).toFixed(2)}us`)
+  console.log(
+    `  Promise.resolve() creation: ~${(sampleOverhead.promiseCreationTime * 1000).toFixed(2)}us`
+  )
   console.log(`  .then() scheduling: ~${(sampleOverhead.asyncSchedulingTime * 1000).toFixed(2)}us`)
 
   // === SECTION 2: Event Loop Blocking ===
@@ -640,9 +652,15 @@ async function main() {
           `${result.globlinAsync.toFixed(1)}ms`.padStart(10) +
           `${result.globAsync.toFixed(1)}ms`.padStart(10) +
           `${result.fgAsync.toFixed(1)}ms`.padStart(10) +
-          `${result.globlinAsyncOverhead >= 0 ? '+' : ''}${result.globlinAsyncOverhead.toFixed(0)}%`.padStart(10) +
-          `${result.globAsyncOverhead >= 0 ? '+' : ''}${result.globAsyncOverhead.toFixed(0)}%`.padStart(10) +
-          `${result.fgAsyncOverhead >= 0 ? '+' : ''}${result.fgAsyncOverhead.toFixed(0)}%`.padStart(10)
+          `${result.globlinAsyncOverhead >= 0 ? '+' : ''}${result.globlinAsyncOverhead.toFixed(0)}%`.padStart(
+            10
+          ) +
+          `${result.globAsyncOverhead >= 0 ? '+' : ''}${result.globAsyncOverhead.toFixed(0)}%`.padStart(
+            10
+          ) +
+          `${result.fgAsyncOverhead >= 0 ? '+' : ''}${result.fgAsyncOverhead.toFixed(0)}%`.padStart(
+            10
+          )
       )
     }
   }
@@ -652,13 +670,16 @@ async function main() {
   console.log('BOTTLENECK ANALYSIS SUMMARY')
   console.log('='.repeat(80))
 
-  const avgOverhead = overheadResults.reduce((sum, r) => sum + r.overheadPercent, 0) / overheadResults.length
-  const maxOverhead = Math.max(...overheadResults.map((r) => r.overheadPercent))
-  const minOverhead = Math.min(...overheadResults.map((r) => r.overheadPercent))
+  const avgOverhead =
+    overheadResults.reduce((sum, r) => sum + r.overheadPercent, 0) / overheadResults.length
+  const maxOverhead = Math.max(...overheadResults.map(r => r.overheadPercent))
+  const minOverhead = Math.min(...overheadResults.map(r => r.overheadPercent))
 
   console.log('\n1. ASYNC OVERHEAD:')
   console.log(`   Average: ${avgOverhead >= 0 ? '+' : ''}${avgOverhead.toFixed(1)}%`)
-  console.log(`   Range: ${minOverhead >= 0 ? '+' : ''}${minOverhead.toFixed(1)}% to ${maxOverhead >= 0 ? '+' : ''}${maxOverhead.toFixed(1)}%`)
+  console.log(
+    `   Range: ${minOverhead >= 0 ? '+' : ''}${minOverhead.toFixed(1)}% to ${maxOverhead >= 0 ? '+' : ''}${maxOverhead.toFixed(1)}%`
+  )
   console.log('   Conclusion: Async overhead is MINIMAL (typically <5%)')
 
   console.log('\n2. EVENT LOOP BLOCKING:')