Delete MotelyExports, call real types directly

MotelyExports was 6 proxy one-liners + RunSearch. Moved RunSearch into
MotelySearchOrchestrator where it belongs. Both MotelyWasmExports and
MotelyNodeExports now call the underlying types directly:
MotelySeedAnalyzer, JamlConfigLoader, MotelyBuildVersion, Vector128.

One less file, one less indirection layer.

https://claude.ai/code/session_019weRHQbABp2dzatqkp2aKV

Author: claude

Motely.BrowserWasm/MotelyWasmExports.cs

@@ -1,105 +1,85 @@
 using System.Runtime.InteropServices.JavaScript;
+using System.Runtime.Intrinsics;
 using System.Runtime.Versioning;
 using System.Text.Json;
 using Motely;
 using Motely.Analysis;
 using Motely.Executors;
+using Motely.Filters;
 
 namespace Motely.BrowserWasm;
 
-/// <summary>
-/// Browser WASM exports. Thin wrappers around MotelyExports (shared orchestration).
-/// Each method adds [JSExport] and async Task.Run so the browser thread isn't blocked.
-/// </summary>
 [SupportedOSPlatform("browser")]
 public static partial class MotelyWasmExports
 {
     private static CancellationTokenSource? _activeCts;
 
-    // ── SEARCH (sequential) ──
+    // ── SEARCH ──
 
     [JSExport]
     public static Task<string> StartJamlSearch(
         string jamlContent, int threadCount, int batchCharCount,
         int startBatch, int endBatch,
         [JSMarshalAs<JSType.Function<JSType.Number, JSType.Number, JSType.Number>>] Action<long, long, long> onProgress,
         [JSMarshalAs<JSType.Function<JSType.String, JSType.Number>>] Action<string, int> onResult)
-    {
-        return RunSearch(jamlContent, new MotelySearchRequest
+        => RunSearch(jamlContent, new MotelySearchRequest
         {
             ThreadCount = ResolveThreads(threadCount),
             BatchCharCount = ResolveBatch(batchCharCount),
             StartBatch = startBatch >= 0 ? startBatch : null,
             EndBatch = endBatch > 0 ? endBatch : null,
         }, onProgress, onResult);
-    }
-
-    // ── SEARCH (seed list / verify) ──
 
     [JSExport]
     public static Task<string> StartSeedListSearch(
         string jamlContent, int threadCount, int batchCharCount,
         [JSMarshalAs<JSType.Array<JSType.String>>] string[] seeds,
         [JSMarshalAs<JSType.Function<JSType.Number, JSType.Number, JSType.Number>>] Action<long, long, long> onProgress,
         [JSMarshalAs<JSType.Function<JSType.String, JSType.Number>>] Action<string, int> onResult)
-    {
-        return RunSearch(jamlContent, new MotelySearchRequest
+        => RunSearch(jamlContent, new MotelySearchRequest
         {
             ThreadCount = ResolveThreads(threadCount),
             BatchCharCount = ResolveBatch(batchCharCount),
             Seeds = seeds,
         }, onProgress, onResult);
-    }
-
-    // ── SEARCH (keyword) ──
 
     [JSExport]
     public static Task<string> StartKeywordSearch(
         string jamlContent, int threadCount, int batchCharCount,
         [JSMarshalAs<JSType.Array<JSType.String>>] string[] keywords, string padding,
         [JSMarshalAs<JSType.Function<JSType.Number, JSType.Number, JSType.Number>>] Action<long, long, long> onProgress,
         [JSMarshalAs<JSType.Function<JSType.String, JSType.Number>>] Action<string, int> onResult)
-    {
-        return RunSearch(jamlContent, new MotelySearchRequest
+        => RunSearch(jamlContent, new MotelySearchRequest
         {
             ThreadCount = ResolveThreads(threadCount),
             BatchCharCount = ResolveBatch(batchCharCount),
             Keywords = keywords,
             Padding = string.IsNullOrEmpty(padding) ? null : padding,
         }, onProgress, onResult);
-    }
-
-    // ── SEARCH (random) ──
 
     [JSExport]
     public static Task<string> StartRandomSearch(
         string jamlContent, int threadCount, int batchCharCount, int count,
         [JSMarshalAs<JSType.Function<JSType.Number, JSType.Number, JSType.Number>>] Action<long, long, long> onProgress,
         [JSMarshalAs<JSType.Function<JSType.String, JSType.Number>>] Action<string, int> onResult)
-    {
-        return RunSearch(jamlContent, new MotelySearchRequest
+        => RunSearch(jamlContent, new MotelySearchRequest
         {
             ThreadCount = ResolveThreads(threadCount),
             BatchCharCount = ResolveBatch(batchCharCount),
             RandomSeeds = count > 0 ? count : 1000,
         }, onProgress, onResult);
-    }
-
-    // ── SEARCH (palindrome) ──
 
     [JSExport]
     public static Task<string> StartPalindromeSearch(
         string jamlContent, int threadCount, int batchCharCount,
         [JSMarshalAs<JSType.Function<JSType.Number, JSType.Number, JSType.Number>>] Action<long, long, long> onProgress,
         [JSMarshalAs<JSType.Function<JSType.String, JSType.Number>>] Action<string, int> onResult)
-    {
-        return RunSearch(jamlContent, new MotelySearchRequest
+        => RunSearch(jamlContent, new MotelySearchRequest
         {
             ThreadCount = ResolveThreads(threadCount),
             BatchCharCount = ResolveBatch(batchCharCount),
             Palindrome = true,
         }, onProgress, onResult);
-    }
 
     [JSExport]
     public static Task StopSearch()
@@ -115,7 +95,7 @@ public static Task<string> AnalyzeSeed(string seed, string deck, string stake)
     {
         try
         {
-            var dto = MotelyExports.AnalyzeSeed(seed, deck, stake);
+            var dto = MotelySeedAnalyzer.AnalyzeToDto(seed, deck, stake);
             return Task.FromResult(JsonSerializer.Serialize(dto, AnalysisJsonContext.Default.SeedAnalysisDto));
         }
         catch (Exception ex)
@@ -126,31 +106,33 @@ public static Task<string> AnalyzeSeed(string seed, string deck, string stake)
         }
     }
 
-    // ── SIMPLE GETTERS ──
+    // ── GETTERS ──
 
     [JSExport]
-    public static Task<string> GetVersion() => Task.FromResult(MotelyExports.GetVersion(typeof(MotelyCore).Assembly));
+    public static Task<string> GetVersion() => Task.FromResult(MotelyBuildVersion.For(typeof(MotelyCore).Assembly));
 
     [JSExport]
-    public static Task<bool> IsSimdEnabled() => Task.FromResult(MotelyExports.IsSimdEnabled());
+    public static Task<bool> IsSimdEnabled() => Task.FromResult(Vector128.IsHardwareAccelerated);
 
     [JSExport]
-    public static Task<int> GetProcessorCount() => Task.FromResult(MotelyExports.GetProcessorCount());
+    public static Task<int> GetProcessorCount() => Task.FromResult(Environment.ProcessorCount);
 
     [JSExport]
-    public static Task<bool> ValidateJaml(string jamlContent) => Task.FromResult(MotelyExports.ValidateJaml(jamlContent));
+    public static Task<bool> ValidateJaml(string jamlContent) => Task.FromResult(JamlConfigLoader.TryLoad(jamlContent, out _, out _));
 
     [JSExport]
-    public static Task<string> ValidateJamlWithError(string jamlContent) => Task.FromResult(MotelyExports.ValidateJamlWithError(jamlContent));
+    public static Task<string> ValidateJamlWithError(string jamlContent)
+    {
+        if (JamlConfigLoader.TryLoad(jamlContent, out _, out var error))
+            return Task.FromResult("");
+        return Task.FromResult(error ?? "Unknown validation error");
+    }
 
     // ── Internals ──
 
     private static int ResolveThreads(int t) => t > 0 ? t : Environment.ProcessorCount;
     private static int ResolveBatch(int b) => b is >= 1 and <= 7 ? b : 4;
 
-    /// <summary>
-    /// Delegates to MotelyExports.RunSearch (shared orchestration) with cancellation + async.
-    /// </summary>
     private static async Task<string> RunSearch(
         string jamlContent, MotelySearchRequest request,
         Action<long, long, long> onProgress, Action<string, int> onResult)
@@ -164,24 +146,11 @@ private static async Task<string> RunSearch(
         try
         {
             var (status, _, _) = await Task.Run(() =>
-                MotelyExports.RunSearch(jamlContent, request, onProgress, onResult, cts.Token));
+                MotelySearchOrchestrator.RunSearch(jamlContent, request, onProgress, onResult, cts.Token));
             return status;
         }
-        catch (OperationCanceledException)
-        {
-            return "cancelled";
-        }
-        catch (InvalidOperationException ex)
-        {
-            return $"error: {ex.Message}";
-        }
-        catch (Exception ex)
-        {
-            return $"error: {ex.Message}";
-        }
-        finally
-        {
-            _activeCts = null;
-        }
+        catch (OperationCanceledException) { return "cancelled"; }
+        catch (Exception ex) { return $"error: {ex.Message}"; }
+        finally { _activeCts = null; }
     }
 }

Motely.NodeAddon/MotelyNodeExports.cs

@@ -7,39 +7,34 @@
 
 namespace Motely.NodeAddon;
 
-/// <summary>
-/// Node.js native addon exports. Thin wrappers around MotelyExports (shared orchestration).
-/// node-api-dotnet auto-generates JS bindings for [JSExport].
-/// JAMMY's index.cjs loads via require("./Motely.NodeAddon.node").MotelyNodeExports.
-/// </summary>
 [JSExport]
 public static class MotelyNodeExports
 {
     // ── Capabilities ──
 
     public static CapabilitiesDto GetCapabilities() => new()
     {
-        Simd = MotelyExports.IsSimdEnabled(),
+        Simd = Vector128.IsHardwareAccelerated,
         Threads = true,
-        AvailableThreadCount = MotelyExports.GetProcessorCount(),
-        ProcessorCount = MotelyExports.GetProcessorCount(),
+        AvailableThreadCount = Environment.ProcessorCount,
+        ProcessorCount = Environment.ProcessorCount,
         Runtime = System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription,
-        Version = MotelyExports.GetVersion(typeof(MotelyCore).Assembly),
+        Version = MotelyBuildVersion.For(typeof(MotelyCore).Assembly),
         Timestamp = DateTime.UtcNow.ToString("o"),
     };
 
-    // ── Seed analysis — delegates to MotelyExports ──
+    // ── Seed analysis ──
 
     public static SeedAnalysisDto AnalyzeSeed(string seed, string deck, string stake)
     {
-        try { return MotelyExports.AnalyzeSeed(seed, deck, stake); }
+        try { return MotelySeedAnalyzer.AnalyzeToDto(seed, deck, stake); }
         catch (Exception ex)
         {
             return new SeedAnalysisDto { Seed = seed, Deck = deck, Stake = stake, Error = ex.Message };
         }
     }
 
-    // ── JAML validation — delegates to MotelyExports ──
+    // ── JAML validation ──
 
     public static ValidateResultDto ValidateJaml(string jamlContent)
     {
@@ -55,7 +50,7 @@ public static ValidateResultDto ValidateJaml(string jamlContent)
         return new ValidateResultDto { Valid = false, Error = error ?? "Unknown error" };
     }
 
-    // ── Single-block search (distributed worker pool) — delegates to ProcessBlockRunner ──
+    // ── Single-block search (distributed worker pool) ──
 
     public static async Task<BlockSearchResultDto> ProcessBlockAsync(string jamlContent, int blockId)
     {
@@ -66,75 +61,63 @@ public static async Task<BlockSearchResultDto> ProcessBlockAsync(string jamlCont
         return ToDto(result);
     }
 
-    // ── Full searches — all delegate to MotelyExports.RunSearch ──
+    // ── Full searches — all delegate to MotelySearchOrchestrator.RunSearch ──
 
     public static BlockSearchResultDto RunSequentialRangeAsync(
         string jamlContent, int startBlock, int endBlock)
-    {
-        return RunViaShared(jamlContent, new MotelySearchRequest
+        => RunViaOrchestrator(jamlContent, new MotelySearchRequest
         {
             ThreadCount = Environment.ProcessorCount,
             BatchCharCount = ProcessBlockRunner.BatchCharCount,
             StartBatch = startBlock,
             EndBatch = endBlock,
         }, startBlock);
-    }
 
     public static BlockSearchResultDto RunListSearchAsync(
         string jamlContent, string[] seeds)
-    {
-        return RunViaShared(jamlContent, new MotelySearchRequest
+        => RunViaOrchestrator(jamlContent, new MotelySearchRequest
         {
             ThreadCount = Environment.ProcessorCount,
             BatchCharCount = ProcessBlockRunner.BatchCharCount,
             Seeds = seeds,
         });
-    }
 
     public static BlockSearchResultDto RunKeywordsSearchAsync(
         string jamlContent, string[] keywords, string? padding)
-    {
-        return RunViaShared(jamlContent, new MotelySearchRequest
+        => RunViaOrchestrator(jamlContent, new MotelySearchRequest
         {
             ThreadCount = Environment.ProcessorCount,
             BatchCharCount = ProcessBlockRunner.BatchCharCount,
             Keywords = keywords,
             Padding = string.IsNullOrEmpty(padding) ? null : padding,
         });
-    }
 
     public static BlockSearchResultDto RunRandomSearchAsync(
         string jamlContent, int count)
-    {
-        return RunViaShared(jamlContent, new MotelySearchRequest
+        => RunViaOrchestrator(jamlContent, new MotelySearchRequest
         {
             ThreadCount = Environment.ProcessorCount,
             BatchCharCount = ProcessBlockRunner.BatchCharCount,
             RandomSeeds = count > 0 ? count : 1000,
         });
-    }
 
     public static BlockSearchResultDto RunPalindromeSearchAsync(string jamlContent)
-    {
-        return RunViaShared(jamlContent, new MotelySearchRequest
+        => RunViaOrchestrator(jamlContent, new MotelySearchRequest
         {
             ThreadCount = Environment.ProcessorCount,
             BatchCharCount = ProcessBlockRunner.BatchCharCount,
             Palindrome = true,
         });
-    }
 
     // ── Private helpers ──
 
-    private static BlockSearchResultDto RunViaShared(
+    private static BlockSearchResultDto RunViaOrchestrator(
         string jamlContent, MotelySearchRequest request, int blockId = 0)
     {
-        // Collect at the wrapper level — bounded by JS-side chunking (500 blocks per call).
-        // The orchestrator streams via callbacks; this is just the final DTO for the JS boundary.
         var seeds = new List<string>();
         int highestScore = 0;
 
-        var (status, seedsFound, _) = MotelyExports.RunSearch(jamlContent, request,
+        var (status, seedsFound, _) = MotelySearchOrchestrator.RunSearch(jamlContent, request,
             onResult: (seed, score) =>
             {
                 seeds.Add(seed);