feat: release v1.0.1 with t-wise support, constraint fixes, and coverage engine improvements

- Refactor coverage engine with ForEachTuple helper and overflow-safe tuple counting
- Fix greedy algorithm constraint-aware fallback
- Add full Unicode escape support to CLI JSON parser
- Mirror all C++ changes in TypeScript engine
- Add t-wise strength parameter to JS API
- Update bilingual documentation
- Bump TypeScript target to ES2022 for Object.hasOwn support
- Bump version to 1.0.1

Author: libraz

CMakeLists.txt

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

docs/en/examples.md

@@ -73,7 +73,7 @@ const result = cw.generate({
 });
 
 console.log('Positive tests:', result.tests.length);
-console.log('Negative tests:', result.negativeTests?.length);
+console.log('Negative tests:', result.negativeTests.length);
 
 // Positive tests cover valid combinations only.
 // Negative tests each have exactly 1 invalid value.

docs/en/introduction.md

@@ -69,7 +69,7 @@ coverwise is built as a **test design API**, not just a generation tool:
 - **Stateless** — `generate(input) → output`, no session management
 - **Decomposable** — Separate functions for generate, analyze, extend
 - **Explainable** — Every result includes coverage proof and uncovered tuples in human-readable format
-- **Deterministic** — Same input + seed = same output, every time
+- **Deterministic** — Same input + seed = same output, every time (within the same engine; WASM and Pure TS use different RNG algorithms, so the same seed may produce different test orderings across engines while maintaining identical coverage)
 
 ## Platform Support
 

docs/en/js-api.md

@@ -24,7 +24,7 @@ Both styles share the same WASM singleton and are interchangeable.
 
 ## `init()`
 
-Initialize the WASM module. Must be called before any other function. Safe to call multiple times — the module loads only once.
+Initialize the WASM module. Must be called before any other function. Safe to call multiple times — the module loads only once. If initialization fails (e.g., WASM file not found), subsequent calls will retry instead of caching the failure.
 
 ```typescript
 async function init(): Promise<void>
@@ -44,8 +44,8 @@ function generate(input: GenerateInput): GenerateResult
 interface GenerateInput {
   parameters: Parameter[];       // Required. At least 1 parameter.
   constraints?: string[];        // Constraint expressions.
-  strength?: number;             // Interaction strength. Default: 2 (pairwise).
-  seed?: number;                 // RNG seed for determinism. Default: 0.
+  strength?: number;             // Interaction strength (positive integer). Default: 2 (pairwise).
+  seed?: number;                 // RNG seed for determinism (finite number). Default: 0.
   maxTests?: number;             // Max test count. 0 = no limit (default).
   weights?: WeightConfig;        // Value weight hints.
   seeds?: TestCase[];            // Existing test cases to build upon.
@@ -146,12 +146,12 @@ generate({
 ```typescript
 interface GenerateResult {
   tests: TestCase[];                // Positive test cases (no invalid values).
-  negativeTests?: TestCase[];       // Negative tests (exactly 1 invalid value each).
+  negativeTests: TestCase[];        // Negative tests (exactly 1 invalid value each). Empty array if none.
   coverage: number;                 // Coverage ratio (0.0 – 1.0).
   uncovered: UncoveredTuple[];      // Uncovered tuples with reasons.
   stats: GenerateStats;
   suggestions: Suggestion[];        // Actionable suggestions.
-  warnings: string[];               // Performance/configuration warnings.
+  warnings: string[];               // Warnings (e.g., coverage < 100%, seed count exceeds maxTests).
   strength: number;                 // Actual strength used.
   classCoverage?: ClassCoverage;    // Present when equivalence classes are defined.
 }
