Some adjustments

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

CMakeLists.txt

@@ -4,11 +4,13 @@
 # https://opensource.org/licenses/MIT
 
 # Setup
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.13)
 
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
+# [cmake]   This is allowed only when policy CMP0079 is set to NEW.
+cmake_policy(SET CMP0079 NEW)
 
 option(DUSK_BUILD_TESTS "Enable tests" OFF)
 

assets/entities/CubeEntity.js

@@ -0,0 +1,22 @@
+var OverworldEntity = include('entities/OverworldEntity.js');
+
+function CubeEntity() {
+  OverworldEntity.call(this);
+
+  this.add(MESH);
+  this.add(MATERIAL);
+}
+
+CubeEntity.prototype = Object.create(OverworldEntity.prototype);
+CubeEntity.prototype.constructor = CubeEntity;
+
+CubeEntity.prototype.update = function() {
+  OverworldEntity.prototype.update.call(this);
+  var speed = 3.0;
+  var move = Input.axis2D(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT, INPUT_ACTION_UP, INPUT_ACTION_DOWN);
+  this.position.position.x += move.x * speed * TIME.delta;
+  this.position.position.z += move.y * speed * TIME.delta;
+  this.material.setColor(Color.rainbow());
+};
+
+module = CubeEntity;

assets/entities/OverworldEntity.js

@@ -0,0 +1,21 @@
+function OverworldEntity() {
+  Entity.call(this);
+
+  this.add(POSITION);
+}
+
+OverworldEntity.prototype = Object.create(Entity.prototype);
+OverworldEntity.prototype.constructor = OverworldEntity;
+
+OverworldEntity.prototype.update = function() {
+  // var speed = 3.0;
+  // var move = Input.axis2D(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT, INPUT_ACTION_UP, INPUT_ACTION_DOWN);
+  // this.position.position.x += move.x * speed * TIME.delta;
+  // this.position.position.z += move.y * speed * TIME.delta;
+}
+
+OverworldEntity.prototype.dispose = function() {
+  // Nothing to dispose
+}
+
+module = OverworldEntity;

assets/init.js

@@ -0,0 +1,77 @@
+Console.visible = true;
+
+// Default input bindings.
+if (typeof PSP !== 'undefined') {
+  Input.bind("up", INPUT_ACTION_UP);
+  Input.bind("down", INPUT_ACTION_DOWN);
+  Input.bind("left", INPUT_ACTION_LEFT);
+  Input.bind("right", INPUT_ACTION_RIGHT);
+  Input.bind("accept", INPUT_ACTION_ACCEPT);
+  Input.bind("cancel", INPUT_ACTION_CANCEL);
+  Input.bind("select", INPUT_ACTION_RAGEQUIT);
+  Input.bind("lstick_up", INPUT_ACTION_UP);
+  Input.bind("lstick_down", INPUT_ACTION_DOWN);
+  Input.bind("lstick_left", INPUT_ACTION_LEFT);
+  Input.bind("lstick_right", INPUT_ACTION_RIGHT);
+  Input.bind("triangle", INPUT_ACTION_CONSOLE);
+
+} else if (typeof DOLPHIN !== 'undefined') {
+  Input.bind("up", INPUT_ACTION_UP);
+  Input.bind("down", INPUT_ACTION_DOWN);
+  Input.bind("left", INPUT_ACTION_LEFT);
+  Input.bind("right", INPUT_ACTION_RIGHT);
+  Input.bind("b", INPUT_ACTION_CANCEL);
+  Input.bind("a", INPUT_ACTION_ACCEPT);
+  Input.bind("z", INPUT_ACTION_CONSOLE);
+  Input.bind("lstick_up", INPUT_ACTION_UP);
+  Input.bind("lstick_down", INPUT_ACTION_DOWN);
+  Input.bind("lstick_left", INPUT_ACTION_LEFT);
+  Input.bind("lstick_right", INPUT_ACTION_RIGHT);
+
+} else if (typeof LINUX !== 'undefined') {
+  if (typeof INPUT_KEYBOARD !== 'undefined') {
+    Input.bind("w", INPUT_ACTION_UP);
+    Input.bind("s", INPUT_ACTION_DOWN);
+    Input.bind("a", INPUT_ACTION_LEFT);
+    Input.bind("d", INPUT_ACTION_RIGHT);
+
+    Input.bind("left", INPUT_ACTION_LEFT);
+    Input.bind("right", INPUT_ACTION_RIGHT);
+    Input.bind("up", INPUT_ACTION_UP);
+    Input.bind("down", INPUT_ACTION_DOWN);
+
+    Input.bind("enter", INPUT_ACTION_ACCEPT);
+    Input.bind("e", INPUT_ACTION_ACCEPT);
+
+    Input.bind("q", INPUT_ACTION_CANCEL);
+
+    Input.bind("escape", INPUT_ACTION_RAGEQUIT);
+    Input.bind("`", INPUT_ACTION_CONSOLE);
+  }
+
+  if (typeof INPUT_GAMEPAD !== 'undefined') {
+    Input.bind("gamepad_up", INPUT_ACTION_UP);
+    Input.bind("gamepad_down", INPUT_ACTION_DOWN);
+    Input.bind("gamepad_left", INPUT_ACTION_LEFT);
+    Input.bind("gamepad_right", INPUT_ACTION_RIGHT);
+
+    Input.bind("gamepad_a", INPUT_ACTION_ACCEPT);
+    Input.bind("gamepad_b", INPUT_ACTION_CANCEL);
+    Input.bind("gamepad_back", INPUT_ACTION_RAGEQUIT);
+
+    Input.bind("gamepad_lstick_up", INPUT_ACTION_UP);
+    Input.bind("gamepad_lstick_down", INPUT_ACTION_DOWN);
+    Input.bind("gamepad_lstick_left", INPUT_ACTION_LEFT);
+    Input.bind("gamepad_lstick_right", INPUT_ACTION_RIGHT);
+  }
+
+  if (typeof INPUT_POINTER !== 'undefined') {
+    Input.bind("mouse_x", INPUT_ACTION_POINTERX);
+    Input.bind("mouse_y", INPUT_ACTION_POINTERY);
+  }
+
+} else {
+  print("Unknown platform, no default input bindings set.");
+}
+
+Scene.set('scenes/cube.js');

assets/init.lua

@@ -1,81 +0,0 @@
-module('input')
-module('platform')
-module('scene')
-module('locale')
-
--- Default Input bindings.
-if PSP then
-  inputBind("up", INPUT_ACTION_UP)
-  inputBind("down", INPUT_ACTION_DOWN)
-  inputBind("left", INPUT_ACTION_LEFT)
-  inputBind("right", INPUT_ACTION_RIGHT)
-  inputBind("accept", INPUT_ACTION_ACCEPT)
-  inputBind("cancel", INPUT_ACTION_CANCEL)
-  inputBind("select", INPUT_ACTION_RAGEQUIT)
-  inputBind("lstick_up", INPUT_ACTION_UP)
-  inputBind("lstick_down", INPUT_ACTION_DOWN)
-  inputBind("lstick_left", INPUT_ACTION_LEFT)
-  inputBind("lstick_right", INPUT_ACTION_RIGHT)
-  inputBind("triangle", INPUT_ACTION_CONSOLE)
-
-elseif DOLPHIN then
-  inputBind("up", INPUT_ACTION_UP)
-  inputBind("down", INPUT_ACTION_DOWN)
-  inputBind("left", INPUT_ACTION_LEFT)
-  inputBind("right", INPUT_ACTION_RIGHT)
-  inputBind("b", INPUT_ACTION_CANCEL)
-  inputBind("a", INPUT_ACTION_ACCEPT)
-  inputBind("z", INPUT_ACTION_CONSOLE)
-  inputBind("lstick_up", INPUT_ACTION_UP)
-  inputBind("lstick_down", INPUT_ACTION_DOWN)
-  inputBind("lstick_left", INPUT_ACTION_LEFT)
-  inputBind("lstick_right", INPUT_ACTION_RIGHT)
-
-elseif LINUX then
-  if INPUT_KEYBOARD then
-    inputBind("w", INPUT_ACTION_UP)
-    inputBind("s", INPUT_ACTION_DOWN)
-    inputBind("a", INPUT_ACTION_LEFT)
-    inputBind("d", INPUT_ACTION_RIGHT)
-
-    inputBind("left", INPUT_ACTION_LEFT)
-    inputBind("right", INPUT_ACTION_RIGHT)
-    inputBind("up", INPUT_ACTION_UP)
-    inputBind("down", INPUT_ACTION_DOWN)
-
-    inputBind("enter", INPUT_ACTION_ACCEPT)
-    inputBind("e", INPUT_ACTION_ACCEPT)
-    
-    inputBind("q", INPUT_ACTION_CANCEL)
-    
-    inputBind("escape", INPUT_ACTION_RAGEQUIT)
-    inputBind("`", INPUT_ACTION_CONSOLE)
-  end
-
-  if INPUT_GAMEPAD then
-    inputBind("gamepad_up", INPUT_ACTION_UP)
-    inputBind("gamepad_down", INPUT_ACTION_DOWN)
-    inputBind("gamepad_left", INPUT_ACTION_LEFT)
-    inputBind("gamepad_right", INPUT_ACTION_RIGHT)
-
-    inputBind("gamepad_a", INPUT_ACTION_ACCEPT)
-    inputBind("gamepad_b", INPUT_ACTION_CANCEL)
-    inputBind("gamepad_back", INPUT_ACTION_RAGEQUIT)
-
-    inputBind("gamepad_lstick_up", INPUT_ACTION_UP)
-    inputBind("gamepad_lstick_down", INPUT_ACTION_DOWN)
-    inputBind("gamepad_lstick_left", INPUT_ACTION_LEFT)
-    inputBind("gamepad_lstick_right", INPUT_ACTION_RIGHT)
-  end
-
-  if INPUT_POINTER then
-    inputBind("mouse_x", INPUT_ACTION_POINTERX)
-    inputBind("mouse_y", INPUT_ACTION_POINTERY)
-  end
-
-else
-  print("Unknown platform, no default input bindings set.")
-end
-
--- Hand off to initial scene.
-sceneSet('test/scene.lua')

assets/scenes/cube.js

@@ -0,0 +1,32 @@
+var CubeEntity = include('entities/CubeEntity.js');
+
+function CubeScene() {
+  this.cam = new Entity();
+  this.cam.add(POSITION);
+  this.cam.add(CAMERA);
+
+  this.cam.position.position = new Vec3(3, 3, 3);
+  this.cam.position.lookAt(new Vec3(0, 0, 0));
+
+  this.cube = new CubeEntity();
+
+  this.spriteEnt = new Entity();
+  this.spriteEnt.add(POSITION);
+  this.spriteEnt.position.position = new Vec3(16, 16, 0);
+  // this.spriteEnt.sprite.setTexture('ui/minogram.png');
+}
+
+CubeScene.prototype = Object.create(Scene.prototype);
+CubeScene.prototype.constructor = CubeScene;
+
+CubeScene.prototype.update = function() {
+  this.cube.update();
+};
+
+CubeScene.prototype.dispose = function() {
+  this.cam.dispose();
+  this.cube.dispose();
+  this.spriteEnt.dispose();
+};
+
+module = CubeScene;

cmake/modules/Findjerryscript.cmake

@@ -0,0 +1,96 @@
+# Copyright (c) 2026 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Turn things off we don't need
+set(JERRY_CMDLINE OFF CACHE BOOL "" FORCE)
+set(JERRY_EXT ON CACHE BOOL "" FORCE)
+set(JERRY_DEBUGGER OFF CACHE BOOL "" FORCE)
+set(JERRY_BUILTIN_DATE OFF CACHE BOOL "" FORCE)
+set(ENABLE_LTO OFF CACHE BOOL "" FORCE)
+
+# Fetch Jerry
+include(FetchContent)
+FetchContent_Declare(
+  jerryscript
+  GIT_REPOSITORY https://git.wish.moe/YourWishes/jerryscript
+  GIT_TAG float32-fix
+)
+FetchContent_MakeAvailable(jerryscript)
+
+# Mark found
+set(jerryscript_FOUND ON)
+
+# Define targets
+if(TARGET jerryscript-core)
+  set(JERRY_CORE_TARGET jerryscript-core)
+elseif(TARGET jerry-core)
+  set(JERRY_CORE_TARGET jerry-core)
+endif()
+
+if(TARGET jerryscript-ext)
+  set(JERRY_EXT_TARGET jerryscript-ext)
+elseif(TARGET jerry-ext)
+  set(JERRY_EXT_TARGET jerry-ext)
+endif()
+
+if(TARGET jerryscript-port-default)
+  set(JERRY_PORT_TARGET jerryscript-port-default)
+elseif(TARGET jerry-port-default)
+  set(JERRY_PORT_TARGET jerry-port-default)
+elseif(TARGET jerryscript-port)
+  set(JERRY_PORT_TARGET jerryscript-port)
+elseif(TARGET jerry-port)
+  set(JERRY_PORT_TARGET jerry-port)
+endif()
+
+if(NOT JERRY_CORE_TARGET)
+  message(FATAL_ERROR "JerryScript core target not found")
+endif()
+
+if(NOT JERRY_EXT_TARGET)
+  message(FATAL_ERROR "JerryScript ext target not found")
+endif()
+
+if(NOT JERRY_PORT_TARGET)
+  message(FATAL_ERROR "JerryScript port target not found")
+endif()
+
+foreach(tgt IN ITEMS
+  ${JERRY_CORE_TARGET}
+  ${JERRY_EXT_TARGET}
+  ${JERRY_PORT_TARGET}
+)
+  if(TARGET ${tgt})
+    set_property(TARGET ${tgt} PROPERTY INTERPROCEDURAL_OPTIMIZATION OFF)
+    target_compile_definitions(${JERRY_CORE_TARGET} PRIVATE
+      JERRY_NUMBER_TYPE_FLOAT64=0
+      JERRY_BUILTIN_DATE=0
+    )
+  endif()
+endforeach()
+
+# Export include dirs through the targets
+target_include_directories(${JERRY_CORE_TARGET} INTERFACE
+  ${jerryscript_SOURCE_DIR}/jerry-core/include
+)
+
+target_include_directories(${JERRY_EXT_TARGET} INTERFACE
+  ${jerryscript_SOURCE_DIR}/jerry-ext/include
+)
+
+target_include_directories(${JERRY_PORT_TARGET} INTERFACE
+  ${jerryscript_SOURCE_DIR}/jerry-port/default/include
+)
+
+# Suppress JerryScript-only warning
+if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
+  target_compile_options(${JERRY_CORE_TARGET} PRIVATE
+    -Wno-error
+  )
+endif()
+
+add_library(jerryscript::core ALIAS ${JERRY_CORE_TARGET})
+add_library(jerryscript::ext ALIAS ${JERRY_EXT_TARGET})
+add_library(jerryscript::port ALIAS ${JERRY_PORT_TARGET})

cmake/targets/dolphin.cmake

@@ -22,31 +22,9 @@ set(CGLM_SHARED OFF CACHE BOOL "Build cglm shared" FORCE)
 set(CGLM_STATIC ON  CACHE BOOL "Build cglm static" FORCE)
 find_package(cglm REQUIRED)
 
-# Compile lua
-include(FetchContent)
-FetchContent_Declare(
-  liblua
-  URL https://www.lua.org/ftp/lua-5.5.0.tar.gz
-)
-FetchContent_MakeAvailable(liblua)
-set(LUA_SRC_DIR "${liblua_SOURCE_DIR}/src")
-set(LUA_C_FILES 
-  lapi.c lauxlib.c lbaselib.c lcode.c lcorolib.c lctype.c ldblib.c ldebug.c
-  ldo.c ldump.c lfunc.c lgc.c linit.c liolib.c llex.c lmathlib.c lmem.c
-  loadlib.c lobject.c lopcodes.c loslib.c lparser.c lstate.c lstring.c
-  lstrlib.c ltable.c ltablib.c ltm.c lundump.c lutf8lib.c lvm.c lzio.c
-)
-list(TRANSFORM LUA_C_FILES PREPEND "${LUA_SRC_DIR}/")
-add_library(liblua STATIC ${LUA_C_FILES})
-target_include_directories(liblua PUBLIC "${LUA_SRC_DIR}")
-target_compile_definitions(liblua PRIVATE LUA_USE_C89)
-add_library(lua::lua ALIAS liblua)
-set(Lua_FOUND TRUE CACHE BOOL "Lua found" FORCE)
-
 # Link libraries
 target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
   cglm
-  liblua
   m
   fat
   PkgConfig::zip

cmake/targets/psp.cmake

@@ -1,6 +1,19 @@
+# Fixes some problems building JerryScript
+set(CMAKE_AR "$ENV{PSPDEV}/bin/psp-ar" CACHE FILEPATH "" FORCE)
+set(CMAKE_RANLIB "$ENV{PSPDEV}/bin/psp-ranlib" CACHE FILEPATH "" FORCE)
+set(CMAKE_C_COMPILER_AR "$ENV{PSPDEV}/bin/psp-ar" CACHE FILEPATH "" FORCE)
+set(CMAKE_C_COMPILER_RANLIB "$ENV{PSPDEV}/bin/psp-ranlib" CACHE FILEPATH "" FORCE)
+set(CMAKE_C_ARCHIVE_CREATE "$ENV{PSPDEV}/bin/psp-ar qc <TARGET> <LINK_FLAGS> <OBJECTS>")
+set(CMAKE_C_ARCHIVE_APPEND "$ENV{PSPDEV}/bin/psp-ar q <TARGET> <LINK_FLAGS> <OBJECTS>")
+set(CMAKE_C_ARCHIVE_FINISH "$ENV{PSPDEV}/bin/psp-ranlib <TARGET>")
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF CACHE BOOL "" FORCE)
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_C OFF CACHE BOOL "" FORCE)
+set(JERRY_LTO OFF CACHE BOOL "" FORCE)
+
+find_package(jerryscript REQUIRED)
 find_package(SDL2 REQUIRED)
 find_package(OpenGL REQUIRED)
-target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+target_link_libraries(${DUSK_BINARY_TARGET_NAME} PUBLIC
   ${SDL2_LIBRARIES}
   SDL2
   pthread
@@ -29,13 +42,17 @@ target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   pspnet_apctl
   psphttp
   pspssl
+
+  jerryscript::core
+  jerryscript::ext
+  jerryscript::port
 )
 
-target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
+target_include_directories(${DUSK_BINARY_TARGET_NAME} PRIVATE
   ${SDL2_INCLUDE_DIRS}
 )
 
-target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+target_compile_definitions(${DUSK_BINARY_TARGET_NAME} PUBLIC
   DUSK_SDL2
   DUSK_OPENGL
   DUSK_PSP

cmake/targets/vita.cmake

@@ -20,31 +20,9 @@ set(CGLM_SHARED OFF CACHE BOOL "Build cglm shared" FORCE)
 set(CGLM_STATIC ON  CACHE BOOL "Build cglm static" FORCE)
 find_package(cglm REQUIRED)
 
-# Compile lua
-include(FetchContent)
-FetchContent_Declare(
-  liblua
-  URL https://www.lua.org/ftp/lua-5.5.0.tar.gz
-)
-FetchContent_MakeAvailable(liblua)
-set(LUA_SRC_DIR "${liblua_SOURCE_DIR}/src")
-set(LUA_C_FILES 
-  lapi.c lauxlib.c lbaselib.c lcode.c lcorolib.c lctype.c ldblib.c ldebug.c
-  ldo.c ldump.c lfunc.c lgc.c linit.c liolib.c llex.c lmathlib.c lmem.c
-  loadlib.c lobject.c lopcodes.c loslib.c lparser.c lstate.c lstring.c
-  lstrlib.c ltable.c ltablib.c ltm.c lundump.c lutf8lib.c lvm.c lzio.c
-)
-list(TRANSFORM LUA_C_FILES PREPEND "${LUA_SRC_DIR}/")
-add_library(liblua STATIC ${LUA_C_FILES})
-target_include_directories(liblua PUBLIC "${LUA_SRC_DIR}")
-target_compile_definitions(liblua PRIVATE LUA_USE_C89)
-add_library(lua::lua ALIAS liblua)
-set(Lua_FOUND TRUE CACHE BOOL "Lua found" FORCE)
-
 # Link libraries
 target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   ${SDL2_LIBRARIES}
-  liblua
   cglm
   SDL2
   SDL2main

src/dusk/CMakeLists.txt

@@ -32,18 +32,13 @@ if(NOT yyjson_FOUND)
   endif()
 endif()
 
-if(NOT Lua_FOUND)
-  find_package(Lua REQUIRED)
-  if(Lua_FOUND AND NOT TARGET Lua::Lua)
-    add_library(Lua::Lua INTERFACE IMPORTED)
-    set_target_properties(
-      Lua::Lua
-      PROPERTIES
-        INTERFACE_INCLUDE_DIRECTORIES "${LUA_INCLUDE_DIR}"
-        INTERFACE_LINK_LIBRARIES "${LUA_LIBRARIES}"
-    )
-  endif()
-  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC Lua::Lua)
+if(NOT jerryscript_FOUND)
+  find_package(jerryscript REQUIRED)
+  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
+    jerryscript::core
+    jerryscript::ext
+    jerryscript::port
+  )
 endif()
 
 # Includes

src/dusk/asset/loader/script/assetscriptloader.c

@@ -1,82 +1,92 @@
 /**
  * Copyright (c) 2026 Dominic Masters
- * 
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
 
 #include "assetscriptloader.h"
 #include "assert/assert.h"
+#include <stdlib.h>
+#include <zip.h>
 
 errorret_t assetScriptLoader(assetfile_t *file) {
   assertNotNull(file, "Asset file cannot be NULL");
-  assertNull(file->zipFile, "Asset file zip handle must be NULL");
+  assertNull(file->zipFile, "Asset file zip handle must be NULL before open");
   assertNotNull(file->output, "Asset file output cannot be NULL");
 
   assetscript_t *script = (assetscript_t *)file->output;
 
-  // Open the asset for buffering
   errorChain(assetFileOpen(file));
 
-  // Request loading
-  if(!lua_load(
-    script->ctx->luaState,
-    assetScriptReader,
-    file,
-    file->filename,
-    NULL
-  ) == LUA_OK) {
-    const char_t *strErr = lua_tostring(script->ctx->luaState, -1);
-    lua_pop(script->ctx->luaState, 1);
-    errorThrow("Failed to load Lua script: %s", strErr);
+  // Accumulate full source into a dynamically grown buffer.
+  size_t srcLen = 0;
+  size_t capacity = ASSET_SCRIPT_CHUNK_SIZE;
+  char_t *src = (char_t *)malloc(capacity + 1);
+  if(!src) {
+    assetFileClose(file);
+    errorThrow("Out of memory reading script: %s", file->filename);
   }
 
-  // Now loaded, exec
-  if(lua_pcall(script->ctx->luaState, 0, LUA_MULTRET, 0) != LUA_OK) {
-    const char_t *strErr = lua_tostring(script->ctx->luaState, -1);
-    lua_pop(script->ctx->luaState, 1);
-    errorThrow("Failed to execute Lua script: %s", strErr);
+  while(1) {
+    if(srcLen + ASSET_SCRIPT_CHUNK_SIZE > capacity) {
+      capacity = srcLen + ASSET_SCRIPT_CHUNK_SIZE;
+      char_t *tmp = (char_t *)realloc(src, capacity + 1);
+      if(!tmp) {
+        free(src);
+        assetFileClose(file);
+        errorThrow("Out of memory reading script: %s", file->filename);
+      }
+      src = tmp;
+    }
+    zip_int64_t n = zip_fread(
+      file->zipFile, src + srcLen, ASSET_SCRIPT_CHUNK_SIZE
+    );
+    if(n <= 0) break;
+    srcLen += (size_t)n;
+  }
+  src[srcLen] = '\0';
+
+  errorret_t closeRet = assetFileClose(file);
+
+  jerry_value_t result = jerry_eval(
+    (const jerry_char_t *)src,
+    srcLen,
+    JERRY_PARSE_NO_OPTS
+  );
+  free(src);
+
+  if(jerry_value_is_exception(result)) {
+    jerry_value_t errVal = jerry_exception_value(result, false);
+    jerry_value_t errStr = jerry_value_to_string(errVal);
+    char_t buf[256];
+    jerry_size_t len = jerry_string_to_buffer(
+      errStr, JERRY_ENCODING_UTF8, (jerry_char_t *)buf, sizeof(buf) - 1
+    );
+    buf[len] = '\0';
+    jerry_value_free(errStr);
+    jerry_value_free(errVal);
+    jerry_value_free(result);
+    errorThrow("Script error in '%s': %s", file->filename, buf);
   }
 
-  // Close the file
-  return assetFileClose(file);
+  if(script->resultOut != NULL) {
+    *(script->resultOut) = result;
+  } else {
+    jerry_value_free(result);
+  }
+
+  return closeRet;
 }
 
-errorret_t assetScriptLoad(const char_t *path, scriptcontext_t *ctx) {
+errorret_t assetScriptLoad(
+  const char_t *path,
+  jerry_value_t *resultOut
+) {
   assertNotNull(path, "Script path cannot be NULL");
-  assertNotNull(ctx, "Script context cannot be NULL");
-  
-  assetscript_t script;
-  script.ctx = ctx;
 
-  return assetLoad(
-    path,
-    assetScriptLoader,
-    NULL,
-    &script
-  );
+  assetscript_t scriptData;
+  scriptData.resultOut = resultOut;
+
+  return assetLoad(path, assetScriptLoader, NULL, &scriptData);
 }
-
-const char_t * assetScriptReader(lua_State* L, void* data, size_t* size) {
-  assetfile_t *file = (assetfile_t*)data;
-  assertNotNull(file, "Script asset file cannot be NULL");
-  assertNotNull(file->zipFile, "Script asset zip handle cannot be NULL");
-  assertNotNull(file->output, "Script asset output cannot be NULL");
-
-  assetscript_t *script = (assetscript_t *)file->output;
-  assertNotNull(script, "Script asset output cannot be NULL");
-
-  zip_int64_t read = zip_fread(
-    file->zipFile,
-    script->buffer,
-    sizeof(script->buffer)
-  );
-
-  if(read < 0) {
-    *size = 0;
-    return NULL;
-  }
-
-  *size = (size_t)read;
-  return script->buffer;
-}

src/dusk/asset/loader/script/assetscriptloader.h

@@ -1,28 +1,23 @@
 /**
  * Copyright (c) 2026 Dominic Masters
- * 
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
 
 #pragma once
 #include "asset/asset.h"
-#include "script/scriptcontext.h"
 
-#define ASSET_SCRIPT_BUFFER_SIZE 1024
+#define ASSET_SCRIPT_CHUNK_SIZE 1024
 
 typedef struct {
-  void *nothing;
-} assetscriptloaderparams_t;
-
-typedef struct {
-  scriptcontext_t *ctx;
-  char_t buffer[ASSET_SCRIPT_BUFFER_SIZE];
+  jerry_value_t *resultOut;
 } assetscript_t;
 
 /**
- * Handler for script assets.
- * 
+ * Handler for script assets. Reads the full source, evaluates it with
+ * JerryScript, and optionally stores the result.
+ *
  * @param file Asset file to load the script from.
  * @return Any error that occurs during loading.
  */
@@ -30,19 +25,14 @@ errorret_t assetScriptLoader(assetfile_t *file);
 
 /**
  * Loads a script from the specified path.
- * 
- * @param path Path to the script asset.
- * @param ctx Script context to load the script into.
+ *
+ * @param path      Path to the script asset.
+ * @param resultOut Optional out-parameter for the script return value.
+ *                  Caller must call jerry_value_free() if non-NULL.
+ *                  Pass NULL to discard the return value.
  * @return Any error that occurs during loading.
  */
-errorret_t assetScriptLoad(const char_t *path, scriptcontext_t *ctx);
-
-/**
- * Reader function for Lua to read script data from the asset.
- * 
- * @param L Lua state.
- * @param data Pointer to the scriptcontext_t structure.
- * @param size Pointer to store the size of the read data.
- * @return Pointer to the read data buffer.
- */
-const char_t * assetScriptReader(lua_State* L, void* data, size_t* size);
+errorret_t assetScriptLoad(
+  const char_t *path,
+  jerry_value_t *resultOut
+);

src/dusk/console/CMakeLists.txt

@@ -1,15 +1,9 @@
-# Copyright (c) 2025 Dominic Masters
-# 
+# Copyright (c) 2026 Dominic Masters
+#
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-# Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     console.c
-    consolecmd.c
-    consolevar.c
 )
