Fixes

agents/greed-v2.rhai

@@ -0,0 +1,254 @@
+// SECRET
+
+// Return a random valid action on the given board.
+// Used as a last resort.
+fn random_action(board) {
+	let symb = rand_symb();
+	let pos = rand_int(0, 10);
+	let action = Action(symb, pos);
+
+	while !board.can_play(action) {
+		let symb = rand_symb();
+		let pos = rand_int(0, 10);
+		action = Action(symb, pos);
+	}
+
+	return action
+}
+
+
+/// Returns an array of (idx, f32) for each empty slot in the board.
+/// - idx is the index of this slot
+/// - f32 is the "influence of" this slot
+fn compute_influence(board) {
+	// Fill all empty slots with fives and compute starting value
+	let filled = board;
+	for i in filled.free_spots_idx() {
+		filled[i] = 5;
+	}
+
+	// Compute the value of the filled board
+	let base = filled.evaluate();
+
+	// Exit early if the board is invalid.
+	// This is usually caused by zero-division.
+	if (base == ()) {
+		return [];
+	}
+
+	// Increase each slot's value by 1
+	// and record the effect on the expression's total value.
+	//
+	// `influence` is an array of (slot_idx, value)
+	let influence = [];
+	for i in 0..board.size() {
+		let slot = board[i];
+
+		// Ignore slots that are not empty
+		if slot != "" {
+			continue
+		}
+
+		// Don't assign directly to `filled`,
+		// we want to keep it full of fives.
+		// Assigning to `b` make a copy of the board.
+		let b = filled;
+		b[i] = 6;
+
+		influence.push([i, b.evaluate() - base]);
+	}
+
+
+   // Sort by increasing absolute score
+   influence.sort(|a, b| {
+		let a_abs = a[1].abs();
+		let b_abs = b[1].abs();
+
+		// Returns...
+		//  1 if positive (a_abs > b_abs),
+		// -1 if negative,
+		//  0 if equal
+		return sign(a_abs - b_abs);
+	});
+
+	return influence;
+}
+
+fn place_number(board, minimize) {
+	let numbers = [0,1,2,3,4,5,6,7,8,9];
+	let available_numbers = numbers.retain(|x| board.contains(x));
+
+	let influence = compute_influence(board);
+
+	// Stupid edge cases, fall back to random
+	if influence.len() == 0 || available_numbers.len() == 0 {
+		return random_action(board);
+	}
+
+
+	// Get the most influential position
+	let pos = influence[-1][0];
+	let val = influence[-1][1];
+
+	// Pick the number we should use,
+	// This is always either the largest
+	// or the smallest number available to us.
+	let symbol = 0;
+	if minimize {
+		if val > 0 {
+			symbol = available_numbers[0];
+		} else {
+			symbol = available_numbers[-1];
+		}
+	} else {
+		if val > 0 {
+			symbol = available_numbers[-1];
+		} else {
+		  	symbol = available_numbers[0];
+		}
+	}
+
+	return Action(symbol, pos);
+}
+
+
+fn op_value(board) {
+    print(board);
+	let actions = [];
+    for o in ["+", "-", "*", "/"] {
+        if board.contains(o) {
+            continue;
+        }
+
+        for p in 0..=10 {
+            let action = Action(o, p);
+            if board.can_play(action) {
+                actions.push(action);
+            }
+        }
+    }
+
+    // No other operators can be placed, return value of fives
+    if actions.is_empty() {
+        let filled = board;
+        for i in filled.free_spots_idx() {
+            filled[i] = 5;
+        }
+        let v = filled.evaluate();
+        if v == () {
+            return ();
+        } else {
+            return [v, v];
+        }
+    }
+
+
+	let max = ();
+    let min = ();
+   	for a in actions {
+       let tmp = board;
+       tmp.play(a);
+
+       let vals = op_value(tmp);
+       if vals != () {
+           	for v in vals {
+                if max == () || min == () {
+                    max = v;
+                    min = v;
+                }
+
+                if v > max {
+                    max = v;
+                } else if v < min {
+                    min = v;
+                }
+            }
+       }
+   }
+
+   if min == () || max == () {
+       return ();
+   }
+
+   return [min, max];
+}
+
+fn place_op(board, minimize) {
+	let ops = ["+", "-", "*", "/"];
+	let available_ops = ops.retain(|x| board.contains(x));
+
+	// Performance optimization if board is empty.
+    // This is the move we would pick, hard-coded.
+    if available_ops.len() == 4 {
+        if minimize {
+        	let act = Action("+", 3);
+        	if board.can_play(act) {return act}
+    	} else {
+            let act = Action("/", 9);
+        	if board.can_play(act) {return act}
+        }
+    }
+
+	// All possible operator actions
+	let actions = [];
+    for o in ["+", "-", "*", "/"] {
+        for p in 0..=10 {
+            let action = Action(o, p);
+            if board.can_play(action) {
+                let tmp = board;
+                tmp.play(action);
+                let v = op_value(tmp);
+                if v != () {
+                	actions.push([action, v]);
+                }
+            }
+        }
+    }
+
+    if actions.is_empty() {
+        return ();
+    }
+
+   let action = ();
+   if minimize {
+        // Sort by increasing minimum score
+        actions.sort(|a, b| sign(a[1][0] - b[1][0]));
+        action = actions[0][0];
+   } else {
+        // Sort by increasing maximum score
+        actions.sort(|a, b| sign(a[1][1] - b[1][1]));
+        action = actions[-1][0];
+   }
+
+   debug(action);
+
+   return action;
+}
+
+
+// Main step function (shared between min and max)
+fn greed_step(board, minimize) {
+	let action = place_op(board, minimize);
+	if action == () {
+		action = place_number(board, minimize);
+	}
+
+	if board.can_play(action) {
+		return action;
+	}
+
+	// Prevent invalid moves, random fallback
+	return random_action(board);
+}
+
+
+
+// Minimizer step
+fn step_min(board) {
+	greed_step(board, true)
+}
+
+// Maximizer step
+fn step_max(board) {
+	greed_step(board, false)
+}

