Check parallel WPT tests on macOS

Makefile

@@ -109,7 +109,7 @@ test-wpt-litert:
 	$(CARGO) test --test run_wpt_conformance --features "litert-runtime" -- litert --test-threads=1
 
 test-wpt-coreml:
-	$(CARGO) test --test run_wpt_conformance --features coreml-runtime -- coreml --test-threads 1
+	$(CARGO) test --test run_wpt_conformance --features coreml-runtime -- coreml
 
 test-wpt-coreml-report:
 	@mkdir -p reports

docs/development/backend-operator-support.md

@@ -24,76 +24,78 @@ Executor-level operator coverage follows converter coverage for this backend.
 
 - Converter source: `src/converters/coreml_mlprogram.rs`
 - Executor source: `src/executors/coreml.rs`
-- Converter operator count: **88**
-- Executor operator count: **88**
+- Converter operator count: **92**
+- Executor operator count: **92**
 
 ### Converter Operators
 
-- `abs`, `hardSigmoid`, `reducemin`
-- `add`, `hardSwish`, `reduceproduct`
-- `argMax`, `identity`, `reducesum`
-- `argMin`, `instanceNormalization`, `reducesumsquare`
-- `averagePool2d`, `layerNormalization`, `relu`
-- `batchNormalization`, `leakyRelu`, `reshape`
-- `cast`, `lesser`, `reverse`
-- `ceil`, `lesserOrEqual`, `roundEven`
-- `clamp`, `log`, `scatterElements`
-- `concat`, `logicalAnd`, `scatterND`
-- `conv2d`, `logicalNot`, `sigmoid`
-- `convTranspose2d`, `logicalOr`, `sign`
-- `cos`, `logicalXor`, `sin`
-- `cumulativeSum`, `matmul`, `slice`
-- `dequantizeLinear`, `max`, `softmax`
-- `div`, `maxPool2d`, `softplus`
-- `elu`, `min`, `softsign`
-- `equal`, `mul`, `split`
-- `erf`, `neg`, `sqrt`
-- `exp`, `pad`, `squeeze`
-- `expand`, `pow`, `sub`
-- `floor`, `prelu`, `tan`
-- `gather`, `quantizeLinear`, `tanh`
-- `gatherElements`, `reciprocal`, `tile`
-- `gelu`, `reducel1`, `transpose`
-- `gemm`, `reducel2`, `triangular`
-- `globalAveragePool`, `reducelogsum`, `unsqueeze`
-- `globalMaxPool`, `reducelogsumexp`, `where`
-- `greater`, `reducemax`
-- `greaterOrEqual`, `reducemean`
+- `abs`, `hardSigmoid`, `reducemax`
+- `add`, `hardSwish`, `reducemean`
+- `argMax`, `identity`, `reducemin`
+- `argMin`, `instanceNormalization`, `reduceproduct`
+- `averagePool2d`, `isInfinite`, `reducesum`
+- `batchNormalization`, `isNaN`, `reducesumsquare`
+- `cast`, `l2pool2d`, `relu`
+- `ceil`, `layerNormalization`, `reshape`
+- `clamp`, `leakyRelu`, `reverse`
+- `concat`, `lesser`, `roundEven`
+- `conv2d`, `lesserOrEqual`, `scatterElements`
+- `convTranspose2d`, `log`, `scatterND`
+- `cos`, `logicalAnd`, `sigmoid`
+- `cumulativeSum`, `logicalNot`, `sign`
+- `dequantizeLinear`, `logicalOr`, `sin`
+- `div`, `logicalXor`, `slice`
+- `elu`, `matmul`, `softmax`
+- `equal`, `max`, `softplus`
+- `erf`, `maxPool2d`, `softsign`
+- `exp`, `min`, `split`
+- `expand`, `mul`, `sqrt`
+- `floor`, `neg`, `squeeze`
+- `gather`, `pad`, `sub`
+- `gatherElements`, `pow`, `tan`
+- `gatherND`, `prelu`, `tanh`
+- `gelu`, `quantizeLinear`, `tile`
+- `gemm`, `reciprocal`, `transpose`
+- `globalAveragePool`, `reducel1`, `triangular`
+- `globalMaxPool`, `reducel2`, `unsqueeze`
+- `greater`, `reducelogsum`, `where`
+- `greaterOrEqual`, `reducelogsumexp`
 
 ### Executor Operators
 
 Executor-level operator coverage follows converter coverage for this backend.
 
