memlnaut-nisps/tests/solidjs/reactive-inference.spec.ts
monkey-w1n5t0n 1127c8aac9 fix: default to visual mode (20 outputs) and fix FlowField canvas resize
Change default outputMode from 'synth' to 'visual' in ml-store.ts so
FlowField particles render immediately on page load. Fix FlowField
component canvas initialization: create visualizer in ResizeObserver
callback (after layout) instead of in createEffect (before layout
settles), preventing the default 300x150 canvas size issue. Add window
resize listener as fallback. Update all 13 affected tests to expect 20
outputs (visual mode default) instead of 126 (synth mode).

Unblocks VAL-VIS-001, VAL-VIS-002, VAL-VIS-003.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
2026-04-07 19:01:55 +02:00

398 lines
12 KiB
TypeScript

/**
* 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(20); // visual mode default
});
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(20); // visual mode default
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(20); // visual mode default
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(20); // visual mode default
expect(result.changed).toBe(true);
});
});