feat(core,wasm,js): release v1.1.1 with seed validation, invalid-flag parity, and stricter input checks

- Validate seed test cases in C++ generator (src/core/generator.cpp) and TS generator
  (src/ts/core/generator.ts): drop seeds with out-of-range values, invalid-marked values,
  or constraint violations, emitting per-seed warnings instead of silently propagating bad state
- Fix maxTests-overflow warning to emit once after the loop, not inside it, and unify
  warning text across C++ and TS implementations
- Propagate invalid flag from Parameter to GenerateOptions in pure TS adapter
  (js/pure/adapter.ts), closing a parity gap where pure TS silently ignored invalid values
  while WASM correctly excluded them from positive coverage
- Throw on unknown seed values in toInternalTestCase instead of producing UNASSIGNED indices
- Add ParseUint32Option helper in src/wasm/bindings.cpp to validate strength and maxTests
  with descriptive errors before passing to C++ core
- Add input validation (parameters, strength, maxTests, seed) to all public entry points in
  js/index.ts and js/pure/index.ts; relax empty-array check in pure entry to match WASM behavior;
  add estimateModel validation that was missing
- Replace wasmModule! non-null assertion with getModule() call in Coverwise.create()
- New tests: C++ (tests/core/generator_test.cpp), TS (src/ts/core/generator.test.ts), WASM
  (tests/wasm/generate.test.ts), and compat (js/compat.test.ts) cover seed rejection,
  maxTests capping, numeric option rejection, and negativeTests parity
- Bump version to 1.1.1 in package.json and CMakeLists.txt

Author: libraz

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.16)
-project(coverwise VERSION 1.1.0 LANGUAGES CXX)
+project(coverwise VERSION 1.1.1 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

js/compat.test.ts

@@ -226,6 +226,16 @@ const scenarios: Array<{ name: string; input: GenerateInput }> = [
       seed: 42,
     },
   },