-
-# Subdirectories
-add_subdirectory(cmd)

src/dusk/console/cmd/CMakeLists.txt

@@ -1,9 +0,0 @@
-# Copyright (c) 2025 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Sources
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-)

src/dusk/console/cmd/cmdbind.h

@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "console/console.h"
-#include "input/input.h"
-
-void cmdBind(const consolecmdexec_t *exec) {
-  if(exec->argc < 1) {
-    consolePrint("Expected 1 argument: <key> <command]");
-    return;
-  }
-
-  inputbutton_t button = inputButtonGetByName(exec->argv[0]);
-  if(button.type == INPUT_BUTTON_TYPE_NONE) {
-    consolePrint("Unknown button \"%s\"", exec->argv[0]);
-    return;
-  }
-
-  if(exec->argc == 1) {
-    // Get the button data for this button.
-    inputbuttondata_t *data = inputButtonGetData(button);
-    assertNotNull(data, "Input button not found");
-
-    inputaction_t act = data->action;
-    if(act == INPUT_ACTION_NULL || act >= INPUT_ACTION_COUNT) {
-      consolePrint("%s is not bound.", data->name);
-    } else {
-      consolePrint("%s is bound to %s.", data->name, INPUT_ACTION_IDS[act]);
-    }
-    return;
-  }
-
-  inputaction_t action = inputActionGetByName(exec->argv[1]);
-  if(action == INPUT_ACTION_COUNT) {
-    consolePrint("Unknown action \"%s\"", exec->argv[1]);
-    return;
-  }
-
-  inputBind(button, action);
-}

src/dusk/console/cmd/cmdecho.h

@@ -1,18 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "console/console.h"
-
-void cmdEcho(const consolecmdexec_t *exec) {
-  if(exec->argc < 1) {
-    consolePrint("Expected 1 argument: <message>");
-    return;
-  }
-
-  consolePrint("%s", exec->argv[0]);
-}

src/dusk/console/cmd/cmdget.h

@@ -1,25 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "console/console.h"
-
-void cmdGet(const consolecmdexec_t *exec) {
-  assertTrue(
-    exec->argc >= 1,
-    "Get command requires 1 argument."
-  );
-
-  for(uint32_t i = 0; i < CONSOLE.variableCount; i++) {
-    consolevar_t *var = &CONSOLE.variables[i];
-    if(stringCompare(var->name, exec->argv[0]) != 0) continue;
-    consolePrint("%s", var->value);
-    return;
-  }
-
-  consolePrint("Error: Variable '%s' not found.", exec->argv[0]);
-}

src/dusk/console/cmd/cmdquit.h

@@ -1,14 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "console/console.h"
-#include "engine/engine.h"
-
-void cmdQuit(const consolecmdexec_t *exec) {
-  ENGINE.running = false;
-}

src/dusk/console/cmd/cmdset.h

@@ -1,27 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "console/console.h"
-
-void cmdSet(const consolecmdexec_t *exec) {
-  assertTrue(exec->argc >= 2, "set command requires 2 arguments.");
-
-  for(uint32_t i = 0; i < CONSOLE.variableCount; i++) {
-    consolevar_t *var = &CONSOLE.variables[i];
-    if(stringCompare(var->name, exec->argv[0]) != 0) continue;
-    consoleVarSetValue(var, exec->argv[1]);
-    // consolePrint("%s %s", var->name, var->value);
-    for(i = 0; i < var->eventCount; i++) {
-      assertNotNull(var->events[i], "Event is NULL");
-      var->events[i](var);
-    }
-    return;
-  }
-
-  consolePrint("Error: Variable '%s' not found.", exec->argv[0]);
-}

src/dusk/console/cmd/cmdtime.h

@@ -1,14 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "console/console.h"
-#include "time/time.h"
-
-void cmdTime(const consolecmdexec_t *exec) {
-  consolePrint("Time: %.2f", TIME.time);
-}

src/dusk/console/console.c

@@ -1,6 +1,6 @@
 /**
- * Copyright (c) 2025 Dominic Masters
- * 
+ * Copyright (c) 2026 Dominic Masters
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
@@ -12,40 +12,16 @@
 #include "input/input.h"
 #include "log/log.h"
 #include "engine/engine.h"
-
-#include "console/cmd/cmdecho.h"
-#include "console/cmd/cmdset.h"
-#include "console/cmd/cmdget.h"
-#include "console/cmd/cmdquit.h"
-#include "console/cmd/cmdbind.h"
-#include "console/cmd/cmdtime.h"
-
+#include "script/scriptmanager.h"
 #include "display/shader/shaderunlit.h"
 #include "display/text/text.h"
 #include "display/spritebatch/spritebatch.h"
 
 console_t CONSOLE;
 
-void consoleInit() {
+void consoleInit(void) {
   memoryZero(&CONSOLE, sizeof(console_t));
 
-  // Register vars
-  #define REG(name, value) consoleRegVar(name, value, NULL)
-  REG("console", "1");
-  #undef REG
-
-  // Register cmdss
-  CONSOLE.cmdGet = consoleRegCmd("get", cmdGet);
-  CONSOLE.cmdSet = consoleRegCmd("set", cmdSet);
-
-  #define REG(name, func) consoleRegCmd(name, func)
-  REG("echo", cmdEcho);
-  REG("quit", cmdQuit);
-  REG("exit", cmdQuit);
-  REG("bind", cmdBind);
-  REG("time", cmdTime);
-  #undef REG
-
   #ifdef DUSK_CONSOLE_POSIX
     threadInit(&CONSOLE.thread, consoleInputThread);
     threadMutexInit(&CONSOLE.execMutex);
@@ -54,68 +30,6 @@ void consoleInit() {
   #endif
 }
 
-consolecmd_t * consoleRegCmd(const char_t *name, consolecmdfunc_t function) {
-  consolecmd_t *cmd = &CONSOLE.commands[CONSOLE.commandCount++];
-  consoleCmdInit(cmd, name, function);
-  return cmd;
-}
-
-consolevar_t * consoleRegVar(
-  const char_t *name,
-  const char_t *value,
-  consolevarchanged_t event
-) {
-  consolevar_t *var;
-
-  // Existing?
-  var = consoleVarGet(name);
-  if(var != NULL) return var;
-
-  assertTrue(
-    CONSOLE.variableCount < CONSOLE_VARIABLES_MAX,
-    "Too many console variables registered."
-  );
-
-  // Create
-  var = &CONSOLE.variables[CONSOLE.variableCount++];
-  consoleVarInitListener(var, name, value, event);
-  return var;
-}
-
-consolevar_t * consoleVarGet(const char_t *name) {
-  assertNotNull(name, "name must not be NULL");
-  for(uint32_t i = 0; i < CONSOLE.variableCount; i++) {
-    consolevar_t *var = &CONSOLE.variables[i];
-    if(stringCompare(var->name, name) == 0) return var;
-  }
-  return NULL;
-}
-
-int32_t consoleVarGetInt(const char_t *name, const int32_t initial) {
-  consolevar_t *var = consoleVarGet(name);
-  if(var == NULL) return initial;
-  char *end;
-  int32_t value = (int32_t)strtol(var->value, &end, 10);
-  if(*end != '\0') return initial;
-  return value;
-}
-
-bool_t consoleVarGetBool(const char_t *name, const bool_t initial) {
-  return consoleVarGetInt(name, initial ? 1 : 0) != 0;
-}
-
-void consoleVarSetInt(const char_t *name, const int32_t value) {
-  consolevar_t *existing = consoleVarGet(name);
-  assertNotNull(existing, "Variable not found");
-  char_t buffer[CONSOLE_VAR_VALUE_MAX];
-  stringFormat(buffer, CONSOLE_VAR_VALUE_MAX, "%d", value);
-  consoleVarSetValue(existing, buffer);
-}
-
-void consoleVarSetBool(const char_t *name, const bool_t value) {
-  consoleVarSetInt(name, value ? 1 : 0);
-}
-
 void consolePrint(const char_t *message, ...) {
   char_t buffer[CONSOLE_LINE_MAX];
 
@@ -128,19 +42,12 @@ void consolePrint(const char_t *message, ...) {
     threadMutexLock(&CONSOLE.printMutex);
   #endif
 
-  // Move all lines back
   memoryMove(
     CONSOLE.line[0],
     CONSOLE.line[1],
     (CONSOLE_HISTORY_MAX - 1) * CONSOLE_LINE_MAX
   );
-
-  // Copy the new line
-  memoryCopy(
-    CONSOLE.line[CONSOLE_HISTORY_MAX - 1],
-    buffer,
-    len + 1
-  );
+  memoryCopy(CONSOLE.line[CONSOLE_HISTORY_MAX - 1], buffer, len + 1);
 
   #ifdef DUSK_CONSOLE_POSIX
     threadMutexUnlock(&CONSOLE.printMutex);
@@ -150,280 +57,83 @@ void consolePrint(const char_t *message, ...) {
 }
 
 void consoleExec(const char_t *line) {
+  assertNotNull(line, "line must not be NULL");
+
   #ifdef DUSK_CONSOLE_POSIX
     threadMutexLock(&CONSOLE.execMutex);
   #endif
 
-  assertNotNull(line, "line must not be NULL");
   assertTrue(
     CONSOLE.execBufferCount < CONSOLE_EXEC_BUFFER_MAX,
-    "Too many commands in the buffer."
+    "Console exec buffer is full"
   );
 
-  char_t buffer[CONSOLE_LINE_MAX];
-  char_t pendingPrint[CONSOLE_LINE_MAX];
-  size_t i = 0, j = 0;
-  char_t c;
-  consoleexecstate_t state = CONSOLE_EXEC_STATE_INITIAL;
-  consolecmdexec_t *exec = NULL;
-
-  pendingPrint[0] = '\0';
-
-  while(state != CONSOLE_EXEC_STATE_FULLY_PARSED) {
-    c = line[i];
-
-    switch(state) {
-      case CONSOLE_EXEC_STATE_INITIAL:
-        assertTrue(j == 0, "Buffer not empty?");
-
-        if(c == '\0') {
-          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
-          break;
-        }
-
-        if(stringIsWhitespace(c) || c == ';') {
-          i++;
-          continue;
-        }
-
-        state = CONSOLE_EXEC_STATE_PARSE_CMD;
-        break;
-
-      case CONSOLE_EXEC_STATE_PARSE_CMD:
-        if(stringIsWhitespace(c) || c == '\0' || c == ';') {
-          state = CONSOLE_EXEC_STATE_CMD_PARSED;
-          continue;
-        }
-
-        if(c == '"') {
-          // Can't handle quotes within the command.
-          stringCopy(pendingPrint, "Invalid command", CONSOLE_LINE_MAX);
-          while(c != '\0' && c != ';') c = line[++i];
-          continue;
-        }
-
-        buffer[j++] = c;
-        i++;
-
-        if(j >= CONSOLE_LINE_MAX) {
-          stringCopy(pendingPrint, "Command too long", CONSOLE_LINE_MAX);
-          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
-          continue;
-        }
-        break;
-
-      case CONSOLE_EXEC_STATE_CMD_PARSED:
-        if(j == 0) {
-          state = CONSOLE_EXEC_STATE_INITIAL;
-          continue;
-        }
-
-        // Create exec
-        assertNull(exec, "Existing command parsing?");
-
-        exec = &CONSOLE.execBuffer[CONSOLE.execBufferCount];
-        memoryZero(exec, sizeof(consolecmdexec_t));
-
-        buffer[j] = '\0';
-        stringCopy(exec->command, buffer, CONSOLE_LINE_MAX);
-        state = CONSOLE_EXEC_STATE_FIND_ARG;
-
-        j = 0;// Free up buffer
-        break;
-
-      case CONSOLE_EXEC_STATE_FIND_ARG:
-        if(c == '\0' || c == ';') {
-          state = CONSOLE_EXEC_STATE_CMD_FINISHED;
-          continue;
-        }
-
-        if(stringIsWhitespace(c)) {
-          i++;
-          continue;
-        }
-
-        if(c == '"') {
-          state = CONSOLE_EXEC_STATE_PARSE_ARG_QUOTED;
-          i++;
-        } else {
-          state = CONSOLE_EXEC_STATE_PARSE_ARG;
-        }
-        break;
-
-      case CONSOLE_EXEC_STATE_PARSE_ARG:
-        if(stringIsWhitespace(c) || c == '\0' || c == ';') {
-          state = CONSOLE_EXEC_STATE_ARG_PARSED;
-          continue;
-        }
-
-        buffer[j++] = c;
-        i++;
-
-        if(j >= CONSOLE_LINE_MAX) {
-          stringCopy(pendingPrint, "Arg too long", CONSOLE_LINE_MAX);
-          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
-          continue;
-        }
-        break;
-
-      case CONSOLE_EXEC_STATE_PARSE_ARG_QUOTED:
-        if(c == '"') {
-          state = CONSOLE_EXEC_STATE_ARG_PARSED;
-          i++;
-          continue;
-        }
-
-        if(c == '\0' || c == ';') {
-          stringCopy(pendingPrint, "Unterminated quote", CONSOLE_LINE_MAX);
-          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
-          continue;
-        }
-
-        if(c == '\\') {
-          c = line[++i];
-
-          if(c == '\0' || c == ';') {
-            stringCopy(pendingPrint, "Unterminated quote", CONSOLE_LINE_MAX);
-            state = CONSOLE_EXEC_STATE_FULLY_PARSED;
-            continue;
-          }
-        }
-
-        buffer[j++] = c;
-        i++;
-
-        if(j >= CONSOLE_LINE_MAX) {
-          stringCopy(pendingPrint, "Arg too long", CONSOLE_LINE_MAX);
-          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
-          continue;
-        }
-        break;
-
-      case CONSOLE_EXEC_STATE_ARG_PARSED:
-        buffer[j] = '\0';
-        stringCopy(exec->argv[exec->argc++], buffer, CONSOLE_LINE_MAX);
-        state = CONSOLE_EXEC_STATE_FIND_ARG;
-        j = 0;// Free up buffer
-        break;
-
-      case CONSOLE_EXEC_STATE_CMD_FINISHED:
-        assertNotNull(exec, "No command found?");
-
-        // Now, is there a command that matches?
-        for(uint32_t k = 0; k < CONSOLE.commandCount; k++) {
-          consolecmd_t *cmd = &CONSOLE.commands[k];
-          if(stringCompare(cmd->name, exec->command) != 0) continue;
-          exec->cmd = cmd;
-          break;
-        }
-
-        if(exec->cmd == NULL) {
-          // Command wasn't found, is there a variable that matches?
-          for(uint32_t k = 0; k < CONSOLE.variableCount; k++) {
-            consolevar_t *var = &CONSOLE.variables[k];
-            if(stringCompare(var->name, exec->command) != 0) continue;
-
-            // Matching variable found, is this a GET or a SET?
-            if(exec->argc == 0) {
-              exec->cmd = CONSOLE.cmdGet;
-              stringCopy(exec->argv[0], exec->command, CONSOLE_LINE_MAX);
-              exec->argc = 1;
-            } else {
-              exec->cmd = CONSOLE.cmdSet;
-              stringCopy(exec->argv[1], exec->argv[0], CONSOLE_LINE_MAX);
-              stringCopy(exec->argv[0], exec->command, CONSOLE_LINE_MAX);
-              exec->argc = 2;
-            }
-            break;
-          }
-        }
-
-        if(exec->cmd == NULL) {
-          stringFormat(
-            pendingPrint, CONSOLE_LINE_MAX,
-            "Command \"%s\" not found", exec->command
-          );
-          exec = NULL;
-          state = CONSOLE_EXEC_STATE_INITIAL;
-        }
-
-        // Prep for next command.
-        exec = NULL;
-        state = CONSOLE_EXEC_STATE_INITIAL;
-        CONSOLE.execBufferCount++;
-        break;
-
-      default:
-        assertUnreachable("Invalid state.");
-        break;
-    }
-  }
+  stringCopy(
+    CONSOLE.execBuffer[CONSOLE.execBufferCount],
+    line,
+    CONSOLE_LINE_MAX
+  );
+  CONSOLE.execBufferCount++;
 
   #ifdef DUSK_CONSOLE_POSIX
     threadMutexUnlock(&CONSOLE.execMutex);
   #endif
-
-  if(pendingPrint[0] != '\0') consolePrint("%s", pendingPrint);
 }
 
-void consoleUpdate() {
+void consoleUpdate(void) {
   #ifdef DUSK_TIME_DYNAMIC
     if(TIME.dynamicUpdate) return;
   #endif
 
+  if(inputPressed(INPUT_ACTION_CONSOLE)) {
+    CONSOLE.visible = !CONSOLE.visible;
+  }
+
+  if(CONSOLE.execBufferCount == 0) return;
+
   #ifdef DUSK_CONSOLE_POSIX
     threadMutexLock(&CONSOLE.execMutex);
   #endif
 
-  // Toggle console
-  if(inputPressed(INPUT_ACTION_CONSOLE)) {
-    consoleVarSetBool("console", !consoleVarGetBool("console", false));
-  }
-
-  // Anything to exec?
-  if(CONSOLE.execBufferCount == 0) {
-    #ifdef DUSK_CONSOLE_POSIX
-      threadMutexUnlock(&CONSOLE.execMutex);
-    #endif
-    return;
-  }
-
-  // Copy the exec buffer, this allows exec command to work
-  consolecmdexec_t execBuffer[CONSOLE_EXEC_BUFFER_MAX];
+  char_t execBuffer[CONSOLE_EXEC_BUFFER_MAX][CONSOLE_LINE_MAX];
   uint32_t execBufferCount = CONSOLE.execBufferCount;
-  memoryCopy(
-    execBuffer,
-    CONSOLE.execBuffer,
-    sizeof(consolecmdexec_t) * execBufferCount
-  );
-
-  // Clear the exec buffer and unlock so new commands can be added while we
-  // process the current ones.
+  memoryCopy(execBuffer, CONSOLE.execBuffer, sizeof(execBuffer));
   CONSOLE.execBufferCount = 0;
+
   #ifdef DUSK_CONSOLE_POSIX
     threadMutexUnlock(&CONSOLE.execMutex);
   #endif
 
-  // Exec pending buffer.
   for(uint32_t i = 0; i < execBufferCount; i++) {
-    consolecmdexec_t *exec = &execBuffer[i];
-    assertNotNull(exec->cmd, "Command execution has no command.");
-    exec->cmd->function(exec);
+    jerry_value_t result = 0;
+    errorret_t err = scriptManagerExec(execBuffer[i], &result);
+    if(err.code != ERROR_OK) {
+      consolePrint("Error: %s", err.state->message);
+      errorCatch(err);
+    } else if(!jerry_value_is_undefined(result)) {
+      jerry_value_t strVal = jerry_value_to_string(result);
+      char_t buf[CONSOLE_LINE_MAX];
+      jerry_size_t len = jerry_string_to_buffer(
+        strVal, JERRY_ENCODING_UTF8, (jerry_char_t*)buf, sizeof(buf) - 1
+      );
+      buf[len] = '\0';
+      jerry_value_free(strVal);
+      consolePrint("%s", buf);
+    }
+    if(result != 0) jerry_value_free(result);
   }
 }
 
-errorret_t consoleDraw() {
-  if(!consoleVarGetBool("console", false)) {
-    errorOk();
-  }
+errorret_t consoleDraw(void) {
+  if(!CONSOLE.visible) errorOk();
 
   for(uint32_t i = 0; i < CONSOLE_HISTORY_MAX; i++) {
     errorChain(textDraw(
-      0, DEFAULT_FONT_TILESET.tileHeight * i,
+      0, FONT_TILESET_DEFAULT.tileHeight * i,
       CONSOLE.line[i],
       COLOR_WHITE,
-      &DEFAULT_FONT_TILESET,
-      &DEFAULT_FONT_TEXTURE
+      &FONT_TILESET_DEFAULT,
+      &FONT_TEXTURE_DEFAULT
     ));
   }
   errorChain(spriteBatchFlush());
@@ -454,29 +164,23 @@ void consoleDispose(void) {
 
       if(rc == 0) continue;
       if(rc < 0) {
-        if(errno == EINTR) continue; // Interrupted by signal, retry
+        if(errno == EINTR) continue;
         assertUnreachable("poll() failed with unexpected error.");
       }
 
-      // Check for errors or input
-      if (pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) break;
-      if (!(pfd.revents & POLLIN)) {
+      if(pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) break;
+      if(!(pfd.revents & POLLIN)) {
         pfd.revents = 0;
         continue;
       }
-      
-      // Read a line from stdin
+
       if(!fgets(line, CONSOLE_LINE_MAX, stdin)) {
-        if (feof(stdin)) break;
+        if(feof(stdin)) break;
         clearerr(stdin);
         continue;
       }
 
-      // Did we read a full line or did it get truncated?
       size_t len = strlen(line);
-      int32_t fullLine = len > 0 && line[len - 1] == '\n';
-
-      // Strip trailing newline/CR
       while(len && (line[len - 1] == '\n' || line[len - 1] == '\r')) {
         line[--len] = '\0';
       }
@@ -486,4 +190,4 @@ void consoleDispose(void) {
       pfd.revents = 0;
     }
   }
-#endif
+#endif

src/dusk/console/console.h

@@ -1,14 +1,14 @@
 /**
- * Copyright (c) 2025 Dominic Masters
- * 
+ * Copyright (c) 2026 Dominic Masters
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
 
 #pragma once
-#include "consolevar.h"
-#include "consolecmd.h"
+#include "consoledefs.h"
 #include "error/error.h"
+#include "dusk.h"
 
 #ifdef DUSK_CONSOLE_POSIX
   #include "thread/thread.h"
@@ -17,37 +17,14 @@
   #define CONSOLE_POSIX_POLL_RATE 75
 #endif
 
-typedef enum {
-  CONSOLE_EXEC_STATE_INITIAL,
-  CONSOLE_EXEC_STATE_PARSE_CMD,
-  CONSOLE_EXEC_STATE_CMD_PARSED,
-  
-  CONSOLE_EXEC_STATE_FIND_ARG,
-  CONSOLE_EXEC_STATE_PARSE_ARG,
-  CONSOLE_EXEC_STATE_PARSE_ARG_QUOTED,
-  CONSOLE_EXEC_STATE_ARG_PARSED,
-
-  CONSOLE_EXEC_STATE_CMD_FINISHED,
-  CONSOLE_EXEC_STATE_FULLY_PARSED
-} consoleexecstate_t;
-
 typedef struct {
-  consolecmd_t commands[CONSOLE_COMMANDS_MAX];
-  uint32_t commandCount;
-
-  consolevar_t variables[CONSOLE_VARIABLES_MAX];
-  uint32_t variableCount;
-
   char_t line[CONSOLE_HISTORY_MAX][CONSOLE_LINE_MAX];
+  bool_t visible;
 
-  consolecmdexec_t execBuffer[CONSOLE_EXEC_BUFFER_MAX];
+  char_t execBuffer[CONSOLE_EXEC_BUFFER_MAX][CONSOLE_LINE_MAX];
   uint32_t execBufferCount;
 
-  consolecmd_t *cmdGet;
-  consolecmd_t *cmdSet;
-
   #ifdef DUSK_CONSOLE_POSIX
-    char_t inputBuffer[CONSOLE_LINE_MAX];
     thread_t thread;
     threadmutex_t execMutex;
     threadmutex_t printMutex;
@@ -59,104 +36,33 @@ extern console_t CONSOLE;
 /**
  * Initializes the console.
  */
-void consoleInit();
+void consoleInit(void);
 
 /**
- * Registers a console command.
- * 
- * @param name The name of the command.
- * @param function The function to execute when the command is called.
- * @return The registered command.
+ * Prints a message to the console history.
+ *
+ * @param message The message to print (printf-style).
  */
-consolecmd_t * consoleRegCmd(const char_t *name, consolecmdfunc_t function);
+void consolePrint(const char_t *message, ...);
 
 /**
- * Registers a console variable.
- * 
- * @param name The name of the variable.
- * @param value The initial value of the variable.
- * @param event The event to register.
- * @return The registered variable.
- */
-consolevar_t * consoleRegVar(
-  const char_t *name,
-  const char_t *value,
-  consolevarchanged_t event
-);
-
-/**
- * Gets a console variable by name.
- * 
- * @param name The name of the variable.
- * @return The variable, or NULL if not found.
- */
-consolevar_t * consoleVarGet(const char_t *name);
-
-/**
- * Gets the value of a console variable as an int32_t.
- * 
- * @param name The name of the variable.
- * @param initial The default value to return if the variable is not found or
- * invalid.
- * @return The value of the variable, or default if not found or invalid.
- */
-int32_t consoleVarGetInt(const char_t *name, const int32_t initial);
-
-/**
- * Gets the value of a console variable as a bool_t.
- * 
- * @param name The name of the variable.
- * @param initial The default value to return if the variable is not found or
- * invalid.
- * @return The value of the variable, or default if not found or invalid.
- */
-bool_t consoleVarGetBool(const char_t *name, const bool_t initial);
-
-/**
- * Sets the value of a console variable as an int32_t.
- * 
- * @param name The name of the variable.
- * @param value The new value of the variable.
- */
-void consoleVarSetInt(const char_t *name, const int32_t value);
-
-/**
- * Sets the value of a console variable as a bool_t.
- * 
- * @param name The name of the variable.
- * @param value The new value of the variable.
- */
-void consoleVarSetBool(const char_t *name, const bool_t value);
-
-/**
- * Prints a message to the console.
- * 
- * @param message The message to print.
- */
-void consolePrint(
-  const char_t *message,
-  ...
-);
-
-/**
- * Executes a console command. This method is thread safe and can be called from
- * any thread.
- * 
- * @param line The line to execute.
+ * Queues a JS string for execution on the main thread. Thread-safe.
+ *
+ * @param line The JS source line to execute.
  */
 void consoleExec(const char_t *line);
 
 /**
- * Processes the console's pending commands.
+ * Processes pending queued script lines. Call once per frame from main thread.
  */
-void consoleUpdate();
+void consoleUpdate(void);
 
 /**
- * Renders the console to the screen. This is in UI space.
- * 
+ * Renders the console history to the screen (UI space).
+ *
  * @return The error return value.
  */
-errorret_t consoleDraw();
+errorret_t consoleDraw(void);
 
 /**
  * Disposes of the console.
@@ -165,9 +71,9 @@ void consoleDispose(void);
 
 #ifdef DUSK_CONSOLE_POSIX
   /**
-   * Input thread handler for posix input.
-   * 
+   * Input thread handler for POSIX stdin.
+   *
    * @param thread The thread that is running.
    */
   void consoleInputThread(thread_t *thread);
-#endif
+#endif

src/dusk/console/consolecmd.c

@@ -1,27 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "consolecmd.h"
-#include "assert/assert.h"
-#include "util/memory.h"
-#include "util/string.h"
-
-void consoleCmdInit(
-  consolecmd_t *cmd,
-  const char_t *name,
-  consolecmdfunc_t function
-) {
-  assertNotNull(cmd, "Command is NULL.");
-  assertNotNull(name, "Name is NULL.");
-  assertNotNull(function, "Function is NULL.");
-  assertStrLenMin(name, 1, "Name is empty.");
-  assertStrLenMax(name, CONSOLE_CMD_NAME_MAX, "Name is too long.");
-
-  memoryZero(cmd, sizeof(consolecmd_t));
-  stringCopy(cmd->name, name, CONSOLE_CMD_NAME_MAX);
-  cmd->function = function;
-}

src/dusk/console/consolecmd.h

@@ -1,39 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-#include "consoledefs.h"
-
-typedef struct consolecmd_s consolecmd_t;
-
-typedef struct {
-  consolecmd_t *cmd;
-  char_t command[CONSOLE_LINE_MAX];
-  char_t argv[CONSOLE_CMD_ARGC_MAX][CONSOLE_LINE_MAX];
-  uint32_t argc;
-} consolecmdexec_t;
-
-typedef void (*consolecmdfunc_t)(const consolecmdexec_t *exec);
-
-typedef struct consolecmd_s {
-  char_t name[CONSOLE_CMD_NAME_MAX];
-  consolecmdfunc_t function;
-} consolecmd_t;
-
-/**
- * Initializes a console command.
- * 
- * @param cmd Pointer to the console command.
- * @param name The name of the command.
- * @param function The function to execute when the command is called.
- */
-void consoleCmdInit(
-  consolecmd_t *cmd,
-  const char_t *name,
-  consolecmdfunc_t function
-);