-- `abs`, `hardSigmoid`, `reducemin`
-- `add`, `hardSwish`, `reduceproduct`
-- `argMax`, `identity`, `reducesum`
-- `argMin`, `instanceNormalization`, `reducesumsquare`
-- `averagePool2d`, `layerNormalization`, `relu`
-- `batchNormalization`, `leakyRelu`, `reshape`
-- `cast`, `lesser`, `reverse`
-- `ceil`, `lesserOrEqual`, `roundEven`
-- `clamp`, `log`, `scatterElements`
-- `concat`, `logicalAnd`, `scatterND`
-- `conv2d`, `logicalNot`, `sigmoid`
-- `convTranspose2d`, `logicalOr`, `sign`
-- `cos`, `logicalXor`, `sin`
-- `cumulativeSum`, `matmul`, `slice`
-- `dequantizeLinear`, `max`, `softmax`
-- `div`, `maxPool2d`, `softplus`
-- `elu`, `min`, `softsign`
-- `equal`, `mul`, `split`
-- `erf`, `neg`, `sqrt`
-- `exp`, `pad`, `squeeze`
-- `expand`, `pow`, `sub`
-- `floor`, `prelu`, `tan`
-- `gather`, `quantizeLinear`, `tanh`
-- `gatherElements`, `reciprocal`, `tile`
-- `gelu`, `reducel1`, `transpose`
-- `gemm`, `reducel2`, `triangular`
-- `globalAveragePool`, `reducelogsum`, `unsqueeze`
-- `globalMaxPool`, `reducelogsumexp`, `where`
-- `greater`, `reducemax`
-- `greaterOrEqual`, `reducemean`
+- `abs`, `hardSigmoid`, `reducemax`
+- `add`, `hardSwish`, `reducemean`
+- `argMax`, `identity`, `reducemin`
+- `argMin`, `instanceNormalization`, `reduceproduct`
+- `averagePool2d`, `isInfinite`, `reducesum`
+- `batchNormalization`, `isNaN`, `reducesumsquare`
+- `cast`, `l2pool2d`, `relu`
+- `ceil`, `layerNormalization`, `reshape`
+- `clamp`, `leakyRelu`, `reverse`
+- `concat`, `lesser`, `roundEven`
+- `conv2d`, `lesserOrEqual`, `scatterElements`
+- `convTranspose2d`, `log`, `scatterND`
+- `cos`, `logicalAnd`, `sigmoid`
+- `cumulativeSum`, `logicalNot`, `sign`
+- `dequantizeLinear`, `logicalOr`, `sin`
+- `div`, `logicalXor`, `slice`
+- `elu`, `matmul`, `softmax`
+- `equal`, `max`, `softplus`
+- `erf`, `maxPool2d`, `softsign`
+- `exp`, `min`, `split`
+- `expand`, `mul`, `sqrt`
+- `floor`, `neg`, `squeeze`
+- `gather`, `pad`, `sub`
+- `gatherElements`, `pow`, `tan`
+- `gatherND`, `prelu`, `tanh`
+- `gelu`, `quantizeLinear`, `tile`
+- `gemm`, `reciprocal`, `transpose`
+- `globalAveragePool`, `reducel1`, `triangular`
+- `globalMaxPool`, `reducel2`, `unsqueeze`
+- `greater`, `reducelogsum`, `where`
+- `greaterOrEqual`, `reducelogsumexp`
 
 ## TensorRT Backend
 

src/backends/coreml.rs

@@ -267,7 +267,35 @@ impl<'context> MLBackendContext<'context> for CoremlContext {
                     source: format!("model did not produce output '{name}'").into(),
                 })?;
             let logical = tensor_byte_len(ml_tensor.descriptor());
-            if data.len() < logical {
+
+            // When the graph output type is int64/uint64 but CoreML produced int32
+            // bytes (argmin/argmax proxy, or a cast to int64/uint64), widen each
+            // 4-byte value to 8 bytes. int64 is sign-extended so negative results
+            // survive; uint64 is zero-extended.
+            use crate::operator_enums::MLOperandDataType;
+            let out_dt = ml_tensor.descriptor().data_type();
+            let expanded: Option<Vec<u8>> = if data.len() * 2 == logical
+                && matches!(out_dt, MLOperandDataType::Int64 | MLOperandDataType::Uint64)
+            {
+                let sign_extend = matches!(out_dt, MLOperandDataType::Int64);
+                let count = data.len() / 4;
+                let mut buf = vec![0u8; count * 8];
+                for i in 0..count {
+                    let v = i32::from_le_bytes(data[i * 4..i * 4 + 4].try_into().unwrap());
+                    let widened: i64 = if sign_extend {
+                        v as i64
+                    } else {
+                        i64::from(v as u32)
+                    };
+                    buf[i * 8..i * 8 + 8].copy_from_slice(&widened.to_le_bytes());
+                }
+                Some(buf)
+            } else {
+                None
+            };
+            let effective = expanded.as_deref().unwrap_or(data.as_slice());
+
+            if effective.len() < logical {
                 return Err(Error::GraphDispatchError {
                     source: format!(
                         "output '{name}': CoreML produced {} bytes, descriptor expects {logical}",
@@ -286,7 +314,7 @@ impl<'context> MLBackendContext<'context> for CoremlContext {
                     .into(),
                 });
             }
-            dst[..logical].copy_from_slice(&data[..logical]);
+            dst[..logical].copy_from_slice(&effective[..logical]);
         }
         Ok(())
     }