@@ -288,6 +288,17 @@ const result = cw.generate({
 
 See [Constraint Syntax](constraints.md) for the full builder API reference.
 
+## Input Validation
+
+The Pure TypeScript API validates inputs and throws descriptive errors for:
+
+- `strength`: Must be a positive integer. Non-integer, negative, or zero values are rejected.
+- `seed`: Must be a finite number. `NaN` and `Infinity` are rejected.
+- `maxTests`: Must be a non-negative integer when provided.
+- `parameters`: Must be a non-empty array.
+
+The WASM API performs equivalent validation at the C++ boundary.
+
 ## Error Handling
 
 Functions throw `CoverwiseError` on invalid input:

docs/ja/examples.md

@@ -73,7 +73,7 @@ const result = cw.generate({
 });
 
 console.log('正常テスト:', result.tests.length);
-console.log('ネガティブテスト:', result.negativeTests?.length);
+console.log('ネガティブテスト:', result.negativeTests.length);
 
 // 正常テストは有効な組み合わせのみ。
 // ネガティブテストはそれぞれ無効値が正確に1つ。

docs/ja/introduction.md

@@ -69,7 +69,7 @@ coverwise は単なる生成ツールではなく、**テスト設計API** と
 - **ステートレス** — `generate(input) → output`、セッション管理不要
 - **分解可能** — 生成・分析・拡張の独立した関数
 - **説明可能** — すべての結果にカバレッジ証明と人間が読める未カバータプルを含む
-- **決定的** — 同じ入力＋シード＝毎回同じ出力
+- **決定的** — 同じ入力＋シード＝毎回同じ出力（同一エンジン内での保証。WASMとPure TSは異なるRNGアルゴリズムを使用するため、同じシードでもエンジン間ではテスト順序が異なる場合がありますが、カバレッジは同等です）
 
 ## プラットフォームサポート
 

docs/ja/js-api.md

@@ -24,7 +24,7 @@ const result = generate({ parameters: [...] });
 
 ## `init()`
 
-WASM モジュールを初期化します。他の関数を呼ぶ前に必ず呼んでください。複数回呼んでも安全です。モジュールは一度だけロードされます。
+WASM モジュールを初期化します。他の関数を呼ぶ前に必ず呼んでください。複数回呼んでも安全です。モジュールは一度だけロードされます。初期化に失敗した場合（例：WASMファイルが見つからない）、以降の呼び出しは失敗をキャッシュせずリトライします。
 
 ```typescript
 async function init(): Promise<void>
@@ -44,8 +44,8 @@ function generate(input: GenerateInput): GenerateResult
 interface GenerateInput {
   parameters: Parameter[];       // 必須。1つ以上のパラメータ。
   constraints?: string[];        // 制約式。
-  strength?: number;             // 相互作用の強度。デフォルト: 2（ペアワイズ）。
-  seed?: number;                 // 決定性のためのRNGシード。デフォルト: 0。
+  strength?: number;             // 相互作用の強度（正の整数）。デフォルト: 2（ペアワイズ）。
+  seed?: number;                 // 決定性のためのRNGシード（有限数値）。デフォルト: 0。
   maxTests?: number;             // 最大テスト数。0 = 無制限（デフォルト）。
   weights?: WeightConfig;        // 値の重み付けヒント。
   seeds?: TestCase[];            // 既存テストケース。
@@ -146,12 +146,12 @@ generate({
 ```typescript
 interface GenerateResult {
   tests: TestCase[];                // 正常テストケース（無効値なし）。
-  negativeTests?: TestCase[];       // ネガティブテスト（無効値が正確に1つ）。
+  negativeTests: TestCase[];        // ネガティブテスト（無効値が正確に1つ）。該当なしの場合は空配列。
   coverage: number;                 // カバレッジ比率（0.0 – 1.0）。
   uncovered: UncoveredTuple[];      // 未カバータプルと理由。
   stats: GenerateStats;
   suggestions: Suggestion[];        // 改善の提案。
-  warnings: string[];               // パフォーマンス/設定の警告。
+  warnings: string[];               // 警告（例：カバレッジ100%未達、シード数がmaxTestsを超過）。
   strength: number;                 // 使用された強度。
   classCoverage?: ClassCoverage;    // 同値クラス定義時に存在。
 }
@@ -288,6 +288,17 @@ const result = cw.generate({
 
 詳細は[制約構文](constraints.md)を参照してください。
 
+## 入力バリデーション
+
+Pure TypeScript API は入力を検証し、不正な値に対して説明的なエラーをスローします：
+
+- `strength`: 正の整数である必要があります。非整数、負、ゼロは拒否されます。
+- `seed`: 有限な数値である必要があります。`NaN` と `Infinity` は拒否されます。
+- `maxTests`: 指定する場合は非負の整数である必要があります。
+- `parameters`: 空でない配列である必要があります。
+
+WASM API は C++ 側の境界で同等のバリデーションを行います。
+
 ## エラーハンドリング
 
 無効な入力の場合、関数は `CoverwiseError` をスローします：

js/compat.test.ts

@@ -21,114 +21,37 @@ import {
   extend as tsExtendRaw,
   generate as tsGenerateRaw,
 } from '../src/ts/core/generator.js';
-import {
-  createGenerateOptions,
-  createWeightConfig,
-  type GenerateOptions,
-  type SubModel as InternalSubModel,
-  type WeightConfig as InternalWeightConfig,
-} from '../src/ts/model/generate-options.js';
-import { Parameter as InternalParameter } from '../src/ts/model/parameter.js';
+import type { GenerateOptions } from '../src/ts/model/generate-options.js';
+import type { Parameter as InternalParameter } from '../src/ts/model/parameter.js';
 import type { TestCase as InternalTestCase } from '../src/ts/model/test-case.js';
 import { validateCoverage } from '../src/ts/validator/coverage-validator.js';
 
-// ---------------------------------------------------------------------------
-// Adapter helpers: convert between WASM JSON format and TS internal format
-// ---------------------------------------------------------------------------
-
-interface ParameterValueObj {
-  value: string | number | boolean;
-  invalid?: boolean;
-  aliases?: string[];
-}
+// --- Adapter imports (shared conversion logic) ---
 
-function toStringValue(v: string | number | boolean): string {
-  return String(v);
-}
-
-function convertParameters(wasmParams: Parameter[]): InternalParameter[] {
-  return wasmParams.map((wp) => {
-    const values: string[] = [];
-    const invalid: boolean[] = [];
-    const aliases: string[][] = [];
-    let hasInvalid = false;
-    let hasAliases = false;
-
-    for (const v of wp.values) {
-      if (typeof v === 'object' && v !== null && 'value' in v) {
-        const pv = v as ParameterValueObj;
-        values.push(toStringValue(pv.value));
-        invalid.push(pv.invalid === true);
-        aliases.push(pv.aliases ?? []);
-        if (pv.invalid) {
-          hasInvalid = true;
-        }
-        if (pv.aliases && pv.aliases.length > 0) {
-          hasAliases = true;
-        }
-      } else {
-        values.push(toStringValue(v as string | number | boolean));
-        invalid.push(false);
-        aliases.push([]);
-      }
-    }
+import {
+  toInternalOptions,
+  toInternalParams,
+  toInternalTestCase,
+  toPublicTestCase,
+} from './pure/adapter.js';
 
-    const param = hasInvalid
-      ? new InternalParameter(wp.name, values, invalid)
-      : new InternalParameter(wp.name, values);
-    if (hasAliases) {
-      param.setAliases(aliases);
-    }
-    return param;
-  });
-}
+// ---------------------------------------------------------------------------
+// Thin wrappers around adapter functions for compat-test convenience
+// ---------------------------------------------------------------------------
 
+/** Convert public TestCase to internal, delegating to adapter. */
 function namedTestToInternal(namedTest: TestCase, params: InternalParameter[]): InternalTestCase {
-  const values: number[] = new Array(params.length);
-  for (let i = 0; i < params.length; ++i) {
-    const rawVal = namedTest[params[i].name];
-    const strVal = toStringValue(rawVal);
-    const idx = params[i].findValueIndex(strVal);
-    values[i] = idx;
-  }
-  return { values };
+  return toInternalTestCase(namedTest, params);
 }
 
+/** Convert internal TestCase to public, using adapter with rotation=0. */
 function internalTestToNamed(tc: InternalTestCase, params: InternalParameter[]): TestCase {
-  const result: TestCase = {};
-  for (let i = 0; i < params.length; ++i) {
-    result[params[i].name] = params[i].values[tc.values[i]];
-  }
-  return result;
+  return toPublicTestCase(tc, params, 0);
 }
 
+/** Build GenerateOptions from GenerateInput, delegating to adapter. */
 function buildGenerateOptions(input: GenerateInput, params: InternalParameter[]): GenerateOptions {
-  const subModels: InternalSubModel[] = (input.subModels ?? []).map((sm) => ({
-    parameterNames: sm.parameters,
-    strength: sm.strength,
-  }));
-
-  let weights: InternalWeightConfig = createWeightConfig();
-  if (input.weights) {
-    weights = { entries: { ...input.weights } };
-  }
-
-  const seeds: InternalTestCase[] = (input.seeds ?? []).map((s) => namedTestToInternal(s, params));
-
-  return createGenerateOptions({
-    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,
-    maxTests: input.maxTests ?? 0,
-    seeds,
-    subModels,
-    weights,
-  });
+  return toInternalOptions(input, params);
 }
 
 // ---------------------------------------------------------------------------
@@ -148,7 +71,7 @@ function tsGenerate(input: GenerateInput): GenerateResult {
       strength: input.strength ?? 2,
     };
   }
-  const params = convertParameters(input.parameters);
+  const params = toInternalParams(input.parameters);
   const opts = buildGenerateOptions(input, params);
   const result = tsGenerateRaw(opts);
 
@@ -179,7 +102,7 @@ function tsAnalyzeCoverage(
   tests: TestCase[],
   strength?: number,
 ): CoverageReport {
-  const params = convertParameters(parameters);
+  const params = toInternalParams(parameters);
   const internalTests: InternalTestCase[] = tests.map((t) => namedTestToInternal(t, params));
   const report = validateCoverage(params, internalTests, strength ?? 2);
   // Match WASM behavior: 0 tuples => coverageRatio 1.0
@@ -190,7 +113,7 @@ function tsAnalyzeCoverage(
 }
 
 function tsExtendTests(existing: TestCase[], input: GenerateInput): GenerateResult {
-  const params = convertParameters(input.parameters);
+  const params = toInternalParams(input.parameters);
   const existingInternal = existing.map((t) => namedTestToInternal(t, params));
   const opts = buildGenerateOptions(input, params);
   const result = tsExtendRaw(existingInternal, opts);
@@ -211,7 +134,7 @@ function tsExtendTests(existing: TestCase[], input: GenerateInput): GenerateResu
 }
 
 function tsEstimateModel(input: GenerateInput): ModelStats {
-  const params = convertParameters(input.parameters);
+  const params = toInternalParams(input.parameters);
   const opts = buildGenerateOptions(input, params);
   return tsEstimateModelRaw(opts);
 }
@@ -405,11 +328,11 @@ describe('WASM / TS compatibility', () => {
       });
     }
 
-    // Exact output match tests are skipped because the C++ and TypeScript
-    // engines use different RNG implementations (both xoshiro128** but with
-    // different internal sequencing due to algorithm-level differences in
-    // candidate generation and value iteration order). Both produce correct
-    // covering arrays but with different test orderings and counts.
+    // Exact output match tests are skipped because the C++ / WASM engine uses
+    // std::mt19937_64 (Mersenne Twister 64-bit) while the TypeScript engine
+    // uses xoshiro128**. The same seed produces different sequences across
+    // engines, but both are deterministic within their own engine.
+    // Compatibility tests compare coverage completeness, not exact output.
     for (const { name, input } of scenarios) {
       it.skip(`${name}: exact test output match`, () => {
         const wasmResult = generate(input);