src/dusk/console/consoledefs.h

@@ -1,22 +1,12 @@
 /**
- * Copyright (c) 2025 Dominic Masters
- * 
+ * Copyright (c) 2026 Dominic Masters
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
 
 #pragma once
 
-#define CONSOLE_CMD_NAME_MAX 16
-#define CONSOLE_CMD_ARGC_MAX 16
-
-#define CONSOLE_COMMANDS_MAX 32
-#define CONSOLE_VARIABLES_MAX 64
-#define CONSOLE_LINE_MAX 128
+#define CONSOLE_LINE_MAX 512
 #define CONSOLE_HISTORY_MAX 16
 #define CONSOLE_EXEC_BUFFER_MAX 32
-#define CONSOLE_ALIAS_MAX 32
-
-#define CONSOLE_VAR_NAME_MAX 32
-#define CONSOLE_VAR_VALUE_MAX 32
-#define CONSOLE_VAR_EVENTS_MAX 8

src/dusk/console/consolevar.c

@@ -1,64 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "consolevar.h"
-#include "assert/assert.h"
-#include "util/memory.h"
-#include "util/string.h"
-
-void consoleVarInit(
-  consolevar_t *var,
-  const char_t *name,
-  const char_t *value
-) {
-  assertNotNull(var, "var must not be NULL");
-  assertNotNull(name, "name must not be NULL");
-  assertNotNull(value, "value must not be NULL");
-
-  assertStrLenMin(name, 1, "name must not be empty");
-  assertStrLenMax(name, CONSOLE_VAR_NAME_MAX, "name is too long");
-  assertStrLenMax(value, CONSOLE_VAR_VALUE_MAX, "value is too long");
-
-  memoryZero(var, sizeof(consolevar_t));
-  stringCopy(var->name, name, CONSOLE_VAR_NAME_MAX);
-  stringCopy(var->value, value, CONSOLE_VAR_VALUE_MAX);
-}
-
-void consoleVarInitListener(
-  consolevar_t *var,
-  const char_t *name,
-  const char_t *value,
-  consolevarchanged_t event
-) {
-  consoleVarInit(var, name, value);
-  if(event) consoleVarListen(var, event);
-}
-
-void consoleVarSetValue(consolevar_t *var, const char_t *value) {
-  assertNotNull(var, "var must not be NULL");
-  assertNotNull(value, "value must not be NULL");
-  assertStrLenMax(value, CONSOLE_VAR_VALUE_MAX, "value is too long");
-
-  stringCopy(var->value, value, CONSOLE_VAR_VALUE_MAX);
-  
-  uint8_t i = 0;
-  while (i < var->eventCount) {
-    var->events[i](var);
-    i++;
-  }
-}
-
-void consoleVarListen(consolevar_t *var, consolevarchanged_t event) {
-  assertNotNull(var, "var must not be NULL");
-  assertNotNull(event, "event must not be NULL");
-  assertTrue(
-    var->eventCount < CONSOLE_VAR_EVENTS_MAX,
-    "Event count is too high"
-  );
-  var->events[var->eventCount++] = event;
-}
-

src/dusk/console/consolevar.h

@@ -1,65 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-#include "consoledefs.h"
-
-typedef struct consolevar_s consolevar_t;
-
-typedef void (*consolevarchanged_t)(const consolevar_t *var);
-
-typedef struct consolevar_s {
-  char_t name[CONSOLE_VAR_NAME_MAX];
-  char_t value[CONSOLE_VAR_VALUE_MAX];
-  consolevarchanged_t events[CONSOLE_VAR_EVENTS_MAX];
-  uint8_t eventCount;
-} consolevar_t;
-
-/**
- * Initializes a console variable.
- * 
- * @param var Pointer to the console variable.
- * @param name The name of the variable.
- * @param value The initial value of the variable.
- */
-void consoleVarInit(
-  consolevar_t *var,
-  const char_t *name,
-  const char_t *value
-);
-
-/**
- * Initializes a console variable with a listener.
- * 
- * @param var Pointer to the console variable.
- * @param name The name of the variable.
- * @param value The initial value of the variable.
- * @param event The event to register.
- */
-void consoleVarInitListener(
-  consolevar_t *var,
-  const char_t *name,
-  const char_t *value,
-  consolevarchanged_t event
-);
-
-/**
- * Sets the value of a console variable.
- * 
- * @param var Pointer to the console variable.
- * @param value The new value of the variable.
- */
-void consoleVarSetValue(consolevar_t *var, const char_t *value);
-
-/**
- * Registers an event to be called when the value of a console variable changes.
- * 
- * @param var Pointer to the console variable.
- * @param event The event to register.
- */
-void consoleVarListen(consolevar_t *var, consolevarchanged_t event);

src/dusk/display/display.c

@@ -25,8 +25,6 @@
 #include "display/shader/shaderunlit.h"
 #include "time/time.h"
 
-#include "script/module/display/moduleshader.h"
-
 display_t DISPLAY = { 0 };
 
 errorret_t displayInit(void) {

src/dusk/display/text/text.c

@@ -13,19 +13,19 @@
 #include "asset/loader/display/assettilesetloader.h"
 #include "display/shader/shaderunlit.h"
 
-texture_t DEFAULT_FONT_TEXTURE;
-tileset_t DEFAULT_FONT_TILESET;
+texture_t FONT_TEXTURE_DEFAULT;
+tileset_t FONT_TILESET_DEFAULT;
 
 errorret_t textInit(void) {
   errorChain(assetTextureLoad(
-    "ui/minogram.png", &DEFAULT_FONT_TEXTURE, TEXTURE_FORMAT_RGBA
+    "ui/minogram.png", &FONT_TEXTURE_DEFAULT, TEXTURE_FORMAT_RGBA
   ));
-  errorChain(assetTilesetLoad("ui/minogram.dtf", &DEFAULT_FONT_TILESET));
+  errorChain(assetTilesetLoad("ui/minogram.dtf", &FONT_TILESET_DEFAULT));
   errorOk();
 }
 
 errorret_t textDispose(void) {
-  errorChain(textureDispose(&DEFAULT_FONT_TEXTURE));
+  errorChain(textureDispose(&FONT_TEXTURE_DEFAULT));
   errorOk();
 }
 

src/dusk/display/text/text.h

@@ -12,8 +12,8 @@
 
 #define TEXT_CHAR_START '!'
 
-extern texture_t DEFAULT_FONT_TEXTURE;
-extern tileset_t DEFAULT_FONT_TILESET;
+extern texture_t FONT_TEXTURE_DEFAULT;
+extern tileset_t FONT_TILESET_DEFAULT;
 
 /**
  * Initializes the text system.

src/dusk/dusk.h

@@ -21,6 +21,7 @@
 #include <cglm/cglm.h>
 #include <cglm/types.h>
 #include <cglm/vec2.h>
+#include <jerryscript.h>
 
 #include "duskplatform.h"
 

src/dusk/engine/engine.c

@@ -24,6 +24,16 @@
 #include "system/system.h"
 #include "console/console.h"
 
+double jerry_port_current_time(void) {
+  dusktimeepoch_t epoch = timeGetEpoch();
+  return epoch.time * 1000.0;
+}
+
+int32_t jerry_port_local_tza(double unix_ms) {
+  (void) unix_ms;
+  return 0;
+}
+
 engine_t ENGINE;
 
 errorret_t engineInit(const int32_t argc, const char_t **argv) {
@@ -47,13 +57,10 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
   physicsManagerInit();
   errorChain(networkInit());
   errorChain(gameInit());
-  consolePrint("Engine initialized");
-  
+
   /* Run the init script. */
-  scriptcontext_t ctx;
-  errorChain(scriptContextInit(&ctx));
-  errorChain(scriptContextExecFile(&ctx, "init.lua"));
-  scriptContextDispose(&ctx);
+  consolePrint("Engine initialized");
+  errorChain(scriptManagerExecFile("init.js", NULL));
 
   errorOk();
 }

src/dusk/entity/component.c

@@ -12,8 +12,14 @@
 componentdefinition_t COMPONENT_DEFINITIONS[] = {
   [COMPONENT_TYPE_NULL] = { 0 },
 
-  #define X(enumName, type, field, iMethod, dMethod) \
-    [COMPONENT_TYPE_##enumName] = { .init = iMethod, .dispose = dMethod },
+  #define X(enm, type, field, iMethod, dMethod) \
+    [COMPONENT_TYPE_##enm] = { \
+      .enumName = #enm, \
+      .name = #field, \
+      .init = iMethod, \
+      .dispose = dMethod \
+    },
+  
   #include "componentlist.h"
   #undef X
 

src/dusk/entity/component.h

@@ -20,6 +20,8 @@ typedef union {
 } componentdata_t;
 
 typedef struct {
+  const char_t *enumName;
+  const char_t *name;
   void (*init)(const entityid_t, const componentid_t);
   void (*dispose)(const entityid_t, const componentid_t);
 } componentdefinition_t;

src/dusk/entity/component/display/entitycamera.c

@@ -6,6 +6,8 @@
  */
 
 #include "entity/entitymanager.h"
+#include "entity/entity.h"
+#include "entity/component/display/entityposition.h"
 #include "display/framebuffer/framebuffer.h"
 #include "display/screen/screen.h"
 
@@ -19,42 +21,6 @@ void entityCameraInit(const entityid_t ent, const componentid_t comp) {
   cam->perspective.fov = glm_rad(45.0f);
 }
 
-float_t entityCameraGetZNear(const entityid_t ent, const componentid_t comp) {
-  entitycamera_t *cam = (entitycamera_t *)componentGetData(
-    ent, comp, COMPONENT_TYPE_CAMERA
-  );
-  return cam->nearClip;
-}
-
-void entityCameraSetZNear(
-  const entityid_t ent,
-  const componentid_t comp,
-  const float_t zNear
-) {
-  entitycamera_t *cam = (entitycamera_t *)componentGetData(
-    ent, comp, COMPONENT_TYPE_CAMERA
-  );
-  cam->nearClip = zNear;
-}
-
-float_t entityCameraGetZFar(const entityid_t ent, const componentid_t comp) {
-  entitycamera_t *cam = (entitycamera_t *)componentGetData(
-    ent, comp, COMPONENT_TYPE_CAMERA
-  );
-  return cam->farClip;
-}
-
-void entityCameraSetZFar(
-  const entityid_t ent,
-  const componentid_t comp,
-  const float_t zFar
-) {
-  entitycamera_t *cam = (entitycamera_t *)componentGetData(
-    ent, comp, COMPONENT_TYPE_CAMERA
-  );
-  cam->farClip = zFar;
-}
-
 void entityCameraGetProjection(
   const entityid_t ent,
   const componentid_t comp,
@@ -92,4 +58,38 @@ void entityCameraGetProjection(
       out
     );
   }
+}
+
+entityid_t entityCameraGetCurrent(void) {
+  entityid_t camEnts[ENTITY_COUNT_MAX];
+  componentid_t camComps[ENTITY_COUNT_MAX];
+  entityid_t count = componentGetEntitiesWithComponent(
+    COMPONENT_TYPE_CAMERA, camEnts, camComps
+  );
+  if(count == 0) return ENTITY_COUNT_MAX;
+  return camEnts[0];
+}
+
+void entityCameraGetForward(const entityid_t entityId, vec2 out) {
+  componentid_t posComp = entityGetComponent(entityId, COMPONENT_TYPE_POSITION);
+  entityposition_t *pos = entityPositionGet(entityId, posComp);
+  // View matrix column layout: M[col][row], forward = {-M[0][2], -M[1][2], -M[2][2]}
+  float_t fx = -pos->transform[0][2];
+  float_t fz = -pos->transform[2][2];
+  float_t len = sqrtf(fx * fx + fz * fz);
+  if(len > 1e-6f) { fx /= len; fz /= len; }
+  out[0] = fx;
+  out[1] = fz;
+}
+
+void entityCameraGetRight(const entityid_t entityId, vec2 out) {
+  componentid_t posComp = entityGetComponent(entityId, COMPONENT_TYPE_POSITION);
+  entityposition_t *pos = entityPositionGet(entityId, posComp);
+  // View matrix column layout: right = {M[0][0], M[1][0], M[2][0]}
+  float_t rx = pos->transform[0][0];
+  float_t rz = pos->transform[2][0];
+  float_t len = sqrtf(rx * rx + rz * rz);
+  if(len > 1e-6f) { rx /= len; rz /= len; }
+  out[0] = rx;
+  out[1] = rz;
 }

src/dusk/entity/component/display/entitycamera.h

@@ -55,45 +55,24 @@ void entityCameraGetProjection(
 );
 
 /**
- * Gets the near clip distance of a camera.
- *
- * @param ent The entity ID.
- * @param comp The component ID.
- * @return The near clip distance.
+ * Returns the entity ID of the first active camera, or ENTITY_COUNT_MAX if none.
  */
-float_t entityCameraGetZNear(const entityid_t ent, const componentid_t comp);
+entityid_t entityCameraGetCurrent(void);
 
 /**
- * Sets the near clip distance of a camera.
+ * Gets the camera's horizontal forward direction (XZ plane) from its position
+ * component. Automatically finds the position component on the entity.
  *
- * @param ent The entity ID.
- * @param comp The component ID.
- * @param zNear The near clip distance.
+ * @param entityId The camera entity ID.
+ * @param out Output vec2: {forwardX, forwardZ} normalized.
  */
-void entityCameraSetZNear(
-  const entityid_t ent,
-  const componentid_t comp,
-  const float_t zNear
-);
+void entityCameraGetForward(const entityid_t entityId, vec2 out);
 
 /**
- * Gets the far clip distance of a camera.
+ * Gets the camera's horizontal right direction (XZ plane) from its position
+ * component. Automatically finds the position component on the entity.
  *
- * @param ent The entity ID.
- * @param comp The component ID.
- * @return The far clip distance.
+ * @param entityId The camera entity ID.
+ * @param out Output vec2: {rightX, rightZ} normalized.
  */
-float_t entityCameraGetZFar(const entityid_t ent, const componentid_t comp);
-
-/**
- * Sets the far clip distance of a camera.
- *
- * @param ent The entity ID.
- * @param comp The component ID.
- * @param zFar The far clip distance.
- */
-void entityCameraSetZFar(
-  const entityid_t ent,
-  const componentid_t comp,
-  const float_t zFar
-);
+void entityCameraGetRight(const entityid_t entityId, vec2 out);

src/dusk/entity/component/display/entitymaterial.c

@@ -48,4 +48,15 @@ void entityMaterialSetShader(
     entityId, componentId, COMPONENT_TYPE_MATERIAL
   );
   mat->shader = shader;
+}
+
+void entityMaterialSetColor(
+  const entityid_t entityId,
+  const componentid_t componentId,
+  const color_t color
+) {
+  entitymaterial_t *mat = componentGetData(
+    entityId, componentId, COMPONENT_TYPE_MATERIAL
+  );
+  mat->material.unlit.color = color;
 }

src/dusk/entity/component/display/entitymaterial.h

@@ -60,4 +60,17 @@ void entityMaterialSetShader(
   const entityid_t entityId,
   const componentid_t componentId,
   shader_t *shader
+);
+
+/**
+ * Sets the unlit color for the given entity and component.
+ *
+ * @param entityId The entity ID.
+ * @param componentId The component ID.
+ * @param color The color to set.
+ */
+void entityMaterialSetColor(
+  const entityid_t entityId,
+  const componentid_t componentId,
+  const color_t color
 );

src/dusk/entity/component/display/entitymesh.c

@@ -5,9 +5,13 @@
  * https://opensource.org/licenses/MIT
  */
 
+#include "entitymesh.h"
 #include "entity/entitymanager.h"
-
+#include "assert/assert.h"
+#include "util/memory.h"
 #include "display/mesh/cube.h"
+#include "display/mesh/plane.h"
+#include "display/mesh/capsule.h"
 
 void entityMeshInit(
   const entityid_t entityId,
@@ -17,6 +21,8 @@ void entityMeshInit(
     entityId, componentId, COMPONENT_TYPE_MESH
   );
   comp->mesh = &CUBE_MESH_SIMPLE;
+  comp->ownedVertices = NULL;
+  comp->ownsData = false;
 }
 
 mesh_t * entityMeshGetMesh(
@@ -38,4 +44,100 @@ void entityMeshSetMesh(
     entityId, componentId, COMPONENT_TYPE_MESH
   );
   comp->mesh = mesh;
+}
+
+void entityMeshDispose(
+  const entityid_t entityId,
+  const componentid_t componentId
+) {
+  entitymesh_t *comp = componentGetData(
+    entityId, componentId, COMPONENT_TYPE_MESH
+  );
+  if(!comp->ownsData) return;
+  (void)meshDispose(&comp->ownedMesh);
+  memoryFree(comp->ownedVertices);
+  comp->ownedVertices = NULL;
+  comp->ownsData = false;
+  comp->mesh = NULL;
+}
+
+errorret_t entityMeshGeneratePlane(
+  const entityid_t entityId,
+  const componentid_t componentId,
+  const float_t width,
+  const float_t height
+) {
+  entitymesh_t *comp = componentGetData(
+    entityId, componentId, COMPONENT_TYPE_MESH
+  );
+  entityMeshDispose(entityId, componentId);
+
+  comp->ownedVertices = memoryAllocate(PLANE_VERTEX_COUNT * sizeof(meshvertex_t));
+  assertNotNull(comp->ownedVertices, "Failed to allocate plane vertices");
+
+  vec3 min = { -width * 0.5f, 0.0f, -height * 0.5f };
+  vec3 max = {  width * 0.5f, 0.0f,  height * 0.5f };
+  vec2 uvMin = { 0.0f, 0.0f };
+  vec2 uvMax = { 1.0f, 1.0f };
+  planeBuffer(
+    comp->ownedVertices,
+    PLANE_AXIS_XZ,
+    min,
+    max
+    #if MESH_ENABLE_COLOR
+      , COLOR_WHITE_4B
+    #endif
+    , uvMin,
+    uvMax
+  );
+
+  errorChain(meshInit(
+    &comp->ownedMesh,
+    PLANE_PRIMITIVE_TYPE,
+    PLANE_VERTEX_COUNT,
+    comp->ownedVertices
+  ));
+
+  comp->mesh = &comp->ownedMesh;
+  comp->ownsData = true;
+  errorOk();
+}
+
+errorret_t entityMeshGenerateCapsule(
+  const entityid_t entityId,
+  const componentid_t componentId,
+  const float_t radius,
+  const float_t halfHeight
+) {
+  entitymesh_t *comp = componentGetData(
+    entityId, componentId, COMPONENT_TYPE_MESH
+  );
+  entityMeshDispose(entityId, componentId);
+
+  comp->ownedVertices = memoryAllocate(CAPSULE_VERTEX_COUNT * sizeof(meshvertex_t));
+  assertNotNull(comp->ownedVertices, "Failed to allocate capsule vertices");
+
+  vec3 center = { 0.0f, 0.0f, 0.0f };
+  capsuleBuffer(
+    comp->ownedVertices,
+    center,
+    radius,
+    halfHeight,
+    CAPSULE_CAP_RINGS,
+    CAPSULE_SECTORS
+    #if MESH_ENABLE_COLOR
+      , COLOR_WHITE_4B
+    #endif
+  );
+
+  errorChain(meshInit(
+    &comp->ownedMesh,
+    CAPSULE_PRIMITIVE_TYPE,
+    CAPSULE_VERTEX_COUNT,
+    comp->ownedVertices
+  ));
+
+  comp->mesh = &comp->ownedMesh;
+  comp->ownsData = true;
+  errorOk();
 }

src/dusk/entity/component/display/entitymesh.h

@@ -11,6 +11,9 @@
 
 typedef struct {
   mesh_t *mesh;
+  mesh_t ownedMesh;
+  meshvertex_t *ownedVertices;
+  bool_t ownsData;
 } entitymesh_t;
 
 /**
@@ -47,4 +50,47 @@ void entityMeshSetMesh(
   const entityid_t entityId,
   const componentid_t componentId,
   mesh_t *mesh
+);
+
+/**
+ * Disposes the entity mesh component, freeing any owned mesh data.
+ *
+ * @param entityId The entity ID.
+ * @param componentId The component ID.
+ */
+void entityMeshDispose(
+  const entityid_t entityId,
+  const componentid_t componentId
+);
+
+/**
+ * Generates an XZ-aligned plane mesh owned by the component.
+ *
+ * @param entityId The entity ID.
+ * @param componentId The component ID.
+ * @param width Width of the plane along the X axis.
+ * @param height Height of the plane along the Z axis.
+ * @return Error return value.
+ */
+errorret_t entityMeshGeneratePlane(
+  const entityid_t entityId,
+  const componentid_t componentId,
+  const float_t width,
+  const float_t height
+);
+
+/**
+ * Generates a Y-axis capsule mesh owned by the component.
+ *
+ * @param entityId The entity ID.
+ * @param componentId The component ID.
+ * @param radius Radius of the cylinder and hemisphere caps.
+ * @param halfHeight Half-height of the cylindrical section.
+ * @return Error return value.
+ */
+errorret_t entityMeshGenerateCapsule(
+  const entityid_t entityId,
+  const componentid_t componentId,
+  const float_t radius,
+  const float_t halfHeight
 );

src/dusk/entity/component/physics/entityphysics.c

@@ -100,6 +100,25 @@ bool_t entityPhysicsIsOnGround(
   return phys->onGround;
 }
 
+void entityPhysicsSetBodyType(
+  const entityid_t entityId,
+  const componentid_t componentId,
+  const physicsbodytype_t type
+) {
+  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
+  assertNotNull(phys, "Failed to get physics component data");
+  phys->type = type;
+}
+
+physicsbodytype_t entityPhysicsGetBodyType(
+  const entityid_t entityId,
+  const componentid_t componentId
+) {
+  entityphysics_t *phys = entityPhysicsGet(entityId, componentId);
+  assertNotNull(phys, "Failed to get physics component data");
+  return phys->type;
+}
+
 void entityPhysicsDispose(
   const entityid_t entityId,
   const componentid_t componentId

src/dusk/entity/component/physics/entityphysics.h

@@ -122,6 +122,31 @@ bool_t entityPhysicsIsOnGround(
   const componentid_t componentId
 );
 
+/**
+ * Sets the body type of the entity's physics body.
+ *
+ * @param entityId The entity ID.
+ * @param componentId The component ID.
+ * @param type The body type to set.
+ */
+void entityPhysicsSetBodyType(
+  const entityid_t entityId,
+  const componentid_t componentId,
+  const physicsbodytype_t type
+);
+
+/**
+ * Gets the body type of the entity's physics body.
+ *
+ * @param entityId The entity ID.
+ * @param componentId The component ID.
+ * @return The body type of the physics body.
+ */
+physicsbodytype_t entityPhysicsGetBodyType(
+  const entityid_t entityId,
+  const componentid_t componentId
+);
+
 /**
  * Releases the body slot back to PHYSICS_WORLD. Called automatically when
  * the component is disposed via the component system.

src/dusk/entity/component/script/CMakeLists.txt

@@ -3,7 +3,5 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    entityscript.c
-)
+
+

src/dusk/entity/component/script/entityscript.c

@@ -1,115 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entityscript.h"
-#include "entity/entitymanager.h"
-#include "assert/assert.h"
-#include "util/memory.h"
-
-void entityScriptInit(
-  const entityid_t entityId,
-  const componentid_t compId
-) {
-  entityscript_t *data = componentGetData(
-    entityId, compId, COMPONENT_TYPE_ENTITYSCRIPT
-  );
-  memoryZero(data, sizeof(entityscript_t));
-}
-
-void entityScriptUnload(
-  const entityid_t entityId,
-  const componentid_t compId
-) {
-  entityscript_t *data = componentGetData(
-    entityId, compId, COMPONENT_TYPE_ENTITYSCRIPT
-  );
-
-  if(!data->active) return;
-
-  lua_getglobal(data->context.luaState, "entityDispose");
-  if(lua_isfunction(data->context.luaState, -1)) {
-    if(lua_pcall(data->context.luaState, 0, 0, 0) != LUA_OK) {
-      lua_pop(data->context.luaState, 1);
-    }
-  } else {
-    lua_pop(data->context.luaState, 1);
-  }
-
-  scriptContextDispose(&data->context);
-  data->active = false;
-}
-
-errorret_t entityScriptSetScript(
-  const entityid_t entityId,
-  const componentid_t compId,
-  const char_t *filename
-) {
-  assertNotNull(filename, "Entity script filename cannot be NULL");
-
-  entityScriptUnload(entityId, compId);
-
-  entityscript_t *data = componentGetData(
-    entityId, compId, COMPONENT_TYPE_ENTITYSCRIPT
-  );
-
-  errorChain(scriptContextInit(&data->context));
-  data->active = true;
-
-  // Expose entity identity to the script as globals
-  lua_pushnumber(data->context.luaState, (lua_Number)entityId);
-  lua_setglobal(data->context.luaState, "ENTITY_ID");
-  lua_pushnumber(data->context.luaState, (lua_Number)compId);
-  lua_setglobal(data->context.luaState, "ENTITY_COMPONENT_ID");
-
-  errorChain(scriptContextExecFile(&data->context, filename));
-
-  lua_getglobal(data->context.luaState, "entityInit");
-  if(lua_isfunction(data->context.luaState, -1)) {
-    if(lua_pcall(data->context.luaState, 0, 0, 0) != LUA_OK) {
-      errorThrow(
-        "Failed to call entityInit: %s",
-        lua_tostring(data->context.luaState, -1)
-      );
-    }
-  } else {
-    lua_pop(data->context.luaState, 1);
-  }
-
-  errorOk();
-}
-
-errorret_t entityScriptUpdate(
-  const entityid_t entityId,
-  const componentid_t compId
-) {
-  entityscript_t *data = componentGetData(
-    entityId, compId, COMPONENT_TYPE_ENTITYSCRIPT
-  );
-
-  if(!data->active) errorOk();
-
-  lua_getglobal(data->context.luaState, "entityUpdate");
-  if(lua_isfunction(data->context.luaState, -1)) {
-    if(lua_pcall(data->context.luaState, 0, 0, 0) != LUA_OK) {
-      errorThrow(
-        "Failed to call entityUpdate: %s",
-        lua_tostring(data->context.luaState, -1)
-      );
-    }
-  } else {
-    lua_pop(data->context.luaState, 1);
-  }
-
-  errorOk();
-}
-
-void entityScriptDispose(
-  const entityid_t entityId,
-  const componentid_t compId
-) {
-  entityScriptUnload(entityId, compId);
-}

src/dusk/entity/component/script/entityscript.h

@@ -1,77 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "entity/entitybase.h"
-#include "script/scriptcontext.h"
-
-typedef struct {
-  scriptcontext_t context;
-  bool_t active;
-} entityscript_t;
-
-/**
- * Initializes the entity script component (empty context, not yet loaded).
- *
- * @param entityId The entity ID.
- * @param compId The component ID.
- */
-void entityScriptInit(
-  const entityid_t entityId,
-  const componentid_t compId
-);
-
-/**
- * Unloads the currently active script: calls entityDispose if defined and
- * disposes the context. No-op if no script is loaded.
- *
- * @param entityId The entity ID.
- * @param compId The component ID.
- */
-void entityScriptUnload(
-  const entityid_t entityId,
-  const componentid_t compId
-);
-
-/**
- * Sets the script for this component. If a script is already loaded it is
- * unloaded first. Then loads and executes the new file, sets entityId and
- * entityScriptId as Lua globals, and calls entityInit if defined.
- *
- * @param entityId The entity ID.
- * @param compId The component ID.
- * @param filename The script file to load.
- * @return The error return value.
- */
-errorret_t entityScriptSetScript(
-  const entityid_t entityId,
-  const componentid_t compId,
-  const char_t *filename
-);
-
-/**
- * Calls the entityUpdate Lua function in the entity script context, if defined.
- *
- * @param entityId The entity ID.
- * @param compId The component ID.
- * @return The error return value.
- */
-errorret_t entityScriptUpdate(
-  const entityid_t entityId,
-  const componentid_t compId
-);
-
-/**
- * Unloads the script if one is active, then disposes the component.
- *
- * @param entityId The entity ID.
- * @param compId The component ID.
- */
-void entityScriptDispose(
-  const entityid_t entityId,
-  const componentid_t compId
-);

src/dusk/entity/componentlist.h

@@ -10,11 +10,15 @@
 #include "entity/component/display/entitymesh.h"
 #include "entity/component/display/entitymaterial.h"
 #include "entity/component/physics/entityphysics.h"
-#include "entity/component/script/entityscript.h"
+
+// Name (Uppercase)
+// Structure
+// Field name (lowercase)
+// Init function (optional)
+// Dispose function (optional)
 
 X(POSITION, entityposition_t, position, entityPositionInit, NULL)
 X(CAMERA, entitycamera_t, camera, entityCameraInit, NULL)
-X(MESH, entitymesh_t, mesh, entityMeshInit, NULL)
+X(MESH, entitymesh_t, mesh, entityMeshInit, entityMeshDispose)
 X(MATERIAL, entitymaterial_t, material, entityMaterialInit, NULL)
-X(PHYSICS, entityphysics_t, physics, entityPhysicsInit, entityPhysicsDispose)
-X(ENTITYSCRIPT, entityscript_t, entityscript, entityScriptInit, entityScriptDispose)
+X(PHYSICS, entityphysics_t, physics, entityPhysicsInit, entityPhysicsDispose)

src/dusk/entity/entitybase.h

@@ -8,8 +8,8 @@
 #pragma once
 #include "dusk.h"
 
-#define ENTITY_COUNT_MAX 6
-#define ENTITY_COMPONENT_COUNT_MAX 6
+#define ENTITY_COUNT_MAX 20
+#define ENTITY_COMPONENT_COUNT_MAX 8
 
 typedef uint8_t entityid_t;
 typedef uint8_t componentid_t;

src/dusk/event/event.c

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) 2026 Dominic Masters
- * 
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
@@ -8,6 +8,7 @@
 #include "event.h"
 #include "assert/assert.h"
 #include "util/memory.h"