agents/greed.rhai

@@ -1,5 +1,3 @@
-
-
 // Return a random valid action on the given board.
 // Used as a last resort.
 fn random_action(board) {
@@ -85,7 +83,6 @@ fn place_number(board, minimize) {
 		return random_action(board);
 	}
 
-
 	// Get the most influential position
 	let pos = influence[-1][0];
 	let val = influence[-1][1];
@@ -139,25 +136,20 @@ fn place_op(board, minimize) {
 	return ();
 }
 
-
 // Main step function (shared between min and max)
 fn greed_step(board, minimize) {
-
 	let action = place_op(board, minimize);
+
+	// We could not place an op, so place a number
 	if action == () {
 		action = place_number(board, minimize);
 	}
 
-	if board.can_play(action) {
-		return action;
-	}
-
 	// Prevent invalid moves, random fallback
+	if board.can_play(action) { return action; }
 	return random_action(board);
 }
 
-
-
 // Minimizer step
 fn step_min(board) {
 	greed_step(board, true)

docker-compose.yml

@@ -2,7 +2,7 @@ services:
   webui:
     image: minimax
     ports:
-      - "3000:3000"
+      - "4000:3000"
     volumes:
       - ./data:/app/data
     env_file:

rust/minimax/src/agents/rhai.rs

@@ -80,7 +80,6 @@ pub struct RhaiAgent<R: Rng + 'static> {
 
 	engine: Engine,
 	script: AST,
-	scope: Scope<'static>,
 	print_callback: Arc<dyn Fn(&str) + 'static>,
 }
 
@@ -118,7 +117,6 @@ impl<R: Rng + 'static> RhaiAgent<R> {
 
 			// Do not use FULL, rand_* functions are not pure
 			engine.set_optimization_level(OptimizationLevel::Simple);
-
 			engine.disable_symbol("eval");
 			engine.set_max_expr_depths(100, 100);
 			engine.set_max_strings_interned(1024);
@@ -201,13 +199,11 @@ impl<R: Rng + 'static> RhaiAgent<R> {
 		};
 
 		let script = engine.compile(script)?;
