diff --git a/src/stores/ml-store.ts b/src/stores/ml-store.ts index 9ad84c3..fcc62ab 100644 --- a/src/stores/ml-store.ts +++ b/src/stores/ml-store.ts @@ -222,10 +222,13 @@ export async function createMLStore(bus: SignalBus): Promise { setInputs: (x: number, y: number) => { if (!activeIml) return; - const cx = Math.max(0, Math.min(1, x)); - const cy = Math.max(0, Math.min(1, y)); - activeIml.setInput(0, cx); - activeIml.setInput(1, cy); + // Clamp to [0,1] and guard against NaN/Infinity + const clamp = (v: number) => { + if (!Number.isFinite(v)) return 0.5; + return Math.max(0, Math.min(1, v)); + }; + activeIml.setInput(0, clamp(x)); + activeIml.setInput(1, clamp(y)); runInference(); }, diff --git a/tests/solidjs/reactive-inference.spec.ts b/tests/solidjs/reactive-inference.spec.ts new file mode 100644 index 0000000..f4f6903 --- /dev/null +++ b/tests/solidjs/reactive-inference.spec.ts @@ -0,0 +1,398 @@ +/** + * e2e tests for f05-reactive-inference-loop. + * Validates: + * VAL-ML-004: Inference runs when inputs change — different positions produce different outputs + * VAL-ML-005: setInputs is synchronous — getOutputs reflects new state immediately + * + * Also verifies input clamping behavior (values outside [0,1] are clamped). + */ +import { test, expect } from '@playwright/test'; +import { loadSolidApp } from './helpers'; + +test.describe('Reactive Inference Loop (f05)', () => { + + // ─── VAL-ML-004: Inference runs when inputs change ─── + + test('VAL-ML-004a: setInputs(0.25, 0.25) and setInputs(0.75, 0.75) produce different outputs', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + probe.setInputs(0.25, 0.25); + const outputsA = [...probe.getOutputs()]; + + probe.setInputs(0.75, 0.75); + const outputsB = [...probe.getOutputs()]; + + return { + outputsA: outputsA.slice(0, 5), + outputsB: outputsB.slice(0, 5), + same: outputsA.every((v: number, i: number) => v === outputsB[i]), + allBoundedA: outputsA.every((v: number) => v >= 0 && v <= 1), + allBoundedB: outputsB.every((v: number) => v >= 0 && v <= 1), + }; + }); + + expect(result.same).toBe(false); + expect(result.allBoundedA).toBe(true); + expect(result.allBoundedB).toBe(true); + }); + + test('VAL-ML-004b: multiple distinct positions all produce different outputs', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + const positions = [ + [0.1, 0.1], + [0.3, 0.7], + [0.5, 0.5], + [0.7, 0.3], + [0.9, 0.9], + ]; + + const outputSets: number[][] = []; + for (const [x, y] of positions) { + probe.setInputs(x, y); + outputSets.push([...probe.getOutputs()]); + } + + // Every pair should differ in at least one output + let allDifferent = true; + for (let i = 0; i < outputSets.length && allDifferent; i++) { + for (let j = i + 1; j < outputSets.length && allDifferent; j++) { + const same = outputSets[i].every((v, idx) => v === outputSets[j][idx]); + if (same) allDifferent = false; + } + } + + const allBounded = outputSets.every( + set => set.every((v: number) => v >= 0 && v <= 1) + ); + + return { allDifferent, allBounded, count: outputSets.length, eachLength: outputSets[0].length }; + }); + + expect(result.allDifferent).toBe(true); + expect(result.allBounded).toBe(true); + expect(result.count).toBe(5); + expect(result.eachLength).toBe(126); + }); + + test('VAL-ML-004c: changing only X produces different outputs', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + probe.setInputs(0.2, 0.5); + const outputs1 = [...probe.getOutputs()]; + + probe.setInputs(0.8, 0.5); + const outputs2 = [...probe.getOutputs()]; + + return { + same: outputs1.every((v: number, i: number) => v === outputs2[i]), + }; + }); + + expect(result.same).toBe(false); + }); + + test('VAL-ML-004d: changing only Y produces different outputs', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + probe.setInputs(0.5, 0.2); + const outputs1 = [...probe.getOutputs()]; + + probe.setInputs(0.5, 0.8); + const outputs2 = [...probe.getOutputs()]; + + return { + same: outputs1.every((v: number, i: number) => v === outputs2[i]), + }; + }); + + expect(result.same).toBe(false); + }); + + // ─── VAL-ML-005: setInputs is synchronous ─── + + test('VAL-ML-005a: getOutputs immediately reflects setInputs — no async delay', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + // Call setInputs then immediately read outputs — no await + probe.setInputs(0.3, 0.7); + const outputs = probe.getOutputs(); + + return { + length: outputs.length, + allBounded: outputs.every((v: number) => v >= 0 && v <= 1), + allFinite: outputs.every((v: number) => Number.isFinite(v)), + hasNonZero: outputs.some((v: number) => v > 0), + }; + }); + + expect(result.length).toBe(126); + expect(result.allBounded).toBe(true); + expect(result.allFinite).toBe(true); + // With random weights, outputs shouldn't all be zero + expect(result.hasNonZero).toBe(true); + }); + + test('VAL-ML-005b: sequential setInputs calls produce consistent results', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + // Set to position A + probe.setInputs(0.4, 0.6); + const outputsA1 = [...probe.getOutputs()]; + + // Set to position B + probe.setInputs(0.8, 0.2); + const outputsB = [...probe.getOutputs()]; + + // Set back to position A — should produce same results as first time + probe.setInputs(0.4, 0.6); + const outputsA2 = [...probe.getOutputs()]; + + return { + a1EqualsA2: outputsA1.every((v: number, i: number) => v === outputsA2[i]), + aDiffersB: !outputsA1.every((v: number, i: number) => v === outputsB[i]), + }; + }); + + // Same inputs → same outputs (deterministic) + expect(result.a1EqualsA2).toBe(true); + // Different inputs → different outputs + expect(result.aDiffersB).toBe(true); + }); + + test('VAL-ML-005c: repeated setInputs with same values produces same outputs', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + const allOutputs: number[][] = []; + for (let i = 0; i < 5; i++) { + probe.setInputs(0.5, 0.5); + allOutputs.push([...probe.getOutputs()]); + } + + // All 5 should be identical (deterministic inference) + const allSame = allOutputs.slice(1).every( + set => set.every((v, i) => v === allOutputs[0][i]) + ); + + return { allSame, count: allOutputs.length }; + }); + + expect(result.allSame).toBe(true); + expect(result.count).toBe(5); + }); + + // ─── Input clamping (values outside [0,1]) ─── + + test('setInputs(-5, 99) clamps to [0,1] and produces valid outputs', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + probe.setInputs(-5, 99); + const outputs = probe.getOutputs(); + + // Also verify: setInputs(-5,99) should produce same result as setInputs(0,1) + // since clamping maps -5→0 and 99→1 + const outputsClamped = [...outputs]; + + probe.setInputs(0, 1); + const outputsExplicit = [...probe.getOutputs()]; + + return { + length: outputsClamped.length, + allBounded: outputsClamped.every((v: number) => v >= 0 && v <= 1), + allFinite: outputsClamped.every((v: number) => Number.isFinite(v)), + matchesClamped: outputsClamped.every((v: number, i: number) => v === outputsExplicit[i]), + }; + }); + + expect(result.length).toBe(126); + expect(result.allBounded).toBe(true); + expect(result.allFinite).toBe(true); + // Clamped values should produce same outputs as explicitly clamped values + expect(result.matchesClamped).toBe(true); + }); + + test('setInputs with NaN is handled gracefully', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + // First set valid inputs + probe.setInputs(0.5, 0.5); + const validOutputs = [...probe.getOutputs()]; + + // Try NaN — Math.max(0, Math.min(1, NaN)) = NaN in JS + // But we should handle it gracefully + try { + probe.setInputs(NaN, 0.5); + } catch (e) { + // If it throws, that's also acceptable + return { handled: true, threw: true }; + } + + const outputs = probe.getOutputs(); + return { + handled: true, + threw: false, + allFinite: outputs.every((v: number) => Number.isFinite(v)), + length: outputs.length, + }; + }); + + expect(result.handled).toBe(true); + if (!result.threw) { + // If it didn't throw, outputs should still be valid + expect(result.allFinite).toBe(true); + } + }); + + test('setInputs with very small values near 0 boundary', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + probe.setInputs(0.001, 0.001); + const outputs = probe.getOutputs(); + + return { + allBounded: outputs.every((v: number) => v >= 0 && v <= 1), + allFinite: outputs.every((v: number) => Number.isFinite(v)), + }; + }); + + expect(result.allBounded).toBe(true); + expect(result.allFinite).toBe(true); + }); + + test('setInputs with values very close to 1 boundary', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + probe.setInputs(0.999, 0.999); + const outputs = probe.getOutputs(); + + return { + allBounded: outputs.every((v: number) => v >= 0 && v <= 1), + allFinite: outputs.every((v: number) => Number.isFinite(v)), + }; + }); + + expect(result.allBounded).toBe(true); + expect(result.allFinite).toBe(true); + }); + + test('setInputs(0, 0) clamps correctly to corner position', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + probe.setInputs(0, 0); + const outputs = probe.getOutputs(); + + // Verify -1 and -0.001 clamp to same as 0 + probe.setInputs(-1, -0.001); + const outputsNeg = probe.getOutputs(); + + return { + allBounded: outputs.every((v: number) => v >= 0 && v <= 1), + matchesCorner: outputs.every((v: number, i: number) => v === outputsNeg[i]), + }; + }); + + expect(result.allBounded).toBe(true); + expect(result.matchesCorner).toBe(true); + }); + + // ─── Synchronous consistency (three-step verification) ─── + + test('three-step verification: setInputs(A) → setInputs(B) → setInputs(A) returns to original', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const probe = (window as any).__nisps; + + // Step 1: Position A + probe.setInputs(0.25, 0.25); + const outputsA = [...probe.getOutputs()]; + + // Step 2: Position B + probe.setInputs(0.75, 0.75); + const outputsB = [...probe.getOutputs()]; + + // Step 3: Back to A + probe.setInputs(0.25, 0.25); + const outputsA2 = [...probe.getOutputs()]; + + return { + aMatchesA2: outputsA.every((v: number, i: number) => v === outputsA2[i]), + aDiffersB: !outputsA.every((v: number, i: number) => v === outputsB[i]), + bBounded: outputsB.every((v: number) => v >= 0 && v <= 1), + }; + }); + + expect(result.aMatchesA2).toBe(true); + expect(result.aDiffersB).toBe(true); + expect(result.bBounded).toBe(true); + }); + + // ─── Bus emission verification ─── + + test('setInputs emits outputs on bus topic', async ({ page }) => { + await loadSolidApp(page); + + const result = await page.evaluate(() => { + const bus = (window as any).__nispsBus; + const topic = bus.getTopic('ml.outputs'); + + // Record initial value (topic is callable — returns signal value) + const before = topic ? topic() : null; + + // Change inputs + const probe = (window as any).__nisps; + probe.setInputs(0.2, 0.8); + + // Read bus value after change + const after = topic ? topic() : null; + + return { + hasTopic: topic !== null && topic !== undefined, + beforeType: before ? before.constructor.name : 'null', + afterType: after ? after.constructor.name : 'null', + beforeLength: before ? before.length : 0, + afterLength: after ? after.length : 0, + changed: before !== after, + }; + }); + + expect(result.hasTopic).toBe(true); + expect(result.afterLength).toBe(126); + expect(result.changed).toBe(true); + }); +});