+#include "console/console.h"
 
 void eventInit(
   event_t *event,
@@ -46,19 +47,16 @@ eventsub_t eventSubscribeUser(
       "Script event listener context cannot be NULL"
     );
     assertTrue(
-      user.script.luaFunctionRef != LUA_NOREF,
+      user.script.funcValue != 0,
       "Script event listener function reference is invalid"
     );
   } else {
     assertUnreachable("Unknown event listener type");
   }
-  
-  // Gen a new ID
+
   eventsub_t id = event->nextId++;
-  // Did we wrap?
   assertTrue(event->nextId != 0, "Event subscription ID overflow");
 
-  // Append listener
   eventlistener_t *listener = &event->listenerArray[event->listenerCount++];
   memoryZero(listener, sizeof(eventlistener_t));
   listener->user = user;
@@ -73,7 +71,7 @@ eventsub_t eventSubscribe(
   const eventcallback_t callback,
   const void *user
 ) {
-  eventSubscribeUser(
+  return eventSubscribeUser(
     event,
     EVENT_TYPE_C,
     (eventuserdata_t){ .c = { .callback = callback, .user = (void *)user } }
@@ -82,54 +80,34 @@ eventsub_t eventSubscribe(
 
 eventsub_t eventSubscribeScriptContext(
   event_t *event,
-  scriptcontext_t *context,
-  const int functionIndex
+  scriptmanager_t *context,
+  jerry_value_t funcValue
 ) {
   assertNotNull(context, "Script context cannot be NULL");
-  assertTrue(
-    lua_isfunction(context->luaState, functionIndex),
-    "Expected function at given index"
-  );
+  assertTrue(funcValue != 0, "Script function value is invalid");
 
-  // Create a reference to the function
-  lua_pushvalue(context->luaState, functionIndex);
-  int funcRef = luaL_ref(context->luaState, LUA_REGISTRYINDEX);
-
-  eventscript_t scriptUser = {
-    .context = context,
-    .luaFunctionRef = funcRef
-  };
-
-  // Note to the context that it is now a part of this event
   bool_t alreadySubbed = false;
-  uint8_t i;
-  i = 0;
+  uint8_t i = 0;
   do {
-    if(context->subscribedEvents[i] != event) {
-      i++;
-      continue;
+    if(context->subscribedEvents[i] == event) {
+      alreadySubbed = true;
+      break;
     }
-
-    if(context->subscribedEvents[i] == NULL) break;
-
-    alreadySubbed = true;
-    break;
-  } while(i < SCRIPT_CONTEXT_MAX_EVENT_SUBSCRIPTIONS);
+    i++;
+  } while(i < SCRIPT_MANAGER_MAX_EVENT_SUBSCRIPTIONS);
 
   if(!alreadySubbed) {
     i = 0;
     do {
-      if(context->subscribedEvents[i] != NULL) {
-        i++;
-        continue;
+      if(context->subscribedEvents[i] == NULL) {
+        context->subscribedEvents[i] = event;
+        break;
       }
-
-      context->subscribedEvents[i] = event;
-      break;
-    } while(i < SCRIPT_CONTEXT_MAX_EVENT_SUBSCRIPTIONS);
+      i++;
+    } while(i < SCRIPT_MANAGER_MAX_EVENT_SUBSCRIPTIONS);
 
     assertTrue(
-      i < SCRIPT_CONTEXT_MAX_EVENT_SUBSCRIPTIONS,
+      i < SCRIPT_MANAGER_MAX_EVENT_SUBSCRIPTIONS,
       "Script context has reached maximum event subscriptions"
     );
   }
@@ -137,7 +115,12 @@ eventsub_t eventSubscribeScriptContext(
   return eventSubscribeUser(
     event,
     EVENT_TYPE_SCRIPT,
-    (eventuserdata_t){ .script = scriptUser }
+    (eventuserdata_t){
+      .script = {
+        .context = context,
+        .funcValue = funcValue
+      }
+    }
   );
 }
 
@@ -147,38 +130,34 @@ void eventUnsubscribe(event_t *event, const eventsub_t id) {
 
   if(event->listenerCount == 0) return;
 
-  // Find listener
   uint16_t index = 0;
   do {
-    if(event->listenerArray[index].id == id) {
-      // Found it, remove by swapping with last and reducing count
-      event->listenerArray[index] = event->listenerArray[--event->listenerCount];
-      return;
+    if(event->listenerArray[index].id != id) {
+      index++;
+      continue;
     }
-    index++;
+
+    if(event->listenerArray[index].type == EVENT_TYPE_SCRIPT) {
+      jerry_value_t funcVal = event->listenerArray[index].user.script.funcValue;
+      if(funcVal != 0) {
+        jerry_value_free(funcVal);
+      }
+    }
+
+    event->listenerArray[index] = event->listenerArray[--event->listenerCount];
+    return;
   } while(index < event->listenerCount);
-
-  // Did we find it?
-  if(index == event->listenerCount) return;
-
-  // Shift remaining listeners down (if any)
-  if(index < event->listenerCount - 1) {
-    memoryMove(
-      &event->listenerArray[index],
-      &event->listenerArray[index + 1],
-      sizeof(eventlistener_t) * (event->listenerCount - index - 1)
-    );
-  }
-
-  event->listenerCount--;
 }
 
-void eventUnsubscribeScriptContext(event_t *event, const scriptcontext_t *ctx) {
+void eventUnsubscribeScriptContext(
+  event_t *event,
+  const scriptmanager_t *ctx
+) {
   assertNotNull(event, "Event cannot be NULL");
   assertNotNull(ctx, "Script context cannot be NULL");
 
   if(event->listenerCount == 0) return;
-  
+
   uint16_t i = 0;
   do {
     eventlistener_t *listener = &event->listenerArray[i];
@@ -189,9 +168,6 @@ void eventUnsubscribeScriptContext(event_t *event, const scriptcontext_t *ctx) {
       i++;
       continue;
     }
-
-    // This listener belongs to the context and will need to go away. This will
-    // in turn decrement the listener count so we don't increment i here.
     eventUnsubscribe(event, listener->id);
   } while(i < event->listenerCount);
 }
@@ -204,44 +180,55 @@ void eventInvoke(
   assertNotNull(event, "Event cannot be NULL");
 
   if(event->listenerCount == 0) return;
-  
+
   event->isInvoking = true;
 
-  uint16_t i = 0;
-  eventdata_t data ={
+  eventdata_t data = {
     .event = event,
     .eventParams = eventParams,
   };
 
+  uint16_t i = 0;
   do {
     eventlistener_t *listener = &event->listenerArray[i];
 
     if(listener->type == EVENT_TYPE_C) {
       listener->user.c.callback(&data, listener->user.c);
     } else if(listener->type == EVENT_TYPE_SCRIPT) {
-      // Call Lua function
-      lua_State *L = listener->user.script.context->luaState;
-      assertNotNull(L, "Lua state in event listener cannot be NULL");
+      jerry_value_t funcVal = listener->user.script.funcValue;
+      assertNotNull((void *)(uintptr_t)funcVal, "Script function value is NULL");
 
-      // Push function
-      lua_rawgeti(L, LUA_REGISTRYINDEX, listener->user.script.luaFunctionRef);
+      jerry_value_t callArgs[1];
+      jerry_length_t argCount = 0;
 
-      if(eventParams != NULL && metatableName != NULL) {
-        lua_getmetatable(L, -1);
-        luaL_getmetatable(L, metatableName);
-        assertTrue(
-          lua_rawequal(L, -1, -2),
-          "Event parameter metatable does not match expected type"
+      if(eventParams != NULL) {
+        callArgs[0] = jerry_object();
+        jerry_object_set_native_ptr(
+          callArgs[0], &JS_PTR_NATIVE_INFO, (void *)eventParams
         );
+        argCount = 1;
       }
 
-      // Call function with 1 arg, 0 return values
-      if(lua_pcall(L, 1, 0, 0) != LUA_OK) {
-        const char_t *strErr = lua_tostring(L, -1);
-        lua_pop(L, 1);
-        // Log error but continue
-        printf("Error invoking Lua event listener: %s\n", strErr);
+      jerry_value_t result = jerry_call(
+        funcVal, jerry_undefined(), callArgs, argCount
+      );
+
+      if(argCount > 0) jerry_value_free(callArgs[0]);
+
+      if(jerry_value_is_exception(result)) {
+        jerry_value_t errStr = jerry_value_to_string(
+          jerry_exception_value(result, false)
+        );
+        char_t buf[256];
+        jerry_size_t len = jerry_string_to_buffer(
+          errStr, JERRY_ENCODING_UTF8, (jerry_char_t *)buf, sizeof(buf) - 1
+        );
+        buf[len] = '\0';
+        jerry_value_free(errStr);
+        consolePrint("Error invoking script event listener:\n%s\n", buf);
       }
+
+      jerry_value_free(result);
     } else {
       assertUnreachable("Unknown event listener type");
     }
@@ -249,4 +236,4 @@ void eventInvoke(
   } while(i < event->listenerCount);
 
   event->isInvoking = false;
-}
+}

src/dusk/event/event.h

@@ -83,8 +83,8 @@ eventsub_t eventSubscribe(
  */
 eventsub_t eventSubscribeScriptContext(
   event_t *event,
-  scriptcontext_t *context,
-  const int functionIndex
+  scriptmanager_t *context,
+  jerry_value_t funcValue
 );
 
 /**
@@ -101,7 +101,10 @@ void eventUnsubscribe(event_t *event, const eventsub_t subscription);
  * @param event The event to unsubscribe from.
  * @param context The script context whose listeners should be removed.
  */
-void eventUnsubscribeScriptContext(event_t *event, const scriptcontext_t *ctx);
+void eventUnsubscribeScriptContext(
+  event_t *event,
+  const scriptmanager_t *ctx
+);
 
 /**
  * Invoke an event, calling all subscribed listeners. Optionally provide event 

src/dusk/event/eventuser.h

@@ -1,13 +1,13 @@
 /**
  * Copyright (c) 2026 Dominic Masters
- * 
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
 
 #pragma once
 #include "eventcallback.h"
-#include "script/scriptcontext.h"
+#include "script/scriptmanager.h"
 
 typedef enum {
   EVENT_TYPE_C = 0,
@@ -15,8 +15,8 @@ typedef enum {
 } eventtype_t;
 
 typedef struct {
-  scriptcontext_t *context;
-  int luaFunctionRef;
+  scriptmanager_t *context;
+  jerry_value_t funcValue;
 } eventscript_t;
 
 typedef struct eventc_s {
@@ -27,4 +27,4 @@ typedef struct eventc_s {
 typedef union eventuserdata_u {
   eventscript_t script;
   eventc_t c;
-} eventuserdata_t;
+} eventuserdata_t;

src/dusk/input/input.c

@@ -95,27 +95,27 @@ void inputUpdate(void) {
     if(TIME.dynamicUpdate) return;
   #endif
 
-  if(INPUT.eventPressed.listenerCount > 0) {
-    action = &INPUT.actions[0];
-    do {
-      if(inputPressed(action->action)) {
-        inputevent_t inputEvent = { .action = action->action };
-        eventInvoke(&INPUT.eventPressed, &inputEvent, "input_mt");
-      }
-      action++;
-    } while(action < &INPUT.actions[INPUT_ACTION_COUNT]);
-  }
+  // if(INPUT.eventPressed.listenerCount > 0) {
+  //   action = &INPUT.actions[0];
+  //   do {
+  //     if(inputPressed(action->action)) {
+  //       inputevent_t inputEvent = { .action = action->action };
+  //       eventInvoke(&INPUT.eventPressed, &inputEvent, "input_mt");
+  //     }
+  //     action++;
+  //   } while(action < &INPUT.actions[INPUT_ACTION_COUNT]);
+  // }
 
-  if(INPUT.eventReleased.listenerCount > 0) {
-    action = &INPUT.actions[0];
-    do {
-      if(inputReleased(action->action)) {
-        inputevent_t inputEvent = { .action = action->action };
-        eventInvoke(&INPUT.eventReleased, &inputEvent, "input_mt");
-      }
-      action++;
-    } while(action < &INPUT.actions[INPUT_ACTION_COUNT]);
-  }
+  // if(INPUT.eventReleased.listenerCount > 0) {
+  //   action = &INPUT.actions[0];
+  //   do {
+  //     if(inputReleased(action->action)) {
+  //       inputevent_t inputEvent = { .action = action->action };
+  //       eventInvoke(&INPUT.eventReleased, &inputEvent, "input_mt");
+  //     }
+  //     action++;
+  //   } while(action < &INPUT.actions[INPUT_ACTION_COUNT]);
+  // }
 }
 
 float_t inputGetCurrentValue(const inputaction_t action) {
@@ -171,6 +171,16 @@ float_t inputAxis(const inputaction_t neg, const inputaction_t pos) {
   return inputGetCurrentValue(pos) - inputGetCurrentValue(neg);
 }
 
+void inputAxis2D(
+  const inputaction_t negX, const inputaction_t posX,
+  const inputaction_t negY, const inputaction_t posY,
+  vec2 result
+) {
+  assertNotNull(result, "Result vector cannot be null");
+  result[0] = inputAxis(negX, posX);
+  result[1] = inputAxis(negY, posY);
+}
+
 void inputBind(const inputbutton_t button, const inputaction_t act) {
   assertTrue(
     act < INPUT_ACTION_COUNT,

src/dusk/input/input.h

@@ -120,6 +120,22 @@ bool_t inputReleased(const inputaction_t action);
  */
 float_t inputAxis(const inputaction_t neg, const inputaction_t pos);
 
+/**
+ * Gets the values of a 2D input axis, defined by two pairs of actions (negative
+ * and positive for each axis).
+ * 
+ * @param negX The action representing the negative direction of the X axis.
+ * @param posX The action representing the positive direction of the X axis.
+ * @param negY The action representing the negative direction of the Y axis.
+ * @param posY The action representing the positive direction of the Y axis.
+ * @param result A vec2 to store the resulting axis values (-1.0f to 1.0f).
+ */
+void inputAxis2D(
+  const inputaction_t negX, const inputaction_t posX,
+  const inputaction_t negY, const inputaction_t posY,
+  vec2 result
+);
+
 /**
  * Binds an input button to an action.
  * 

src/dusk/scene/scene.c

@@ -1,5 +1,5 @@
 // Copyright (c) 2026 Dominic Masters
-// 
+//
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
@@ -17,11 +17,14 @@
 #include "display/screen/screen.h"
 #include "console/console.h"
 #include "util/string.h"
+#include "script/scriptmanager.h"
+#include "script/module/scene/modulescene.h"
 
 scene_t SCENE;
 
 errorret_t sceneInit(void) {
   memoryZero(&SCENE, sizeof(scene_t));
+  SCENE.scriptRef = SCENE_SCRIPT_REF_NONE;
   errorOk();
 }
 
@@ -32,216 +35,306 @@ errorret_t sceneUpdate(void) {
     }
   #endif
 
-  // Is the scene changing?
   if(stringCompare(SCENE.sceneNext, SCENE.sceneCurrent) != 0) {
     errorChain(sceneSetImmediate(SCENE.sceneNext));
   }
 
-  // Call scene update function if script loaded
-  if(!SCENE.scriptActive) {
-    errorOk();
+  if(SCENE.sceneActive) {
+    errorChain(moduleSceneCall("update"));
   }
 
-  assertNotNull(SCENE.script.luaState, "Script context null?");
-  lua_getglobal(SCENE.script.luaState, "sceneUpdate");
-  if(lua_isfunction(SCENE.script.luaState, -1)) {
-    if(lua_pcall(SCENE.script.luaState, 0, 0, 0) != LUA_OK) {
-      errorThrow(
-        "Failed to call sceneUpdate function in script: %s\n",
-        lua_tostring(SCENE.script.luaState, -1)
-      );
-    }
-  }
-  
   errorOk();
 }
 
+dusktimeepoch_t LAST;
+
 errorret_t sceneRender(void) {
-  // Get Cameras
   entityid_t camEnts[ENTITY_COUNT_MAX];
   componentid_t camComps[ENTITY_COUNT_MAX];
   entityid_t camCount = componentGetEntitiesWithComponent(
     COMPONENT_TYPE_CAMERA, camEnts, camComps
   );
 
-  // Prep Matricies
   mat4 view, proj, model;
 
-  if(camCount > 0) {
-    // Get meshes
-    entityid_t meshEnts[ENTITY_COUNT_MAX];
-    componentid_t meshComps[ENTITY_COUNT_MAX];
-    entityid_t meshCount = componentGetEntitiesWithComponent(
-      COMPONENT_TYPE_MESH, meshEnts, meshComps
-    );
+  // For each camera
+  for(entityid_t camIndex = 0; camIndex < camCount; camIndex++) {
+    entityid_t camEnt = camEnts[camIndex];
+    componentid_t camComp = camComps[camIndex];
+    componentid_t camPos = entityGetComponent(camEnt, COMPONENT_TYPE_POSITION);
+    if(camPos == 0xFF) {
+      logError("Camera entity without entity position found\n");
+      continue;
+    }
 
-    if(meshCount > 0) {
-      errorChain(shaderBind(&SHADER_UNLIT));
+    entityCameraGetProjection(camEnt, camComp, proj);
+    entityPositionGetTransform(camEnt, camPos, view);
 
-      // For each camera.
-      for(entityid_t camIndex = 0; camIndex < camCount; camIndex++) {
-        entityid_t camEnt = camEnts[camIndex];
-        componentid_t camComp = camComps[camIndex];
-        componentid_t camPos = entityGetComponent(camEnt, COMPONENT_TYPE_POSITION);
-        if(camPos == 0xFF) {
-          logError("Camera entity without entity position found\n");
+    // For each entity
+    for(entityid_t entityId = 0; entityId < ENTITY_COUNT_MAX; entityId++) {
+      // Does this entity have a material?
+      componentid_t matComp = entityGetComponent(
+        entityId, COMPONENT_TYPE_MATERIAL
+      );
+      if(matComp != 0xFF) {
+        // Yes, get the mesh
+        componentid_t meshComp = entityGetComponent(
+          entityId, COMPONENT_TYPE_MESH
+        );
+
+        if(meshComp == 0xFF) {
+          logError("Entity with material component without mesh component found\n");
           continue;
         }
 
-        entityCameraGetProjection(camEnt, camComp, proj);
-        entityPositionGetTransform(camEnt, camPos, view);
-
-        // For each mesh.
-        for(entityid_t meshIndex = 0; meshIndex < meshCount; meshIndex++) {
-          entityid_t meshEnt = meshEnts[meshIndex];
-
-          componentid_t meshComp = meshComps[meshIndex];
-          mesh_t *mesh = entityMeshGetMesh(meshEnt, meshComp);
-          if(mesh == NULL) {
-            continue;
-          }
-
-          componentid_t meshPos = entityGetComponent(
-            meshEnt, COMPONENT_TYPE_POSITION
-          );
-          if(meshPos == 0xFF) {
-            logError("Mesh entity without entity position found\n");
-            continue;
-          }
-
-          componentid_t meshMat = entityGetComponent(
-            meshEnt, COMPONENT_TYPE_MATERIAL
-          );
-          if(meshMat == 0xFF) {
-            logError("Mesh entity without material component found\n");
-            continue;
-          }
-
-          shadermaterial_t *material = entityMaterialGetShaderMaterial(
-            meshEnt, meshMat
-          );
-          shader_t *shader = entityMaterialGetShader(meshEnt, meshMat);
-          if(shader == NULL) {
-            logError("Mesh entity with material component without shader found\n");
-            continue;
-          }
-
-          entityPositionGetTransform(meshEnt, meshPos, model);
-
-          errorChain(shaderBind(shader));
-          errorChain(shaderSetMatrix(shader, SHADER_UNLIT_PROJECTION, proj));
-          errorChain(shaderSetMatrix(shader, SHADER_UNLIT_VIEW, view));
-          errorChain(shaderSetMatrix(shader, SHADER_UNLIT_MODEL, model));
-          errorChain(shaderSetMaterial(shader, material));
-          errorChain(meshDraw(mesh, 0, -1));
+        // Yes, get the material and shader.
+        shadermaterial_t *material = entityMaterialGetShaderMaterial(
+          entityId, matComp
+        );
+        shader_t *shader = entityMaterialGetShader(entityId, matComp);
+        if(shader == NULL) {
+          logError("Entity with material component without shader found\n");
+          continue;
         }
+
+        // Get the mesh
+        mesh_t *mesh = entityMeshGetMesh(entityId, meshComp);
+        if(mesh == NULL) {
+          logError("Entity with material component without mesh found\n");
+          continue;
+        }
+
+        // Get the transform.
+        componentid_t meshPos = entityGetComponent(
+          entityId, COMPONENT_TYPE_POSITION
+        );
+        if(meshPos == 0xFF) {
+          glm_mat4_identity(model);
+        } else {
+          entityPositionGetTransform(entityId, meshPos, model);
+        }
+
+        // Render the mesh.
+        errorChain(shaderBind(shader));
+        errorChain(shaderSetMatrix(shader, SHADER_UNLIT_PROJECTION, proj));
+        errorChain(shaderSetMatrix(shader, SHADER_UNLIT_VIEW, view));
+        errorChain(shaderSetMatrix(shader, SHADER_UNLIT_MODEL, model));
+        errorChain(shaderSetMaterial(shader, material));
+        errorChain(meshDraw(mesh, 0, -1));
+        continue;
       }
+
+      // No, in future there may be other renderable types.
     }
   }
 
-  // Here is where UI will go
-  glm_ortho(
-    0.0f, SCREEN.width,
-    SCREEN.height, 0.0f,
-    0.1f, 100.0f,
-    proj
-  );
-  glm_lookat(
-    (vec3){ 0.0f, 0.0f, 1.0f },
-    (vec3){ 0.0f, 0.0f, 0.0f },
-    (vec3){ 0.0f, 1.0f, 0.0f },
-    view
-  );
-  glm_mat4_identity(model);
-
-  errorChain(shaderBind(&SHADER_UNLIT));
-  errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_PROJECTION, proj));
-  errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_VIEW, view));
-  errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_MODEL, model));
-  errorChain(consoleDraw());
-
   errorOk();
+
+  // if(camCount > 0) {
+  //   // For each entity
+  //   for(entityid_t entityId = 0; entityId < ENTITY_COUNT_MAX; entityId++) {
+      
+  //   }
+
+  //   entityid_t meshEnts[ENTITY_COUNT_MAX];
+  //   componentid_t meshComps[ENTITY_COUNT_MAX];
+  //   entityid_t meshCount = componentGetEntitiesWithComponent(
+  //     COMPONENT_TYPE_MESH, meshEnts, meshComps
+  //   );
+
+  //   if(meshCount > 0) {
+  //     errorChain(shaderBind(&SHADER_UNLIT));
+
+  //     for(entityid_t camIndex = 0; camIndex < camCount; camIndex++) {
+  //       entityid_t camEnt = camEnts[camIndex];
+  //       componentid_t camComp = camComps[camIndex];
+  //       componentid_t camPos = entityGetComponent(camEnt, COMPONENT_TYPE_POSITION);
+  //       if(camPos == 0xFF) {
+  //         logError("Camera entity without entity position found\n");
+  //         continue;
+  //       }
+
+  //       entityCameraGetProjection(camEnt, camComp, proj);
+  //       entityPositionGetTransform(camEnt, camPos, view);
+
+  //       for(entityid_t meshIndex = 0; meshIndex < meshCount; meshIndex++) {
+  //         entityid_t meshEnt = meshEnts[meshIndex];
+  //         componentid_t meshComp = meshComps[meshIndex];
+  //         mesh_t *mesh = entityMeshGetMesh(meshEnt, meshComp);
+  //         if(mesh == NULL) continue;
+
+  //         componentid_t meshPos = entityGetComponent(
+  //           meshEnt, COMPONENT_TYPE_POSITION
+  //         );
+  //         if(meshPos == 0xFF) {
+  //           logError("Mesh entity without entity position found\n");
+  //           continue;
+  //         }
+
+  //         componentid_t meshMat = entityGetComponent(
+  //           meshEnt, COMPONENT_TYPE_MATERIAL
+  //         );
+  //         if(meshMat == 0xFF) {
+  //           logError("Mesh entity without material component found\n");
+  //           continue;
+  //         }
+
+  //         shadermaterial_t *material = entityMaterialGetShaderMaterial(
+  //           meshEnt, meshMat
+  //         );
+  //         shader_t *shader = entityMaterialGetShader(meshEnt, meshMat);
+  //         if(shader == NULL) {
+  //           logError("Mesh entity with material component without shader found\n");
+  //           continue;
+  //         }
+
+  //         entityPositionGetTransform(meshEnt, meshPos, model);
+
+  //         errorChain(shaderBind(shader));
+  //         errorChain(shaderSetMatrix(shader, SHADER_UNLIT_PROJECTION, proj));
+  //         errorChain(shaderSetMatrix(shader, SHADER_UNLIT_VIEW, view));
+  //         errorChain(shaderSetMatrix(shader, SHADER_UNLIT_MODEL, model));
+  //         errorChain(shaderSetMaterial(shader, material));
+  //         errorChain(meshDraw(mesh, 0, -1));
+  //       }
+  //     }
+  //   }
+  // }
+
+  // glm_ortho(
+  //   0.0f, SCREEN.width,
+  //   SCREEN.height, 0.0f,
+  //   0.1f, 100.0f,
+  //   proj
+  // );
+  // glm_lookat(
+  //   (vec3){ 0.0f, 0.0f, 1.0f },
+  //   (vec3){ 0.0f, 0.0f, 0.0f },
+  //   (vec3){ 0.0f, 1.0f, 0.0f },
+  //   view
+  // );
+  // glm_mat4_identity(model);
+
+  // errorChain(shaderBind(&SHADER_UNLIT));
+  // errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_PROJECTION, proj));
+  // errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_VIEW, view));
+  // errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_MODEL, model));
+
+  // {
+  //   entityid_t sprEnts[ENTITY_COUNT_MAX];
+  //   componentid_t sprComps[ENTITY_COUNT_MAX];
+  //   entityid_t sprCount = componentGetEntitiesWithComponent(
+  //     COMPONENT_TYPE_SPRITE, sprEnts, sprComps
+  //   );
+  //   for(entityid_t si = 0; si < sprCount; si++) {
+  //     entitysprite_t *spr = entitySpriteGet(sprEnts[si], sprComps[si]);
+  //     vec3 pos = { 0.0f, 0.0f, 0.0f };
+  //     componentid_t posComp = entityGetComponent(
+  //       sprEnts[si], COMPONENT_TYPE_POSITION
+  //     );
+  //     if(posComp != 0xFF) {
+  //       entityPositionGetPosition(sprEnts[si], posComp, pos);
+  //     }
+  //     errorChain(shaderSetTexture(
+  //       &SHADER_UNLIT, SHADER_UNLIT_TEXTURE, spr->texture
+  //     ));
+  //     #if !MESH_ENABLE_COLOR
+  //       errorChain(shaderSetColor(
+  //         &SHADER_UNLIT, SHADER_UNLIT_COLOR, spr->color
+  //       ));
+  //     #endif
+  //     errorChain(spriteBatchPush(
+  //       pos[0], pos[1],
+  //       pos[0] + spr->width, pos[1] + spr->height,
+  //       #if MESH_ENABLE_COLOR
+  //         spr->color,
+  //       #endif
+  //       spr->uv[0], spr->uv[1],
+  //       spr->uv[2], spr->uv[3]
+  //     ));
+  //     errorChain(spriteBatchFlush());
+  //   }
+  // }
+
+  // errorChain(consoleDraw());
+
+  // // FPS
+  // char_t fpsText[32];
+
+  // dusktimeepoch_t now = timeGetEpoch();
+  // double_t delta = now.time - LAST.time;
+  // LAST = now;
+  // double_t fps = delta > 0 ? 1.0 / delta : 0.0;
+  // snprintf(fpsText, sizeof(fpsText), "FPS: %.2f", fps);
+
+  // errorChain(spriteBatchFlush());
+  // errorChain(textDraw(
+  //   0, 0,
+  //   fpsText, COLOR_WHITE,
+  //   &FONT_TILESET_DEFAULT, &FONT_TEXTURE_DEFAULT
+  // ));
+  // errorChain(spriteBatchFlush());
+
+  // errorOk();
 }
 
-errorret_t sceneSetImmediate(const char_t *script) {
-  // Update the next scene name (shouldn't really happen but its for safety).
-  if(script != SCENE.sceneNext) {
+errorret_t sceneSetImmediate(const char_t *scene) {
+  if(scene != SCENE.sceneNext) {
     stringCopy(
       SCENE.sceneNext,
-      script == NULL ? "" : script,
+      scene == NULL ? "" : scene,
       ASSET_FILE_PATH_MAX
     );
   }
 
-  // If there's currently a scene active, dispose of it first.
-  if(SCENE.scriptActive) {
-    assertNotNull(SCENE.script.luaState, "Script context null?");
-    
-    // Call sceneDispose function
-    lua_getglobal(SCENE.script.luaState, "sceneDispose");
-    if(lua_isfunction(SCENE.script.luaState, -1)) {
-      if(lua_pcall(SCENE.script.luaState, 0, 0, 0) != LUA_OK) {
-        errorThrow(
-          "Failed to call sceneDispose function in script: %s\n",
-          lua_tostring(SCENE.script.luaState, -1)
-        );
-      }
-    }
-    
-    // Scenes should ideally clean themselves up, this is just a warning because
-    // you can technically move entities between scenes, but it's messy.
-    for(entityid_t i = 0; i < ENTITY_COUNT_MAX; i++) {
-      if(ENTITY_MANAGER.entities[i].state & ENTITY_STATE_ACTIVE) {
-        consolePrint(
-          "Entity %d is active after scene dispose\n", i
-        );
-      }
-    }
-
-    // Unload script context.
-    scriptContextDispose(&SCENE.script);
-    SCENE.scriptActive = false;
+  if(SCENE.sceneActive) {
+    errorChain(moduleSceneCall("dispose"));
+    SCENE.sceneActive = false;
   }
 
-  // At this point the existing scene is unloaded, update the current scene.
+  moduleSceneReset();
+
   stringCopy(
     SCENE.sceneCurrent,
-    script == NULL ? "" : script,
+    scene == NULL ? "" : scene,
     ASSET_FILE_PATH_MAX
   );
 
-  // If we have a new scene, execute it.
-  if(script != NULL) {
-    errorChain(scriptContextInit(&SCENE.script));
-    SCENE.scriptActive = true;
-    errorChain(scriptContextExecFile(&SCENE.script, script));
+  if(scene != NULL) {
+    jerry_value_t sceneClass = SCENE_SCRIPT_REF_NONE;
+    errorChain(scriptManagerExecFile(scene, &sceneClass));
 
-    // Call the init function.
-    lua_getglobal(SCENE.script.luaState, "sceneInit");
-    if(lua_isfunction(SCENE.script.luaState, -1)) {
-      if(lua_pcall(SCENE.script.luaState, 0, 0, 0) != LUA_OK) {
-        errorThrow(
-          "Failed to call sceneInit function in script: %s\n",
-          lua_tostring(SCENE.script.luaState, -1)
-        );
-      }
+    if(!jerry_value_is_function(sceneClass)) {
+      if(sceneClass != SCENE_SCRIPT_REF_NONE) jerry_value_free(sceneClass);
+      errorThrow("Scene '%s' must export a constructor function", scene);
     }
+
+    jerry_value_t sceneObj = jerry_construct(sceneClass, NULL, 0);
+    jerry_value_free(sceneClass);
+
+    if(jerry_value_is_exception(sceneObj)) {
+      char_t errMsg[512];
+      moduleBaseExceptionMessage(sceneObj, errMsg, sizeof(errMsg));
+      jerry_value_free(sceneObj);
+      errorThrow("Scene '%s' constructor threw: %s", scene, errMsg);
+    }
+
+    SCENE.scriptRef = sceneObj;
+    SCENE.sceneActive = true;
   }
 
   errorOk();
 }
 
-void sceneSet(const char_t *script) {
-  // Tell the scene that next update it needs to change scenes. This will always
-  // occur on the NEXT frame.
+void sceneSet(const char_t *scene) {
   stringCopy(
     SCENE.sceneNext,
-    script == NULL ? "" : script,
+    scene == NULL ? "" : scene,
     ASSET_FILE_PATH_MAX
   );
 }
 
 errorret_t sceneDispose(void) {
-  errorChain(sceneSetImmediate(NULL));
+  errorChain(moduleSceneCall("dispose"));
   errorOk();
-}
+}

src/dusk/scene/scene.h

@@ -1,61 +1,68 @@
 /**
  * Copyright (c) 2026 Dominic Masters
- * 
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
 
 #pragma once
-#include "script/scriptcontext.h"
+#include "script/scriptmanager.h"
 #include "asset/assetfile.h"
+#include "event/event.h"
+
+#define SCENE_EVENT_UPDATE_MAX 16
 
 typedef struct {
-  scriptcontext_t script;
-  bool_t scriptActive;
+  bool_t sceneActive;
+  jerry_value_t scriptRef;
   char_t sceneCurrent[ASSET_FILE_PATH_MAX];
   char_t sceneNext[ASSET_FILE_PATH_MAX];
 } scene_t;
 
 extern scene_t SCENE;
 
+/** Sentinel value meaning no scene script is loaded. */
+#define SCENE_SCRIPT_REF_NONE ((jerry_value_t)0)
+
 /**
- * Initialize the scene subsystem.
- * 
- * @return The error return value.
+ * Initializes the scene manager.
+ *
+ * @return Any error state that happened.
  */
 errorret_t sceneInit(void);
 
 /**
- * Update the current scene.
- * 
- * @return The error return value.
+ * Ticks the scene manager; may call the scene's update method.
+ *
+ * @return Any error state that happened.
  */
 errorret_t sceneUpdate(void);
 
 /**
- * Render the current scene.
- * 
- * @return The error return value.
+ * Renders the scene.
+ *
+ * @return Any error state that happened.
  */
 errorret_t sceneRender(void);
 
 /**
- * Internal only method, immediately sets the scene. This will basically crash
- * Lua if called from its tree.
+ * Immediately switches scenes, disposing the current one first.
+ *
+ * @param scene Scene to switch to (asset file path).
+ * @return Any error state that happened.
  */
-errorret_t sceneSetImmediate(const char_t *script);
+errorret_t sceneSetImmediate(const char_t *scene);
 
 /**
- * Set the current scene by script name.
- * 
- * @param script The script name of the scene to set.
- * @return The error return value.
+ * Requests a scene change on the next safe opportunity.
+ *
+ * @param scene Which scene to set.
  */
-void sceneSet(const char_t *script);
+void sceneSet(const char_t *scene);
 
 /**
- * Dispose of the scene subsystem.
- * 
- * @return The error return value.
+ * Disposes of the current scene.
+ *
+ * @return Any error state that happened.
  */
-errorret_t sceneDispose(void);
+errorret_t sceneDispose(void);

src/dusk/script/CMakeLists.txt

@@ -7,9 +7,7 @@
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     scriptmanager.c
-    scriptcontext.c
-    scriptmodule.c
+    scriptproto.c
 )
 
-# Subdirectories
-add_subdirectory(module)
+# Subdirectories

src/dusk/script/module/CMakeLists.txt

@@ -1,15 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Subdirectories
-add_subdirectory(display)
-add_subdirectory(entity)
-add_subdirectory(event)
-add_subdirectory(input)
-add_subdirectory(locale)
-add_subdirectory(system)
-add_subdirectory(scene)
-add_subdirectory(time)
-add_subdirectory(ui)

src/dusk/script/module/console/moduleconsole.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "script/module/modulebase.h"
+#include "script/scriptproto.h"
+#include "console/console.h"
+
+static scriptproto_t MODULE_CONSOLE_PROTO;
+
+moduleBaseFunction(moduleConsolePrint) {
+  char_t buf[512];
+  char_t msg[4096];
+  size_t msgLen = 0;
+
+  for(jerry_length_t i = 0; i < argc; ++i) {
+    jerry_value_t strVal = jerry_value_to_string(args[i]);
+    moduleBaseToString(strVal, buf, sizeof(buf));
+    jerry_value_free(strVal);
+
+    size_t partLen = strlen(buf);
+    if(msgLen + partLen + 1 < sizeof(msg)) {
+      stringCopy(msg + msgLen, buf, sizeof(msg) - msgLen);
+      msgLen += partLen;
+    }
+
+    if(i + 1 < argc && msgLen + 1 < sizeof(msg)) {
+      msg[msgLen++] = '\t';
+      msg[msgLen] = '\0';
+    }
+  }
+
+  consolePrint("%s", msg);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleConsoleGetVisible) {
+  return jerry_boolean(CONSOLE.visible);
+}
+
+moduleBaseFunction(moduleConsoleSetVisible) {
+  moduleBaseRequireArgs(1);
+  if(!jerry_value_is_boolean(args[0])) {
+    return moduleBaseThrow("Console.visible: expected boolean");
+  }
+  CONSOLE.visible = jerry_value_is_true(args[0]);
+  return jerry_undefined();
+}
+
+static void moduleConsole(void) {
+  scriptProtoInit(
+    &MODULE_CONSOLE_PROTO, "Console",
+    sizeof(uint8_t), NULL
+  );
+
+  scriptProtoDefineStaticFunc(
+    &MODULE_CONSOLE_PROTO, "print", moduleConsolePrint
+  );
+  scriptProtoDefineStaticProp(
+    &MODULE_CONSOLE_PROTO, "visible",
+    moduleConsoleGetVisible, moduleConsoleSetVisible
+  );
+}

src/dusk/script/module/display/CMakeLists.txt

@@ -1,18 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Sources
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    moduleglm.c
-    modulespritebatch.c
-    moduleglm.c
-    modulecolor.c
-    moduletext.c
-    modulescreen.c
-    moduletileset.c
-    moduletexture.c
-    moduleshader.c
-)

src/dusk/script/module/display/modulecolor.c

@@ -1,186 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "modulecolor.h"
-#include "display/color.h"
-#include "assert/assert.h"
-#include "util/string.h"
-#include "time/time.h"
-
-void moduleColor(scriptcontext_t *context) {
-  assertNotNull(context, "Context cannot be NULL.");
-
-  if(luaL_newmetatable(context->luaState, "color_mt")) {
-    // Metatable is new, set __index and __newindex
-    lua_pushstring(context->luaState, "__index");
-    lua_pushcfunction(context->luaState, moduleColorIndex);
-    lua_settable(context->luaState, -3);
-
-    lua_pushstring(context->luaState, "__newindex");
-    lua_pushcfunction(context->luaState, moduleColorNewIndex);
-    lua_settable(context->luaState, -3);
-
-    lua_pushstring(context->luaState, "__tostring");
-    lua_pushcfunction(context->luaState, moduleColorToString);
-    lua_settable(context->luaState, -3);
-  }
-  lua_pop(context->luaState, 1);
-
-  lua_register(context->luaState, "color", moduleColorFuncColor);
-  lua_register(context->luaState, "colorRainbow", moduleColorRainbow);
-
-  scriptContextExec(context, COLOR_SCRIPT);
-}
-
-int moduleColorFuncColor(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL.");
-
-  scriptcontext_t *context = *(scriptcontext_t **)lua_getextraspace(L);
-  assertNotNull(context, "Script context cannot be NULL.");
-
-  // Needs 4 channel uint8_t
-  if(
-    !lua_isnumber(L, 1) || !lua_isnumber(L, 2) ||
-    !lua_isnumber(L, 3) || !lua_isnumber(L, 4)
-  ) {
-    return luaL_error(L, "color(r, g, b, a) requires four number arguments.");
-  }
-
-  colorchannel8_t r = (colorchannel8_t)lua_tonumber(L, 1);
-  colorchannel8_t g = (colorchannel8_t)lua_tonumber(L, 2);
-  colorchannel8_t b = (colorchannel8_t)lua_tonumber(L, 3);
-  colorchannel8_t a = (colorchannel8_t)lua_tonumber(L, 4);
-
-  // Create color_t as lua memory, and push metatable
-  color_t *color = (color_t *)lua_newuserdata(L, sizeof(color_t));
-  luaL_getmetatable(L, "color_mt");
-  lua_setmetatable(L, -2);
-
-  // Initial values.
-  color->r = r;
-  color->g = g;
-  color->b = b;
-  color->a = a;
-
-  return 1;
-}
-
-int moduleColorIndex(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL.");
-
-  const char_t *key = lua_tostring(L, 2);
-  assertStrLenMin(key, 1, "Key cannot be empty.");
-
-  const color_t *color = (const color_t*)luaL_checkudata(L, 1, "color_mt");
-  assertNotNull(color, "Color struct cannot be NULL.");
-  
-  if(stringCompare(key, "r") == 0) {
-    lua_pushnumber(L, color->r);
-    return 1;
-  }
-  if(stringCompare(key, "g") == 0) {
-    lua_pushnumber(L, color->g);
-    return 1;
-  }
-  if(stringCompare(key, "b") == 0) {
-    lua_pushnumber(L, color->b);
-    return 1;
-  }
-  if(stringCompare(key, "a") == 0) {
-    lua_pushnumber(L, color->a);
-    return 1;
-  }
-
-  lua_pushnil(L);
-  return 1;
-}
-
-int moduleColorNewIndex(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL.");
-
-  const char_t *key = lua_tostring(L, 2);
-  assertStrLenMin(key, 1, "Key cannot be empty.");
-
-  color_t *color = (color_t*)luaL_checkudata(L, 1, "color_mt");
-  assertNotNull(color, "Color struct cannot be NULL.");
-
-  if(stringCompare(key, "r") == 0) {
-    if(!lua_isnumber(L, 3)) {
-      return luaL_error(L, "color channel r must be a number.");
-    }
-    color->r = (colorchannel8_t)lua_tonumber(L, 3);
-    return 0;
-  } else if(stringCompare(key, "g") == 0) {
-    if(!lua_isnumber(L, 3)) {
-      return luaL_error(L, "color channel g must be a number.");
-    }
-    color->g = (colorchannel8_t)lua_tonumber(L, 3);
-    return 0;
-  } else if(stringCompare(key, "b") == 0) {
-    if(!lua_isnumber(L, 3)) {
-      return luaL_error(L, "color channel b must be a number.");
-    }
-    color->b = (colorchannel8_t)lua_tonumber(L, 3);
-    return 0;
-  } else if(stringCompare(key, "a") == 0) {
-    if(!lua_isnumber(L, 3)) {
-      return luaL_error(L, "color channel a must be a number.");
-    }
-    color->a = (colorchannel8_t)lua_tonumber(L, 3);
-    return 0;
-  }
-
-  return 0;
-}
-
-int moduleColorToString(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL.");
-
-  const color_t *color = (const color_t*)luaL_checkudata(L, 1, "color_mt");
-  assertNotNull(color, "Color struct cannot be NULL.");
-
-  lua_pushfstring(
-    L, "color(r=%d, g=%d, b=%d, a=%d)",
-    color->r, color->g, color->b, color->a
-  );
-
-  return 1;
-}
-
-int moduleColorRainbow(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL.");
-
-  // Allow time offset
-  float_t t = TIME.time;
-  if(lua_gettop(L) >= 1) {
-    if(!lua_isnumber(L, 1)) {
-      return luaL_error(L, "Rainbow time offset must be a number.");
-    }
-    t += (float_t)lua_tonumber(L, 1);
-  }
-
-  // Allow speed multiplier
-  if(lua_gettop(L) >= 2) {
-    if(!lua_isnumber(L, 2)) {
-      return luaL_error(L, "Rainbow speed multiplier must be a number.");
-    }
-    t *= (float_t)lua_tonumber(L, 2);
-  }
-
-  // Generate rainbow based on time.
-  color_t *color = (color_t *)lua_newuserdata(L, sizeof(color_t));
-  color->r = (colorchannel8_t)((sinf(t) + 1.0f) * 0.5f * 255.0f);
-  color->g = (colorchannel8_t)((sinf(t + 2.0f) + 1.0f) * 0.5f * 255.0f);
-  color->b = (colorchannel8_t)((sinf(t + 4.0f) + 1.0f) * 0.5f * 255.0f);
-  color->a = 255;
-
-  // Set metatable
-  luaL_getmetatable(L, "color_mt");
-  lua_setmetatable(L, -2);
-
-  return 1;
-}

src/dusk/script/module/display/modulecolor.h

@@ -1,55 +1,158 @@
 /**
  * Copyright (c) 2026 Dominic Masters
- * 
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
 
 #pragma once
-#include "script/scriptcontext.h"
+#include "script/module/modulebase.h"
+#include "display/color.h"
+#include "time/time.h"
+#include "script/scriptproto.h"
 
-/**
- * Registers the color module with the given script context.
- * 
- * @param context The script context to register the module with.
- */
-void moduleColor(scriptcontext_t *context);
+static scriptproto_t MODULE_COLOR_PROTO;
 
-/**
- * Lua function to create a color.
- * 
- * @param L The Lua state.
- * @return Number of return values.
- */
-int moduleColorFuncColor(lua_State *L);
+static inline color_t * moduleColorGet(
+  const jerry_call_info_t *callInfo
+) {
+  return (color_t*)scriptProtoGetValue(
+    &MODULE_COLOR_PROTO, callInfo->this_value
+  );
+}
 
-/**
- * Index function for the color structure.
- * @param L The Lua state.
- * @return Number of return values.
- */
-int moduleColorIndex(lua_State *L);
+moduleBaseFunction(moduleColorGetR) {
+  color_t *c = moduleColorGet(callInfo);
+  return c ? jerry_number(c->r) : jerry_undefined();
+}
 
-/**
- * New index function for the color structure.
- * 
- * @param L The Lua state.
- * @return Number of return values.
- */
-int moduleColorNewIndex(lua_State *L);
+moduleBaseFunction(moduleColorGetG) {
+  color_t *c = moduleColorGet(callInfo);
+  return c ? jerry_number(c->g) : jerry_undefined();
+}
 
-/**
- * Color to string method for script
- * 
- * @param L The Lua state.
- * @return Number of return values.
- */
-int moduleColorToString(lua_State *L);
+moduleBaseFunction(moduleColorGetB) {
+  color_t *c = moduleColorGet(callInfo);
+  return c ? jerry_number(c->b) : jerry_undefined();
+}
 
-/**
- * Lua function to create a rainbow color based on time.
- * 
- * @param L The Lua state.
- * @return Number of return values.
- */
-int moduleColorRainbow(lua_State *L);
+moduleBaseFunction(moduleColorGetA) {
+  color_t *c = moduleColorGet(callInfo);
+  return c ? jerry_number(c->a) : jerry_undefined();
+}
+
+moduleBaseFunction(moduleColorSetR) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  color_t *c = moduleColorGet(callInfo);
+  if(!c) return jerry_undefined();
+  c->r = (colorchannel8_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleColorSetG) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  color_t *c = moduleColorGet(callInfo);
+  if(!c) return jerry_undefined();
+  c->g = (colorchannel8_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleColorSetB) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  color_t *c = moduleColorGet(callInfo);
+  if(!c) return jerry_undefined();
+  c->b = (colorchannel8_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleColorSetA) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  color_t *c = moduleColorGet(callInfo);
+  if(!c) return jerry_undefined();
+  c->a = (colorchannel8_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleColorToString) {
+  color_t *c = moduleColorGet(callInfo);
+  if(!c) return jerry_undefined();
+  char_t buf[64];
+  stringFormat(
+    buf, sizeof(buf),
+    "{ \"r\": %d, \"g\": %d, \"b\": %d, \"a\": %d }",
+    (int32_t)c->r, (int32_t)c->g,
+    (int32_t)c->b, (int32_t)c->a
+  );
+  return jerry_string_sz(buf);
+}
+
+static jerry_value_t moduleColorMakeObject(color_t color) {
+  return scriptProtoCreateValue(&MODULE_COLOR_PROTO, &color);
+}
+
+moduleBaseFunction(moduleColorConstructor) {
+  if(argc > 0 && !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Color: r must be a number");
+  }
+  if(argc > 1 && !jerry_value_is_number(args[1])) {
+    return moduleBaseThrow("Color: g must be a number");
+  }
+  if(argc > 2 && !jerry_value_is_number(args[2])) {
+    return moduleBaseThrow("Color: b must be a number");
+  }
+  if(argc > 3 && !jerry_value_is_number(args[3])) {
+    return moduleBaseThrow("Color: a must be a number");
+  }
+  color_t c;
+  c.r = argc > 0 ? (colorchannel8_t)jerry_value_as_number(args[0]) : 255;
+  c.g = argc > 1 ? (colorchannel8_t)jerry_value_as_number(args[1]) : 255;
+  c.b = argc > 2 ? (colorchannel8_t)jerry_value_as_number(args[2]) : 255;
+  c.a = argc > 3 ? (colorchannel8_t)jerry_value_as_number(args[3]) : 255;
+  return moduleColorMakeObject(c);
+}
+
+moduleBaseFunction(moduleColorRainbow) {
+  float_t t;
+
+  if(argc >= 1 && jerry_value_is_number(args[0])) {
+    t = (float_t)jerry_value_as_number(args[0]);
+  } else {
+    t = TIME.time * 4.0f;
+  }
+
+  if(argc >= 2 && jerry_value_is_number(args[1])) {
+    t *= (float_t)jerry_value_as_number(args[1]);
+  }
+
+  color_t c;
+  c.r = (colorchannel8_t)((sinf(t) + 1.0f) * 0.5f * 255.0f);
+  c.g = (colorchannel8_t)((sinf(t + 2.0f) + 1.0f) * 0.5f * 255.0f);
+  c.b = (colorchannel8_t)((sinf(t + 4.0f) + 1.0f) * 0.5f * 255.0f);
+  c.a = 255;
+  return moduleColorMakeObject(c);
+}
+
+static void moduleColor(void) {
+  scriptProtoInit(
+    &MODULE_COLOR_PROTO, "Color", sizeof(color_t), moduleColorConstructor
+  );
+
+  scriptProtoDefineProp(
+    &MODULE_COLOR_PROTO, "r", moduleColorGetR, moduleColorSetR
+  );
+  scriptProtoDefineProp(
+    &MODULE_COLOR_PROTO, "g", moduleColorGetG, moduleColorSetG
+  );
+  scriptProtoDefineProp(
+    &MODULE_COLOR_PROTO, "b", moduleColorGetB, moduleColorSetB
+  );
+  scriptProtoDefineProp(
+    &MODULE_COLOR_PROTO, "a", moduleColorGetA, moduleColorSetA
+  );
+
+  scriptProtoDefineStaticFunc(
+    &MODULE_COLOR_PROTO, "rainbow", moduleColorRainbow
+  );
+  scriptProtoDefineToString(&MODULE_COLOR_PROTO, moduleColorToString);
+  moduleBaseEval(COLOR_SCRIPT);
+}

src/dusk/script/module/display/moduleglm.c

@@ -1,283 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleglm.h"
-#include "assert/assert.h"
-#include "util/string.h"
-#include "util/memory.h"
-
-void moduleGLM(scriptcontext_t *context) {
-  assertNotNull(context, "Context cannot be NULL.");
-
-  // Create metatable for vec3 structure.
-  if(luaL_newmetatable(context->luaState, "vec3_mt")) {
-    // Metatable methods
-    lua_pushcfunction(context->luaState, moduleVec3Index);
-    lua_setfield(context->luaState, -2, "__index");
-    lua_pushcfunction(context->luaState, moduleVec3NewIndex);
-    lua_setfield(context->luaState, -2, "__newindex");
-    lua_pushcfunction(context->luaState, moduleVec3ToString);
-    lua_setfield(context->luaState, -2, "__tostring");
-  }
-  lua_pop(context->luaState, 1);
-
-  if(luaL_newmetatable(context->luaState, "vec4_mt")) {
-    // Metatable methods
-    lua_pushcfunction(context->luaState, moduleVec4Index);
-    lua_setfield(context->luaState, -2, "__index");
-    lua_pushcfunction(context->luaState, moduleVec4NewIndex);
-    lua_setfield(context->luaState, -2, "__newindex");
-    lua_pushcfunction(context->luaState, moduleVec4ToString);
-    lua_setfield(context->luaState, -2, "__tostring");
-  }
-  lua_pop(context->luaState, 1);
-
-  lua_register(context->luaState, "vec3", moduleVec3Create);
-}
-
-
-int moduleVec3Create(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  vec3 *v = (vec3 *)lua_newuserdata(l, sizeof(vec3));
-  memoryZero(v, sizeof(vec3));
-
-  // May be expecting between 1 and 3 values.
-  int top = lua_gettop(l);
-  if(top >= 1) {
-    if(!lua_isnumber(l, 1)) {
-      luaL_error(l, "Vec3 x component must be a number.");
-    }
-    (*v)[0] = (float_t)lua_tonumber(l, 1);
-  }
-  if(top >= 2) {
-    if(!lua_isnumber(l, 2)) {
-      luaL_error(l, "Vec3 y component must be a number.");
-    }
-    (*v)[1] = (float_t)lua_tonumber(l, 2);
-  }
-  if(top >= 3) {
-    if(!lua_isnumber(l, 3)) {
-      luaL_error(l, "Vec3 z component must be a number.");
-    }
-    (*v)[2] = (float_t)lua_tonumber(l, 3);
-  }
-
-  // Set metatable
-  luaL_getmetatable(l, "vec3_mt");
-  lua_setmetatable(l, -2);
-
-  return 1;
-}
-
-int moduleVec3Index(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  const char_t *key = lua_tostring(l, 2);
-  assertStrLenMin(key, 1, "Key cannot be empty.");
-
-  vec3 *vec = (vec3 *)luaL_checkudata(l, 1, "vec3_mt");
-  assertNotNull(vec, "Vec3 pointer cannot be NULL.");
-
-  if(stringCompare(key, "x") == 0) {
-    lua_pushnumber(l, (*vec)[0]);
-    return 1;
-  } else if(stringCompare(key, "y") == 0) {
-    lua_pushnumber(l, (*vec)[1]);
-    return 1;
-  } else if(stringCompare(key, "z") == 0) {
-    lua_pushnumber(l, (*vec)[2]);
-    return 1;
-  }
-}
-
-int moduleVec3NewIndex(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  const char_t *key = luaL_checkstring(l, 2);
-  assertStrLenMin(key, 1, "Key cannot be empty.");
-
-  vec3 *vec = (vec3 *)luaL_checkudata(l, 1, "vec3_mt");
-  assertNotNull(vec, "Vec3 pointer cannot be NULL.");
-
-  if(stringCompare(key, "x") == 0) {
-    if(!lua_isnumber(l, 3)) {
-      luaL_error(l, "Vec3 x component must be a number.");
-    }
-    (*vec)[0] = (float_t)lua_tonumber(l, 3);
-    return 0;
-  } else if(stringCompare(key, "y") == 0) {
-    if(!lua_isnumber(l, 3)) {
-      luaL_error(l, "Vec3 y component must be a number.");
-    }
-    (*vec)[1] = (float_t)lua_tonumber(l, 3);
-    return 0;
-  } else if(stringCompare(key, "z") == 0) {
-    if(!lua_isnumber(l, 3)) {
-      luaL_error(l, "Vec3 z component must be a number.");
-    }
-    (*vec)[2] = (float_t)lua_tonumber(l, 3);
-    return 0;
-  }
-
-  luaL_error(l, "Invalid key for vec3: %s", key);
-  return 0;
-}
-
-int moduleVec3ToString(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  vec3 *vec = (vec3 *)luaL_checkudata(l, 1, "vec3_mt");
-  assertNotNull(vec, "Vec3 pointer cannot be NULL.");
-
-  char buf[128];
-  snprintf(
-    buf, sizeof(buf),
-    "vec3(%.3f, %.3f, %.3f)",
-    (*vec)[0], (*vec)[1], (*vec)[2]
-  );
-  lua_pushstring(l, buf);
-
-  return 1;
-}
-
-
-
-int moduleVec4Create(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  vec4 *v = (vec4 *)lua_newuserdata(l, sizeof(vec4));
-  memoryZero(v, sizeof(vec4));
-
-  // May be expecting between 1 and 4 values.
-  int top = lua_gettop(l);
-  if(top >= 1) {
-    if(!lua_isnumber(l, 1)) {
-      luaL_error(l, "Vec4 x component must be a number.");
-    }
-    (*v)[0] = (float_t)lua_tonumber(l, 1);
-  }
-  if(top >= 2) {
-    if(!lua_isnumber(l, 2)) {
-      luaL_error(l, "Vec4 y component must be a number.");
-    }
-    (*v)[1] = (float_t)lua_tonumber(l, 2);
-  }
-  if(top >= 3) {
-    if(!lua_isnumber(l, 3)) {
-      luaL_error(l, "Vec4 z component must be a number.");
-    }
-    (*v)[2] = (float_t)lua_tonumber(l, 3);
-  }
-  if(top >= 4) {
-    if(!lua_isnumber(l, 4)) {
-      luaL_error(l, "Vec4 w component must be a number.");
-    }
-    (*v)[3] = (float_t)lua_tonumber(l, 4);
-  }
-
-  // Set metatable
-  luaL_getmetatable(l, "vec4_mt");
-  lua_setmetatable(l, -2);
-
-  return 1;
-}
-
-int moduleVec4Index(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  const char_t *key = lua_tostring(l, 2);
-  assertStrLenMin(key, 1, "Key cannot be empty.");
-
-  vec4 *vec = (vec4 *)luaL_checkudata(l, 1, "vec4_mt");
-  assertNotNull(vec, "Vec4 pointer cannot be NULL.");
-
-  if(stringCompare(key, "x") == 0) {
-    lua_pushnumber(l, (*vec)[0]);
-    return 1;
-  } else if(stringCompare(key, "y") == 0) {
-    lua_pushnumber(l, (*vec)[1]);
-    return 1;
-  } else if(stringCompare(key, "z") == 0) {
-    lua_pushnumber(l, (*vec)[2]);
-    return 1;
-  } else if(stringCompare(key, "w") == 0) {
-    lua_pushnumber(l, (*vec)[3]);
-    return 1;
-  } else if(stringCompare(key, "u0") == 0) {
-    lua_pushnumber(l, (*vec)[0]);
-    return 1;
-  } else if(stringCompare(key, "v0") == 0) {
-    lua_pushnumber(l, (*vec)[1]);
-    return 1;
-  } else if(stringCompare(key, "u1") == 0) {
-    lua_pushnumber(l, (*vec)[2]);
-    return 1;
-  } else if(stringCompare(key, "v1") == 0) {
-    lua_pushnumber(l, (*vec)[3]);
-    return 1;
-  }
-
-  lua_pushnil(l);
-  return 1;
-}
-
-int moduleVec4NewIndex(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  const char_t *key = luaL_checkstring(l, 2);
-  assertStrLenMin(key, 1, "Key cannot be empty.");
-
-  vec4 *vec = (vec4 *)luaL_checkudata(l, 1, "vec4_mt");
-  assertNotNull(vec, "Vec4 pointer cannot be NULL.");
-
-  if(stringCompare(key, "x") == 0) {
-    if(!lua_isnumber(l, 3)) {
-      luaL_error(l, "Vec4 x component must be a number.");
-    }
-    (*vec)[0] = (float_t)lua_tonumber(l, 3);
-    return 0;
-  } else if(stringCompare(key, "y") == 0) {
-    if(!lua_isnumber(l, 3)) {
-      luaL_error(l, "Vec4 y component must be a number.");
-    }
-    (*vec)[1] = (float_t)lua_tonumber(l, 3);
-    return 0;
-  } else if(stringCompare(key, "z") == 0) {
-    if(!lua_isnumber(l, 3)) {
-      luaL_error(l, "Vec4 z component must be a number.");
-    }
-    (*vec)[2] = (float_t)lua_tonumber(l, 3);
-    return 0;
-  } else if(stringCompare(key, "w") == 0) {
-    if(!lua_isnumber(l, 3)) {
-      luaL_error(l, "Vec4 w component must be a number.");
-    }
-    (*vec)[3] = (float_t)lua_tonumber(l, 3);
-    return 0;
-  }
-
-  luaL_error(l, "Invalid key for vec4: %s", key);
-  return 0;
-}
-
-int moduleVec4ToString(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  vec4 *vec = (vec4 *)luaL_checkudata(l, 1, "vec4_mt");
-  assertNotNull(vec, "Vec4 pointer cannot be NULL.");
-
-  char buf[128];
-  snprintf(
-    buf, sizeof(buf),
-    "vec4(%.3f, %.3f, %.3f, %.3f)",
-    (*vec)[0], (*vec)[1], (*vec)[2], (*vec)[3]
-  );
-  lua_pushstring(l, buf);
-
-  return 1;
-}

src/dusk/script/module/display/moduleglm.h

@@ -1,80 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-/**
- * Registers the GLM module with the given script context.
- * 
- * @param context The script context to register the module with.
- */
-void moduleGLM(scriptcontext_t *context);
-
-/**
- * Creates a new vec3 structure in Lua.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleVec3Create(lua_State *l);
-
-/**
- * Lua __index metamethod for vec3 structure.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleVec3Index(lua_State *l);
-
-/**
- * Lua __newindex metamethod for vec3 structure.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleVec3NewIndex(lua_State *l);
-
-/**
- * Lua __tostring metamethod for vec3 structure.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleVec3ToString(lua_State *l);
-
-/**
- * Creates a new vec4 structure in Lua.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleVec4Create(lua_State *l);
-
-/**
- * Lua __index metamethod for vec4 structure.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleVec4Index(lua_State *l);
-
-/**
- * Lua __newindex metamethod for vec4 structure.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleVec4NewIndex(lua_State *l);
-
-/**
- * Lua __tostring metamethod for vec4 structure.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleVec4ToString(lua_State *l);

src/dusk/script/module/display/modulescreen.c

@@ -1,43 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "modulescreen.h"
-#include "assert/assert.h"
-#include "display/screen/screen.h"
-
-void moduleScreen(scriptcontext_t *context) {
-  assertNotNull(context, "Context cannot be NULL.");
-
-  lua_register(context->luaState, "screenGetWidth", moduleScreenGetWidth);
-  lua_register(context->luaState, "screenGetHeight", moduleScreenGetHeight);
-  lua_register(context->luaState, "screenSetBackground", moduleScreenSetBackground);
-}
-
-int moduleScreenGetWidth(lua_State *L) {
-  assertNotNull(L, "Lua state is null");
-  lua_pushnumber(L, SCREEN.width);
-  return 1;
-}
-
-int moduleScreenGetHeight(lua_State *L) {
-  assertNotNull(L, "Lua state is null");
-  lua_pushnumber(L, SCREEN.height);
-  return 1;
-}
-
-int moduleScreenSetBackground(lua_State *L) {
-  assertNotNull(L, "Lua state is null");
-  
-  if(!lua_isuserdata(L, 1)) {
-    luaL_error(L, "Screen background color must be a color struct");
-    return 0;
-  }
-
-  color_t *color = (color_t*)luaL_checkudata(L, 1, "color_mt");
-  SCREEN.background = *color;
-  return 0;
-}

src/dusk/script/module/display/modulescreen.h

@@ -1,40 +1,74 @@
 /**
  * Copyright (c) 2026 Dominic Masters
- * 
+ *
  * This software is released under the MIT License.
  * https://opensource.org/licenses/MIT
  */
 
 #pragma once
-#include "script/scriptcontext.h"
+#include "script/module/display/modulecolor.h"
+#include "display/screen/screen.h"
 
-/**
- * Registers the Screen module with the given script context.
- * 
- * @param context The script context to register the module with.
- */
-void moduleScreen(scriptcontext_t *context);
+static scriptproto_t MODULE_SCREEN_PROTO;
 
-/**
- * Gets the current screen width.
- * 
- * @param L The Lua state.
- * @return Count of return values.
- */
-int moduleScreenGetWidth(lua_State *L);
+moduleBaseFunction(moduleScreenGetWidth) {
+  return jerry_number(SCREEN.width);
+}
 
-/**
- * Gets the current screen height.
- * 
- * @param L The Lua state.
- * @return Count of return values.
- */
-int moduleScreenGetHeight(lua_State *L);
+moduleBaseFunction(moduleScreenGetHeight) {
+  return jerry_number(SCREEN.height);
+}
 
-/**
- * Sets the screen background color.
- * 
- * @param L The Lua state.
- * @return Count of return values.
- */
-int moduleScreenSetBackground(lua_State *L);
+moduleBaseFunction(moduleScreenGetAspect) {
+  return jerry_number(SCREEN.aspect);
+}
+
+moduleBaseFunction(moduleScreenGetBackground) {
+  return moduleColorMakeObject(SCREEN.background);
+}
+
+moduleBaseFunction(moduleScreenSetBackground) {
+  if(argc < 1 || !jerry_value_is_object(args[0])) {
+    return moduleBaseThrow("Screen background color must be a color object");
+  }
+  color_t *color = (color_t*)scriptProtoGetValue(
+    &MODULE_COLOR_PROTO, args[0]
+  );
+  if(!color) {
+    return moduleBaseThrow("Background must be a valid color object");
+  }
+  memoryCopy(&SCREEN.background, color, sizeof(color_t));
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleScreenToString) {
+  char_t buf[128];
+  stringFormat(
+    buf, sizeof(buf),
+    "{ \"width\": %d, \"height\": %d, \"aspect\": %.2f }",
+    SCREEN.width, SCREEN.height, SCREEN.aspect
+  );
+  return jerry_string_sz(buf);
+}
+
+static void moduleScreen(void) {
+  scriptProtoInit(
+    &MODULE_SCREEN_PROTO, "Screen", sizeof(screen_t), NULL
+  );
+
+  scriptProtoDefineProp(
+    &MODULE_SCREEN_PROTO, "width", moduleScreenGetWidth, NULL
+  );
+  scriptProtoDefineProp(
+    &MODULE_SCREEN_PROTO, "height", moduleScreenGetHeight, NULL
+  );
+  scriptProtoDefineProp(
+    &MODULE_SCREEN_PROTO, "aspect", moduleScreenGetAspect, NULL
+  );
+  scriptProtoDefineProp(
+    &MODULE_SCREEN_PROTO, "background",
+    moduleScreenGetBackground, moduleScreenSetBackground
+  );
+
+  scriptProtoDefineToString(&MODULE_SCREEN_PROTO, moduleScreenToString);
+}

src/dusk/script/module/display/moduleshader.c

@@ -1,119 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleshader.h"
-#include "assert/assert.h"
-#include "display/shader/shader.h"
-#include "display/shader/shaderunlit.h"
-
-void moduleShader(scriptcontext_t *context) {
-  assertNotNull(context, "Context cannot be NULL.");
-
-  // Shader unlit defs
-  lua_pushlightuserdata(context->luaState, &SHADER_UNLIT);
-  lua_setglobal(context->luaState, "SHADER_UNLIT");
-
-  lua_pushstring(context->luaState, SHADER_UNLIT_PROJECTION);
-  lua_setglobal(context->luaState, "SHADER_UNLIT_PROJECTION");
-  lua_pushstring(context->luaState, SHADER_UNLIT_VIEW);
-  lua_setglobal(context->luaState, "SHADER_UNLIT_VIEW");
-  lua_pushstring(context->luaState, SHADER_UNLIT_MODEL);
-  lua_setglobal(context->luaState, "SHADER_UNLIT_MODEL");
-  lua_pushstring(context->luaState, SHADER_UNLIT_TEXTURE);
-  lua_setglobal(context->luaState, "SHADER_UNLIT_TEXTURE");
-
-  // Shader methods
-  lua_register(context->luaState, "shaderBind", moduleShaderBind);
-  lua_register(context->luaState, "shaderSetMatrix", moduleShaderSetMatrix);
-  lua_register(context->luaState, "shaderSetTexture", moduleShaderSetTexture);
-}
-
-int moduleShaderBind(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  // Should be passed a shader userdata pointer only.
-  shader_t *shader = (shader_t *)lua_touserdata(l, 1);
-  assertNotNull(shader, "Shader pointer cannot be NULL.");
-
-  errorret_t ret = shaderBind(shader);
-  if(ret.code != ERROR_OK) {
-    luaL_error(l, "Failed to bind shader: %s", ret.state->message);
-    errorCatch(errorPrint(ret));
-    return 0;
-  }
-
-  return 0;
-}
-
-int moduleShaderSetMatrix(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  // Expect shader, string and matrix.
-  if(!lua_isuserdata(l, 1)) {
-    luaL_error(l, "First argument must be a shader_mt userdata.");
-    return 0;
-  }
-
-  if(!lua_isstring(l, 2)) {
-    luaL_error(l, "Second argument must be a string.");
-    return 0;
-  }
-
-  if(!lua_isuserdata(l, 3)) {
-    luaL_error(l, "Third argument must be a mat4_mt userdata.");
-    return 0;
-  }
-
-  shader_t *shader = (shader_t *)lua_touserdata(l, 1);
-  assertNotNull(shader, "Shader pointer cannot be NULL.");
-
-  const char_t *uniformName = luaL_checkstring(l, 2);
-  assertStrLenMin(uniformName, 1, "Uniform name cannot be empty.");
-
-  mat4 *mat = (mat4 *)lua_touserdata(l, 3);
-  assertNotNull(mat, "Matrix pointer cannot be NULL.");
-
-  errorret_t ret = shaderSetMatrix(shader, uniformName, *mat);
-  if(ret.code != ERROR_OK) {
-    luaL_error(l, "Failed to set shader matrix: %s", ret.state->message);
-    errorCatch(errorPrint(ret));
-    return 0;
-  }
-
-  return 0;
-}
-
-int moduleShaderSetTexture(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  shader_t *shader = (shader_t *)lua_touserdata(l, 1);
-  assertNotNull(shader, "Shader pointer cannot be NULL.");
-
-  const char_t *uniformName = luaL_checkstring(l, 2);
-  assertStrLenMin(uniformName, 1, "Uniform name cannot be empty.");
-
-  texture_t *texture;
-  // Texture can be Nil or a pointer, if not nil it must be a texture pointer.
-  if(lua_isnil(l, 3)) {
-    texture = NULL;
-  } else if(lua_isuserdata(l, 3)) {
-    texture = (texture_t *)lua_touserdata(l, 3);
-    assertNotNull(texture, "Texture pointer cannot be NULL.");
-  } else {
-    luaL_error(l, "Third argument must be a texture_mt userdata or nil.");
-    return 0;
-  }
-
-  errorret_t ret = shaderSetTexture(shader, uniformName, texture);
-  if(ret.code != ERROR_OK) {
-    luaL_error(l, "Failed to set shader texture: %s", ret.state->message);
-    errorCatch(errorPrint(ret));
-    return 0;
-  }
-
-  return 0;
-}

src/dusk/script/module/display/moduleshader.h

@@ -1,42 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-/**
- * Register shader functions to the given script context.
- * 
- * @param context The script context to register shader functions to.
- */
-void moduleShader(scriptcontext_t *context);
-
-/**
- * Script binding for binding a shader.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleShaderBind(lua_State *l);
-
-/**
- * Script binding for setting a matrix uniform in a shader.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleShaderSetMatrix(lua_State *l);
-
-/**
- * Script binding for setting a texture uniform in a shader.
- * 
- * @param l The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleShaderSetTexture(lua_State *l);
-
-errorret_t doThing();

src/dusk/script/module/display/modulespritebatch.c

@@ -1,105 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "modulespritebatch.h"
-#include "display/spritebatch/spritebatch.h"
-#include "assert/assert.h"
-
-void moduleSpriteBatch(scriptcontext_t *context) {
-  lua_register(context->luaState, "spriteBatchFlush", moduleSpriteBatchFlush);
-  lua_register(context->luaState, "spriteBatchClear", moduleSpriteBatchClear);
-  lua_register(context->luaState, "spriteBatchPush", moduleSpriteBatchPush);
-}
-
-int moduleSpriteBatchFlush(lua_State *L) {
-  assertNotNull(L, "Lua state is null");
-
-  spriteBatchFlush();
-  return 0;
-}
-
-int moduleSpriteBatchClear(lua_State *L) {
-  assertNotNull(L, "Lua state is null");
-
-  spriteBatchClear();
-  return 0;
-}
-
-int moduleSpriteBatchPush(lua_State *L) {
-  assertNotNull(L, "Lua state is null");
-
-  // MinX, MinY, MaxX, MaxY
-  if(
-    !lua_isnumber(L, 1) || !lua_isnumber(L, 2) || !lua_isnumber(L, 3) ||
-    !lua_isnumber(L, 4)
-  ) {
-    return luaL_error(L, "Sprite coordinates must be numbers");
-  }
-  
-  // Color (struct) or nil for white
-  color_t *color = NULL;
-  if(lua_gettop(L) < 5 || lua_isnil(L, 5)) {
-    // Allow NULL
-  } else if(lua_isuserdata(L, 5)) {
-    color = (color_t*)luaL_checkudata(L, 5, "color_mt");
-  } else {
-    return luaL_error(L, "Sprite color must be a color struct or nil");
-  }
-
-  // Optional UV min and maxes, defaults to 0,0 -> 1,1
-  float_t u0 = 0.0f;
-  float_t v0 = 0.0f;
-  float_t u1 = 1.0f;
-  float_t v1 = 1.0f;
-
-  if(lua_gettop(L) >= 7) {
-    if(!lua_isnumber(L, 6) || !lua_isnumber(L, 7)) {
-      return luaL_error(L, "Sprite UV min coordinates must be numbers");
-    }
-
-    u0 = (float_t)lua_tonumber(L, 6);
-    v0 = (float_t)lua_tonumber(L, 7);
-  }
-
-  if(lua_gettop(L) >= 9) {
-    if(!lua_isnumber(L, 8) || !lua_isnumber(L, 9)) {
-      return luaL_error(L, "Sprite UV max coordinates must be numbers");
-    }
-
-    u1 = (float_t)lua_tonumber(L, 8);
-    v1 = (float_t)lua_tonumber(L, 9);
-  }
-
-  float_t minX = (float_t)lua_tonumber(L, 1);
-  float_t minY = (float_t)lua_tonumber(L, 2);
-  float_t maxX = (float_t)lua_tonumber(L, 3);
-  float_t maxY = (float_t)lua_tonumber(L, 4);
-  
-  errorret_t ret = spriteBatchPush(
-    minX,
-    minY,
-    maxX,
-    maxY,
-    #if MESH_ENABLE_COLOR
-      color == NULL ? COLOR_WHITE : *color,
-    #endif
-    u0,
-    v0,
-    u1,
-    v1
-  );
-  if(ret.code != ERROR_OK) {
-    int err = luaL_error(L,
-      "Failed to push sprite to batch: %s",
-      ret.state->message
-    );
-    errorCatch(errorPrint(ret));
-    return err;
-  }
-
-  return 0;
-}

src/dusk/script/module/display/modulespritebatch.h

@@ -1,40 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-/**
- * Register sprite batch functions to the given script context.
- * 
- * @param context The script context to register sprite batch functions to.
- */
-void moduleSpriteBatch(scriptcontext_t *context);
-
-/**
- * Script binding for flushing the sprite batch.
- * 
- * @param L The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleSpriteBatchFlush(lua_State *L);
-
-/**
- * Script binding for clearing the sprite batch.
- * 
- * @param L The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleSpriteBatchClear(lua_State *L);
-
-/**
- * Script binding for pushing a sprite to the sprite batch.
- * 
- * @param L The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleSpriteBatchPush(lua_State *L);

src/dusk/script/module/display/moduletext.c

@@ -1,92 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduletext.h"
-#include "assert/assert.h"
-#include "display/text/text.h"
-#include "display/spritebatch/spritebatch.h"
-
-void moduleText(scriptcontext_t *context) {
-  assertNotNull(context, "Script context is null");
-
-  lua_register(context->luaState, "textDraw", moduleTextDraw);
-  lua_register(context->luaState, "textMeasure", moduleTextMeasure);
-}
-
-int moduleTextDraw(lua_State *L) {
-  assertNotNull(L, "Lua state is null");
-
-  // Position.
-  if(!lua_isnumber(L, 1)) {
-    return luaL_error(L, "X position must be a number");
-  }
-  if(!lua_isnumber(L, 2)) {
-    return luaL_error(L, "Y position must be a number");
-  }
-
-  const float_t x = (float_t)lua_tonumber(L, 1);
-  const float_t y = (float_t)lua_tonumber(L, 2);
-
-  // String
-  if(!lua_isstring(L, 3)) {
-    return luaL_error(L, "Text to draw must be a string");
-  }
-  const char_t *text = (const char_t*)lua_tostring(L, 3);
-
-  // Optional color
-  color_t *color = NULL;
-  if(lua_gettop(L) < 4 || lua_isnil(L, 4)) {
-    // Allow NULL
-  } else if(lua_isuserdata(L, 4)) {
-    color = (color_t*)luaL_checkudata(L, 4, "color_mt");
-  } else {
-    return luaL_error(L, "Sprite color must be a color struct or nil");
-  }
-
-  // For now, use the default font tileset and texture.
-  errorret_t ret = textDraw(
-    x,
-    y,
-    text,
-    color == NULL ? COLOR_WHITE : *color,
-    &DEFAULT_FONT_TILESET,
-    &DEFAULT_FONT_TEXTURE
-  );
-  if(ret.code != ERROR_OK) {
-    errorCatch(errorPrint(ret));
-    luaL_error(L, "Failed to draw text");
-  }
-
-  ret = spriteBatchFlush();
-  if(ret.code != ERROR_OK) {
-    errorCatch(errorPrint(ret));
-    luaL_error(L, "Failed to flush sprite batch after drawing text");
-  }
-}
-
-int moduleTextMeasure(lua_State *L) {
-  assertNotNull(L, "Lua state is null");
-
-  // String
-  if(!lua_isstring(L, 1)) {
-    return luaL_error(L, "Text to measure must be a string");
-  }
-  const char_t *text = (const char_t*)lua_tostring(L, 1);
-
-  int32_t width = 0;
-  int32_t height = 0;
-  textMeasure(
-    text,
-    &DEFAULT_FONT_TILESET,
-    &width,
-    &height
-  );
-
-  lua_pushnumber(L, width);
-  lua_pushnumber(L, height);
-  return 2;
-}

src/dusk/script/module/display/moduletext.h

@@ -1,32 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-/**
- * Register text rendering functions to the given script context.
- * 
- * @param context The script context to register text functions to.
- */
-void moduleText(scriptcontext_t *context);
-
-/**
- * Script binding for drawing text.
- * 
- * @param L The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleTextDraw(lua_State *L);
-
-/**
- * Script binding for measuring text dimensions.
- * 
- * @param L The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleTextMeasure(lua_State *L);

src/dusk/script/module/display/moduletexture.c

@@ -1,119 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduletexture.h"
-#include "assert/assert.h"
-#include "display/texture/texture.h"
-#include "asset/loader/display/assettextureloader.h"
-#include "util/memory.h"
-#include "util/string.h"
-
-void moduleTexture(scriptcontext_t *ctx) {
-  assertNotNull(ctx, "Script context cannot be null");
-
-  lua_State *l = ctx->luaState;
-  assertNotNull(l, "Lua state cannot be null");
-
-  // Create metatable for texture structure.
-  if(luaL_newmetatable(l, "texture_mt") == 1) {
-    lua_pushcfunction(l, moduleTextureIndex);
-    lua_setfield(l, -2, "__index");
-    
-    lua_pushcfunction(l, moduleTextureToString);
-    lua_setfield(l, -2, "__tostring");
-
-    lua_pushcfunction(l, moduleTextureGC);
-    lua_setfield(l, -2, "__gc");
-  }
-
-  // Texture formats
-  lua_pushnumber(l, TEXTURE_FORMAT_RGBA);
-  lua_setglobal(l, "TEXTURE_FORMAT_RGBA");
-
-  lua_register(ctx->luaState, "textureLoad", moduleTextureLoad);
-}
-
-int moduleTextureIndex(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  texture_t *tex = (texture_t *)luaL_checkudata(l, 1, "texture_mt");
-  assertNotNull(tex, "Texture pointer cannot be NULL.");
-
-  const char *key = luaL_checkstring(l, 2);
-  assertNotNull(key, "Key cannot be NULL.");
-
-  if(stringCompare(key, "width") == 0) {
-    lua_pushnumber(l, tex->width);
-    return 1;
-  } else if(stringCompare(key, "height") == 0) {
-    lua_pushnumber(l, tex->height);
-    return 1;
-  }
-
-  lua_pushnil(l);
-  return 1;
-}
-
-int moduleTextureToString(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  texture_t *tex = (texture_t *)luaL_checkudata(l, 1, "texture_mt");
-  assertNotNull(tex, "Texture pointer cannot be NULL.");
-
-  char buffer[64];
-  snprintf(buffer, sizeof(buffer), "Texture(%dx%d)", tex->width, tex->height);
-  lua_pushstring(l, buffer);
-  return 1;
-}
-
-int moduleTextureGC(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  texture_t *tex = (texture_t *)luaL_checkudata(l, 1, "texture_mt");
-  assertNotNull(tex, "Texture pointer cannot be NULL.");
-
-  textureDispose(tex);
-  return 0;
-}
-
-int moduleTextureLoad(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  if(!lua_isstring(l, 1)) {
-    luaL_error(l, "First argument must be a string filename.");
-    return 0;
-  }
-
-  if(!lua_isnumber(l, 2)) {
-    luaL_error(l, "Second argument must be a number format.");
-    return 0;
-  }
-  
-  const char_t *filename = lua_tostring(l, 1);
-  assertNotNull(filename, "Filename cannot be NULL.");
-  assertStrLenMin(filename, 1, "Filename cannot be empty.");
-
-  // Create texture owned to lua
-  texture_t *tex = (texture_t *)lua_newuserdata(l, sizeof(texture_t));
-  memoryZero(tex, sizeof(texture_t));
-
-  textureformat_t format = (textureformat_t)lua_tonumber(l, 2);
-
-  errorret_t ret = assetTextureLoad(filename, tex, format);
-  if(ret.code != ERROR_OK) {
-    errorCatch(errorPrint(ret));
-    luaL_error(l, "Failed to load texture asset: %s", filename);
-    return 0;
-  }
-
-  // Set metatable
-  luaL_getmetatable(l, "texture_mt");
-  lua_setmetatable(l, -2);
-
-  // Return the texture
-  return 1;
-}

src/dusk/script/module/display/moduletexture.h

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-void moduleTexture(scriptcontext_t *ctx);
-int moduleTextureIndex(lua_State *l);
-int moduleTextureToString(lua_State *l);
-int moduleTextureGC(lua_State *l);
-int moduleTextureLoad(lua_State *l);

src/dusk/script/module/display/moduletileset.c

@@ -1,164 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduletileset.h"
-#include "assert/assert.h"
-#include "display/texture/tileset.h"
-#include "util/memory.h"
-#include "util/string.h"
-#include "asset/loader/display/assettilesetloader.h"
-
-void moduleTileset(scriptcontext_t *ctx) {
-  assertNotNull(ctx, "Script context cannot be NULL");
-
-  // Tileset metatable
-  if(luaL_newmetatable(ctx->luaState, "tileset_mt")) {
-    lua_pushcfunction(ctx->luaState, moduleTilesetIndex);
-    lua_setfield(ctx->luaState, -2, "__index");
-
-    lua_pushcfunction(ctx->luaState, moduleTilesetToString);
-    lua_setfield(ctx->luaState, -2, "__tostring");
-  }
-  lua_pop(ctx->luaState, 1); // Pop the metatable
-
-  lua_register(ctx->luaState, "tilesetLoad", moduleTilesetLoad);
-  lua_register(ctx->luaState, "tilesetTileGetUV", moduleTilesetTileGetUV);
-  lua_register(
-    ctx->luaState, "tilesetPositionGetUV", moduleTilesetPositionGetUV
-  );
-}
-
-int moduleTilesetIndex(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  const char_t *key = luaL_checkstring(l, 2);
-  assertNotNull(key, "Key cannot be NULL.");
-
-  tileset_t *ts = (tileset_t *)luaL_checkudata(l, 1, "tileset_mt");
-  assertNotNull(ts, "Tileset pointer cannot be NULL.");
-
-  if(stringCompare(key, "tileWidth") == 0) {
-    lua_pushnumber(l, ts->tileWidth);
-    return 1;
-  } else if(stringCompare(key, "tileHeight") == 0) {
-    lua_pushnumber(l, ts->tileHeight);
-    return 1;
-  } else if(stringCompare(key, "tileCount") == 0) {
-    lua_pushnumber(l, ts->tileCount);
-    return 1;
-  } else if(stringCompare(key, "columns") == 0) {
-    lua_pushnumber(l, ts->columns);
-    return 1;
-  } else if(stringCompare(key, "rows") == 0) {
-    lua_pushnumber(l, ts->rows);
-    return 1;
-  }
-
-  lua_pushnil(l);
-  return 1;
-}
-
-int moduleTilesetToString(lua_State *l) {
-  tileset_t *ts = (tileset_t *)luaL_checkudata(l, 1, "tileset_mt");
-  assertNotNull(ts, "Tileset pointer cannot be NULL.");
-
-  lua_pushfstring(l, "Tileset: %dx%d tile, %d columns, %d rows", 
-    ts->tileWidth, ts->tileHeight, ts->columns, ts->rows
-  );
-  return 1;
-}
-
-int moduleTilesetTileGetUV(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  if(!lua_isuserdata(l, 1)) {
-    luaL_error(l, "First argument must be a tileset userdata.");
-    return 0;
-  }
-
-  tileset_t *ts = (tileset_t *)luaL_checkudata(l, 1, "tileset_mt");
-  assertNotNull(ts, "Tileset pointer cannot be NULL.");
-
-  if(!lua_isnumber(l, 2)) {
-    luaL_error(l, "Second arguments must be tile index.");
-    return 0;
-  }
-  uint16_t tileIndex = (uint16_t)lua_tonumber(l, 2);
-
-  // Create vec4 that lua owns
-  vec4 *uv = (vec4 *)lua_newuserdata(l, sizeof(vec4));
-  tilesetTileGetUV(ts, tileIndex, *uv);
-
-  // Set metatable
-  luaL_getmetatable(l, "vec4_mt");
-  lua_setmetatable(l, -2);
-  return 1;
-}
-
-int moduleTilesetPositionGetUV(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-  
-  if(!lua_isuserdata(l, 1)) {
-    luaL_error(l, "First argument must be a tileset userdata.");
-    return 0;
-  }
-
-  tileset_t *ts = (tileset_t *)luaL_checkudata(l, 1, "tileset_mt");
-  assertNotNull(ts, "Tileset pointer cannot be NULL.");
-
-  if(!lua_isnumber(l, 2)) {
-    luaL_error(l, "Second arguments must be column number.");
-    return 0;
-  }
-  uint16_t column = (uint16_t)lua_tonumber(l, 2);
-
-  if(!lua_isnumber(l, 3)) {
-    luaL_error(l, "Third arguments must be row number.");
-    return 0;
-  }
-  uint16_t row = (uint16_t)lua_tonumber(l, 3);
-
-  // Create vec4 that lua owns
-  vec4 *uv = (vec4 *)lua_newuserdata(l, sizeof(vec4));
-  tilesetPositionGetUV(ts, column, row, *uv);
-
-  // Set metatable
-  luaL_getmetatable(l, "vec4_mt");
-  lua_setmetatable(l, -2);
-  return 1;
-}
-
-int moduleTilesetLoad(lua_State *l) {
-  assertNotNull(l, "Lua state cannot be NULL.");
-
-  if(!lua_isstring(l, 1)) {
-    luaL_error(l, "First argument must be a string filename.");
-    return 0;
-  }
-  
-  const char_t *filename = lua_tostring(l, 1);
-  assertNotNull(filename, "Filename cannot be NULL.");
-  assertStrLenMin(filename, 1, "Filename cannot be empty.");
-
-  // Create texture owned to lua
-  tileset_t *tileset = (tileset_t *)lua_newuserdata(l, sizeof(tileset_t));
-  memoryZero(tileset, sizeof(tileset_t));
-
-  errorret_t ret = assetTilesetLoad(filename, tileset);
-  if(ret.code != ERROR_OK) {
-    errorCatch(errorPrint(ret));
-    luaL_error(l, "Failed to load tileset asset: %s", filename);
-    return 0;
-  }
-
-  // Set metatable
-  luaL_getmetatable(l, "tileset_mt");
-  lua_setmetatable(l, -2);
-
-  // Return the tileset
-  return 1;
-}

src/dusk/script/module/display/moduletileset.h

@@ -1,56 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-/**
- * Registers the tileset module in the scripting context.
- * 
- * @param ctx The scripting context to register the module in.
- */
-void moduleTileset(scriptcontext_t *ctx);
-
-/**
- * __index metamethod for tileset userdata.
- * 
- * @param l The Lua state.
- * @return The number of return values on the Lua stack.
- */
-int moduleTilesetIndex(lua_State *l);
-
-/**
- * __tostring metamethod for tileset userdata.
- * 
- * @param l The Lua state.
- * @return The number of return values on the Lua stack.
- */
-int moduleTilesetToString(lua_State *l);
-
-/**
- * Lua function to get the UV coordinates for a tile index in a tileset.
- * 
- * @param l The Lua state.
- * @return The number of return values on the Lua stack.
- */
-int moduleTilesetTileGetUV(lua_State *l);
-
-/**
- * Lua function to get the UV coordinates for a tile position in a tileset.
- * 
- * @param l The Lua state.
- * @return The number of return values on the Lua stack.
- */
-int moduleTilesetPositionGetUV(lua_State *l);
-
-/**
- * Lua function to load a tileset from a texture and tile dimensions.
- * 
- * @param l The Lua state.
- * @return The number of return values on the Lua stack.
- */
-int moduleTilesetLoad(lua_State *l);

src/dusk/script/module/engine/moduleengine.h

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "script/module/modulebase.h"
+#include "script/scriptproto.h"
+#include "engine/engine.h"
+
+static scriptproto_t MODULE_ENGINE_PROTO;
+
+moduleBaseFunction(moduleEngineExit) {
+  ENGINE.running = false;
+  return jerry_undefined();
+}
+
+static void moduleEngine(void) {
+  scriptProtoInit(
+    &MODULE_ENGINE_PROTO, "Engine",
+    sizeof(uint8_t), NULL
+  );
+
+  scriptProtoDefineStaticFunc(
+    &MODULE_ENGINE_PROTO, "exit", moduleEngineExit
+  );
+}

src/dusk/script/module/entity/CMakeLists.txt

@@ -1,15 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-#
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Sources
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    moduleentity.c
-)
-
-# Subdirectories
-add_subdirectory(display)
-add_subdirectory(physics)
-add_subdirectory(script)

src/dusk/script/module/entity/component/moduleentitycamera.h

@@ -0,0 +1,244 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "script/module/modulebase.h"
+#include "script/scriptproto.h"
+#include "entity/entity.h"
+#include "entity/component/display/entitycamera.h"
+#include "moduleentityposition.h"
+
+static scriptproto_t MODULE_ENTITY_CAMERA_PROTO;
+
+static entitycamera_t * moduleEntityCameraGet(
+  const jerry_call_info_t *callInfo
+) {
+  componenthandle_t *h = scriptProtoGetValue(
+    &MODULE_ENTITY_CAMERA_PROTO, callInfo->this_value
+  );
+  if(!h) return NULL;
+  return (entitycamera_t*)componentGetData(
+    h->eid, h->cid, COMPONENT_TYPE_CAMERA
+  );
+}
+
+moduleBaseFunction(moduleEntityCameraGetZNear) {
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam) return jerry_undefined();
+  return jerry_number(cam->nearClip);
+}
+
+moduleBaseFunction(moduleEntityCameraGetZFar) {
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam) return jerry_undefined();
+  return jerry_number(cam->farClip);
+}
+
+moduleBaseFunction(moduleEntityCameraGetOrthoTop) {
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    return jerry_undefined();
+  }
+  return jerry_number(cam->orthographic.top);
+}
+
+moduleBaseFunction(moduleEntityCameraGetOrthoBottom) {
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    return jerry_undefined();
+  }
+  return jerry_number(cam->orthographic.bottom);
+}
+
+moduleBaseFunction(moduleEntityCameraGetOrthoLeft) {
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    return jerry_undefined();
+  }
+  return jerry_number(cam->orthographic.left);
+}
+
+moduleBaseFunction(moduleEntityCameraGetOrthoRight) {
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    return jerry_undefined();
+  }
+  return jerry_number(cam->orthographic.right);
+}
+
+moduleBaseFunction(moduleEntityCameraGetFov) {
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || (
+    cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE &&
+    cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED
+  )) {
+    return jerry_undefined();
+  }
+  return jerry_number(cam->perspective.fov);
+}
+
+moduleBaseFunction(moduleEntityCameraGetProjectionType) {
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam) return jerry_undefined();
+  return jerry_number(cam->projType);
+}
+
+moduleBaseFunction(moduleEntityCameraSetZNear) {
+  if(argc < 1 || !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Expected a number");
+  }
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam) return jerry_undefined();
+  cam->nearClip = (float_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleEntityCameraSetZFar) {
+  if(argc < 1 || !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Expected a number");
+  }
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam) return jerry_undefined();
+  cam->farClip = (float_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleEntityCameraSetOrthoTop) {
+  if(argc < 1 || !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Expected a number");
+  }
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    return jerry_undefined();
+  }
+  cam->orthographic.top = (float_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleEntityCameraSetOrthoBottom) {
+  if(argc < 1 || !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Expected a number");
+  }
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    return jerry_undefined();
+  }
+  cam->orthographic.bottom = (float_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleEntityCameraSetOrthoLeft) {
+  if(argc < 1 || !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Expected a number");
+  }
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    return jerry_undefined();
+  }
+  cam->orthographic.left = (float_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleEntityCameraSetOrthoRight) {
+  if(argc < 1 || !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Expected a number");
+  }
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    return jerry_undefined();
+  }
+  cam->orthographic.right = (float_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleEntityCameraSetFov) {
+  if(argc < 1 || !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Expected a number");
+  }
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam || (
+    cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE &&
+    cam->projType != ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED
+  )) {
+    return jerry_undefined();
+  }
+  cam->perspective.fov = (float_t)jerry_value_as_number(args[0]);
+  return args[0];
+}
+
+moduleBaseFunction(moduleEntityCameraSetProjectionType) {
+  if(argc < 1 || !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Expected a number");
+  }
+  entitycamera_t *cam = moduleEntityCameraGet(callInfo);
+  if(!cam) return jerry_undefined();
+  int32_t projType = (int32_t)jerry_value_as_number(args[0]);
+  if(
+    projType < ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE ||
+    projType > ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC
+  ) {
+    return moduleBaseThrow("Invalid projection type");
+  }
+  cam->projType = (entitycameraprojectiontype_t)projType;
+  return args[0];
+}
+
+moduleBaseFunction(moduleEntityCameraAdd) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  entityid_t id = (entityid_t)jerry_value_as_number(args[0]);
+  componentid_t comp = entityAddComponent(id, COMPONENT_TYPE_CAMERA);
+  componenthandle_t h = { .eid = id, .cid = comp };
+  return scriptProtoCreateValue(&MODULE_ENTITY_CAMERA_PROTO, &h);
+}
+
+static void moduleEntityCAMERA(void) {
+  scriptProtoInit(
+    &MODULE_ENTITY_CAMERA_PROTO, NULL, sizeof(componenthandle_t), NULL
+  );
+
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_CAMERA_PROTO, "zNear",
+    moduleEntityCameraGetZNear, moduleEntityCameraSetZNear
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_CAMERA_PROTO, "zFar",
+    moduleEntityCameraGetZFar, moduleEntityCameraSetZFar
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_CAMERA_PROTO, "orthoTop",
+    moduleEntityCameraGetOrthoTop, moduleEntityCameraSetOrthoTop
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_CAMERA_PROTO, "orthoBottom",
+    moduleEntityCameraGetOrthoBottom, moduleEntityCameraSetOrthoBottom
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_CAMERA_PROTO, "orthoLeft",
+    moduleEntityCameraGetOrthoLeft, moduleEntityCameraSetOrthoLeft
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_CAMERA_PROTO, "orthoRight",
+    moduleEntityCameraGetOrthoRight, moduleEntityCameraSetOrthoRight
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_CAMERA_PROTO, "fov",
+    moduleEntityCameraGetFov, moduleEntityCameraSetFov
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_CAMERA_PROTO, "projectionType",
+    moduleEntityCameraGetProjectionType, moduleEntityCameraSetProjectionType
+  );
+
+  moduleBaseSetInt(
+    "CAMERA_TYPE_ORTHOGRAPHIC",
+    ENTITY_CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC
+  );
+  moduleBaseSetInt(
+    "CAMERA_TYPE_PERSPECTIVE",
+    ENTITY_CAMERA_PROJECTION_TYPE_PERSPECTIVE
+  );
+}