-		let scope = Scope::new(); // Not used
 
 		Ok(Self {
 			rng,
 			engine,
 			script,
-			scope,
 			print_callback,
 		})
 	}
@@ -227,7 +223,7 @@ impl<R: Rng + 'static> Agent for RhaiAgent<R> {
 	fn step_min(&mut self, board: &Board) -> Result<PlayerAction, Self::ErrorType> {
 		let res = self.engine.call_fn_with_options::<PlayerAction>(
 			CallFnOptions::new().eval_ast(false),
-			&mut self.scope,
+			&mut Scope::new(),
 			&self.script,
 			"step_min",
 			(board.clone(),),
@@ -242,7 +238,7 @@ impl<R: Rng + 'static> Agent for RhaiAgent<R> {
 	fn step_max(&mut self, board: &Board) -> Result<PlayerAction, Self::ErrorType> {
 		let res = self.engine.call_fn_with_options::<PlayerAction>(
 			CallFnOptions::new().eval_ast(false),
-			&mut self.scope,
+			&mut Scope::new(),
 			&self.script,
 			"step_max",
 			(board.clone(),),

webui/src/app/api/get-script/route.ts

@@ -2,11 +2,14 @@ import { NextRequest, NextResponse } from "next/server";
 import { readFile } from "fs/promises";
 import { join } from "path";
 import { existsSync } from "fs";
-import { SAVE_CONFIG } from "@/lib/saveConfig";
+import { CONFIG } from "@/lib/config";
+
+// Force dynamic rendering for this API route
+export const dynamic = "force-dynamic";
 
 export async function GET(request: NextRequest) {
 	try {
-		const { searchParams } = new URL(request.url);
+		const { searchParams } = request.nextUrl;
 		const name = searchParams.get("name");
 
 		if (!name) {
@@ -17,18 +20,17 @@ export async function GET(request: NextRequest) {
 		}
 
 		// Validate filename (same validation as save)
-		if (!SAVE_CONFIG.FILENAME_REGEX.test(name)) {
+		if (!CONFIG.FILENAME_REGEX.test(name)) {
 			return NextResponse.json(
 				{ error: "Invalid script name" },
 				{ status: 400 }
 			);
 		}
 
-		const saveDir = SAVE_CONFIG.SAVE_DIRECTORY;
+		const saveDir = CONFIG.SAVE_DIRECTORY;
 		const filename = `${name}.rhai`;
 		const filepath = join(saveDir, filename);
 
-		// Check if file exists
 		if (!existsSync(filepath)) {
 			return NextResponse.json(
 				{ error: `Script "${name}" not found` },
@@ -36,8 +38,7 @@ export async function GET(request: NextRequest) {
 			);
 		}
 
-		// Read and return file content
-		const content = await readFile(filepath, "utf8");
+		let content = await readFile(filepath, "utf8");
 
 		return NextResponse.json({
 			name,

webui/src/app/api/list-scripts/route.ts

@@ -1,31 +1,40 @@
-import { NextResponse } from "next/server";
+import { NextRequest, NextResponse } from "next/server";
 import { readdir } from "fs/promises";
-import { join } from "path";
 import { existsSync } from "fs";
-import { SAVE_CONFIG } from "@/lib/saveConfig";
+import { CONFIG } from "@/lib/config";
 
-export async function GET() {
+// Force dynamic rendering for this API route
+export const dynamic = "force-dynamic";
+
+const headers = {
+	"Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate",
+	Pragma: "no-cache",
+	Expires: "0",
+};
+
+export async function GET(_request: NextRequest) {
 	try {
-		const saveDir = SAVE_CONFIG.SAVE_DIRECTORY;
+		const saveDir = CONFIG.SAVE_DIRECTORY;
 
 		// If save directory doesn't exist, return empty array
 		if (!existsSync(saveDir)) {
-			return NextResponse.json({ scripts: [] });
+			return NextResponse.json({ scripts: [] }, { headers });
 		}
 
 		// Read directory and filter for .rhai files
 		const files = await readdir(saveDir);
+
 		const scripts = files
 			.filter((file) => file.endsWith(".rhai"))
 			.map((file) => file.replace(".rhai", ""))
 			.sort(); // Sort alphabetically
 
-		return NextResponse.json({ scripts });
+		return NextResponse.json({ scripts }, { headers });
 	} catch (error) {
 		console.error("List scripts error:", error);
 		return NextResponse.json(
 			{ error: "Failed to list scripts" },
-			{ status: 500 }
+			{ status: 500, headers }
 		);
 	}
 }

webui/src/app/api/save-script/route.ts

@@ -2,12 +2,12 @@ import { NextRequest, NextResponse } from "next/server";
 import { writeFile, mkdir } from "fs/promises";
 import { join } from "path";
 import { existsSync } from "fs";
-import { SAVE_CONFIG } from "@/lib/saveConfig";
+import { CONFIG } from "@/lib/config";
 
 export async function POST(request: NextRequest) {
 	try {
 		// Check if saving is enabled
-		if (!SAVE_CONFIG.ENABLE_SAVE) {
+		if (!CONFIG.ENABLE_SAVE) {
 			return NextResponse.json(
 				{ error: "Script saving is disabled" },
 				{ status: 403 }
@@ -16,15 +16,13 @@ export async function POST(request: NextRequest) {
 
 		const { name, content, secret } = await request.json();
 
-		// Validate secret
-		if (secret !== SAVE_CONFIG.SAVE_SECRET) {
+		if (secret !== CONFIG.SAVE_SECRET) {
 			return NextResponse.json(
-				{ error: "Invalid save secret" },
+				{ error: "Invalid secret" },
 				{ status: 401 }
 			);
 		}
 
-		// Validate required fields
 		if (!name || !content) {
 			return NextResponse.json(
 				{ error: "Name and content are required" },
@@ -32,17 +30,25 @@ export async function POST(request: NextRequest) {
 			);
 		}
 
-		// Validate filename
-		if (name.length > SAVE_CONFIG.MAX_FILENAME_LENGTH) {
+		if (name.length > CONFIG.MAX_FILENAME_LENGTH) {
 			return NextResponse.json(
 				{
-					error: `Filename must be ${SAVE_CONFIG.MAX_FILENAME_LENGTH} characters or less`,
+					error: `Filename must be ${CONFIG.MAX_FILENAME_LENGTH} characters or less`,
 				},
 				{ status: 400 }
 			);
 		}
 
-		if (!SAVE_CONFIG.FILENAME_REGEX.test(name)) {
+		if (content.length > CONFIG.MAX_FILE_SIZE) {
+			return NextResponse.json(
+				{
+					error: `File is too large`,
+				},
+				{ status: 400 }
+			);
+		}
+
+		if (!CONFIG.FILENAME_REGEX.test(name)) {
 			return NextResponse.json(
 				{
 					error: "Filename can only contain alphanumerics, underscores, spaces, and hyphens",
@@ -52,7 +58,7 @@ export async function POST(request: NextRequest) {
 		}
 
 		// Ensure save directory exists
-		const saveDir = SAVE_CONFIG.SAVE_DIRECTORY;
+		const saveDir = CONFIG.SAVE_DIRECTORY;
 		if (!existsSync(saveDir)) {
 			await mkdir(saveDir, { recursive: true });
 		}

webui/src/components/Editor.tsx

@@ -128,7 +128,8 @@ export const Editor = forwardRef<any, EditorProps>(function Editor(
 				editorRef.current = null;
 			}
 		};
-	}, []); // DO NOT FILL ARRAY
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, []); // DO NOT FILL ARRAY - intentionally empty to prevent re-initialization
 
 	// Update font size when it changes
 	useEffect(() => {

webui/src/components/Playground.tsx

@@ -42,28 +42,6 @@ fn step_max(board) {
 const AGENTS = {
 	// special-cased below
 	Self: undefined,
-
-	Random: `fn random_action(board) {
-	let symb = rand_symb();
-	let pos = rand_int(0, 10);
-	let action = Action(symb, pos);
-
-	while !board.can_play(action) {
-		let symb = rand_symb();
-		let pos = rand_int(0, 10);
-		action = Action(symb, pos);
-	}
-
-	return action;
-}
-
-fn step_min(board) {
-	return random_action(board);
-}
-
-fn step_max(board) {
-	return random_action(board);
-}`,
 };
 
 export default function Playground() {
@@ -71,7 +49,7 @@ export default function Playground() {
 	const [isEditorReady, setIsEditorReady] = useState(false);
 	const [fontSize, setFontSize] = useState(14);
 	const [bulkRounds, setBulkRounds] = useState(1000);
-	const [selectedAgent, setSelectedAgent] = useState("Random");
+	const [selectedAgent, setSelectedAgent] = useState("Self");
 	const [isHelpOpen, setIsHelpOpen] = useState(false);
 	const [scriptName, setScriptName] = useState("");
 	const [saveSecret, setSaveSecret] = useState("");
@@ -126,10 +104,7 @@ export default function Playground() {
 				// Combine hardcoded agents with saved scripts, ensuring Self and Random are first
 				const combinedAgents = [
 					"Self",
-					"Random",
-					...Object.keys(AGENTS).filter(
-						(key) => key !== "Self" && key !== "Random"
-					),
+					...Object.keys(AGENTS).filter((key) => key !== "Self"),
 					...scripts,
 				];
 
@@ -265,7 +240,7 @@ export default function Playground() {
 		}
 
 		if (!saveSecret.trim()) {
-			alert("Please enter the save secret");
+			alert("Please enter a secret");
 			return;
 		}
 
@@ -323,6 +298,11 @@ export default function Playground() {
 			return;
 		}
 
+		if (scriptContent.trim().startsWith("// SECRET")) {
+			alert("This script is hidden :)");
+			return;
+		}
+
 		// Warn user about losing current content
 		const confirmed = confirm(
 			`This will replace your current script with "${selectedAgent}". Your current work will be lost. Continue?`
@@ -433,11 +413,11 @@ export default function Playground() {
 										</div>
 
 										<div className={styles.configField}>
-											<label>Save secret</label>
+											<label>Secret</label>
 											<input
 												type="password"
 												className={styles.saveInput}
-												placeholder="Enter save secret..."
+												placeholder="Enter secret..."
 												value={saveSecret}
 												onChange={(e) =>
 													setSaveSecret(

webui/src/lib/config.ts

@@ -1,8 +1,9 @@
-export const SAVE_CONFIG = {
-	ENABLE_SAVE: process.env.ENABLE_SAVE === 'true' || true,
+export const CONFIG = {
+	ENABLE_SAVE: process.env.ENABLE_SAVE === "true" || true,
 	SAVE_SECRET: process.env.SAVE_SECRET || "save",
 
 	SAVE_DIRECTORY: process.env.SAVE_DIRECTORY || "./data/scripts",
 	MAX_FILENAME_LENGTH: parseInt(process.env.MAX_FILENAME_LENGTH || "32"),
+	MAX_FILE_SIZE: parseInt(process.env.MAX_FILE_SIZE || "1048576"),
 	FILENAME_REGEX: /^[a-zA-Z0-9_\s-]+$/,
 } as const;

webui/src/lib/worker_human.ts

@@ -24,6 +24,7 @@ self.onmessage = async (event) => {
 
 	if (type === "data") {
 		if (currentGame !== null) {
+			try {
 				currentGame.take_input(event_data.data);
 
 				if (currentGame.is_error()) {
@@ -33,6 +34,9 @@ self.onmessage = async (event) => {
 					currentGame = null;
 					self.postMessage({ type: "complete" });
 				}
+			} catch (error) {
+				self.postMessage({ type: "error", error: String(error) });
+			}
 		}
 	} else if (type === "init") {
 		try {