Fix home directory crash + use ArrayPool in BPE heap path

FileScanner: catch all exceptions (not just IO types) in Parallel.ForEach
workers and sequential branches. Nested Parallel.ForEach wraps inner errors
in AggregateException which escaped the previous IOException-only catch filter.

Also:
- Lower depth guard from 64 to 40 (no real source tree is that deep)
- Add macOS inner-Library excludes (Developer, Caches, Containers, etc.)
  as defense-in-depth for --no-default-excludes or scanning inside ~/Library
- Add Steam.AppBundle to default excludes (recursive .app bundle)

BytePairEncoding: replace heap allocations (new int[n]) with
ArrayPool<int>.Shared.Rent/Return in FindPartsHeap to reduce GC
pressure when tokenizing many large files.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: HavenDV

src/cli/Tiktoken.Cli/IO/FileScanner.cs

@@ -47,6 +47,8 @@ internal sealed class FileScanner
             "coverage", ".nyc_output",
             // macOS / filesystem metadata
             ".Spotlight-V100", ".fseventsd", ".TemporaryItems",
+            // App bundles with recursive symlink structures
+            "Steam.AppBundle",
         ], StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
@@ -55,7 +57,13 @@ internal sealed class FileScanner
     /// </summary>
     private static readonly FrozenSet<string> MacOsExcludedDirs = OperatingSystem.IsMacOS()
         ? FrozenSet.ToFrozenSet(
-            ["Library", "Applications", "Movies", "Music", "Pictures"],
+            [
+                "Library", "Applications", "Movies", "Music", "Pictures",
+                // Inside ~/Library — excluded as a second line of defense if Library itself
+                // is not excluded (e.g. --no-default-excludes, or scanning inside ~/Library)
+                "Developer", "Application Support", "Containers", "Group Containers",
+                "Caches", "Logs", "Saved Application State", "WebKit",
+            ],
             StringComparer.OrdinalIgnoreCase)
         : FrozenSet<string>.Empty;
 
@@ -257,8 +265,9 @@ private void ScanDirectory(
             effectiveHasFileRules = anyHasFileRules;
         }
 
-        // Guard against symlink loops and extremely deep paths
-        if (depth > 64)
+        // Guard against symlink loops, recursive .app bundles, and extremely deep paths
+        // that would cause PathTooLongException. 40 levels is far beyond any real source tree.
+        if (depth > 40)
         {
             localStats.DirsErrored++;
             return;
@@ -426,20 +435,27 @@ private void ScanDirectory(
                     {
                         ScanDirectory(subDir, rootPath, rootPrefixLen, effectiveIgnores, effectiveHasFileRules, localResults, localSubStats, depth + 1, cancellationToken);
                     }
-                    catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or PathTooLongException)
+                    catch (OperationCanceledException)
                     {
+                        throw; // Let cancellation propagate to Parallel.ForEach
+                    }
+                    catch (Exception)
+                    {
+                        // Catch ALL exceptions including AggregateException from nested
+                        // Parallel.ForEach, IOException, PathTooLongException, etc.
                         localSubStats.DirsErrored++;
                     }
                     bags.Add((localResults, localSubStats));
                 });
             }
-            catch (AggregateException ae)
+            catch (OperationCanceledException)
             {
-                // If any worker threw an unhandled exception, count it and continue
-                foreach (var _ in ae.InnerExceptions)
-                {
-                    localStats.DirsErrored++;
-                }
+                throw;
+            }
+            catch (Exception)
+            {
+                // AggregateException or any other exception from Parallel.ForEach
+                localStats.DirsErrored++;
             }
 
             foreach (var (subResults, subStats) in bags)
@@ -456,7 +472,11 @@ private void ScanDirectory(
                 {
                     ScanDirectory(subDir, rootPath, rootPrefixLen, effectiveIgnores, effectiveHasFileRules, results, localStats, depth + 1, cancellationToken);
                 }
-                catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or PathTooLongException)
+                catch (OperationCanceledException)
+                {
+                    throw;
+                }
+                catch (Exception)
                 {
                     localStats.DirsErrored++;
                 }

src/libs/Tiktoken.Core/BytePairEncoding.cs

@@ -7,6 +7,7 @@
 using System.Collections.Frozen;
 #endif
 #if NET8_0_OR_GREATER
+using System.Buffers;
 using Tiktoken.Core;
 #endif
 
@@ -204,22 +205,35 @@ private static unsafe int FindPartsHeap(
     {
         var n = partsLength;
 
-        // For large pieces, heap-allocate to avoid stack overflow on thread pool threads.
+        // For large pieces, rent from ArrayPool to avoid stack overflow on thread pool
+        // threads and reduce GC pressure on repeated large-file tokenizations.
         // 5 arrays × n × 4 bytes each — for n > 512 this exceeds safe stackalloc limits.
         if (n > MaxStackAllocLength)
         {
-            var nextArr = new int[n];
-            var prevArr = new int[n];
-            var ranksArr = new int[n];
-            var heapArr = new int[n];
-            var heapPosArr = new int[n];
-            fixed (int* next = nextArr)
-            fixed (int* prev = prevArr)
-            fixed (int* ranks = ranksArr)
-            fixed (int* heap = heapArr)
-            fixed (int* heapPos = heapPosArr)
-            {
-                return FindPartsHeapCore(pieceSpan, resultIndexes, n, encoder, next, prev, ranks, heap, heapPos);
+            var pool = ArrayPool<int>.Shared;
+            var nextArr = pool.Rent(n);
+            var prevArr = pool.Rent(n);
+            var ranksArr = pool.Rent(n);
+            var heapArr = pool.Rent(n);
+            var heapPosArr = pool.Rent(n);
+            try
+            {
+                fixed (int* next = nextArr)
+                fixed (int* prev = prevArr)
+                fixed (int* ranks = ranksArr)
+                fixed (int* heap = heapArr)
+                fixed (int* heapPos = heapPosArr)
+                {
+                    return FindPartsHeapCore(pieceSpan, resultIndexes, n, encoder, next, prev, ranks, heap, heapPos);
+                }
+            }
+            finally
+            {
+                pool.Return(heapPosArr);
+                pool.Return(heapArr);
+                pool.Return(ranksArr);
+                pool.Return(prevArr);
+                pool.Return(nextArr);
             }
         }
         else