src/dusk/script/module/entity/component/moduleentitymaterial.h

@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "script/module/modulebase.h"
+#include "script/scriptproto.h"
+#include "entity/entity.h"
+#include "entity/component/display/entitymaterial.h"
+#include "display/color.h"
+#include "moduleentityposition.h"
+
+static scriptproto_t MODULE_ENTITY_MATERIAL_PROTO;
+
+static entitymaterial_t * moduleEntityMaterialGet(
+  const jerry_call_info_t *callInfo
+) {
+  componenthandle_t *h = scriptProtoGetValue(
+    &MODULE_ENTITY_MATERIAL_PROTO, callInfo->this_value
+  );
+  if(!h) return NULL;
+  return (entitymaterial_t*)componentGetData(
+    h->eid, h->cid, COMPONENT_TYPE_MATERIAL
+  );
+}
+
+moduleBaseFunction(moduleEntityMaterialSetColor) {
+  moduleBaseRequireArgs(1);
+  if(!jerry_value_is_object(args[0])) {
+    return moduleBaseThrow("expected color object");
+  }
+  entitymaterial_t *mat = moduleEntityMaterialGet(callInfo);
+  if(!mat) return jerry_undefined();
+
+  jerry_value_t key;
+  jerry_value_t v;
+  color_t col;
+
+  key = jerry_string_sz("r");
+  v = jerry_object_get(args[0], key);
+  jerry_value_free(key);
+  col.r = (colorchannel8_t)jerry_value_as_number(v);
+  jerry_value_free(v);
+
+  key = jerry_string_sz("g");
+  v = jerry_object_get(args[0], key);
+  jerry_value_free(key);
+  col.g = (colorchannel8_t)jerry_value_as_number(v);
+  jerry_value_free(v);
+
+  key = jerry_string_sz("b");
+  v = jerry_object_get(args[0], key);
+  jerry_value_free(key);
+  col.b = (colorchannel8_t)jerry_value_as_number(v);
+  jerry_value_free(v);
+
+  key = jerry_string_sz("a");
+  v = jerry_object_get(args[0], key);
+  jerry_value_free(key);
+  col.a = (colorchannel8_t)jerry_value_as_number(v);
+  jerry_value_free(v);
+
+  mat->material.unlit.color = col;
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityMaterialAdd) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  entityid_t id = (entityid_t)jerry_value_as_number(args[0]);
+  componentid_t comp = entityAddComponent(id, COMPONENT_TYPE_MATERIAL);
+  componenthandle_t h = { .eid = id, .cid = comp };
+  return scriptProtoCreateValue(&MODULE_ENTITY_MATERIAL_PROTO, &h);
+}
+
+static void moduleEntityMATERIAL(void) {
+  scriptProtoInit(
+    &MODULE_ENTITY_MATERIAL_PROTO,
+    NULL,
+    sizeof(componenthandle_t),
+    NULL
+  );
+
+  scriptProtoDefineFunc(
+    &MODULE_ENTITY_MATERIAL_PROTO,
+    "setColor",
+    moduleEntityMaterialSetColor
+  );
+}