+  {
+    name: 'with invalid values',
+    input: {
+      parameters: [
+        { name: 'browser', values: ['chrome', 'firefox', { value: 'ie6', invalid: true }] },
+        { name: 'os', values: ['win', 'mac'] },
+      ],
+      seed: 42,
+    },
+  },
   {
     name: 'with sub-models',
     input: {
@@ -321,6 +331,7 @@ describe('WASM / TS compatibility', () => {
         expect(tsResult.stats.totalTuples).toBe(wasmResult.stats.totalTuples);
         expect(tsResult.stats.coveredTuples).toBe(wasmResult.stats.coveredTuples);
         expect(tsResult.uncovered.length).toBe(wasmResult.uncovered.length);
+        expect(tsResult.negativeTests?.length ?? 0).toBe(wasmResult.negativeTests?.length ?? 0);
         // Note: tests.length may differ between engines because the greedy
         // algorithm's RNG produces different value orderings in C++ vs TS,
         // which can lead to different numbers of tests while still achieving

js/index.ts

@@ -101,6 +101,49 @@ function getModule(): WasmModule {
   return wasmModule;
 }
 
+// --- Input Validation ---
+
+function validateStrength(strength: unknown): number {
+  if (strength === undefined || strength === null) {
+    return 2;
+  }
+  if (typeof strength !== 'number' || !Number.isInteger(strength) || strength <= 0) {
+    throw new Error(`Invalid strength: ${String(strength)}. Must be a positive integer.`);
+  }
+  return strength;
+}
+
+function validateMaxTests(maxTests: unknown): void {
+  if (maxTests === undefined || maxTests === null) {
+    return;
+  }
+  if (typeof maxTests !== 'number' || !Number.isInteger(maxTests) || maxTests < 0) {
+    throw new Error(`Invalid maxTests: ${String(maxTests)}. Must be a non-negative integer.`);
+  }
+}
+
+function validateSeed(seed: unknown): void {
+  if (seed === undefined || seed === null) {
+    return;
+  }
+  if (typeof seed !== 'number' || !Number.isFinite(seed)) {
+    throw new Error(`Invalid seed: ${String(seed)}. Must be a finite number.`);
+  }
+}
+
+function validateParameters(parameters: unknown): void {
+  if (!Array.isArray(parameters)) {
+    throw new Error('Invalid parameters: must be an array.');
+  }
+}
+
+function validateGenerateInput(input: GenerateInput): void {
+  validateParameters(input.parameters);
+  validateStrength(input.strength);
+  validateMaxTests(input.maxTests);
+  validateSeed(input.seed);
+}
+
 // --- Result Checking ---
 
 function checkResult<T>(result: unknown): T {
@@ -131,6 +174,7 @@ function checkResult<T>(result: unknown): T {
  * // result.coverage: 1.0
  */
 export function generate(input: GenerateInput): GenerateResult {
+  validateGenerateInput(input);
   const mod = getModule();
   const result = checkResult<GenerateResult>(mod.generate(input));
   result.negativeTests = result.negativeTests ?? [];
@@ -154,9 +198,11 @@ export function analyzeCoverage(
   strength?: number,
   constraints?: string[],
 ): CoverageReport {
+  validateParameters(parameters);
+  const s = validateStrength(strength);
   const mod = getModule();
   const result = checkResult<CoverageReport>(
-    mod.analyzeCoverage(parameters, tests, strength ?? 2, constraints ?? []),
+    mod.analyzeCoverage(parameters, tests, s, constraints ?? []),
   );
   // When there are no tuples (e.g. fewer parameters than strength), coverage is vacuously 1.0.
   if (result.totalTuples === 0) {
@@ -172,6 +218,7 @@ export function analyzeCoverage(
  * Only "strict" mode is supported (existing tests are kept as-is).
  */
 export function extendTests(existing: TestCase[], input: ExtendInput): GenerateResult {
+  validateGenerateInput(input);
   const mod = getModule();
   const result = checkResult<GenerateResult>(mod.extendTests(existing, input));
   result.negativeTests = result.negativeTests ?? [];
@@ -182,6 +229,7 @@ export function extendTests(existing: TestCase[], input: ExtendInput): GenerateR
  * Get model statistics without running generation.
  */
 export function estimateModel(input: GenerateInput): ModelStats {
+  validateGenerateInput(input);
   const mod = getModule();
   const result = checkResult<ModelStats>(mod.estimateModel(input));
   return result;
@@ -214,13 +262,14 @@ export class Coverwise {
    */
   static async create(): Promise<Coverwise> {
     await init();
-    return new Coverwise(wasmModule!);
+    return new Coverwise(getModule());
   }
 
   /**
    * Generate a covering array. One function, sensible defaults.
    */
   generate(input: GenerateInput): GenerateResult {
+    validateGenerateInput(input);
     const result = checkResult<GenerateResult>(this.module.generate(input));
     result.negativeTests = result.negativeTests ?? [];
     return result;
@@ -235,8 +284,10 @@ export class Coverwise {
     strength?: number,
     constraints?: string[],
   ): CoverageReport {
+    validateParameters(parameters);
+    const s = validateStrength(strength);
     const result = checkResult<CoverageReport>(
-      this.module.analyzeCoverage(parameters, tests, strength ?? 2, constraints ?? []),
+      this.module.analyzeCoverage(parameters, tests, s, constraints ?? []),
     );
     if (result.totalTuples === 0) {
       result.coverageRatio = 1.0;
@@ -248,6 +299,7 @@ export class Coverwise {
    * Extend an existing test suite with additional tests to improve coverage.
    */
   extendTests(existing: TestCase[], input: ExtendInput): GenerateResult {
+    validateGenerateInput(input);
     const result = checkResult<GenerateResult>(this.module.extendTests(existing, input));
     result.negativeTests = result.negativeTests ?? [];
     return result;
@@ -257,6 +309,7 @@ export class Coverwise {
    * Get model statistics without running generation.
    */
   estimateModel(input: GenerateInput): ModelStats {
+    validateGenerateInput(input);
     return checkResult<ModelStats>(this.module.estimateModel(input));
   }
 }

js/pure/adapter.ts

@@ -108,7 +108,11 @@ export function toInternalTestCase(
     const paramName = params[i].name;
     if (Object.hasOwn(tc, paramName)) {
       const valStr = valueToString(tc[paramName]);
-      values[i] = params[i].findValueIndex(valStr);
+      const idx = params[i].findValueIndex(valStr);
+      if (idx === UNASSIGNED) {
+        throw new Error(`Unknown value '${valStr}' for parameter '${paramName}'`);
+      }
+      values[i] = idx;
     }
   }
   return { values };
@@ -147,7 +151,11 @@ export function toInternalOptions(
   const seeds = (input.seeds ?? []).map((tc) => toInternalTestCase(tc, params));
 
   return createGenerateOptions({
-    parameters: params.map((p) => ({ name: p.name, values: p.values })),
+    parameters: params.map((p) => ({
+      name: p.name,
+      values: p.values,
+      ...(p.hasInvalidValues ? { invalid: p.invalid } : {}),
+    })),
     constraintExpressions: input.constraints ?? [],
     strength: input.strength ?? 2,
     seed: input.seed ?? 0,

js/pure/index.ts

@@ -89,8 +89,8 @@ function validateSeed(seed: unknown): void {
 }
 
 function validateParameters(parameters: unknown): void {
-  if (!Array.isArray(parameters) || parameters.length === 0) {
-    throw new Error('Invalid parameters: must be a non-empty array.');
+  if (!Array.isArray(parameters)) {
+    throw new Error('Invalid parameters: must be an array.');
   }
 }
 
@@ -201,6 +201,7 @@ export function extendTests(existing: TestCase[], input: ExtendInput): GenerateR
  * Get model statistics without running generation.
  */
 export function estimateModel(input: GenerateInput): ModelStats {
+  validateGenerateInput(input);
   const params = toInternalParams(input.parameters);
   const opts = toInternalOptions(input, params);
   const stats = internalEstimateModel(opts);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libraz/coverwise",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "packageManager": "yarn@4.12.0",
   "description": "Combinatorial test coverage engine — analyze, generate, and extend t-wise test suites via WASM",

src/core/generator.cpp

@@ -81,6 +81,35 @@ std::vector<std::vector<bool>> BuildValidOnlyMask(const std::vector<model::Param
   return mask;
 }
 
+/// @brief Validate that a seed can participate in positive coverage.
+std::string ValidatePositiveSeed(const model::TestCase& seed,
+                                 const std::vector<model::Parameter>& params,
+                                 const std::vector<model::Constraint>& constraints) {
+  if (seed.values.size() < params.size()) {
+    return "expected " + std::to_string(params.size()) + " value(s), got " +
+           std::to_string(seed.values.size());
+  }
+
+  for (uint32_t pi = 0; pi < static_cast<uint32_t>(params.size()); ++pi) {
+    uint32_t vi = seed.values[pi];
+    if (vi >= params[pi].size()) {
+      return "value index " + std::to_string(vi) + " is out of range for parameter " +
+             params[pi].name;
+    }
+    if (params[pi].is_invalid(vi)) {
+      return "value " + params[pi].name + "=" + params[pi].values[vi] + " is marked invalid";
+    }
+  }
+
+  for (const auto& constraint : constraints) {
+    if (constraint->Evaluate(seed.values) == model::ConstraintResult::kFalse) {
+      return "violates a constraint";
+    }
+  }
+
+  return {};
+}
+
 /// @brief Build an allowed_values mask for negative test generation.
 ///
 /// The fixed parameter is allowed only at the given invalid value index.
@@ -266,19 +295,29 @@ model::GenerateResult Generate(const GenerateOptions& options) {
   util::Rng rng(opts.seed);
 
   // Pre-load seed tests into all engines.
-  for (const auto& seed_test : opts.seeds) {
+  bool dropped_for_max_tests = false;
+  for (size_t si = 0; si < opts.seeds.size(); ++si) {
+    const auto& seed_test = opts.seeds[si];
     if (opts.max_tests > 0 && result.tests.size() >= static_cast<size_t>(opts.max_tests)) {
-      result.warnings.push_back("Seed test count (" + std::to_string(opts.seeds.size()) +
-                                ") exceeds max_tests (" + std::to_string(opts.max_tests) +
-                                "); some seeds were dropped");
+      dropped_for_max_tests = true;
       break;
     }
+    auto seed_error = ValidatePositiveSeed(seed_test, opts.parameters, constraints);
+    if (!seed_error.empty()) {
+      result.warnings.push_back("Seed test " + std::to_string(si) + " ignored: " + seed_error);
+      continue;
+    }
     coverage.AddTestCase(seed_test);
     for (auto& eng : sub_engines) {
       eng.AddTestCase(seed_test);
     }
     result.tests.push_back(seed_test);
   }
+  if (dropped_for_max_tests) {
+    result.warnings.push_back("Seed test count (" + std::to_string(opts.seeds.size()) +
+                              ") exceeds max_tests (" + std::to_string(opts.max_tests) +
+                              "); some seeds were dropped");
+  }
 
   // Scoring lambdas: avoid std::function wrapper on the hot path.
   auto simple_score_fn = [&](const model::TestCase& partial, uint32_t pi, uint32_t vi) {

src/ts/core/generator.test.ts

@@ -154,6 +154,51 @@ describe('generate', () => {
     expect(result.tests[1].values).toEqual([1, 1]);
   });
 
+  it('does not count invalid or constraint-violating seeds as positive coverage', () => {
+    const opts = createGenerateOptions({
+      parameters: [
+        { name: 'os', values: ['win', 'mac'] },
+        { name: 'browser', values: ['chrome', 'ie'], invalid: [false, true] },
+      ],
+      constraintExpressions: ['IF os = mac THEN browser != chrome'],
+      strength: 2,
+      seed: 42,
+      seeds: [
+        { values: [0, 1] }, // invalid browser value
+        { values: [1, 0] }, // violates constraint
+      ],
+    });
+
+    const result = generate(opts);
+
+    expect(result.coverage).toBe(1.0);
+    expect(result.tests.every((tc) => tc.values[1] !== 1)).toBe(true);
+    expect(result.tests.every((tc) => !(tc.values[0] === 1 && tc.values[1] === 0))).toBe(true);
+    expect(result.warnings).toEqual([
+      'Seed test 0 ignored: value browser=ie is marked invalid',
+      'Seed test 1 ignored: violates a constraint',
+    ]);
+  });
+
+  it('drops seed tests beyond maxTests', () => {
+    const opts = createGenerateOptions({
+      parameters: [
+        { name: 'a', values: ['0', '1'] },
+        { name: 'b', values: ['0', '1'] },
+      ],
+      maxTests: 1,
+      seeds: [{ values: [0, 0] }, { values: [1, 1] }],
+    });
+
+    const result = generate(opts);
+
+    expect(result.tests).toHaveLength(1);
+    expect(result.tests[0].values).toEqual([0, 0]);
+    expect(result.warnings).toContain(
+      'Seed test count (2) exceeds maxTests (1); some seeds were dropped',
+    );
+  });
+
   it('handles sub-models with mixed strength', () => {
     const opts = createGenerateOptions({
       parameters: [