Fix TypeScript errors for isolated declarations

scripts/test/main.ts

···
 import { createBirpc } from 'birpc'
+import type { ExecFileOptions } from 'node:child_process'
 import { execFile } from 'node:child_process'
 import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
···
 		console.log(`Building ${commit}`)
 
 		// Create worktree for this commit
-		await exec_file('git', ['worktree', 'add', temp_dir, commit], { stdio: 'inherit' })
+		await exec_file('git', ['worktree', 'add', temp_dir, commit], { stdio: 'inherit' } as ExecFileOptions)
 
 		// Install dependencies and build
-		await exec_file('npm', ['install'], { stdio: 'inherit', cwd: temp_dir })
-		await exec_file('npm', ['run', 'build'], { stdio: 'inherit', cwd: temp_dir })
+		await exec_file('npm', ['install'], { stdio: 'inherit', cwd: temp_dir } as ExecFileOptions)
+		await exec_file('npm', ['run', 'build'], { stdio: 'inherit', cwd: temp_dir } as ExecFileOptions)
 
 		console.log(`Completed building ${commit}`)
 
···
 		await Promise.all(
 			temp_dirs.map(async temp_dir => {
 				try {
-					await exec_file('git', ['worktree', 'remove', temp_dir], { stdio: 'inherit' })
+					await exec_file('git', ['worktree', 'remove', temp_dir], { stdio: 'inherit' } as ExecFileOptions)
 				} catch (error) {
 					console.warn(`Failed to remove worktree ${temp_dir}:`, error)
 				}

scripts/test/runtime.ts

···
 			return benchmarks
 		} else {
 			// Multiple builds - comparison mode
-			const libraries = []
+			const libraries: Array<{
+				index: { html: any }
+				client: { invalidate: any; createRoot: any }
+				server: any
+				ref: string
+			}> = []
 
 			// Dynamically import all library versions
 			for (const build of builds) {
···
 				}
 			}
 
-			// Import get_benchmarks function
-			const benchModule = await import('../../../src/client/tests/bench-comparison.ts')
-			const get_benchmarks = benchModule.get_benchmarks
+			// Import get_benchmarks function dynamically
+			const benchPath = '../../../src/client/tests/bench-comparison.ts'
+			const benchModule = (await import(benchPath)) as any
+			const get_benchmarks = benchModule.get_benchmarks as Function
 
 			// Setup mitata comparison
 			mitata.summary(() => {
···
 						const benchmarks = get_benchmarks(lib)
 						// Run all benchmark functions
 						for (const [name, fn] of Object.entries(benchmarks)) {
-							if (name.startsWith('bench_')) {
+							if (name.startsWith('bench_') && typeof fn === 'function') {
 								fn()
 							}
 						}

src/client/tests/bench-comparison.ts

···
 }: {
 	index: { html: any }
 	client: { invalidate: any; createRoot: any }
-}) {
+}): Record<string, () => void> {
 	// Setup function using the passed library version
 	function setup(initial_html = '') {
 		const el = document.createElement('div')
···
 	// Benchmark Functions
 	// ==============================
 
-	function bench_table_small_render() {
+	function bench_table_small_render(): void {
 		const { root } = setup()
 		const state = new TableState(15, 4)
 		root.render(state)
 	}
 
-	function bench_table_small_removeAll() {
+	function bench_table_small_removeAll(): void {
 		const { root } = setup()
 		const state = new TableState(15, 4)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_table_small_sort() {
+	function bench_table_small_sort(): void {
 		const { root } = setup()
 		const state = new TableState(15, 4)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_table_small_filter() {
+	function bench_table_small_filter(): void {
 		const { root } = setup()
 		const state = new TableState(15, 4)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_table_small_activate() {
+	function bench_table_small_activate(): void {
 		const { root } = setup()
 		const state = new TableState(15, 4)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_table_large_render() {
+	function bench_table_large_render(): void {
 		const { root } = setup()
 		const state = new TableState(100, 4)
 		root.render(state)
 	}
 
-	function bench_table_large_removeAll() {
+	function bench_table_large_removeAll(): void {
 		const { root } = setup()
 		const state = new TableState(100, 4)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_table_large_sort() {
+	function bench_table_large_sort(): void {
 		const { root } = setup()
 		const state = new TableState(100, 4)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_table_large_filter() {
+	function bench_table_large_filter(): void {
 		const { root } = setup()
 		const state = new TableState(100, 4)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_table_large_activate() {
+	function bench_table_large_activate(): void {
 		const { root } = setup()
 		const state = new TableState(100, 4)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_anim_small_advance() {
+	function bench_anim_small_advance(): void {
 		const { root } = setup()
 		const state = new AnimState(30)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_anim_large_advance() {
+	function bench_anim_large_advance(): void {
 		const { root } = setup()
 		const state = new AnimState(100)
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_small_render() {
+	function bench_tree_small_render(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
 	}
 
-	function bench_tree_small_removeAll() {
+	function bench_tree_small_removeAll(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_small_reverse() {
+	function bench_tree_small_reverse(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_small_insertFirst() {
+	function bench_tree_small_insertFirst(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_small_insertLast() {
+	function bench_tree_small_insertLast(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_small_removeFirst() {
+	function bench_tree_small_removeFirst(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_small_removeLast() {
+	function bench_tree_small_removeLast(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_small_moveFromEndToStart() {
+	function bench_tree_small_moveFromEndToStart(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_small_moveFromStartToEnd() {
+	function bench_tree_small_moveFromStartToEnd(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_small_no_change() {
+	function bench_tree_small_no_change(): void {
 		const { root } = setup()
 		const state = new TreeState([5, 10])
 		root.render(state)
 		invalidate(state)
 	}
 
-	function bench_tree_large_render() {
+	function bench_tree_large_render(): void {
 		const { root } = setup()
 		const state = new TreeState([50, 10])
 		root.render(state)
 	}
 
-	function bench_tree_large_removeAll() {
+	function bench_tree_large_removeAll(): void {
 		const { root } = setup()
 		const state = new TreeState([50, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_large_reverse() {
+	function bench_tree_large_reverse(): void {
 		const { root } = setup()
 		const state = new TreeState([50, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_worst_case_kivi() {
+	function bench_tree_worst_case_kivi(): void {
 		const { root } = setup()
 		const state = new TreeState([10, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_worst_case_snabbdom() {
+	function bench_tree_worst_case_snabbdom(): void {
 		const { root } = setup()
 		const state = new TreeState([10, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_worst_case_react() {
+	function bench_tree_worst_case_react(): void {
 		const { root } = setup()
 		const state = new TreeState([10, 10])
 		root.render(state)
···
 		invalidate(state)
 	}
 
-	function bench_tree_worst_case_virtual_dom() {
+	function bench_tree_worst_case_virtual_dom(): void {
 		const { root } = setup()
 		const state = new TreeState([10, 10])
 		root.render(state)
···
 	}
 
 	return {
-		bench_table_small_render,
-		bench_table_small_removeAll,
-		bench_table_small_sort,
-		bench_table_small_filter,
-		bench_table_small_activate,
-		bench_table_large_render,
-		bench_table_large_removeAll,
-		bench_table_large_sort,
-		bench_table_large_filter,
-		bench_table_large_activate,
-		bench_anim_small_advance,
-		bench_anim_large_advance,
-		bench_tree_small_render,
-		bench_tree_small_removeAll,
-		bench_tree_small_reverse,
-		bench_tree_small_insertFirst,
-		bench_tree_small_insertLast,
-		bench_tree_small_removeFirst,
-		bench_tree_small_removeLast,
-		bench_tree_small_moveFromEndToStart,
-		bench_tree_small_moveFromStartToEnd,
-		bench_tree_small_no_change,
-		bench_tree_large_render,
-		bench_tree_large_removeAll,
-		bench_tree_large_reverse,
-		bench_tree_worst_case_kivi,
-		bench_tree_worst_case_snabbdom,
-		bench_tree_worst_case_react,
-		bench_tree_worst_case_virtual_dom,
+		bench_table_small_render: bench_table_small_render,
+		bench_table_small_removeAll: bench_table_small_removeAll,
+		bench_table_small_sort: bench_table_small_sort,
+		bench_table_small_filter: bench_table_small_filter,
+		bench_table_small_activate: bench_table_small_activate,
+		bench_table_large_render: bench_table_large_render,
+		bench_table_large_removeAll: bench_table_large_removeAll,
+		bench_table_large_sort: bench_table_large_sort,
+		bench_table_large_filter: bench_table_large_filter,
+		bench_table_large_activate: bench_table_large_activate,
+		bench_anim_small_advance: bench_anim_small_advance,
+		bench_anim_large_advance: bench_anim_large_advance,
+		bench_tree_small_render: bench_tree_small_render,
+		bench_tree_small_removeAll: bench_tree_small_removeAll,
+		bench_tree_small_reverse: bench_tree_small_reverse,
+		bench_tree_small_insertFirst: bench_tree_small_insertFirst,
+		bench_tree_small_insertLast: bench_tree_small_insertLast,
+		bench_tree_small_removeFirst: bench_tree_small_removeFirst,
+		bench_tree_small_removeLast: bench_tree_small_removeLast,
+		bench_tree_small_moveFromEndToStart: bench_tree_small_moveFromEndToStart,
+		bench_tree_small_moveFromStartToEnd: bench_tree_small_moveFromStartToEnd,
+		bench_tree_small_no_change: bench_tree_small_no_change,
+		bench_tree_large_render: bench_tree_large_render,
+		bench_tree_large_removeAll: bench_tree_large_removeAll,
+		bench_tree_large_reverse: bench_tree_large_reverse,
+		bench_tree_worst_case_kivi: bench_tree_worst_case_kivi,
+		bench_tree_worst_case_snabbdom: bench_tree_worst_case_snabbdom,
+		bench_tree_worst_case_react: bench_tree_worst_case_react,
+		bench_tree_worst_case_virtual_dom: bench_tree_worst_case_virtual_dom,
 	}
 }