src/dusk/script/module/entity/component/moduleentitymesh.h

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "script/module/modulebase.h"
+#include "script/scriptproto.h"
+#include "entity/entity.h"
+#include "entity/component/display/entitymesh.h"
+#include "moduleentityposition.h"
+
+static scriptproto_t MODULE_ENTITY_MESH_PROTO;
+
+static entitymesh_t * moduleEntityMeshGet(
+  const jerry_call_info_t *callInfo
+) {
+  componenthandle_t *h = scriptProtoGetValue(
+    &MODULE_ENTITY_MESH_PROTO, callInfo->this_value
+  );
+  if(!h) return NULL;
+  return (entitymesh_t*)componentGetData(h->eid, h->cid, COMPONENT_TYPE_MESH);
+}
+
+moduleBaseFunction(moduleEntityMeshAdd) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  entityid_t id = (entityid_t)jerry_value_as_number(args[0]);
+  componentid_t comp = entityAddComponent(id, COMPONENT_TYPE_MESH);
+  componenthandle_t h = { .eid = id, .cid = comp };
+  return scriptProtoCreateValue(&MODULE_ENTITY_MESH_PROTO, &h);
+}
+
+static void moduleEntityMESH(void) {
+  scriptProtoInit(
+    &MODULE_ENTITY_MESH_PROTO, NULL,
+    sizeof(componenthandle_t), NULL
+  );
+}

src/dusk/script/module/entity/component/moduleentityphysics.h

@@ -0,0 +1,183 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "script/module/modulebase.h"
+#include "script/module/math/modulevec3ref.h"
+#include "script/scriptproto.h"
+#include "entity/entity.h"
+#include "entity/component/physics/entityphysics.h"
+#include "moduleentityposition.h"
+
+static scriptproto_t MODULE_ENTITY_PHYSICS_PROTO;
+
+static entityphysics_t * moduleEntityPhysicsGet(
+  const jerry_call_info_t *callInfo
+) {
+  componenthandle_t *h = scriptProtoGetValue(
+    &MODULE_ENTITY_PHYSICS_PROTO, callInfo->this_value
+  );
+  if(!h) return NULL;
+  return entityPhysicsGet(h->eid, h->cid);
+}
+
+moduleBaseFunction(moduleEntityPhysicsGetVelocity) {
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  return moduleVec3RefPush(phys->velocity, NULL, NULL);
+}
+
+moduleBaseFunction(moduleEntityPhysicsSetVelocity) {
+  moduleBaseRequireArgs(1);
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  vec3 v;
+  if(!moduleVec3AnyCheck(args[0], v)) {
+    return moduleBaseThrow("expected Vec3");
+  }
+  glm_vec3_copy(v, phys->velocity);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPhysicsGetOnGround) {
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  return jerry_boolean(phys->onGround);
+}
+
+moduleBaseFunction(moduleEntityPhysicsGetBodyType) {
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  return jerry_number((double)phys->type);
+}
+
+moduleBaseFunction(moduleEntityPhysicsSetBodyType) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  phys->type = (physicsbodytype_t)(int32_t)jerry_value_as_number(args[0]);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPhysicsApplyImpulse) {
+  moduleBaseRequireArgs(1);
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  if(phys->type == PHYSICS_BODY_STATIC) return jerry_undefined();
+  vec3 impulse;
+  if(!moduleVec3Check(args[0], impulse)) {
+    return moduleBaseThrow("expected Vec3 impulse");
+  }
+  glm_vec3_add(phys->velocity, impulse, phys->velocity);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPhysicsSetShapeCube) {
+  moduleBaseRequireArgs(1);
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  vec3 half;
+  if(!moduleVec3Check(args[0], half)) {
+    return moduleBaseThrow("expected Vec3 halfExtents");
+  }
+  phys->shape.type = PHYSICS_SHAPE_CUBE;
+  glm_vec3_copy(half, phys->shape.data.cube.halfExtents);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPhysicsSetShapeSphere) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  phys->shape.type = PHYSICS_SHAPE_SPHERE;
+  phys->shape.data.sphere.radius = (float_t)jerry_value_as_number(args[0]);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPhysicsSetShapeCapsule) {
+  moduleBaseRequireArgs(2);
+  moduleBaseRequireNumber(0); moduleBaseRequireNumber(1);
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  phys->shape.type = PHYSICS_SHAPE_CAPSULE;
+  phys->shape.data.capsule.radius = (float_t)jerry_value_as_number(args[0]);
+  phys->shape.data.capsule.halfHeight =
+    (float_t)jerry_value_as_number(args[1]);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPhysicsSetShapePlane) {
+  moduleBaseRequireArgs(2); moduleBaseRequireNumber(1);
+  entityphysics_t *phys = moduleEntityPhysicsGet(callInfo);
+  if(!phys) return jerry_undefined();
+  vec3 normal;
+  if(!moduleVec3Check(args[0], normal)) {
+    return moduleBaseThrow("expected Vec3 normal");
+  }
+  phys->shape.type = PHYSICS_SHAPE_PLANE;
+  glm_vec3_copy(normal, phys->shape.data.plane.normal);
+  phys->shape.data.plane.distance = (float_t)jerry_value_as_number(args[1]);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPhysicsAdd) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  entityid_t id = (entityid_t)jerry_value_as_number(args[0]);
+  componentid_t comp = entityAddComponent(id, COMPONENT_TYPE_PHYSICS);
+  componenthandle_t h = { .eid = id, .cid = comp };
+  return scriptProtoCreateValue(&MODULE_ENTITY_PHYSICS_PROTO, &h);
+}
+
+static void moduleEntityPHYSICS(void) {
+  scriptProtoInit(
+    &MODULE_ENTITY_PHYSICS_PROTO, NULL,
+    sizeof(componenthandle_t), NULL
+  );
+
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_PHYSICS_PROTO, "velocity",
+    moduleEntityPhysicsGetVelocity, moduleEntityPhysicsSetVelocity
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_PHYSICS_PROTO, "onGround",
+    moduleEntityPhysicsGetOnGround, NULL
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_PHYSICS_PROTO, "bodyType",
+    moduleEntityPhysicsGetBodyType, moduleEntityPhysicsSetBodyType
+  );
+
+  scriptProtoDefineFunc(
+    &MODULE_ENTITY_PHYSICS_PROTO, "applyImpulse",
+    moduleEntityPhysicsApplyImpulse
+  );
+  scriptProtoDefineFunc(
+    &MODULE_ENTITY_PHYSICS_PROTO, "setShapeCube",
+    moduleEntityPhysicsSetShapeCube
+  );
+  scriptProtoDefineFunc(
+    &MODULE_ENTITY_PHYSICS_PROTO, "setShapeSphere",
+    moduleEntityPhysicsSetShapeSphere
+  );
+  scriptProtoDefineFunc(
+    &MODULE_ENTITY_PHYSICS_PROTO, "setShapeCapsule",
+    moduleEntityPhysicsSetShapeCapsule
+  );
+  scriptProtoDefineFunc(
+    &MODULE_ENTITY_PHYSICS_PROTO, "setShapePlane",
+    moduleEntityPhysicsSetShapePlane
+  );
+
+  moduleBaseSetInt("PHYSICS_BODY_STATIC",    PHYSICS_BODY_STATIC);
+  moduleBaseSetInt("PHYSICS_BODY_DYNAMIC",   PHYSICS_BODY_DYNAMIC);
+  moduleBaseSetInt("PHYSICS_BODY_KINEMATIC", PHYSICS_BODY_KINEMATIC);
+
+  moduleBaseSetInt("PHYSICS_SHAPE_CUBE",    PHYSICS_SHAPE_CUBE);
+  moduleBaseSetInt("PHYSICS_SHAPE_SPHERE",  PHYSICS_SHAPE_SPHERE);
+  moduleBaseSetInt("PHYSICS_SHAPE_CAPSULE", PHYSICS_SHAPE_CAPSULE);
+  moduleBaseSetInt("PHYSICS_SHAPE_PLANE",   PHYSICS_SHAPE_PLANE);
+}

src/dusk/script/module/entity/component/moduleentityposition.h

@@ -0,0 +1,147 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "script/module/modulebase.h"
+#include "script/module/math/modulevec3ref.h"
+#include "script/scriptproto.h"
+#include "entity/entity.h"
+#include "entity/component/display/entityposition.h"
+
+// Shared component handle struct — defined once, used by all component modules.
+#ifndef COMPONENT_HANDLE_DEFINED
+#define COMPONENT_HANDLE_DEFINED
+typedef struct {
+  entityid_t eid;
+  componentid_t cid;
+} componenthandle_t;
+#endif
+
+static scriptproto_t MODULE_ENTITY_POSITION_PROTO;
+
+static entityposition_t * moduleEntityPositionGet(
+  const jerry_call_info_t *callInfo
+) {
+  componenthandle_t *h = scriptProtoGetValue(
+    &MODULE_ENTITY_POSITION_PROTO, callInfo->this_value
+  );
+  if(!h) return NULL;
+  return entityPositionGet(h->eid, h->cid);
+}
+
+moduleBaseFunction(moduleEntityPositionGetPosition) {
+  entityposition_t *pos = moduleEntityPositionGet(callInfo);
+  if(!pos) return jerry_undefined();
+  return moduleVec3RefPush(
+    pos->position, (void(*)(void*))entityPositionRebuild, pos
+  );
+}
+
+moduleBaseFunction(moduleEntityPositionSetPosition) {
+  moduleBaseRequireArgs(1);
+  entityposition_t *pos = moduleEntityPositionGet(callInfo);
+  if(!pos) return jerry_undefined();
+  vec3 v;
+  if(!moduleVec3AnyCheck(args[0], v)) {
+    return moduleBaseThrow("expected Vec3");
+  }
+  glm_vec3_copy(v, pos->position);
+  entityPositionRebuild(pos);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPositionGetRotation) {
+  entityposition_t *pos = moduleEntityPositionGet(callInfo);
+  if(!pos) return jerry_undefined();
+  return moduleVec3RefPush(
+    pos->rotation, (void(*)(void*))entityPositionRebuild, pos
+  );
+}
+
+moduleBaseFunction(moduleEntityPositionSetRotation) {
+  moduleBaseRequireArgs(1);
+  entityposition_t *pos = moduleEntityPositionGet(callInfo);
+  if(!pos) return jerry_undefined();
+  vec3 v;
+  if(!moduleVec3AnyCheck(args[0], v)) {
+    return moduleBaseThrow("expected Vec3");
+  }
+  glm_vec3_copy(v, pos->rotation);
+  entityPositionRebuild(pos);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPositionGetScale) {
+  entityposition_t *pos = moduleEntityPositionGet(callInfo);
+  if(!pos) return jerry_undefined();
+  return moduleVec3RefPush(
+    pos->scale, (void(*)(void*))entityPositionRebuild, pos
+  );
+}
+
+moduleBaseFunction(moduleEntityPositionSetScale) {
+  moduleBaseRequireArgs(1);
+  entityposition_t *pos = moduleEntityPositionGet(callInfo);
+  if(!pos) return jerry_undefined();
+  vec3 v;
+  if(!moduleVec3AnyCheck(args[0], v)) {
+    return moduleBaseThrow("expected Vec3");
+  }
+  glm_vec3_copy(v, pos->scale);
+  entityPositionRebuild(pos);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPositionLookAt) {
+  moduleBaseRequireArgs(1);
+  entityposition_t *pos = moduleEntityPositionGet(callInfo);
+  if(!pos) return jerry_undefined();
+  vec3 target;
+  if(!moduleVec3AnyCheck(args[0], target)) {
+    return moduleBaseThrow("expected Vec3 target");
+  }
+  vec3 up = { 0.0f, 1.0f, 0.0f };
+  if(argc >= 2 && !moduleVec3AnyCheck(args[1], up)) {
+    return moduleBaseThrow("expected Vec3 up");
+  }
+  glm_lookat(pos->position, target, up, pos->transform);
+  entityPositionDecompose(pos);
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityPositionAdd) {
+  moduleBaseRequireArgs(1); moduleBaseRequireNumber(0);
+  entityid_t id = (entityid_t)jerry_value_as_number(args[0]);
+  componentid_t comp = entityAddComponent(id, COMPONENT_TYPE_POSITION);
+  componenthandle_t h = { .eid = id, .cid = comp };
+  return scriptProtoCreateValue(&MODULE_ENTITY_POSITION_PROTO, &h);
+}
+
+static void moduleEntityPOSITION(void) {
+  scriptProtoInit(
+    &MODULE_ENTITY_POSITION_PROTO, NULL,
+    sizeof(componenthandle_t), NULL
+  );
+
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_POSITION_PROTO, "position",
+    moduleEntityPositionGetPosition, moduleEntityPositionSetPosition
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_POSITION_PROTO, "rotation",
+    moduleEntityPositionGetRotation, moduleEntityPositionSetRotation
+  );
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_POSITION_PROTO, "scale",
+    moduleEntityPositionGetScale, moduleEntityPositionSetScale
+  );
+
+  scriptProtoDefineFunc(
+    &MODULE_ENTITY_POSITION_PROTO, "lookAt",
+    moduleEntityPositionLookAt
+  );
+}

src/dusk/script/module/entity/display/CMakeLists.txt

@@ -1,12 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-#
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    moduleentityposition.c
-    moduleentitycamera.c
-    moduleentitymesh.c
-    moduleentitymaterial.c
-)

src/dusk/script/module/entity/display/moduleentitycamera.c

@@ -1,70 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleentitycamera.h"
-#include "assert/assert.h"
-#include "entity/entity.h"
-#include "entity/component/display/entitycamera.h"
-
-void moduleEntityCamera(scriptcontext_t *ctx) {
-  assertNotNull(ctx, "Script context cannot be NULL");
-
-  #define REG(name, func) lua_register(ctx->luaState, name, func)
-  REG("entityCameraAdd", moduleEntityCameraAdd);
-  REG("entityCameraGetZNear", moduleEntityCameraGetZNear);
-  REG("entityCameraSetZNear", moduleEntityCameraSetZNear);
-  REG("entityCameraGetZFar", moduleEntityCameraGetZFar);
-  REG("entityCameraSetZFar", moduleEntityCameraSetZFar);
-  #undef REG
-}
-
-int moduleEntityCameraAdd(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = entityAddComponent(entityId, COMPONENT_TYPE_CAMERA);
-  lua_pushnumber(L, (lua_Number)compId);
-  return 1;
-}
-
-int moduleEntityCameraGetZNear(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  lua_pushnumber(L, (lua_Number)entityCameraGetZNear(entityId, compId));
-  return 1;
-}
-
-int moduleEntityCameraSetZNear(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  float_t zNear = (float_t)luaL_checknumber(L, 3);
-  entityCameraSetZNear(entityId, compId, zNear);
-  return 0;
-}
-
-int moduleEntityCameraGetZFar(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  lua_pushnumber(L, (lua_Number)entityCameraGetZFar(entityId, compId));
-  return 1;
-}
-
-int moduleEntityCameraSetZFar(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  float_t zFar = (float_t)luaL_checknumber(L, 3);
-  entityCameraSetZFar(entityId, compId, zFar);
-  return 0;
-}

src/dusk/script/module/entity/display/moduleentitycamera.h

@@ -1,17 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-void moduleEntityCamera(scriptcontext_t *ctx);
-
-int moduleEntityCameraAdd(lua_State *L);
-int moduleEntityCameraGetZNear(lua_State *L);
-int moduleEntityCameraSetZNear(lua_State *L);
-int moduleEntityCameraGetZFar(lua_State *L);
-int moduleEntityCameraSetZFar(lua_State *L);

src/dusk/script/module/entity/display/moduleentitymaterial.c

@@ -1,26 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleentitymaterial.h"
-#include "assert/assert.h"
-#include "entity/entity.h"
-#include "entity/component/display/entitymaterial.h"
-
-void moduleEntityMaterial(scriptcontext_t *ctx) {
-  assertNotNull(ctx, "Script context cannot be NULL");
-
-  lua_register(ctx->luaState, "entityMaterialAdd", moduleEntityMaterialAdd);
-}
-
-int moduleEntityMaterialAdd(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = entityAddComponent(entityId, COMPONENT_TYPE_MATERIAL);
-  lua_pushnumber(L, (lua_Number)compId);
-  return 1;
-}

src/dusk/script/module/entity/display/moduleentitymaterial.h

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-void moduleEntityMaterial(scriptcontext_t *ctx);
-
-int moduleEntityMaterialAdd(lua_State *L);

src/dusk/script/module/entity/display/moduleentitymesh.c

@@ -1,26 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleentitymesh.h"
-#include "assert/assert.h"
-#include "entity/entity.h"
-#include "entity/component/display/entitymesh.h"
-
-void moduleEntityMesh(scriptcontext_t *ctx) {
-  assertNotNull(ctx, "Script context cannot be NULL");
-
-  lua_register(ctx->luaState, "entityMeshAdd", moduleEntityMeshAdd);
-}
-
-int moduleEntityMeshAdd(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = entityAddComponent(entityId, COMPONENT_TYPE_MESH);
-  lua_pushnumber(L, (lua_Number)compId);
-  return 1;
-}

src/dusk/script/module/entity/display/moduleentityposition.c

@@ -1,140 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleentityposition.h"
-#include "assert/assert.h"
-#include "entity/entity.h"
-#include "entity/component/display/entityposition.h"
-
-void moduleEntityPosition(scriptcontext_t *ctx) {
-  assertNotNull(ctx, "Script context cannot be NULL");
-
-  #define REG(name, func) lua_register(ctx->luaState, name, func)
-  REG("entityPositionAdd", moduleEntityPositionAdd);
-  REG("entityPositionSetPosition", moduleEntityPositionSetPosition);
-  REG("entityPositionGetPosition", moduleEntityPositionGetPosition);
-  REG("entityPositionSetRotation", moduleEntityPositionSetRotation);
-  REG("entityPositionGetRotation", moduleEntityPositionGetRotation);
-  REG("entityPositionSetScale", moduleEntityPositionSetScale);
-  REG("entityPositionGetScale", moduleEntityPositionGetScale);
-  REG("entityPositionLookAt", moduleEntityPositionLookAt);
-  #undef REG
-}
-
-int moduleEntityPositionAdd(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = entityAddComponent(entityId, COMPONENT_TYPE_POSITION);
-  lua_pushnumber(L, (lua_Number)compId);
-  return 1;
-}
-
-int moduleEntityPositionSetPosition(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 pos = {
-    (float_t)luaL_checknumber(L, 3),
-    (float_t)luaL_checknumber(L, 4),
-    (float_t)luaL_checknumber(L, 5)
-  };
-  entityPositionSetPosition(entityId, compId, pos);
-  return 0;
-}
-
-int moduleEntityPositionGetPosition(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 pos;
-  entityPositionGetPosition(entityId, compId, pos);
-  lua_pushnumber(L, pos[0]);
-  lua_pushnumber(L, pos[1]);
-  lua_pushnumber(L, pos[2]);
-  return 3;
-}
-
-int moduleEntityPositionSetRotation(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 rot = {
-    (float_t)luaL_checknumber(L, 3),
-    (float_t)luaL_checknumber(L, 4),
-    (float_t)luaL_checknumber(L, 5)
-  };
-  entityPositionSetRotation(entityId, compId, rot);
-  return 0;
-}
-
-int moduleEntityPositionGetRotation(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 rot;
-  entityPositionGetRotation(entityId, compId, rot);
-  lua_pushnumber(L, rot[0]);
-  lua_pushnumber(L, rot[1]);
-  lua_pushnumber(L, rot[2]);
-  return 3;
-}
-
-int moduleEntityPositionSetScale(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 scale = {
-    (float_t)luaL_checknumber(L, 3),
-    (float_t)luaL_checknumber(L, 4),
-    (float_t)luaL_checknumber(L, 5)
-  };
-  entityPositionSetScale(entityId, compId, scale);
-  return 0;
-}
-
-int moduleEntityPositionGetScale(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 scale;
-  entityPositionGetScale(entityId, compId, scale);
-  lua_pushnumber(L, scale[0]);
-  lua_pushnumber(L, scale[1]);
-  lua_pushnumber(L, scale[2]);
-  return 3;
-}
-
-int moduleEntityPositionLookAt(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 target = {
-    (float_t)luaL_checknumber(L, 3),
-    (float_t)luaL_checknumber(L, 4),
-    (float_t)luaL_checknumber(L, 5)
-  };
-  vec3 up = {
-    (float_t)luaL_checknumber(L, 6),
-    (float_t)luaL_checknumber(L, 7),
-    (float_t)luaL_checknumber(L, 8)
-  };
-  vec3 eye = {
-    (float_t)luaL_checknumber(L, 9),
-    (float_t)luaL_checknumber(L, 10),
-    (float_t)luaL_checknumber(L, 11)
-  };
-  entityPositionLookAt(entityId, compId, target, up, eye);
-  return 0;
-}

src/dusk/script/module/entity/display/moduleentityposition.h

@@ -1,20 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-void moduleEntityPosition(scriptcontext_t *ctx);
-
-int moduleEntityPositionAdd(lua_State *L);
-int moduleEntityPositionSetPosition(lua_State *L);
-int moduleEntityPositionGetPosition(lua_State *L);
-int moduleEntityPositionSetRotation(lua_State *L);
-int moduleEntityPositionGetRotation(lua_State *L);
-int moduleEntityPositionSetScale(lua_State *L);
-int moduleEntityPositionGetScale(lua_State *L);
-int moduleEntityPositionLookAt(lua_State *L);

src/dusk/script/module/entity/moduleentity.c

@@ -1,52 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleentity.h"
-#include "assert/assert.h"
-#include "entity/entitymanager.h"
-#include "entity/entity.h"
-#include "display/moduleentityposition.h"
-#include "display/moduleentitycamera.h"
-#include "display/moduleentitymesh.h"
-#include "display/moduleentitymaterial.h"
-#include "physics/moduleentityphysics.h"
-#include "script/moduleentityscript.h"
-
-void moduleEntity(scriptcontext_t *ctx) {
-  assertNotNull(ctx, "Script context cannot be NULL");
-
-  lua_register(ctx->luaState, "entityAdd", moduleEntityAdd);
-  lua_register(ctx->luaState, "entityRemove", moduleEntityRemove);
-
-  moduleEntityPosition(ctx);
-  moduleEntityCamera(ctx);
-  moduleEntityMesh(ctx);
-  moduleEntityMaterial(ctx);
-  moduleEntityPhysics(ctx);
-  moduleEntityScript(ctx);
-}
-
-int moduleEntityAdd(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t id = entityManagerAdd();
-  lua_pushnumber(L, (lua_Number)id);
-  return 1;
-}
-
-int moduleEntityRemove(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  if(!lua_isnumber(L, 1)) {
-    luaL_error(L, "entityRemove requires a number entity ID");
-    return 0;
-  }
-
-  entityid_t id = (entityid_t)luaL_checknumber(L, 1);
-  entityDispose(id);
-  return 0;
-}

src/dusk/script/module/entity/moduleentity.h

@@ -6,27 +6,200 @@
  */
 
 #pragma once
-#include "script/scriptcontext.h"
+#include "script/module/modulebase.h"
+#include "script/scriptproto.h"
+#include "entity/entity.h"
+#include "entity/entitymanager.h"
 
-/**
- * Register the entity module within the given script context.
- *
- * @param ctx The script context to register the module in.
- */
-void moduleEntity(scriptcontext_t *ctx);
+#include "component/moduleentityposition.h"
+#include "component/moduleentitycamera.h"
+#include "component/moduleentitymesh.h"
+#include "component/moduleentitymaterial.h"
+#include "component/moduleentityphysics.h"
 
-/**
- * Lua binding for entityManagerAdd - creates a new entity and returns its ID.
- *
- * @param L The Lua state.
- * @return int Number of return values on the Lua stack.
- */
-int moduleEntityAdd(lua_State *L);
+typedef struct {
+  entityid_t id;
+} entityscript_t;
 
-/**
- * Lua binding for entityDispose - disposes of an entity by its ID.
- *
- * @param L The Lua state.
- * @return int Number of return values on the Lua stack.
- */
-int moduleEntityRemove(lua_State *L);
+static scriptproto_t MODULE_ENTITY_PROTO;
+
+// Getters
+moduleBaseFunction(moduleEntityGetId) {
+  entityscript_t *inst = (entityscript_t*)scriptProtoGetValue(
+    &MODULE_ENTITY_PROTO, callInfo->this_value
+  );
+  if(!inst) return jerry_undefined();
+  return jerry_number(inst->id);
+}
+
+// Getter defined for each component type
+static jerry_value_t moduleEntityGetComponent(
+  const jerry_call_info_t *callInfo,
+  const jerry_value_t args[],
+  const jerry_length_t argc,
+  const componenttype_t type,
+  scriptproto_t *proto
+) {
+  assertNotNull(callInfo, "Call info must not be null");
+  assertTrue(argc >= 0, "Argc must be non-negative");
+  assertTrue(
+    type > COMPONENT_TYPE_NULL && type < COMPONENT_TYPE_COUNT,
+    "Invalid component type"
+  );
+  
+  entityid_t entityId;
+  componentid_t compId;
+
+  // Get the entity script data.
+  entityscript_t *inst = (entityscript_t*)scriptProtoGetValue(
+    &MODULE_ENTITY_PROTO, callInfo->this_value
+  );
+  if(!inst) return jerry_undefined();
+  entityId = inst->id;
+
+  // Find the component ID of the requested type.
+  compId = entityGetComponent(entityId, type);
+  if(compId == 0xFF) {
+    return jerry_undefined();
+  }
+  
+  componenthandle_t h = { .eid = entityId, .cid = compId };
+  return scriptProtoCreateValue(proto, &h);
+}
+
+#define X(enumName, type, field, init, dispose) \
+  moduleBaseFunction(moduleEntityGet##enumName) { \
+    return moduleEntityGetComponent( \
+      callInfo, \
+      args, \
+      argc, \
+      COMPONENT_TYPE_##enumName, \
+      &MODULE_ENTITY_##enumName##_PROTO \
+    ); \
+  }
+#include "entity/componentlist.h"
+#undef X
+
+moduleBaseFunction(moduleEntityToString) {
+  entityscript_t *inst = (entityscript_t*)scriptProtoGetValue(
+    &MODULE_ENTITY_PROTO, callInfo->this_value
+  );
+  if(!inst) return jerry_string_sz("Entity(?)");
+
+  char_t components[128];
+  size_t clen = 0;
+  bool_t first = true;
+
+  for(componenttype_t t = 1; t < COMPONENT_TYPE_COUNT; t++) {
+    if(entityGetComponent(inst->id, t) == 0xFF) continue;
+    if(!first) {
+      stringCopy(components + clen, ", ", sizeof(components) - clen);
+      clen += 2;
+    }
+    const char_t *name = COMPONENT_DEFINITIONS[t].enumName;
+    stringCopy(components + clen, name, sizeof(components) - clen);
+    clen += strlen(name);
+    first = false;
+  }
+
+  char_t buf[256];
+  if(first) {
+    stringFormat(
+      buf, sizeof(buf),
+      "{ \"id\": %d, \"components\": [] }", inst->id
+    );
+  } else {
+    stringFormat(
+      buf, sizeof(buf),
+      "{ \"id\": %d, \"components\": [ %s ] }", inst->id, components
+    );
+  }
+  return jerry_string_sz(buf);
+}
+
+// Methods
+moduleBaseFunction(moduleEntityConstructor) {
+  entityscript_t *inst = (entityscript_t*)memoryAllocate(
+    sizeof(entityscript_t)
+  );
+  inst->id = entityManagerAdd();
+  jerry_object_set_native_ptr(
+    callInfo->this_value, &MODULE_ENTITY_PROTO.info, inst
+  );
+  return jerry_undefined();
+}
+
+moduleBaseFunction(moduleEntityAddComponent) {
+  if(argc < 1 || !jerry_value_is_number(args[0])) {
+    return moduleBaseThrow("Entity.add: expected a valid component type");
+  }
+
+  componenttype_t type = (componenttype_t)jerry_value_as_number(args[0]);
+  if(type <= COMPONENT_TYPE_NULL || type >= COMPONENT_TYPE_COUNT) {
+    return moduleBaseThrow("Entity.add: invalid component type");
+  }
+
+  // Get the entity script data.
+  entityscript_t *inst = (entityscript_t*)scriptProtoGetValue(
+    &MODULE_ENTITY_PROTO, callInfo->this_value
+  );
+  if(!inst) return moduleBaseThrow("Entity.add: invalid entity");
+
+  componentid_t id = entityAddComponent(inst->id, type);
+  return jerry_number(id);
+}
+
+moduleBaseFunction(moduleEntityDisposeMethod) {
+  entityscript_t *inst = (entityscript_t*)scriptProtoGetValue(
+    &MODULE_ENTITY_PROTO, callInfo->this_value
+  );
+  if(!inst) return jerry_undefined();
+  entityDispose(inst->id);
+  return jerry_undefined();
+}
+
+static void moduleEntity(void) {
+  // Init the entity prototype
+  scriptProtoInit(
+    &MODULE_ENTITY_PROTO,
+    "Entity",
+    sizeof(entityscript_t),
+    moduleEntityConstructor
+  );
+
+  scriptProtoDefineToString(&MODULE_ENTITY_PROTO, moduleEntityToString);
+
+  // Entity Methods
+  scriptProtoDefineFunc(
+    &MODULE_ENTITY_PROTO, "add", moduleEntityAddComponent
+  );
+  scriptProtoDefineFunc(
+    &MODULE_ENTITY_PROTO, "dispose", moduleEntityDisposeMethod
+  );
+
+  // Entity props
+  scriptProtoDefineProp(
+    &MODULE_ENTITY_PROTO, "id", moduleEntityGetId, NULL
+  );
+
+  // Init component type modules.
+  char_t buffer[64];
+
+  #define X(enumName, type, field, iMethod, dMethod) \
+    moduleEntity##enumName(); \
+    scriptProtoDefineProp( \
+      &MODULE_ENTITY_PROTO, \
+      COMPONENT_DEFINITIONS[COMPONENT_TYPE_##enumName].name, \
+      moduleEntityGet##enumName, \
+      NULL \
+    ); \
+    snprintf( \
+      buffer, sizeof(buffer), \
+      "%s = %d\n", \
+      #enumName, \
+      COMPONENT_TYPE_##enumName \
+    ); \
+    moduleBaseEval(buffer);
+  #include "entity/componentlist.h"
+  #undef X
+}

src/dusk/script/module/entity/physics/moduleentityphysics.c

@@ -1,140 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleentityphysics.h"
-#include "assert/assert.h"
-#include "entity/entity.h"
-#include "entity/component/physics/entityphysics.h"
-
-void moduleEntityPhysics(scriptcontext_t *ctx) {
-  assertNotNull(ctx, "Script context cannot be NULL");
-
-  #define REG(name, func) lua_register(ctx->luaState, name, func)
-  REG("entityPhysicsAdd", moduleEntityPhysicsAdd);
-  REG("entityPhysicsSetVelocity", moduleEntityPhysicsSetVelocity);
-  REG("entityPhysicsGetVelocity", moduleEntityPhysicsGetVelocity);
-  REG("entityPhysicsApplyImpulse", moduleEntityPhysicsApplyImpulse);
-  REG("entityPhysicsIsOnGround", moduleEntityPhysicsIsOnGround);
-  REG("entityPhysicsSetShapeCube", moduleEntityPhysicsSetShapeCube);
-  REG("entityPhysicsSetShapeSphere", moduleEntityPhysicsSetShapeSphere);
-  REG("entityPhysicsSetShapeCapsule", moduleEntityPhysicsSetShapeCapsule);
-  REG("entityPhysicsSetShapePlane", moduleEntityPhysicsSetShapePlane);
-  #undef REG
-}
-
-int moduleEntityPhysicsAdd(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = entityAddComponent(entityId, COMPONENT_TYPE_PHYSICS);
-  lua_pushnumber(L, (lua_Number)compId);
-  return 1;
-}
-
-int moduleEntityPhysicsSetVelocity(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 vel = {
-    (float_t)luaL_checknumber(L, 3),
-    (float_t)luaL_checknumber(L, 4),
-    (float_t)luaL_checknumber(L, 5)
-  };
-  entityPhysicsSetVelocity(entityId, compId, vel);
-  return 0;
-}
-
-int moduleEntityPhysicsGetVelocity(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 vel;
-  entityPhysicsGetVelocity(entityId, compId, vel);
-  lua_pushnumber(L, vel[0]);
-  lua_pushnumber(L, vel[1]);
-  lua_pushnumber(L, vel[2]);
-  return 3;
-}
-
-int moduleEntityPhysicsApplyImpulse(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  vec3 impulse = {
-    (float_t)luaL_checknumber(L, 3),
-    (float_t)luaL_checknumber(L, 4),
-    (float_t)luaL_checknumber(L, 5)
-  };
-  entityPhysicsApplyImpulse(entityId, compId, impulse);
-  return 0;
-}
-
-int moduleEntityPhysicsIsOnGround(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  lua_pushboolean(L, (int)entityPhysicsIsOnGround(entityId, compId));
-  return 1;
-}
-
-int moduleEntityPhysicsSetShapeCube(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  physicsshape_t shape;
-  shape.type = PHYSICS_SHAPE_CUBE;
-  shape.data.cube.halfExtents[0] = (float_t)luaL_checknumber(L, 3);
-  shape.data.cube.halfExtents[1] = (float_t)luaL_checknumber(L, 4);
-  shape.data.cube.halfExtents[2] = (float_t)luaL_checknumber(L, 5);
-  entityPhysicsSetShape(entityId, compId, shape);
-  return 0;
-}
-
-int moduleEntityPhysicsSetShapeSphere(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  physicsshape_t shape;
-  shape.type = PHYSICS_SHAPE_SPHERE;
-  shape.data.sphere.radius = (float_t)luaL_checknumber(L, 3);
-  entityPhysicsSetShape(entityId, compId, shape);
-  return 0;
-}
-
-int moduleEntityPhysicsSetShapeCapsule(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  physicsshape_t shape;
-  shape.type = PHYSICS_SHAPE_CAPSULE;
-  shape.data.capsule.radius = (float_t)luaL_checknumber(L, 3);
-  shape.data.capsule.halfHeight = (float_t)luaL_checknumber(L, 4);
-  entityPhysicsSetShape(entityId, compId, shape);
-  return 0;
-}
-
-int moduleEntityPhysicsSetShapePlane(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  physicsshape_t shape;
-  shape.type = PHYSICS_SHAPE_PLANE;
-  shape.data.plane.normal[0] = (float_t)luaL_checknumber(L, 3);
-  shape.data.plane.normal[1] = (float_t)luaL_checknumber(L, 4);
-  shape.data.plane.normal[2] = (float_t)luaL_checknumber(L, 5);
-  shape.data.plane.distance = (float_t)luaL_checknumber(L, 6);
-  entityPhysicsSetShape(entityId, compId, shape);
-  return 0;
-}

src/dusk/script/module/entity/physics/moduleentityphysics.h

@@ -1,21 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-void moduleEntityPhysics(scriptcontext_t *ctx);
-
-int moduleEntityPhysicsAdd(lua_State *L);
-int moduleEntityPhysicsSetVelocity(lua_State *L);
-int moduleEntityPhysicsGetVelocity(lua_State *L);
-int moduleEntityPhysicsApplyImpulse(lua_State *L);
-int moduleEntityPhysicsIsOnGround(lua_State *L);
-int moduleEntityPhysicsSetShapeCube(lua_State *L);
-int moduleEntityPhysicsSetShapeSphere(lua_State *L);
-int moduleEntityPhysicsSetShapeCapsule(lua_State *L);
-int moduleEntityPhysicsSetShapePlane(lua_State *L);

src/dusk/script/module/entity/script/moduleentityscript.c

@@ -1,85 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleentityscript.h"
-#include "assert/assert.h"
-#include "entity/entity.h"
-#include "entity/entitymanager.h"
-#include "entity/component/script/entityscript.h"
-
-void moduleEntityScript(scriptcontext_t *ctx) {
-  assertNotNull(ctx, "Script context cannot be NULL");
-
-  #define REG(name, func) lua_register(ctx->luaState, name, func)
-  REG("entityScriptAdd", moduleEntityScriptAdd);
-  REG("entityScriptSetScript", moduleEntityScriptSetScript);
-  REG("entityScriptUpdate", moduleEntityScriptUpdate);
-  REG("entityAddScripted", moduleEntityAddScripted);
-  #undef REG
-}
-
-int moduleEntityScriptAdd(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = entityAddComponent(entityId, COMPONENT_TYPE_ENTITYSCRIPT);
-  lua_pushnumber(L, (lua_Number)compId);
-  return 1;
-}
-
-int moduleEntityScriptSetScript(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-  const char_t *filename = luaL_checkstring(L, 3);
-
-  errorret_t err = entityScriptSetScript(entityId, compId, filename);
-  if(err.code != ERROR_OK) {
-    luaL_error(L, "Failed to set entity script: %s", filename);
-    errorCatch(errorPrint(err));
-    return 0;
-  }
-
-  return 0;
-}
-
-int moduleEntityAddScripted(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  const char_t *filename = luaL_checkstring(L, 1);
-
-  entityid_t entityId = entityManagerAdd();
-  componentid_t compId = entityAddComponent(entityId, COMPONENT_TYPE_ENTITYSCRIPT);
-
-  errorret_t err = entityScriptSetScript(entityId, compId, filename);
-  if(err.code != ERROR_OK) {
-    luaL_error(L, "Failed to set entity script: %s", filename);
-    errorCatch(errorPrint(err));
-    return 0;
-  }
-
-  lua_pushnumber(L, (lua_Number)entityId);
-  lua_pushnumber(L, (lua_Number)compId);
-  return 2;
-}
-
-int moduleEntityScriptUpdate(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  entityid_t entityId = (entityid_t)luaL_checknumber(L, 1);
-  componentid_t compId = (componentid_t)luaL_checknumber(L, 2);
-
-  errorret_t err = entityScriptUpdate(entityId, compId);
-  if(err.code != ERROR_OK) {
-    luaL_error(L, "Failed to update entity script");
-    errorCatch(errorPrint(err));
-    return 0;
-  }
-
-  return 0;
-}

src/dusk/script/module/entity/script/moduleentityscript.h

@@ -1,16 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-void moduleEntityScript(scriptcontext_t *ctx);
-
-int moduleEntityScriptAdd(lua_State *L);
-int moduleEntityScriptSetScript(lua_State *L);
-int moduleEntityScriptUpdate(lua_State *L);
-int moduleEntityAddScripted(lua_State *L);

src/dusk/script/module/event/CMakeLists.txt

@@ -1,10 +0,0 @@
-# Copyright (c) 2025 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Sources
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    moduleevent.c
-)

src/dusk/script/module/event/moduleevent.c

@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "moduleevent.h"
-#include "event/event.h"
-#include "engine/engine.h"
-#include "assert/assert.h"
-
-int moduleEventSubscribe(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  // State has user pointer to owning scriptcontext_t
-  scriptcontext_t *context = *(scriptcontext_t **)lua_getextraspace(L);
-  assertNotNull(context, "Script context cannot be NULL");
-
-  // Expecting event pointer
-  if(!lua_islightuserdata(L, 1)) {
-    luaL_error(L, "eventSubscribe: Expected event pointer as first argument");
-    return 0;
-  }
-
-  // Expecting callback function (Lua function)
-  if(!lua_isfunction(L, 2)) {
-    luaL_error(L, "eventSubscribe: Expected function as second argument");
-    return 0;
-  }
-
-  event_t *event = (event_t *)lua_touserdata(L, 1);
-  assertNotNull(event, "Event cannot be NULL");
-
-  eventsub_t id = eventSubscribeScriptContext(event, context, 2);
-
-  // Pass back to lua.
-  lua_pushnumber(L, id);
-  return 1;
-}
-
-void moduleEvent(scriptcontext_t *context) {
-  // Reg functions
-  lua_register(context->luaState, "eventSubscribe", moduleEventSubscribe);
-}

src/dusk/script/module/event/moduleevent.h

@@ -1,21 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "script/scriptcontext.h"
-
-/**
- * Register event functions to the given script context.
- * 
- * @param context The script context to register event functions to.
- */
-void moduleEvent(scriptcontext_t *context);
-
-/**
- * Script binding for subscribing to an event.
- */
-int moduleEventSubscribe(lua_State *L);

src/dusk/script/module/input/CMakeLists.txt

@@ -1,10 +0,0 @@
-# Copyright (c) 2025 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Sources
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    moduleinput.c
-)