diff --git a/common/include/km_types.h b/common/include/km_types.h
index 05bc0aa432..cd0ca7f8d0 100644
--- a/common/include/km_types.h
+++ b/common/include/km_types.h
@@ -11,12 +11,20 @@
 
 #if defined(__LP64__) || defined(_LP64)
 /* 64-bit, g++ */
-#define KMX_64BIT
+#define KMX_REQUIRES_REALIGNMENT
 #endif
 
 #if defined(_WIN64) && !defined(USE_64)
 /* 64-bit, Windows */
-#define KMX_64BIT
+#define KMX_REQUIRES_REALIGNMENT
+#endif
+
+#if defined(__EMSCRIPTEN__)
+// Emscripten/WASM. Emscripten even though it uses 32-bit (and not 64-bit
+// pointers like the 64-bit architectures above) requires 32-bit alignment
+// for pointers which we don't always have in the KMX data from file
+// (see #12844).
+#define KMX_REQUIRES_REALIGNMENT
 #endif
 
 typedef uint32_t   KMX_DWORD;
diff --git a/core/include/keyman/keyman_core_api.h b/core/include/keyman/keyman_core_api.h
index 7863689296..6ed5847894 100644
--- a/core/include/keyman/keyman_core_api.h
+++ b/core/include/keyman/keyman_core_api.h
@@ -302,11 +302,15 @@ typedef uint8_t (*km_core_keyboard_imx_platform)(km_core_state*, uint32_t, void*
 
 ## Description
 
-An error code mechanism similar to COM’s `HRESULT` scheme (unlike COM, any
+An error code mechanism similar to COM's `HRESULT` scheme (unlike COM, any
 non-zero value is an error).
 
 ## Specification
 
+-->
+// keep in sync with web/src/engine/core-processor/src/core-factory.ts
+// (see https://github.com/emscripten-core/emscripten/issues/18585)
+<!--
 ```c */
 enum km_core_status_codes {
   KM_CORE_STATUS_OK = 0,
@@ -1162,7 +1166,7 @@ returned by [km_core_keyboard_load_from_blob].
 ```c */
 KMN_API
 void
-km_core_keyboard_dispose(km_core_keyboard *keyboard);
+km_core_keyboard_dispose(km_core_keyboard const* keyboard);
 
 /*
 ```
@@ -1380,7 +1384,7 @@ the environment passed.
 ```c */
 KMN_API
 km_core_status
-km_core_state_create(km_core_keyboard *keyboard,
+km_core_state_create(km_core_keyboard const *keyboard,
                     km_core_option_item const *env,
                     km_core_state **out);
 
@@ -1466,7 +1470,7 @@ invalid.
 ```c */
 KMN_API
 void
-km_core_state_dispose(km_core_state *state);
+km_core_state_dispose(km_core_state const *state);
 
 /*
 ```
@@ -1534,7 +1538,7 @@ Returns a debug formatted string of the context from the state.
 ```c */
 KMN_API
 km_core_cu *
-km_core_state_context_debug(km_core_state *state, km_core_debug_context_type context_type);
+km_core_state_context_debug(const km_core_state *state, km_core_debug_context_type context_type);
 
 /*
 ```
@@ -1673,7 +1677,7 @@ the state may also be modified.
 ```c */
 KMN_API
 km_core_status
-km_core_process_event(km_core_state *state,
+km_core_process_event(km_core_state const *state,
                      km_core_virtual_key vk,
                      uint16_t modifier_state,
                      uint8_t is_key_down,
@@ -1729,7 +1733,7 @@ the state may also be modified.
 KMN_API
 km_core_status
 km_core_event(
-  km_core_state *state,
+  km_core_state const *state,
   uint32_t event,
   void* data
 );
diff --git a/core/include/keyman/keyman_core_api_bits.h b/core/include/keyman/keyman_core_api_bits.h
index bd1f519bff..2fcc832f01 100644
--- a/core/include/keyman/keyman_core_api_bits.h
+++ b/core/include/keyman/keyman_core_api_bits.h
@@ -33,7 +33,7 @@
     #undef _kmn_export_flag
     #undef _kmn_import_flag
     #undef _kmn_static_flag
-  #else  // How MSVC sepcifies function level attributes adn deprecation
+  #else  // How MSVC sepcifies function level attributes and deprecation
     #define _kmn_and
     #define _kmn_tag_fn(a)     __declspec(a)
     #define _kmn_deprecated_flag deprecated
diff --git a/core/meson.build b/core/meson.build
index 01e016ad27..6b33f16202 100644
--- a/core/meson.build
+++ b/core/meson.build
@@ -37,7 +37,10 @@ endif
 
 # shared with a number of subdirs
 if cpp_compiler.get_id() == 'emscripten'
-  wasm_exported_runtime_methods = '-sEXPORTED_RUNTIME_METHODS=[\'UTF8ToString\',\'stringToNewUTF8\']'
+  wasm_exported_runtime_methods = '-sEXPORTED_RUNTIME_METHODS=[\'UTF8ToString\',\'stringToNewUTF8\',\'wasmExports\']'
+
+  # For Google Test
+  add_global_arguments('-pthread', language: [ 'cpp', 'c' ] )
 endif
 
 subdir('docs/internal')
diff --git a/core/src/km_core_keyboard_api.cpp b/core/src/km_core_keyboard_api.cpp
index 70d37fa63b..ab24e7b292 100644
--- a/core/src/km_core_keyboard_api.cpp
+++ b/core/src/km_core_keyboard_api.cpp
@@ -40,18 +40,16 @@ namespace
 }  // namespace
 
 km_core_status
-km_core_keyboard_load_from_blob(
+keyboard_load_from_blob_internal(
   const km_core_path_name kb_name,
-  const void* blob,
-  const size_t blob_size,
+  const std::vector<uint8_t>& buf,
   km_core_keyboard** keyboard
 ) {
   assert(keyboard);
-  if (!keyboard || !blob) {
+  if (!keyboard) {
     return KM_CORE_STATUS_INVALID_ARGUMENT;
   }
 
-  std::vector<uint8_t> buf((uint8_t*)blob, (uint8_t*)blob + blob_size);
   *keyboard = nullptr;
   try {
     abstract_processor* kp = processor_factory(kb_name, buf);
@@ -67,8 +65,23 @@ km_core_keyboard_load_from_blob(
   return KM_CORE_STATUS_OK;
 }
 
+km_core_status
+km_core_keyboard_load_from_blob(
+  const km_core_path_name kb_name,
+  const void* blob,
+  const size_t blob_size,
+  km_core_keyboard** keyboard
+) {
+  if (!blob) {
+    return KM_CORE_STATUS_INVALID_ARGUMENT;
+  }
+
+  std::vector<uint8_t> buf((uint8_t*)blob, (uint8_t*)blob + blob_size);
+  return keyboard_load_from_blob_internal(kb_name, buf, keyboard);
+}
+
 void
-km_core_keyboard_dispose(km_core_keyboard *keyboard)
+km_core_keyboard_dispose(km_core_keyboard const* keyboard)
 {
   delete keyboard;
 }
diff --git a/core/src/km_core_processevent_api.cpp b/core/src/km_core_processevent_api.cpp
index a2bca95ea8..736e5ee6e0 100644
--- a/core/src/km_core_processevent_api.cpp
+++ b/core/src/km_core_processevent_api.cpp
@@ -15,7 +15,7 @@
 
 km_core_status
 km_core_event(
-  km_core_state *state,
+  km_core_state const *state,
   uint32_t event,
   void* data
 ) {
@@ -37,19 +37,20 @@ km_core_event(
       return KM_CORE_STATUS_INVALID_ARGUMENT;
   }
 
-  return state->processor().external_event(state, event, data);
+  return const_cast<km_core_state*>(state)->processor().external_event(const_cast<km_core_state*>(state), event, data);
 }
 
 km_core_status
-km_core_process_event(km_core_state *state,
+km_core_process_event(km_core_state const *state_,
                      km_core_virtual_key vk,
                      uint16_t modifier_state,
                      uint8_t is_key_down,
                      uint16_t event_flags) {
-  assert(state != nullptr);
-  if(state == nullptr) {
+  assert(state_ != nullptr);
+  if(state_ == nullptr) {
     return KM_CORE_STATUS_INVALID_ARGUMENT;
   }
+  km_core_state *state = const_cast<km_core_state*>(state_);
   km_core_status status = state->processor().process_event(state, vk, modifier_state, is_key_down, event_flags);
 
   if (state_should_invalidate_context(state, vk, modifier_state, is_key_down, event_flags)) {
diff --git a/core/src/km_core_state_api.cpp b/core/src/km_core_state_api.cpp
index 6c74cd159b..82e24909f0 100644
--- a/core/src/km_core_state_api.cpp
+++ b/core/src/km_core_state_api.cpp
@@ -28,7 +28,7 @@ using namespace km::core;
 // Forward declarations
 class context;
 
-km_core_status km_core_state_create(km_core_keyboard * keyboard,
+km_core_status km_core_state_create(km_core_keyboard const *keyboard,
                                   km_core_option_item const *env,
                                   km_core_state ** out)
 {
@@ -38,7 +38,7 @@ km_core_status km_core_state_create(km_core_keyboard * keyboard,
 
   try
   {
-    *out = new km_core_state(static_cast<abstract_processor&>(*keyboard), env);
+    *out = new km_core_state(static_cast<abstract_processor&>(*const_cast<km_core_keyboard*>(keyboard)), env);
   }
   catch (std::bad_alloc &)
   {
@@ -60,7 +60,7 @@ km_core_status km_core_state_clone(km_core_state const *state,
 }
 
 
-void km_core_state_dispose(km_core_state *state)
+void km_core_state_dispose(km_core_state const *state)
 {
   delete state;
 }
@@ -301,10 +301,11 @@ km_core_cu * _new_error_string(std::u16string const str) {
 }
 
 km_core_cu * km_core_state_context_debug(
-  km_core_state *state,
+  const km_core_state *state_,
   km_core_debug_context_type context_type
 ) {
   km_core_context_item * context_items = nullptr;
+  km_core_state* state = const_cast<km_core_state*>(state_);
 
   if(context_type == KM_CORE_DEBUG_CONTEXT_INTERMEDIATE) {
     if(km_core_state_get_intermediate_context(state, &context_items) != KM_CORE_STATUS_OK) {
diff --git a/core/src/kmx/kmx_file.cpp b/core/src/kmx/kmx_file.cpp
index 2eea018581..ab90df7d52 100644
--- a/core/src/kmx/kmx_file.cpp
+++ b/core/src/kmx/kmx_file.cpp
@@ -68,11 +68,11 @@ KMX_BOOL KMX_ProcessEvent::LoadKeyboardFromBlob(
 
   *lpKeyboard = NULL;
 
-#ifdef KMX_64BIT
+#ifdef KMX_REQUIRES_REALIGNMENT
   // allocate enough memory for expanded data structure + original data.
-  // Expanded data structure is double the size of data on disk (8-byte
-  // pointers) - on disk the "pointers" are relative to the beginning of
-  // the file.
+  // Expanded data structure is no more than double the size of data on
+  // disk (8-byte pointers for 64-bit architectures) - on disk the
+  // "pointers" are relative to the beginning of the file.
   // We save the original data at the end of buf; we don't copy strings, so
   // those will remain in the location at the end of the buffer.
   buf = new KMX_BYTE[sz * 3];
@@ -84,7 +84,7 @@ KMX_BOOL KMX_ProcessEvent::LoadKeyboardFromBlob(
     DebugLog("Not allocmem");
     return FALSE;
   }
-#ifdef KMX_64BIT
+#ifdef KMX_REQUIRES_REALIGNMENT
   filebase = buf + sz * 2;
 #else
   filebase = buf;
@@ -103,7 +103,7 @@ KMX_BOOL KMX_ProcessEvent::LoadKeyboardFromBlob(
     return FALSE;
   }
 
-#ifdef KMX_64BIT
+#ifdef KMX_REQUIRES_REALIGNMENT
   kbp = CopyKeyboard(buf, filebase);
 #else
   kbp = FixupKeyboard(buf, filebase);
@@ -132,13 +132,15 @@ PKMX_WCHAR KMX_ProcessEvent::StringOffset(PKMX_BYTE base, KMX_DWORD offset)
   return (PKMX_WCHAR)(base + offset);
 }
 
-#ifdef KMX_64BIT
+#ifdef KMX_REQUIRES_REALIGNMENT
 /**
   CopyKeyboard will copy the data read into bufp from x86-sized structures into
   x64-sized structures starting at `base`
   * After this function finishes, we still need to keep the original data because
     we don't copy the strings
-  This method is used on 64-bit architectures.
+  This method is used on 64-bit architectures as well as with Emscripten.
+  Emscripten requires 32-bit alignment for pointers which we don't always
+  have in the KMX data (see #12844).
 */
 LPKEYBOARD KMX_ProcessEvent::CopyKeyboard(PKMX_BYTE bufp, PKMX_BYTE base)
 {
diff --git a/core/src/kmx/kmx_processevent.h b/core/src/kmx/kmx_processevent.h
index 8082c37833..fef6864cec 100644
--- a/core/src/kmx/kmx_processevent.h
+++ b/core/src/kmx/kmx_processevent.h
@@ -60,7 +60,7 @@ private:
   KMX_BOOL LoadKeyboardFromBlob(PKMX_BYTE buf, size_t sz, LPKEYBOARD* lpKeyboard);
   KMX_BOOL VerifyKeyboard(PKMX_BYTE filebase, size_t sz);
   KMX_BOOL VerifyChecksum(PKMX_BYTE buf,  size_t sz);
-#ifdef KMX_64BIT
+#ifdef KMX_REQUIRES_REALIGNMENT
   LPKEYBOARD CopyKeyboard(PKMX_BYTE bufp, PKMX_BYTE base);
 #else
   LPKEYBOARD FixupKeyboard(PKMX_BYTE bufp, PKMX_BYTE base);
diff --git a/core/src/layout.hpp b/core/src/layout.hpp
new file mode 100644
index 0000000000..2e3d2833b4
--- /dev/null
+++ b/core/src/layout.hpp
@@ -0,0 +1,185 @@
+/*
+ * Keyman is copyright (C) SIL International. MIT License.
+ *
+ * Keyman Keyboard Processor API - On-Screen Keyboard Layout Interfaces
+ */
+
+#pragma once
+
+#include <string>
+#include <map>
+#include <vector>
+
+#include "keyman_core_api.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * Possible directions of a flick
+ */
+enum keyboard_layout_flick_direction {
+  /** flick up (north) */
+  n = 0,
+  /** flick down (south) */
+  s = 1,
+  /** flick right (east) */
+  e = 2,
+  /** flick left (west) */
+  w = 3,
+  /** flick up-right (north-east) */
+  ne = 4,
+  /** flick up-left (north-west) */
+  nw = 5,
+  /** flick down-right (south-east) */
+  se = 6,
+  /** flick down-left (south-west) */
+  sw = 7
+};
+
+/**
+ * key type like regular key, framekeys, deadkeys, blank, etc.
+ */
+enum keyboard_layout_key_type {
+  /** regular key */
+  normal = 0,
+  /** A 'frame' key, such as Shift or Enter */
+  special = 1,
+  /** A 'frame' key, such as Shift or Enter, which is is active, such as
+   * the shift key on a shift layer */
+  specialActive = 2,
+  /** **KeymanWeb runtime private use:** a variant of `special` with the
+   *  keyboard font rather than 'KeymanwebOsk' font */
+  customSpecial = 3,
+  /** **KeymanWeb runtime private use:** a  variant of `specialActive` with the
+   *  keyboard font rather than 'KeymanwebOsk' font. */
+  customSpecialActive = 4,
+  /** A deadkey */
+  deadkey = 8,
+  /** A key which is rendered as a blank keycap, should block any interaction */
+  blank = 9,
+  /** Renders the key only as a gap or spacer, should block any interaction */
+  spacer = 10
+};
+
+/**
+ * A key on a touch layout/on-screen keyboard
+ */
+struct keyboard_layout_key {
+  /** key id */
+  std::u16string id;  // TODO-WEB-CORE: perhaps necessary for special keys, Enter, etc? or can we get that from virtualKey?
+  /** the virtual key code */
+  int virtualKey; // TODO-WEB-CORE: do we need this? both id and virtualKey? Or just one of them?
+  /** text to display on key cap */
+  std::u16string display;
+  /** hint e.g. for longpress */
+  std::u16string hint;
+  /** the type of key */
+  keyboard_layout_key_type type;
+
+  /**
+   * the modifier combination (not layer) that should be used in key events,
+   * for this key, overriding the layer that the key is a part of.
+   */
+  int modifiersOverride;
+  /** the next layer to switch to after this key is pressed */
+  std::u16string nextLayerId;
+
+  // touch layouts only
+
+  /** padding - space to the left of key (in what units?) */
+  int gap;
+  /** width of the key (in what units?) */
+  int width;
+
+  /** longpress keys, also known as subkeys */
+  std::vector<keyboard_layout_key> longpresses;
+  /** multitaps */
+  std::vector<keyboard_layout_key> multiTaps;
+  /** flicks */
+  std::map<keyboard_layout_flick_direction, keyboard_layout_key> flicks;
+};
+
+/**
+ * a row of keys on a touch layout/on-screen keyboard
+ */
+struct keyboard_layout_row {
+  /** row id */
+  int id; // TODO-WEB-CORE: do we need this? Web has it (`TouchLayoutRow`)
+  /** keys in this row */
+  std::vector<keyboard_layout_key> keys;
+};
+
+/**
+ * a layer with rows of keys on a touch layout/on-screen keyboard
+ */
+struct keyboard_layout_layer {
+  /** layer id */
+  std::u16string id;
+  /** layer modifiers */
+  // TODO-WEB-CORE: we added this during our discussion, but Web doesn't have it.
+  // Should be an enum if it's needed.
+  int modifiers;  //? 0 = default, n = shift, etc. -1 = unspecified?
+  /** rows in this layer */
+  std::vector<keyboard_layout_row> rows;
+};
+
+/**
+ * layout specification for a specific platform like desktop, phone or tablet
+ */
+struct keyboard_layout_platform {
+  /** platform form factor, e.g. 'iso', 'touch', 'ansi', ... (see ldml spec) */
+  std::u16string form;
+  /** width of screen for touch layout */
+  int minWidthMm;       // we don't have mobile vs tablet, instead use this
+  /** layers for this platform */
+  std::vector<keyboard_layout_layer> layers;
+
+  // TODO-WEB-CORE: Do we need these:
+  // Web additionally has:
+  // - font (should be in CSS; we have it in `keyboard_layout`)
+  // - fontsize (should be in CSS; we have it in `keyboard_layout`)
+  // - displayUnderlying
+  // - defaultHint ("none"|"dot"|"longpress"|"multitap"|"flick"|"flick-n"|"flick-ne"|
+  //               "flick-e"|"flick-se"|"flick-s"|"flick-sw"|"flick-w"|"flick-nw")
+};
+
+/**
+ * On screen keyboard description consisting of specific layouts for different
+ * form factors.
+ */
+struct keyboard_layout {
+  /** layouts for different form factors */
+  std::vector<keyboard_layout_platform> platforms;
+  /** font face name to use for key caps*/
+  std::string fontFacename;
+  /** font size to use for key caps */
+  int fontSizeEm;  // TODO-WEB-CORE: em? px? something else?
+};
+
+
+/**
+ * Get the on-screen keyboard layout for the specified keyboard.
+ *
+ * @param keyboard         [in]  The keyboard to get the layout for.
+ * @param layout           [out] The on-screen keyboard layout.
+ * @return km_core_status  `KM_CORE_STATUS_OK`: On success.
+ *                         `KM_CORE_STATUS_INVALID_ARGUMENT`: If `keyboard` is not a valid keyboard or `layout` is null.
+ */
+km_core_status
+keyboard_get_layout(
+  km_core_keyboard const* keyboard,
+  keyboard_layout**       layout
+);
+
+
+/**
+ * Dispose the on-screen keyboard layout.
+ */
+void
+keyboard_layout_dispose(keyboard_layout* layout);
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/core/src/meson.build b/core/src/meson.build
index 449dd3644f..128d72b7f7 100644
--- a/core/src/meson.build
+++ b/core/src/meson.build
@@ -32,8 +32,6 @@ else
 endif
 
 if cpp_compiler.get_id() == 'emscripten'
-  # TODO: why do we need this defn here?
-  defns += ['-DKM_CORE_LIBRARY']
   icu_if_not_on_wasm = []
 else
   # only include this if NOT on wasm.
@@ -54,19 +52,21 @@ if cpp_compiler.get_id() == 'emscripten'
     '-g', '-Wlimited-postlink-optimizations',
     '-lembind'
   ]
+  util_normalize_table_generator = executable(
+    'util_normalize_table_generator',
+    ['util_normalize_table_generator.cpp'],
+    cpp_args: defns + warns,
+    include_directories: [inc],
+    link_args: links,
+    dependencies: [icu_uc, icu_i18n],
+  )
 
-  util_normalize_table_generator = executable('util_normalize_table_generator',
-      ['util_normalize_table_generator.cpp'],
-      cpp_args: defns + warns,
-      include_directories: [inc],
-      link_args: links,
-      dependencies: [icu_uc, icu_i18n],
-      )
-
-  util_normalize_table_h = custom_target('util_normalize_table.h',
-                      output: 'util_normalize_table.h',
-                      command: [util_normalize_table_generator],
-                      capture:true)
+  util_normalize_table_h = custom_target(
+    'util_normalize_table.h',
+    output: 'util_normalize_table.h',
+    command: [util_normalize_table_generator],
+    capture:true
+  )
 
   generated_headers += util_normalize_table_h
 endif
@@ -122,6 +122,7 @@ api_files = files(
   'km_core_state_api.cpp',
   'km_core_debug_api.cpp',
   'km_core_processevent_api.cpp',
+  'wasm.cpp',
 )
 
 core_files = files(
@@ -137,6 +138,33 @@ mock_files = files(
   'mock/mock_processor.cpp',
 )
 
+extra_defns = []
+extra_links = []
+if cpp_compiler.get_id() == 'emscripten'
+  extra_defns += ['-g']
+  extra_links += ['-sSAFE_HEAP=1', wasm_exported_runtime_methods,
+    # Forcing inclusion of debug symbols
+    '-g', '-Wlimited-postlink-optimizations',
+    '--emit-tsd', 'keymancore.d.ts',
+    '-lembind'
+  ]
+  host_links = [
+    '--whole-archive',
+    '-sALLOW_MEMORY_GROWTH=1',
+    '-sMODULARIZE=1', '-sEXPORT_NAME=createCoreProcessor',
+    '-sEXPORT_ES6',
+    '-sENVIRONMENT=web,webview',
+    # '-sERROR_ON_UNDEFINED_SYMBOLS=0'
+  ]
+  node_links = [
+    '--whole-archive',
+    '-sALLOW_MEMORY_GROWTH=1',
+    '-sMODULARIZE=1', '-sEXPORT_NAME=createCoreProcessor',
+    '-sEXPORT_ES6',
+    '-sENVIRONMENT=node',
+  ]
+endif
+
 lib = library('keymancore',
   api_files,
   core_files,
@@ -144,8 +172,8 @@ lib = library('keymancore',
   mock_files,
   version_res,
   generated_headers,
-  cpp_args: defns + warns + flags,
-  link_args: links,
+  cpp_args: defns + extra_defns + warns + flags,
+  link_args: links + extra_links,
   version: lib_version,
   include_directories: inc,
   pic: true,
@@ -164,3 +192,31 @@ pkg.generate(
     description: 'Keyman processor for KMN keyboards.',
     subdirs: headerdirs,
     libraries: lib)
+
+if cpp_compiler.get_id() == 'emscripten'
+  # Build an executable for web/webview
+  host = executable('km-core',
+    cpp_args: defns + extra_defns,
+    include_directories: inc,
+    link_args: links + host_links + extra_links,
+    objects: lib.extract_all_objects(recursive: false))
+  # Build an executable for node (used for testing)
+  host = executable('km-core-node',
+    cpp_args: defns + extra_defns,
+    include_directories: inc,
+    link_args: links + node_links + extra_links,
+    objects: lib.extract_all_objects(recursive: false),
+    name_suffix: 'mjs')
+
+  if get_option('buildtype') == 'release'
+    # TODO: #12888
+    # Split debug symbols into separate wasm file for release builds only
+    # as the release symbols will be uploaded to sentry
+    # custom_target('core.wasm',
+    #   depends: host,
+    #   input: host,
+    #   output: 'core.wasm',
+    #   command: ['wasm-split', '@OUTDIR@/core.wasm', '-o', '@OUTPUT@', '--strip', '--debug-out=@OUTDIR@/core.debug.wasm'],
+    #   build_by_default: true)
+  endif
+endif
diff --git a/core/src/wasm.cpp b/core/src/wasm.cpp
new file mode 100644
index 0000000000..34487f937d
--- /dev/null
+++ b/core/src/wasm.cpp
@@ -0,0 +1,288 @@
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#include <emscripten/bind.h>
+#include <vector>
+
+#ifdef __cplusplus
+#define EXTERN extern "C" EMSCRIPTEN_KEEPALIVE
+#else
+#define EXTERN EMSCRIPTEN_KEEPALIVE
+#endif
+
+#include <keyman_core.h>
+#include "processor.hpp"
+#include "state.hpp"
+
+namespace em = emscripten;
+
+// This little bit of magic gives us implicit bindings for any `std::vector`,
+// so long as we bind `emscripten::value_object<T>`, and comes from:
+// https://github.com/emscripten-core/emscripten/issues/11070#issuecomment-717675128
+namespace emscripten {
+namespace internal {
+
+template <typename T, typename Allocator>
+struct BindingType<std::vector<T, Allocator>> {
+    using ValBinding = BindingType<val>;
+    using WireType = ValBinding::WireType;
+
+#if __EMSCRIPTEN_major__ == 3 && __EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ >= 60
+    // emscripten-core/emscripten#21692
+    static WireType toWireType(const std::vector<T, Allocator> &vec, rvp::default_tag) {
+        return ValBinding::toWireType(val::array(vec), rvp::default_tag{});
+    }
+#else
+    static WireType toWireType(const std::vector<T, Allocator> &vec) {
+        return ValBinding::toWireType(val::array(vec));
+    }
+#endif
+
+    static std::vector<T, Allocator> fromWireType(WireType value) {
+        return vecFromJSArray<T>(ValBinding::fromWireType(value));
+    }
+};
+
+template <typename T>
+struct TypeID<T,
+              typename std::enable_if_t<std::is_same<
+                  typename Canonicalized<T>::type,
+                  std::vector<typename Canonicalized<T>::type::value_type,
+                              typename Canonicalized<T>::type::allocator_type>>::value>> {
+    static constexpr TYPEID get() { return TypeID<val>::get(); }
+};
+
+}  // namespace internal
+}  // namespace emscripten
+
+constexpr km_core_attr const engine_attrs = {
+  256,
+  KM_CORE_LIB_CURRENT,
+  KM_CORE_LIB_AGE,
+  KM_CORE_LIB_REVISION,
+  KM_CORE_TECH_KMX,
+  "SIL International"
+};
+
+EMSCRIPTEN_KEEPALIVE km_core_attr const& tmp_wasm_attributes() {
+  return engine_attrs;
+}
+
+struct km_core_option_item_wasm {
+  std::u16string   key;
+  std::u16string   value;
+  uint8_t          scope;
+};
+
+
+class km_core_keyboard_attrs_wasm {
+public:
+  std::u16string version_string;
+  std::u16string id;
+  std::vector<km_core_option_item_wasm> default_options;
+};
+
+class km_core_actions_wasm {
+public:
+  unsigned int code_points_to_delete;
+  std::u32string output;
+  std::vector<km_core_option_item_wasm> persist_options;
+  bool do_alert;
+  bool emit_keystroke;
+  int new_caps_lock_state;
+  std::u32string deleted_context;
+};
+
+template <typename T> class CoreReturn {
+public:
+  CoreReturn(int status = 0, const T* obj = nullptr) : status(status), object(obj) {
+  }
+  void setStatus(int status) {
+    this->status = status;
+  }
+  int getStatus() const {
+    return status;
+  }
+  void setObject(const T* obj) {
+    object = obj;
+  }
+  const T* getObject() const {
+    return object;
+  }
+
+private:
+  int status;
+  const T* object;
+};
+
+km_core_status
+keyboard_load_from_blob_internal(const km_core_path_name kb_name, const std::vector<uint8_t>& buf, km_core_keyboard** keyboard);
+
+EMSCRIPTEN_KEEPALIVE const CoreReturn<km_core_keyboard>*
+km_core_keyboard_load_from_blob_wasm(
+  std::string kb_name,
+  const emscripten::val& blob_val
+) {
+  std::vector<uint8_t> blob = emscripten::convertJSArrayToNumberVector<uint8_t>(blob_val);
+  km_core_keyboard* keyboard_ptr = nullptr;
+
+  km_core_status retVal = ::keyboard_load_from_blob_internal(kb_name.c_str(), blob, &keyboard_ptr);
+  return new CoreReturn<km_core_keyboard>(retVal, keyboard_ptr);
+}
+
+EMSCRIPTEN_KEEPALIVE const CoreReturn<km_core_keyboard_attrs_wasm>*
+km_core_keyboard_get_attrs_wasm(const km_core_keyboard* keyboard) {
+  const km_core_keyboard_attrs* attrs = nullptr;
+  km_core_status retVal = km_core_keyboard_get_attrs(keyboard, &attrs);
+  km_core_keyboard_attrs_wasm* attrs_wasm = nullptr;
+  if (attrs) {
+    attrs_wasm = new km_core_keyboard_attrs_wasm();
+    attrs_wasm->version_string = std::u16string(attrs->version_string);
+    attrs_wasm->id = std::u16string(attrs->id);
+    for (const km_core_option_item* item = attrs->default_options; item->key; ++item) {
+      km_core_option_item_wasm item_wasm;
+      item_wasm.key = std::u16string(item->key);
+      item_wasm.value = std::u16string(item->value);
+      item_wasm.scope = item->scope;
+      attrs_wasm->default_options.push_back(item_wasm);
+    }
+  }
+  return new CoreReturn<km_core_keyboard_attrs_wasm>(retVal, attrs_wasm);
+}
+
+EMSCRIPTEN_KEEPALIVE const CoreReturn<km_core_state>*
+km_core_state_create_wasm(const km_core_keyboard* keyboard,
+                          const std::vector<km_core_option_item_wasm>& env) {
+  km_core_option_item* env_c = new km_core_option_item[env.size() + 1];
+  for (size_t i = 0; i < env.size(); ++i) {
+    env_c[i].key = env[i].key.c_str();
+    env_c[i].value = env[i].value.c_str();
+    env_c[i].scope = env[i].scope;
+  }
+  env_c[env.size()] = {nullptr, nullptr, 0};
+
+  km_core_state* state = nullptr;
+  km_core_status retVal = km_core_state_create(keyboard, env_c, &state);
+  delete[] env_c;
+  return new CoreReturn<km_core_state>(retVal, state);
+}
+
+EMSCRIPTEN_KEEPALIVE const CoreReturn<km_core_state>*
+km_core_state_clone_wasm(const km_core_state* state) {
+  km_core_state* new_state = nullptr;
+  km_core_status retVal = km_core_state_clone(state, &new_state);
+  return new CoreReturn<km_core_state>(retVal, new_state);
+}
+
+EMSCRIPTEN_KEEPALIVE int
+km_core_state_context_set_if_needed_wasm(
+  km_core_state const* state,
+std::u16string application_context) {
+  return km_core_state_context_set_if_needed(const_cast<km_core_state*>(state), application_context.c_str());
+}
+
+EMSCRIPTEN_KEEPALIVE std::u16string
+km_core_state_context_debug_wasm(const km_core_state* state, int context_type) {
+  std::u16string context;
+  km_core_cu* context_c = km_core_state_context_debug(state, static_cast<km_core_debug_context_type>(context_type));
+  if (context_c) {
+    context = std::u16string(context_c);
+    km_core_cu_dispose(context_c);
+  }
+  return context;
+}
+
+EMSCRIPTEN_KEEPALIVE km_core_actions_wasm*
+km_core_state_get_actions_wasm(km_core_state const *state) {
+  km_core_actions const* actions = km_core_state_get_actions(state);
+  km_core_actions_wasm* actions_wasm = new km_core_actions_wasm();
+  actions_wasm->code_points_to_delete = actions->code_points_to_delete;
+  actions_wasm->output = std::u32string(actions->output);
+  actions_wasm->do_alert = actions->do_alert;
+  actions_wasm->emit_keystroke = actions->emit_keystroke;
+  actions_wasm->new_caps_lock_state = actions->new_caps_lock_state;
+  actions_wasm->deleted_context = std::u32string(actions->deleted_context);
+  for (const km_core_option_item* item = actions->persist_options; item->key; ++item) {
+    km_core_option_item_wasm item_wasm;
+    item_wasm.key = std::u16string(item->key);
+    item_wasm.value = std::u16string(item->value);
+    item_wasm.scope = item->scope;
+    actions_wasm->persist_options.push_back(item_wasm);
+  }
+  return actions_wasm;
+}
+
+EMSCRIPTEN_BINDINGS(core_interface) {
+
+  em::value_object<km_core_attr>("km_core_attr")
+    .field("max_context", &km_core_attr::max_context)
+    .field("current", &km_core_attr::current)
+    .field("revision", &km_core_attr::revision)
+    .field("age", &km_core_attr::age)
+    .field("technology", &km_core_attr::technology)
+    //.field("vendor", &km_core_attr::vendor, em::allow_raw_pointers())
+    ;
+  em::value_object<km_core_option_item_wasm>("km_core_option_item")
+    .field("key", &km_core_option_item_wasm::key)
+    .field("value", &km_core_option_item_wasm::value)
+    .field("scope", &km_core_option_item_wasm::scope);
+
+  em::function("tmp_wasm_attributes", &tmp_wasm_attributes);
+
+
+  // Unfortunately embind has an open issue with enums and typescript where it
+  // only generates a type for the enum, but not the values in a usable way.
+  // Therefore it's not much use to expose the enum here.
+  // See https://github.com/emscripten-core/emscripten/issues/18585
+
+  // em::enum_<km_core_status_codes>("km_core_status_codes")
+  //   .value("OK", KM_CORE_STATUS_OK)
+  //   .value("NO_MEM", KM_CORE_STATUS_NO_MEM)
+  //   .value("IO_ERROR", KM_CORE_STATUS_IO_ERROR)
+  //   .value("INVALID_ARGUMENT", KM_CORE_STATUS_INVALID_ARGUMENT)
+  //   .value("KEY_ERROR", KM_CORE_STATUS_KEY_ERROR)
+  //   .value("INSUFFICENT_BUFFER", KM_CORE_STATUS_INSUFFICENT_BUFFER)
+  //   .value("INVALID_UTF", KM_CORE_STATUS_INVALID_UTF)
+  //   .value("INVALID_KEYBOARD", KM_CORE_STATUS_INVALID_KEYBOARD)
+  //   .value("NOT_IMPLEMENTED", KM_CORE_STATUS_NOT_IMPLEMENTED)
+  //   .value("OS_ERROR", KM_CORE_STATUS_OS_ERROR);
+
+  em::class_<km_core_keyboard>("km_core_keyboard");
+  em::class_<CoreReturn<km_core_keyboard>>("CoreKeyboardReturn")
+      .property("status", &CoreReturn<km_core_keyboard>::getStatus)
+      .property("object", &CoreReturn<km_core_keyboard>::getObject, em::allow_raw_pointers());
+  em::class_<CoreReturn<km_core_keyboard_attrs_wasm>>("CoreKeyboardAttrsReturn")
+      .property("status", &CoreReturn<km_core_keyboard_attrs_wasm>::getStatus)
+      .property("object", &CoreReturn<km_core_keyboard_attrs_wasm>::getObject, em::allow_raw_pointers());
+  em::class_<km_core_keyboard_attrs_wasm>("km_core_keyboard_attrs")
+    .property("version_string", &km_core_keyboard_attrs_wasm::version_string)
+    .property("id", &km_core_keyboard_attrs_wasm::id)
+    .property("default_options", &km_core_keyboard_attrs_wasm::default_options);
+  em::class_<km_core_actions_wasm>("km_core_actions")
+    .property("code_points_to_delete", &km_core_actions_wasm::code_points_to_delete)
+    .property("output", &km_core_actions_wasm::output)
+    .property("persist_options", &km_core_actions_wasm::persist_options)
+    .property("do_alert", &km_core_actions_wasm::do_alert)
+    .property("emit_keystroke", &km_core_actions_wasm::emit_keystroke)
+    .property("new_caps_lock_state", &km_core_actions_wasm::new_caps_lock_state)
+    .property("deleted_context", &km_core_actions_wasm::deleted_context);
+
+  em::class_<km_core_state>("km_core_state");
+  em::class_<CoreReturn<km_core_state>>("CoreStateReturn")
+      .property("status", &CoreReturn<km_core_state>::getStatus)
+      .property("object", &CoreReturn<km_core_state>::getObject, em::allow_raw_pointers());
+
+  em::function("keyboard_load_from_blob", &km_core_keyboard_load_from_blob_wasm, em::allow_raw_pointers());
+  em::function("keyboard_dispose", &km_core_keyboard_dispose, em::allow_raw_pointers());
+  em::function("keyboard_get_attrs", &km_core_keyboard_get_attrs_wasm, em::allow_raw_pointers());
+  em::function("state_create", &km_core_state_create_wasm, em::allow_raw_pointers());
+  em::function("state_clone", &km_core_state_clone_wasm, em::allow_raw_pointers());
+  em::function("state_dispose", &km_core_state_dispose, em::allow_raw_pointers());
+  em::function("process_event", &km_core_process_event, em::allow_raw_pointers());
+
+  em::function("state_context_set_if_needed", &km_core_state_context_set_if_needed_wasm, em::allow_raw_pointers());
+  em::function("state_context_clear", &km_core_state_context_clear, em::allow_raw_pointers());
+  em::function("state_context_debug", &km_core_state_context_debug_wasm, em::allow_raw_pointers());
+
+  em::function("state_get_actions", &km_core_state_get_actions_wasm, em::allow_raw_pointers());
+}
+#endif
diff --git a/core/tests/meson.build b/core/tests/meson.build
index ce0f68a257..1f686c260d 100644
--- a/core/tests/meson.build
+++ b/core/tests/meson.build
@@ -10,10 +10,7 @@
 cmpfiles = ['-c', 'import sys; a = open(sys.argv[1], \'r\').read(); b = open(sys.argv[2], \'r\').read(); sys.exit(not (a==b))']
 stnds = join_paths(meson.current_source_dir(), 'standards')
 
-libsrc = include_directories(
-  '../src',
-  '../../common/include'
-)
+libsrc = include_directories('../src')
 
 # kmx_test_source is required for linux builds, so always enable it even when we
 # disable all other tests
diff --git a/core/tests/unit/json/meson.build b/core/tests/unit/json/meson.build
index 6289d7db0c..aaed69104e 100644
--- a/core/tests/unit/json/meson.build
+++ b/core/tests/unit/json/meson.build
@@ -11,7 +11,7 @@ else
 endif
 
 e = executable('jsontest', 'jsontest.cpp',
-    include_directories: [libsrc],
+    include_directories: [inc, libsrc],
     link_args: links + tests_flags,
     objects: lib.extract_objects('jsonpp.cpp'))
 test('jsontest', e, args: 'jsontest.json')
diff --git a/core/tests/unit/kmx/meson.build b/core/tests/unit/kmx/meson.build
index 22158b6a83..71e2aed1b5 100644
--- a/core/tests/unit/kmx/meson.build
+++ b/core/tests/unit/kmx/meson.build
@@ -239,7 +239,7 @@ kbd_log = custom_target(test_kbd + '.kmx'.underscorify(),
   input: kbd_src,
   command: kmc_cmd + ['build', '--debug', '--no-compiler-version', '@INPUT@', '--out-file', kbd_obj]
 )
-  test('imx_list', imx_e,  depends: kbd_log, args: [kbd_obj] )
+test('imx_list', imx_e,  depends: kbd_log, args: [kbd_obj] )
 
 external_e = executable('ext_event_tests', ['kmx_external_event.tests.cpp', common_test_files],
                 cpp_args: defns + warns,
@@ -258,4 +258,4 @@ kbd_log = custom_target(test_kbd + '.kmx'.underscorify(),
   input: kbd_src,
   command: kmc_cmd + ['build', '--debug', '--no-compiler-version', '@INPUT@', '--out-file', kbd_obj]
 )
-  test('ext_event', external_e,  depends: kbd_log, args: [kbd_obj] )
+test('ext_event', external_e,  depends: kbd_log, args: [kbd_obj] )
diff --git a/core/tests/unit/meson.build b/core/tests/unit/meson.build
index 0637ace96e..3f661f6cac 100644
--- a/core/tests/unit/meson.build
+++ b/core/tests/unit/meson.build
@@ -53,3 +53,4 @@ subdir('utftest')
 subdir('kmnkbd')
 subdir('kmx')
 subdir('ldml')
+subdir('wasm')
diff --git a/core/tests/unit/utftest/meson.build b/core/tests/unit/utftest/meson.build
index c82b6f98c5..70253739b3 100644
--- a/core/tests/unit/utftest/meson.build
+++ b/core/tests/unit/utftest/meson.build
@@ -6,5 +6,5 @@
 
 e = executable('utftest', 'utftest.tests.cpp',
                objects: lib.extract_objects('../../common/cpp/utfcodec.cpp'),
-               include_directories: [libsrc])
+               include_directories: [inc, libsrc])
 test('utftest', e)
diff --git a/core/tests/unit/wasm/meson.build b/core/tests/unit/wasm/meson.build
new file mode 100644
index 0000000000..b563894407
--- /dev/null
+++ b/core/tests/unit/wasm/meson.build
@@ -0,0 +1,5 @@
+if cpp_compiler.get_id() == 'emscripten'
+  npm = find_program('npm', required: true)
+
+  test('wasm-tests', npm, args: ['test'], workdir: meson.current_source_dir())
+endif
diff --git a/core/tests/unit/wasm/package-lock.json b/core/tests/unit/wasm/package-lock.json
new file mode 100644
index 0000000000..f2c3485da5
--- /dev/null
+++ b/core/tests/unit/wasm/package-lock.json
@@ -0,0 +1,1425 @@
+{
+  "name": "wasm-tests",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "wasm-tests",
+      "version": "1.0.0",
+      "license": "MIT",
+      "devDependencies": {
+        "chai": "^5.1.2",
+        "mocha": "^11.0.1"
+      }
+    },
+    "node_modules/@isaacs/cliui": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
+      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^5.1.2",
+        "string-width-cjs": "npm:string-width@^4.2.0",
+        "strip-ansi": "^7.0.1",
+        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+        "wrap-ansi": "^8.1.0",
+        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@pkgjs/parseargs": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/ansi-colors": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
+      "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
+      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/browser-stdout": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz",
+      "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/camelcase": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
+      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/chai": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.1.2.tgz",
+      "integrity": "sha512-aGtmf24DW6MLHHG5gCx4zaI3uBq3KRtxeVs0DjFH6Z0rDNbsvTxFASFvdj79pxjxZ8/5u3PIiN3IwEIQkiiuPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chalk/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/check-error": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
+      "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
+      "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.0",
+        "wrap-ansi": "^7.0.0"
+      }
+    },
+    "node_modules/cliui/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cliui/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cliui/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cliui/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cliui/node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decamelize": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz",
+      "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/diff": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz",
+      "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.3.1"
+      }
+    },
+    "node_modules/eastasianwidth": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz",
+      "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "bin": {
+        "flat": "cli.js"
+      }
+    },
+    "node_modules/foreground-child": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.0.tgz",
+      "integrity": "sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "cross-spawn": "^7.0.0",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/glob": {
+      "version": "10.4.5",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+      "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/he": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
+      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "he": "bin/he"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/is-plain-obj": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
+      "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-unicode-supported": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz",
+      "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/jackspeak": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
+      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/cliui": "^8.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      },
+      "optionalDependencies": {
+        "@pkgjs/parseargs": "^0.11.0"
+      }
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/log-symbols": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
+      "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^4.1.0",
+        "is-unicode-supported": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/loupe": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.1.2.tgz",
+      "integrity": "sha512-23I4pFZHmAemUnz8WZXbYRSKYj801VDaNv9ETuMh7IrMc7VuVVSo+Z9iLE3ni30+U48iDWfi30d3twAXBYmnCg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/minimatch": {
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/mocha": {
+      "version": "11.0.1",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.0.1.tgz",
+      "integrity": "sha512-+3GkODfsDG71KSCQhc4IekSW+ItCK/kiez1Z28ksWvYhKXV/syxMlerR/sC7whDp7IyreZ4YxceMLdTs5hQE8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-colors": "^4.1.3",
+        "browser-stdout": "^1.3.1",
+        "chokidar": "^3.5.3",
+        "debug": "^4.3.5",
+        "diff": "^5.2.0",
+        "escape-string-regexp": "^4.0.0",
+        "find-up": "^5.0.0",
+        "glob": "^10.4.5",
+        "he": "^1.2.0",
+        "js-yaml": "^4.1.0",
+        "log-symbols": "^4.1.0",
+        "minimatch": "^5.1.6",
+        "ms": "^2.1.3",
+        "serialize-javascript": "^6.0.2",
+        "strip-json-comments": "^3.1.1",
+        "supports-color": "^8.1.1",
+        "workerpool": "^6.5.1",
+        "yargs": "^16.2.0",
+        "yargs-parser": "^20.2.9",
+        "yargs-unparser": "^2.0.0"
+      },
+      "bin": {
+        "_mocha": "bin/_mocha",
+        "mocha": "bin/mocha.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0"
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-scurry": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
+      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^10.2.0",
+        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/pathval": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.0.tgz",
+      "integrity": "sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.16"
+      }
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/randombytes": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
+      "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "^5.1.0"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/serialize-javascript": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
+      "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "randombytes": "^2.1.0"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/string-width-cjs": {
+      "name": "string-width",
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width-cjs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width-cjs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/string-width-cjs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
+      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/strip-ansi-cjs": {
+      "name": "strip-ansi",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi-cjs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/workerpool": {
+      "version": "6.5.1",
+      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz",
+      "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/wrap-ansi": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.1.0",
+        "string-width": "^5.0.1",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs": {
+      "name": "wrap-ansi",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/ansi-styles": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
+      "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "16.2.0",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
+      "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^7.0.2",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.0",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^20.2.2"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "20.2.9",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz",
+      "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs-unparser": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz",
+      "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "camelcase": "^6.0.0",
+        "decamelize": "^4.0.0",
+        "flat": "^5.0.2",
+        "is-plain-obj": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yargs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/yargs/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yargs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    }
+  }
+}
diff --git a/core/tests/unit/wasm/package.json b/core/tests/unit/wasm/package.json
new file mode 100644
index 0000000000..9736ad249e
--- /dev/null
+++ b/core/tests/unit/wasm/package.json
@@ -0,0 +1,16 @@
+{
+  "name": "wasm-tests",
+  "version": "1.0.0",
+  "description": "Unit tests for WASM version of Core",
+  "main": "tests.js",
+  "type": "module",
+  "scripts": {
+    "test": "mocha ."
+  },
+  "author": "SIL Global",
+  "license": "MIT",
+  "devDependencies": {
+    "chai": "^5.1.2",
+    "mocha": "^11.0.1"
+  }
+}
diff --git a/core/tests/unit/wasm/wasm.tests.js b/core/tests/unit/wasm/wasm.tests.js
new file mode 100644
index 0000000000..110ff6f888
--- /dev/null
+++ b/core/tests/unit/wasm/wasm.tests.js
@@ -0,0 +1,149 @@
+import { assert } from 'chai';
+import { fileURLToPath, pathToFileURL } from 'url';
+import fs from 'fs';
+import path from 'path';
+
+let km_core = null;
+
+describe('Unit tests for wasm Core API', function () {
+  let __dirname = null;
+
+  before(async function () {
+    // Define __dirname for ES modules
+    const filename = fileURLToPath(import.meta.url);
+    __dirname = path.join(path.dirname(filename), '../../../build/wasm/debug');
+
+    let km_core_file = path.join(__dirname, 'src/km-core-node.mjs');
+    if (!fs.existsSync(km_core_file)) {
+      __dirname = path.join(path.dirname(filename), '../../../build/wasm/release');
+      km_core_file = path.join(__dirname, 'src/km-core-node.mjs');
+    }
+    const wasmdir = path.dirname(km_core_file);
+    const module = await import(pathToFileURL(km_core_file));
+    const createCoreProcessor = module.default;
+    km_core = await createCoreProcessor({
+      locateFile: function (path, scriptDirectory) {
+        return wasmdir + '/' + path;
+      }
+    });
+  });
+
+  it('can load keyboard from blob', function () {
+    // Setup
+    const kmxdata = fs.readFileSync(path.join(__dirname, 'tests/unit/kmx/k_020___deadkeys_and_backspace.kmx'));
+
+    // Execute
+    const result = km_core.keyboard_load_from_blob('k_020___deadkeys_and_backspace', kmxdata);
+
+    // Verify
+    assert.equal(result.status, 0);
+    assert.isOk(result.object);
+  });
+
+  function loadKeyboard(name) {
+    const kmxdata = fs.readFileSync(path.join(__dirname, `tests/unit/kmx/${name}.kmx`));
+    const result = km_core.keyboard_load_from_blob(name, kmxdata);
+    assert.equal(result.status, 0);
+    assert.isOk(result.object);
+    return result.object;
+  }
+
+  function createState(keyboardName) {
+    const keyboard = loadKeyboard(keyboardName);
+    const state = km_core.state_create(keyboard, []);
+    assert.equal(state.status, 0);
+    assert.isOk(state.object);
+    return state.object;
+  }
+
+  it('can dispose keyboard', function () {
+    // Setup
+    const keyboard = loadKeyboard('k_020___deadkeys_and_backspace');
+
+    // Execute
+    km_core.keyboard_dispose(keyboard);
+  });
+
+  it('can get keyboard attributes', function () {
+    // Setup
+    const keyboard = loadKeyboard('k_022___options_with_preset');
+
+    // Execute
+    const result = km_core.keyboard_get_attrs(keyboard);
+
+    // Verify
+    assert.equal(result.status, 0);
+    assert.isOk(result.object);
+    assert.equal(result.object.id, 'k_022___options_with_preset');
+    assert.equal(result.object.version_string, '0.0');
+    assert.deepEqual(result.object.default_options, [{ key: 'foo', value: '0', scope: 1 }]);
+  });
+
+  it('can create the state object', function () {
+    // Setup
+    const keyboard = loadKeyboard('k_020___deadkeys_and_backspace');
+
+    // Execute
+    const result = km_core.state_create(keyboard, []);
+
+    // Verify
+    assert.equal(result.status, 0);
+    assert.isOk(result.object);
+  });
+
+  it('can dispose the state object', function () {
+    // Setup
+    const keyboard = loadKeyboard('k_020___deadkeys_and_backspace');
+    const state = km_core.state_create(keyboard, []);
+
+    // Execute
+    km_core.state_dispose(state.object);
+  });
+
+  it('can clone the state object', function () {
+    // Setup
+    const keyboard = loadKeyboard('k_020___deadkeys_and_backspace');
+    const state = km_core.state_create(keyboard, []);
+
+    // Execute
+    const result = km_core.state_clone(state.object);
+
+    // Verify
+    assert.equal(result.status, 0);
+    assert.isOk(result.object);
+    // TODO-web-core: add deeper tests
+  });
+
+  it('can process event', function () {
+    // Setup
+    const state = createState('k_020___deadkeys_and_backspace');
+
+    // Execute
+    const status = km_core.process_event(state, 0x20, 0, 1, 0);
+
+    // Verify
+    assert.equal(status, 0);
+
+    const actions = km_core.state_get_actions(state);
+    assert.equal(actions.output, ' ');
+    assert.lengthOf(actions.persist_options, 0);
+    assert.equal(actions.do_alert, false);
+    assert.equal(actions.emit_keystroke, false);
+    assert.equal(actions.new_caps_lock_state, -1);
+    assert.equal(actions.deleted_context, '');
+  });
+
+  it('can set the context', function () {
+    // Setup
+    const state = createState('k_020___deadkeys_and_backspace');
+
+    // Execute
+    const status = km_core.state_context_set_if_needed(state, 'abc');
+
+    // Verify
+    assert.equal(status, 1); // KM_CORE_CONTEXT_STATUS_UPDATED
+
+    const context = km_core.state_context_debug(state, 0);
+    assert.equal(context, '|abc| (len: 3) [ U+0061 U+0062 U+0063 ]');
+  });
+});
diff --git a/docs/minimum-versions.md b/docs/minimum-versions.md
index 19e0bf4420..25b2733ce0 100644
--- a/docs/minimum-versions.md
+++ b/docs/minimum-versions.md
@@ -61,7 +61,7 @@ https://help.keyman.com/developer/engine/android/latest-version/
 | KEYMAN_MIN_TARGET_VERSION_WINDOWS | 10 |
 | KEYMAN_MIN_VERSION_ANDROID_SDK | 21 |
 | KEYMAN_MIN_VERSION_CPP | 17 |
-| KEYMAN_MIN_VERSION_EMSCRIPTEN | 3.1.58 |
+| KEYMAN_MIN_VERSION_EMSCRIPTEN | 3.1.64 |
 | KEYMAN_MIN_VERSION_MESON | 1.0.0 |
 | KEYMAN_MIN_VERSION_NODE_MAJOR | 20 |
 | KEYMAN_MIN_VERSION_NPM | 10.5.1 |
diff --git a/linux/mcompile/keymap/mc_kmxfile.cpp b/linux/mcompile/keymap/mc_kmxfile.cpp
index 674da61fa1..039ae075f1 100644
--- a/linux/mcompile/keymap/mc_kmxfile.cpp
+++ b/linux/mcompile/keymap/mc_kmxfile.cpp
@@ -346,7 +346,7 @@ LPKMX_KEYBOARD CopyKeyboard(PKMX_BYTE bufp, PKMX_BYTE base) {
  * @return pointer to the keyboard
  */
 LPKMX_KEYBOARD KMX_FixupKeyboard(PKMX_BYTE bufp, PKMX_BYTE base, KMX_DWORD dwFileSize) {
-  UNREFERENCED_PARAMETER(dwFileSize);
+  // UNREFERENCED_PARAMETER(dwFileSize);
 
   KMX_DWORD i, j;
   PCOMP_KEYBOARD ckbp = (PCOMP_KEYBOARD)base;
@@ -369,9 +369,9 @@ LPKMX_KEYBOARD KMX_FixupKeyboard(PKMX_BYTE bufp, PKMX_BYTE base, KMX_DWORD dwFil
   for (gp = kbp->dpGroupArray, cgp = (PCOMP_GROUP)gp, i = 0; i < kbp->cxGroupArray; i++, gp++, cgp++) {
     gp->dpName = KMX_StringOffset(base, cgp->dpName);
     gp->dpKeyArray = (LPKMX_KEY)(base + cgp->dpKeyArray);
-    if (cgp->dpMatch != NULL)
+    if (cgp->dpMatch != 0)
       gp->dpMatch = (PKMX_WCHAR)(base + cgp->dpMatch);
-    if (cgp->dpNoMatch != NULL)
+    if (cgp->dpNoMatch != 0)
       gp->dpNoMatch = (PKMX_WCHAR)(base + cgp->dpNoMatch);
 
     for (kp = gp->dpKeyArray, ckp = (PCOMP_KEY)kp, j = 0; j < gp->cxKeyArray; j++, kp++, ckp++) {
diff --git a/package-lock.json b/package-lock.json
index c5286e36b4..c28480648e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14197,6 +14197,7 @@
         "@sentry/cli": "^2.31.0",
         "@zip.js/zip.js": "^2.7.32",
         "c8": "^7.12.0",
+        "express": "^4.19.2",
         "jsdom": "^23.0.1",
         "tsx": "^4.19.0"
       }
diff --git a/resources/build/builder-full.inc.sh b/resources/build/builder-full.inc.sh
index e937582565..ca4d7c38ac 100644
--- a/resources/build/builder-full.inc.sh
+++ b/resources/build/builder-full.inc.sh
@@ -14,7 +14,7 @@ set -eu
 # Prevents 'clear' on exit of mingw64 bash shell
 SHLVL=0
 
-function _builder_full_not_a_builder_script() {
+function __builder_full_not_a_builder_script() {
   if ! _builder_has_function_been_called builder_describe; then
     builder_echo warning "builder_describe was never called; script is not a valid builder script"
     exit 1
@@ -25,7 +25,7 @@ function _builder_full_not_a_builder_script() {
   fi
 }
 
-trap _builder_full_not_a_builder_script exit
+trap __builder_full_not_a_builder_script exit
 
 # This will also import /resources/builder.inc.sh
 . "${BASH_SOURCE[0]%/*}/builder-basic.inc.sh"
diff --git a/resources/build/minimum-versions.inc.sh b/resources/build/minimum-versions.inc.sh
index 8320c80954..c3b0a34519 100644
--- a/resources/build/minimum-versions.inc.sh
+++ b/resources/build/minimum-versions.inc.sh
@@ -28,7 +28,7 @@ KEYMAN_MIN_TARGET_VERSION_WEB_SAFARI=13.0     # iOS 13.0, macOS 10.13.6+
 # Dependency minimum versions
 KEYMAN_MIN_VERSION_NODE_MAJOR=20              # node version source of truth is /package.json:/engines/node; use KEYMAN_USE_NVM to automatically update
 KEYMAN_MIN_VERSION_NPM=10.5.1                 # 10.5.0 has bug, discussed in #10350
-KEYMAN_MIN_VERSION_EMSCRIPTEN=3.1.58          # Use KEYMAN_USE_EMSDK to automatically update to this version
+KEYMAN_MIN_VERSION_EMSCRIPTEN=3.1.64          # Use KEYMAN_USE_EMSDK to automatically update to this version
 KEYMAN_MIN_VERSION_VISUAL_STUDIO=2019
 KEYMAN_MIN_VERSION_MESON=1.0.0
 
diff --git a/web/README.md b/web/README.md
index 7f7415c698..5417309067 100644
--- a/web/README.md
+++ b/web/README.md
@@ -29,8 +29,9 @@ src/test/auto              A Node-driven test suite for automated testing of Key
 
 ## Usage
 
-Open **index.html** or **samples/index.html** in your browser. Be sure to
-compile Keyman Engine for Web before viewing the pages.
+Start the test server by running `./build.sh start`, then open
+your browser to http://localhost:3000. Be sure to compile Keyman Engine
+for Web before viewing the pages.
 
 Refer to the samples for usage details.
 
diff --git a/web/build.sh b/web/build.sh
index 4dc5189353..5c9b54647d 100755
--- a/web/build.sh
+++ b/web/build.sh
@@ -20,12 +20,14 @@ builder_describe "Builds engine modules for Keyman Engine for Web (KMW)." \
   "clean" \
   "configure" \
   "build" \
+  "start                     Starts the test server" \
   "test" \
   "coverage                  Create an HTML page with code coverage" \
   ":app/browser              The form of Keyman Engine for Web for use on websites" \
   ":app/webview              A puppetable version of KMW designed for use in a host app's WebView" \
   ":app/ui                   Builds KMW's desktop form-factor keyboard-selection UI modules" \
   ":engine/attachment        Subset used for detecting valid page contexts for use in text editing " \
+  ":engine/core-processor    Keyman Core WASM integration" \
   ":engine/common/web-utils  Low-level, headless utility methods and classes used across multiple modules" \
   ":engine/dom-utils         A common subset of function used for DOM calculations, layout, etc" \
   ":engine/events            Specialized classes utilized to support KMW API events" \
@@ -60,6 +62,7 @@ builder_describe_outputs \
   build:app/webview             "/web/build/app/webview/${config}/keymanweb-webview.js" \
   build:app/ui                  "/web/build/app/ui/${config}/kmwuitoggle.js" \
   build:engine/attachment       "/web/build/engine/attachment/lib/index.mjs" \
+  build:engine/core-processor   "/web/build/engine/core-processor/lib/index.mjs" \
   build:engine/dom-utils        "/web/build/engine/dom-utils/obj/index.js" \
   build:engine/events           "/web/build/engine/events/lib/index.mjs" \
   build:engine/element-wrappers "/web/build/engine/element-wrappers/lib/index.mjs" \
@@ -122,6 +125,9 @@ build_action() {
 
   tsc --project "${KEYMAN_ROOT}/web/src/test/auto/tsconfig.json"
 
+  mkdir -p "${KEYMAN_ROOT}/web/build/test/dom/cases/core-processor/import/core/"
+  cp "${KEYMAN_ROOT}/web/src/engine/core-processor/src/import/core/keymancore.d.ts" "${KEYMAN_ROOT}/web/build/test/dom/cases/core-processor/import/core/"
+
   for dir in \
     "${KEYMAN_ROOT}/web/build/test/dom/cases"/*/ \
     "${KEYMAN_ROOT}/web/build/test/integrated/" \
@@ -180,6 +186,9 @@ builder_run_child_actions build:engine/keyboard-storage
 builder_run_child_actions build:engine/predictive-text
 
 # Uses engine/interfaces, engine/keyboard-storage, engine/predictive-text, & engine/osk
+builder_run_child_actions build:engine/core-processor
+
+# Uses engine/interfaces, engine/keyboard-storage, & engine/osk
 builder_run_child_actions build:engine/main
 
 # Uses all but engine/element-wrappers and engine/attachment
@@ -214,3 +223,6 @@ builder_run_action test:help do_test_help
 
 # Create coverage report
 builder_run_action coverage:_all coverage_action
+
+# Start the test server
+builder_run_action start node src/tools/testing/test-server/index.cjs
diff --git a/web/docs/internal/context-state-management.md b/web/docs/internal/context-state-management.md
index 4c049a9092..910129ac0b 100644
--- a/web/docs/internal/context-state-management.md
+++ b/web/docs/internal/context-state-management.md
@@ -65,8 +65,8 @@ A cache of recent context-state transitions is stored at `keyman.core.contextCac
 
 For JS-keyboard keystroke processing, a `Mock` clone of the context is generated before any actual keyboard rule checks are applied.  This provides a clear "before" state (eventually saved at `Transcription.preInput`) useful for determining the scope of the keystroke's changes once processing is completed via `buildTranscriptionFrom`.
 
-Once keystroke processing is completed by a JS-keyboard, the JS-processor constructs a `RuleBehavior` object describing all primary and side effects of the keystroke.  Defined at [web/src/engine/js-processor/src/ruleBehavior.ts](https://github.com/keymanapp/keyman/blob/master/web/src/engine/js-processor/src/ruleBehavior.ts), all of its fields aside from `transcription` are specific to JS-keyboard side effects, some of which do need special handling and support outside of the keystroke processor.  None of these side effects apply for common-case keystrokes and so have default handling in place within the engine for cases where they are not needed.
+Once keystroke processing is completed by a JS-keyboard, the JS-processor constructs a `ProcessorAction` object describing all primary and side effects of the keystroke.  Defined at [web/src/engine/keyboard/src/keyboards/processorAction.ts](https://github.com/keymanapp/keyman/blob/master/web/src/engine/keyboard/src/keyboards/processorAction.ts), all of its fields aside from `transcription` are specific to JS-keyboard side effects, some of which do need special handling and support outside of the keystroke processor.  None of these side effects apply for common-case keystrokes and so have default handling in place within the engine for cases where they are not needed.
 
 ---
 
-In case referenced classes/files have moved:  this doc was last updated in 18.0-beta, based upon commit d1e45a0df49f81597887577a8c83af36d4a85283
\ No newline at end of file
+In case referenced classes/files have moved:  this doc was last updated in 19.0-alpha, based upon PR #14001.
diff --git a/web/docs/internal/keystroke-lifecycle.md b/web/docs/internal/keystroke-lifecycle.md
index c2e401b008..9940ac6d8e 100644
--- a/web/docs/internal/keystroke-lifecycle.md
+++ b/web/docs/internal/keystroke-lifecycle.md
@@ -212,13 +212,13 @@ host cleanly, as it may have special implications for the site or host app.
 
 With that out of the way, the JS keyboard's main group is then provided with the
 `KeyEvent` object in order to evaluate the keyboard's rules against the
-keystroke.  This involves constructing a `RuleBehavior` object to track any and
+keystroke.  This involves constructing a `ProcessorAction` object to track any and
 all needed side-effects for the keystroke.  Such changes are generally not
 applied to the engine at large at this time in order to prevent unwanted side
 effects that may arise to and from predictive text operations that follow
 shortly afterward.
 
-The `KeyboardInterface` class defines the internal API used by keyboards for
+The `JSKeyboardInterface` class defines the internal API used by keyboards for
 their evaluation of keyboard rules.
 
 Once the keyboard's script returns control to the main engine, the engine then
@@ -233,7 +233,7 @@ keyboard rules that is applied.  (A keyboard's source must _explicitly_ specify
 to not emit anything for such keys if such an outcome is desired.)  This occurs
 regardless of the keystroke's source, as such effects are necessary to
 incorporate for predictive-text operations.  If no such rule exists, the
-processor will add a note to the `RuleBehavior` object that default processing
+processor will add a note to the `ProcessorAction` object that default processing
 could not be provided and is thus needed from the engine's host.
 
 ### KMX keyboards & KMX+ (LDML) keyboards
@@ -263,12 +263,12 @@ detected.
 ### Keystroke post-processing
 
 At this stage, the side-effects desired for the original keystroke, as saved to
-its `RuleBehavior`, are then applied.  Note that this includes changes to the
+its `ProcessorAction`, are then applied.  Note that this includes changes to the
 `&layer` store - this update will also trigger an event that updates the state
 of the OSK to match the desired layer.
 
 Once that is done, the engine will then save data relevant to the original
-context state, the `KeyEvent`, and the `RuleBehavior` to the "context cache"
+context state, the `KeyEvent`, and the `ProcessorAction` to the "context cache"
 supporting multitap context reversion.  These effects include layer-change
 effects that result from JS keyboard rules, which modify the KMN-style keyboard
 stores `&oldlayer` and `&newlayer` in preparation for `begin PostKeystroke`
@@ -298,4 +298,4 @@ whether or not native handling for the keystroke should be triggered - such as
 for TAB and ENTER keys, which may have semantic command-like functionality
 depending on the state of the Web engine's host - be that a web page or an
 Android/iOS app utilizing the keyboard.  ENTER keys are often used to submit
-forms, and this helps ensure we trigger such functionality when appropriate.
\ No newline at end of file
+forms, and this helps ensure we trigger such functionality when appropriate.
diff --git a/web/docs/internal/keystroke-processing.md b/web/docs/internal/keystroke-processing.md
index 8606d18cba..0945615c09 100644
--- a/web/docs/internal/keystroke-processing.md
+++ b/web/docs/internal/keystroke-processing.md
@@ -19,9 +19,9 @@ When `true`, the keystroke processor will need to simulate the results of "stand
 
 On-screen keyboard modules and hardware-keyboard event interception modules will produce instances of `KeyEvent` as noted above.  Once this is completed, both module types will _signal_ the keystroke event by raising an event with ID `keyevent` and provide the `KeyEvent` instance as its first parameter.  The main module of the engine will then forward that `KeyEvent` object to the input processing pipeline via `InputProcessor.processKeyEvent` (see below).
 
-## Output:  RuleBehavior
+## Output:  ProcessorAction
 
-Once keystroke processing is completed, the outward-facing components of the engine expect to receive a `RuleBehavior` object describing all primary and side effects of the keystroke.  Defined at [web/src/engine/js-processor/src/ruleBehavior.ts](https://github.com/keymanapp/keyman/blob/master/web/src/engine/js-processor/src/ruleBehavior.ts), all of its fields aside from `transcription` are specific to existing JS-keyboard side effects.  (Certain Keyman language features can make permanent side-effect changes to state that should only be persisted for the "true" keystroke - not for any predictive-text 'alternative' keys.)
+Once keystroke processing is completed, the outward-facing components of the engine expect to receive a `ProcessorAction` object describing all primary and side effects of the keystroke.  Defined at [web/src/engine/keyboard/src/keyboards/processorAction.ts](https://github.com/keymanapp/keyman/blob/master/web/src/engine/keyboard/src/keyboards/processorAction.ts), all of its fields aside from `transcription` are specific to existing JS-keyboard side effects.  (Certain Keyman language features can make permanent side-effect changes to state that should only be persisted for the "true" keystroke - not for any predictive-text 'alternative' keys.)
 
 See also:  [context-state-management.md](context-state-management.md#js-keyboard-keystroke-processing)
 
@@ -31,7 +31,7 @@ See also:  [context-state-management.md](context-state-management.md#js-keyboard
 
 The "first stop" for incoming keystrokes is the `InputProcessor`, found at [web/src/engine/main/src/headless/inputProcessor.ts](https://github.com/keymanapp/keyman/blob/master/web/src/engine/main/src/headless/.inputProcessor.ts), through its `processKeyEvent` method.  This class manages higher-level functionality triggered by keystroke events while deferring actual interpretation of the incoming keystroke further down the line.  Of particular note is that it also handles control-flows that require restoration of previously-occuring contexts.
 
-This class is the connection point for generating prediction requests and receiving corresponding suggestions.  In order to facilitate higher-quality predictive-text when enabled, the `InputProcessor` will _also_ generate and trigger processing for nearby keys.  This process allows transforms, reorders, and KMN keyboard rules to take effect and be used as alternative context roots for predictions.  These are generally run against `Mock`-based clones of the true context source and are additionally prevented from triggering long-term side-effects, such as changes to KMN-keyboard variable stores, by only calling `RuleBehavior.finalize` for the true input keystroke's result object.
+This class is the connection point for generating prediction requests and receiving corresponding suggestions.  In order to facilitate higher-quality predictive-text when enabled, the `InputProcessor` will _also_ generate and trigger processing for nearby keys.  This process allows transforms, reorders, and KMN keyboard rules to take effect and be used as alternative context roots for predictions.  These are generally run against `Mock`-based clones of the true context source and are additionally prevented from triggering long-term side-effects, such as changes to KMN-keyboard variable stores, by only calling `KeyboardProcessor.finalizeProcessorAction` for the true input keystroke's result object.
 
 Keys generated by OSK multitap need special handling here as well; they should always be applied to the context state as it existed at the time of the initial tap.  To facilitate this, the `InputProcessor` will directly rewind the active context-source to match the corresponding context state before requesting that the `KeyEvent` be processed.
 
@@ -64,18 +64,17 @@ The method linked above is the primary entrypoint for rule processing of individ
 
 #### JS-keyboard interfacing
 
-Certain Keyman language features can make permanent side-effect changes to state.  In order to prevent these from taking place for every keystroke, the method that interfaces with JS keyboards - `KeyboardInterface.process` - saves the context state (as a `Mock`) and current variable store values, then prepares a fresh `RuleBehavior` instance, before passing control off to the keyboard's backing script.  (Note that `KeyboardInterface` itself primarily consists of keyboard-script API called by JS-keyboard script.)
-- `epic/web-core` note:  renamed to `JSKeyboardInterface`.
+Certain Keyman language features can make permanent side-effect changes to state.  In order to prevent these from taking place for every keystroke, the method that interfaces with JS keyboards - `JSKeyboardInterface.process` - saves the context state (as a `Mock`) and current variable store values, then prepares a fresh `ProcessorAction` instance, before passing control off to the keyboard's backing script.  (Note that `JSKeyboardInterface` itself primarily consists of keyboard-script API called by JS-keyboard script.)
 
-A few of the keyboard-script API methods will mark `RuleBehavior` properties directly when called, but the bulk of its data will be set once the keyboard-script returns control to Keyman Engine for Web.  At this time, variable store values will also be reverted to prevent possible cross-contamination effects when predictive text is active - they're reapplied later if `RuleBehavior.finalize` is leveraged on the resulting instance.  Components documented in [context-state-management.md](./context-state-management.md) are then leveraged to determine the total change to context caused by the keystroke.
+A few of the keyboard-script API methods will mark `ProcessorAction` properties directly when called, but the bulk of its data will be set once the keyboard-script returns control to Keyman Engine for Web.  At this time, variable store values will also be reverted to prevent possible cross-contamination effects when predictive text is active - they're reapplied later if `KeyboardProcessor.finalizeProcessorAction` is leveraged on the resulting instance.  Components documented in [context-state-management.md](./context-state-management.md) are then leveraged to determine the total change to context caused by the keystroke.
 
 Note that for JS-keyboards, in 18.0 and before the true keystroke is processed against the _true_ context state, not a cloned copy, and thus its changes are applied immediately.
 
 #### Keystroke-default emulation
 
-Note that browser-default keystroke processing is defined within the `DefaultRules` class found at [web/src/engine/keyboard/src/defaultRules.ts](https://github.com/keymanapp/keyman/blob/master/web/src/engine/keyboard/src/defaultRules.ts).  It currently produces a (possibly `null`) string output rather than a `RuleBehavior`, but the latter can be easily constructed based on the returned string and the existing context state.
+Note that browser-default keystroke processing is defined within the `DefaultRules` class found at [web/src/engine/keyboard/src/defaultRules.ts](https://github.com/keymanapp/keyman/blob/master/web/src/engine/keyboard/src/defaultRules.ts).  It currently produces a (possibly `null`) string output rather than a `ProcessorAction`, but the latter can be easily constructed based on the returned string and the existing context state.
 - For `epic/web-core`, it may be wise to spin the `DefaultRules` component off as its own processor, serving as a backup for _all_ keystroke processing variants.
 
 ----
 
-In case referenced classes/files have moved:  this doc was last updated in 18.0-beta, based upon commit d1e45a0df49f81597887577a8c83af36d4a85283
\ No newline at end of file
+In case referenced classes/files have moved:  this doc was last updated in 19.0-alpha, based upon PR #14001.
diff --git a/web/package.json b/web/package.json
index 3d73175202..5d3f9be6f6 100644
--- a/web/package.json
+++ b/web/package.json
@@ -12,10 +12,10 @@
       "types": "./build/engine/attachment/obj/index.d.ts",
       "import": "./build/engine/attachment/obj/index.js"
     },
-    "./engine/interfaces": {
-      "es6-bundling": "./src/engine/interfaces/src/index.ts",
-      "types": "./build/engine/interfaces/obj/index.d.ts",
-      "import": "./build/engine/interfaces/obj/index.js"
+    "./engine/core-processor": {
+      "es6-bundling": "./src/engine/core-processor/src/index.ts",
+      "types": "./build/engine/core-processor/obj/index.d.ts",
+      "import": "./build/engine/core-processor/obj/index.js"
     },
     "./engine/dom-utils": {
       "es6-bundling": "./src/engine/dom-utils/src/index.ts",
@@ -32,6 +32,11 @@
       "types": "./build/engine/events/obj/index.d.ts",
       "import": "./build/engine/events/obj/index.js"
     },
+    "./engine/interfaces": {
+      "es6-bundling": "./src/engine/interfaces/src/index.ts",
+      "types": "./build/engine/interfaces/obj/index.d.ts",
+      "import": "./build/engine/interfaces/obj/index.js"
+    },
     "./engine/js-processor": {
       "es6-bundling": "./src/engine/js-processor/src/index.ts",
       "types": "./build/engine/js-processor/obj/index.d.ts",
@@ -81,6 +86,10 @@
     "./engine/osk/internals": {
       "types": "./build/engine/osk/obj/test-index.d.ts",
       "import": "./build/engine/osk/obj/test-index.js"
+    },
+    "./tools/testing/test-utils": {
+      "types": "./build/tools/testing/test-utils/obj/index.d.ts",
+      "import": "./build/tools/testing/test-utils/obj/index.js"
     }
   },
   "imports": {
@@ -108,6 +117,7 @@
     "@sentry/cli": "^2.31.0",
     "@zip.js/zip.js": "^2.7.32",
     "c8": "^7.12.0",
+    "express": "^4.19.2",
     "jsdom": "^23.0.1",
     "tsx": "^4.19.0"
   },
diff --git a/web/src/app/browser/build.sh b/web/src/app/browser/build.sh
index a61ce1517c..ef23b7c046 100755
--- a/web/src/app/browser/build.sh
+++ b/web/src/app/browser/build.sh
@@ -72,6 +72,10 @@ compile_and_copy() {
   mkdir -p "$KEYMAN_ROOT/web/build/app/resources/osk"
   cp -R "$KEYMAN_ROOT/web/src/resources/osk/." "$KEYMAN_ROOT/web/build/app/resources/osk/"
 
+  # Copy Keyman Core build artifacts for local reference
+  cp "${KEYMAN_ROOT}/web/build/engine/core-processor/obj/import/core/"km-core.{js,wasm} "${KEYMAN_ROOT}/web/build/app/browser/debug/"
+  cp "${KEYMAN_ROOT}/web/build/engine/core-processor/obj/import/core/"km-core.{js,wasm} "${KEYMAN_ROOT}/web/build/app/browser/release/"
+
   # Update the build/publish copy of our build artifacts
   prepare
 
diff --git a/web/src/app/browser/src/beepHandler.ts b/web/src/app/browser/src/beepHandler.ts
index 6e23c09464..9d1896b10a 100644
--- a/web/src/app/browser/src/beepHandler.ts
+++ b/web/src/app/browser/src/beepHandler.ts
@@ -1,5 +1,6 @@
-import { type KeyboardInterface } from 'keyman/engine/js-processor';
-import { DesignIFrame, OutputTarget } from 'keyman/engine/element-wrappers';
+import { type JSKeyboardInterface } from 'keyman/engine/js-processor';
+import { JSKeyboard, type KeyboardMinimalInterface } from 'keyman/engine/keyboard';
+import { DesignIFrame, OutputTargetElementWrapper } from 'keyman/engine/element-wrappers';
 
 // Utility object used to handle beep (keyboard error response) operations.
 class BeepData {
@@ -17,9 +18,9 @@ class BeepData {
 }
 
 export class BeepHandler {
-  readonly keyboardInterface: KeyboardInterface;
+  readonly keyboardInterface: KeyboardMinimalInterface;
 
-  constructor(keyboardInterface: KeyboardInterface) {
+  constructor(keyboardInterface: KeyboardMinimalInterface) {
     this.keyboardInterface = keyboardInterface;
   }
 
@@ -32,8 +33,8 @@ export class BeepHandler {
    * @param       {Object}      Pelem     element to flash
    * Description  Flash body as substitute for audible beep; notify embedded device to vibrate
    */
-  beep(outputTarget: OutputTarget<any>) {
-    if(!(outputTarget instanceof OutputTarget)) {
+  beep(outputTarget: OutputTargetElementWrapper<any>) {
+    if (!(outputTarget instanceof OutputTargetElementWrapper)) {
       return;
     }
 
@@ -75,11 +76,13 @@ export class BeepHandler {
    * Description  Reset/terminate beep or flash (not currently used: Aug 2011)
    */
   readonly reset = () => {
-    this.keyboardInterface.resetContextCache();
+    // TODO-web-core: implement for KMX keyboards if needed
+    if (this.keyboardInterface.activeKeyboard instanceof JSKeyboard) {
+      (this.keyboardInterface as JSKeyboardInterface).resetContextCache();
+    }
 
-    let Lbo;
     this._BeepTimeout = 0;
-    for(Lbo=0;Lbo<this._BeepObjects.length;Lbo++) { // I1511 - array prototype extended
+    for(let Lbo=0;Lbo<this._BeepObjects.length;Lbo++) { // I1511 - array prototype extended
       this._BeepObjects[Lbo].reset();
     }
     this._BeepObjects = [];
diff --git a/web/src/app/browser/src/configuration.ts b/web/src/app/browser/src/configuration.ts
index df2153df82..0b01bbe130 100644
--- a/web/src/app/browser/src/configuration.ts
+++ b/web/src/app/browser/src/configuration.ts
@@ -1,7 +1,8 @@
 import { EngineConfiguration, InitOptionSpec, InitOptionDefaults } from "keyman/engine/main";
 
-import { OutputTarget as DOMOutputTarget } from 'keyman/engine/element-wrappers';
-import { isEmptyTransform, OutputTarget, RuleBehavior } from 'keyman/engine/js-processor';
+import { OutputTargetElementWrapper as DOMOutputTarget } from 'keyman/engine/element-wrappers';
+import { OutputTargetInterface, ProcessorAction } from 'keyman/engine/keyboard';
+import { isEmptyTransform } from 'keyman/engine/js-processor';
 import { AlertHost } from "./utils/alertHost.js";
 import { whenDocumentReady } from "./utils/documentReady.js";
 
@@ -65,7 +66,7 @@ export class BrowserConfiguration extends EngineConfiguration {
     return baseReport;
   }
 
-  onRuleFinalization(ruleBehavior: RuleBehavior, outputTarget: OutputTarget) {
+  onRuleFinalization(ruleBehavior: ProcessorAction, outputTarget: OutputTargetInterface) {
     // TODO: Patch up to modularized form.  But that doesn't exist yet for some of these...
 
     // If the transform isn't empty, we've changed text - which should produce a 'changed' event in the DOM.
diff --git a/web/src/app/browser/src/contextManager.ts b/web/src/app/browser/src/contextManager.ts
index c898544fb8..3826f78bb4 100644
--- a/web/src/app/browser/src/contextManager.ts
+++ b/web/src/app/browser/src/contextManager.ts
@@ -1,12 +1,12 @@
-import { type Keyboard, KeyboardScriptError } from 'keyman/engine/keyboard';
+import { JSKeyboard, type Keyboard, KeyboardScriptError } from 'keyman/engine/keyboard';
 import { type KeyboardStub } from 'keyman/engine/keyboard-storage';
 import { CookieSerializer } from 'keyman/engine/dom-utils';
 import { eventOutputTarget, outputTargetForElement, PageContextAttachment } from 'keyman/engine/attachment';
 import { DomEventTracker, LegacyEventEmitter } from 'keyman/engine/events';
-import { DesignIFrame, OutputTarget, nestedInstanceOf } from 'keyman/engine/element-wrappers';
+import { DesignIFrame, OutputTargetElementWrapper, nestedInstanceOf } from 'keyman/engine/element-wrappers';
 import {
   ContextManagerBase,
-  type KeyboardInterface,
+  type KeyboardInterfaceBase,
   LegacyAPIEvents
 } from 'keyman/engine/main';
 import { BrowserConfiguration } from './configuration.js';
@@ -23,10 +23,12 @@ export interface KeyboardCookie {
  * has the same directionality, text runs will be re-ordered which is confusing and causes
  * incorrect caret positioning
  *
- * @param       {Object}      Ptarg      Target element
+ * @param       {Object}      Ptarg           Target element
+ * @param       {Keyboard}    activeKeyboard  The active keyboard
  */
 function _SetTargDir(Ptarg: HTMLElement, activeKeyboard: Keyboard) {
-  const elDir = activeKeyboard?.isRTL ? 'rtl' : 'ltr';
+  // TODO-web-core: do we need to support RTL in Core?
+  const elDir = activeKeyboard instanceof JSKeyboard && activeKeyboard?.isRTL ? 'rtl' : 'ltr';
 
   if(Ptarg) {
     if(Ptarg instanceof Ptarg.ownerDocument.defaultView.HTMLInputElement
@@ -41,14 +43,14 @@ function _SetTargDir(Ptarg: HTMLElement, activeKeyboard: Keyboard) {
 }
 
 export default class ContextManager extends ContextManagerBase<BrowserConfiguration> {
-  private _activeKeyboard: {keyboard: Keyboard, metadata: KeyboardStub};
+  private _activeKeyboard: {keyboard: JSKeyboard, metadata: KeyboardStub};
   private cookieManager = new CookieSerializer<KeyboardCookie>('KeymanWeb_Keyboard');
   readonly focusAssistant = new FocusAssistant(() => this.activeTarget?.isForcingScroll());
   readonly page: PageContextAttachment;
-  private mostRecentTarget: OutputTarget<any>;
-  private currentTarget: OutputTarget<any>;
+  private mostRecentTarget: OutputTargetElementWrapper<any>;
+  private currentTarget: OutputTargetElementWrapper<any>;
 
-  private globalKeyboard: {keyboard: Keyboard, metadata: KeyboardStub};
+  private globalKeyboard: {keyboard: JSKeyboard, metadata: KeyboardStub};
 
   private _eventsObj: () => LegacyEventEmitter<LegacyAPIEvents>;
   private domEventTracker = new DomEventTracker();
@@ -173,7 +175,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
     });
   }
 
-  get activeTarget(): OutputTarget<any> {
+  get activeTarget(): OutputTargetElementWrapper<any> {
     /*
      * Assumption:  the maintainingFocus flag may only be set when there is a current target.
      * This is not enforced proactively at present, but the assumption should hold.  (2023-05-03)
@@ -182,7 +184,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
     return this.currentTarget || (maintainingFocus ? this.mostRecentTarget : null);
   }
 
-  get lastActiveTarget(): OutputTarget<any> {
+  get lastActiveTarget(): OutputTargetElementWrapper<any> {
     return this.mostRecentTarget;
   }
 
@@ -227,7 +229,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
     }
   }
 
-  public setActiveTarget(target: OutputTarget<any>, sendEvents?: boolean) {
+  public setActiveTarget(target: OutputTargetElementWrapper<any>, sendEvents?: boolean) {
     const previousTarget = this.mostRecentTarget;
     const originalTarget = this.activeTarget; // may differ, depending on focus state.
 
@@ -342,7 +344,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
     this.focusAssistant.restoringFocus = false;
   }
 
-  insertText(kbdInterface: KeyboardInterface<ContextManager>, Ptext: string, PdeadKey: number) {
+  insertText(kbdInterface: KeyboardInterfaceBase<ContextManager>, Ptext: string, PdeadKey: number) {
     // Find the correct output target to manipulate.  The user has likely be interacting with a
     // 'help page' keyboard, like desktop `sil_euro_latin`, and active browser focus on the
     // original context element may have been lost.
@@ -367,7 +369,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
    *
    * This is based on the current `.activeTarget` and its related attachment metadata.
    */
-  protected currentKeyboardSrcTarget(): OutputTarget<any> {
+  protected currentKeyboardSrcTarget(): OutputTargetElementWrapper<any> {
     const target = this.currentTarget || this.mostRecentTarget;
 
     if(this.isTargetKeyboardIndependent(target)) {
@@ -377,7 +379,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
     }
   }
 
-  private isTargetKeyboardIndependent(target: OutputTarget<any>): boolean {
+  private isTargetKeyboardIndependent(target: OutputTargetElementWrapper<any>): boolean {
     const attachmentInfo = target?.getElement()._kmwAttachment;
 
     // If null or undefined, we're in 'global' mode.
@@ -385,7 +387,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
   }
 
   // Note:  is part of the keyboard activation process.  Not to be called directly by published API.
-  activateKeyboardForTarget(kbd: {keyboard: Keyboard, metadata: KeyboardStub}, target: OutputTarget<any>) {
+  activateKeyboardForTarget(kbd: { keyboard: JSKeyboard, metadata: KeyboardStub }, target: OutputTargetElementWrapper<any>) {
     const attachment = target?.getElement()._kmwAttachment;
 
     if(!attachment) {
@@ -419,7 +421,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
    * @param target
    * @param metadata
    */
-  public setKeyboardForTarget(target: OutputTarget<any>, kbdId: string, langId: string) {
+  public setKeyboardForTarget(target: OutputTargetElementWrapper<any>, kbdId: string, langId: string) {
     if(target instanceof DesignIFrame) {
       console.warn("'keymanweb.setKeyboardForControl' cannot set keyboard on iframes.");
       return;
@@ -454,7 +456,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
     }
   }
 
-  public getKeyboardStubForTarget(target: OutputTarget<any>) {
+  public getKeyboardStubForTarget(target: OutputTargetElementWrapper<any>) {
     if(!this.isTargetKeyboardIndependent(target)) {
       return this.globalKeyboard.metadata;
     } else {
@@ -612,7 +614,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
    *                      The return value indicates whether (true) or not (false) the calling event handler
    *                      should be terminated immediately after the call.
    */
-  _CommonFocusHelper(outputTarget: OutputTarget<any>): boolean {
+  _CommonFocusHelper(outputTarget: OutputTargetElementWrapper<any>): boolean {
     const focusAssistant = this.focusAssistant;
 
     const activeKeyboard = this.activeKeyboard?.keyboard;
@@ -736,7 +738,7 @@ export default class ContextManager extends ContextManagerBase<BrowserConfigurat
     return true;
   }
 
-  doChangeEvent(target: OutputTarget<any>) {
+  doChangeEvent(target: OutputTargetElementWrapper<any>) {
     if(target.changed) {
       const event = new Event('change', {"bubbles": true, "cancelable": false});
       target.getElement().dispatchEvent(event);
diff --git a/web/src/app/browser/src/defaultBrowserRules.ts b/web/src/app/browser/src/defaultBrowserRules.ts
index 349fe4fed6..ec87f459d4 100644
--- a/web/src/app/browser/src/defaultBrowserRules.ts
+++ b/web/src/app/browser/src/defaultBrowserRules.ts
@@ -2,9 +2,9 @@ import { ModifierKeyConstants } from '@keymanapp/common-types';
 import {
   Codes,
   DefaultRules,
-  type KeyEvent
+  type KeyEvent,
+  type OutputTargetInterface
 } from 'keyman/engine/keyboard';
-import { type OutputTarget } from 'keyman/engine/js-processor';
 
 import ContextManager from './contextManager.js';
 
@@ -30,9 +30,9 @@ export default class DefaultBrowserRules extends DefaultRules {
   }
 
   /**
-   * applyCommand - used when a RuleBehavior represents a non-text "command" within the Engine.
+   * applyCommand - used when a ProcessorAction represents a non-text "command" within the Engine.
    */
-  applyCommand(Lkc: KeyEvent, outputTarget: OutputTarget): void {
+  applyCommand(Lkc: KeyEvent, outputTarget: OutputTargetInterface): void {
     const code = this.codeForEvent(Lkc);
 
     const moveToNext = (back: boolean) => {
diff --git a/web/src/app/browser/src/hardwareEventKeyboard.ts b/web/src/app/browser/src/hardwareEventKeyboard.ts
index ae5fa680a3..fde312baef 100644
--- a/web/src/app/browser/src/hardwareEventKeyboard.ts
+++ b/web/src/app/browser/src/hardwareEventKeyboard.ts
@@ -1,5 +1,5 @@
-import { Codes, DeviceSpec, KeyEvent, KeyMapping, Keyboard } from 'keyman/engine/keyboard';
-import { KeyboardProcessor } from 'keyman/engine/js-processor';
+import { Codes, DeviceSpec, KeyEvent, KeyMapping, JSKeyboard } from 'keyman/engine/keyboard';
+import { JSKeyboardProcessor } from 'keyman/engine/js-processor';
 import { ModifierKeyConstants } from '@keymanapp/common-types';
 
 import { HardKeyboardBase, processForMnemonicsAndLegacy } from 'keyman/engine/main';
@@ -10,7 +10,7 @@ import { eventOutputTarget, outputTargetForElement } from 'keyman/engine/attachm
 import ContextManager from './contextManager.js';
 
 type KeyboardState = {
-  activeKeyboard: Keyboard,
+  activeKeyboard: JSKeyboard,
   modStateFlags: number,
   baseLayout: string
 }
@@ -38,15 +38,23 @@ export function _GetEventKeyCode(e: KeyboardEvent) {
 // Keeping this as a separate function affords us the opportunity to unit-test the method more simply.
 
 /**
- * Function     _GetKeyEventProperties
- * Scope        Private
- * @param       {Event}       e         Event object
- * @return      {Object.<string,*>}     KMW keyboard event object:
- * Description  Get object with target element, key code, shift state, virtual key state
- *                Lcode=keyCode
- *                Lmodifiers=shiftState
- *                LisVirtualKeyCode e.g. ctrl/alt key
- *                LisVirtualKey     e.g. Virtual key or non-keypress event
+ * Translate a browser KeyboardEvent into a KeymanWeb KeyEvent
+ *
+ * The function calculates the true state of the keyboard's modifiers, taking
+ * into account chiral modifiers where applicable.
+ * Special handling is included for AltGr emulation and browser quirks, particularly
+ * for Firefox, which may use different key codes for certain keys. The code remaps
+ * these as needed for consistency. It adds the OS meta key if pressed, ensuring
+ * that system shortcuts can bypass Keyman processing. Adjustments are made for
+ * mnemonic and legacy keyboards, before finally returning a KeyEvent object
+ * with the computed key code, modifiers and state.
+ *
+ * @param  {KeyboardEvent}  e              Event object
+ * @param  {KeyboardState}  keyboardState  Keyboard state object
+ * @param  {DeviceSpec}     device         Device object
+ * @return {KeyEvent}                      KeymanWeb KeyEvent object, or null
+ *                                         for duplicate/spurious events or if
+ *                                         there is no key code.
  */
 export function preprocessKeyboardEvent(e: KeyboardEvent, keyboardState: KeyboardState, device: DeviceSpec): KeyEvent {
   if(e.cancelBubble === true) {
@@ -60,7 +68,6 @@ export function preprocessKeyboardEvent(e: KeyboardEvent, keyboardState: Keyboar
 
   // Stage 1 - track the true state of the keyboard's modifiers.
   const prevModState = keyboardState.modStateFlags;
-  let curModState = 0x0000;
   let ctrlEvent = false, altEvent = false;
 
   const keyCodes = Codes.keyCodes;
@@ -97,17 +104,18 @@ export function preprocessKeyboardEvent(e: KeyboardEvent, keyboardState: Keyboar
    * `e.location != 0` if true matches condition 1 and matches condition 2 if false.
    */
 
+  let curModState = 0x0000;
   curModState |= (e.getModifierState("Shift") ? 0x10 : 0);
 
   if(e.getModifierState("Control")) {
     curModState |= ((e.location != 0 && ctrlEvent) ?
       (e.location == 1 ? ModifierKeyConstants.LCTRLFLAG : ModifierKeyConstants.RCTRLFLAG) : // Condition 1
-      prevModState & 0x0003);                                                       // Condition 2
+      prevModState & 0x0003 /* LCTRLFLAG | RCTRLFLAG */);                                   // Condition 2
   }
   if(e.getModifierState("Alt")) {
     curModState |= ((e.location != 0 && altEvent) ?
       (e.location == 1 ? ModifierKeyConstants.LALTFLAG : ModifierKeyConstants.RALTFLAG) :   // Condition 1
-      prevModState & 0x000C);                                                       // Condition 2
+      prevModState & 0x000C /* LALTFLAG | RALTFLAG */);                                     // Condition 2
   }
 
   // Stage 2 - detect state key information.  It can be looked up per keypress with no issue.
@@ -122,7 +130,7 @@ export function preprocessKeyboardEvent(e: KeyboardEvent, keyboardState: Keyboar
   curModState |= Lstates;
 
   // Stage 3 - Set our modifier state tracking variable and perform basic AltGr-related management.
-  const LmodifierChange = keyboardState.modStateFlags != curModState;
+  const LmodifierChanged = keyboardState.modStateFlags != curModState;
 
   // KeyboardState update:  save our known modifier/state analysis bits.
   // Note:  `keyboardState` is typically the full-fledged KeyboardProcessor instance.  As a result,
@@ -140,8 +148,8 @@ export function preprocessKeyboardEvent(e: KeyboardEvent, keyboardState: Keyboar
     curModState &= ~ModifierKeyConstants.LCTRLFLAG;
   }
 
-  const modifierBitmasks = Codes.modifierBitmasks;
   // Stage 4 - map the modifier set to the appropriate keystroke's modifiers.
+  const modifierBitmasks = Codes.modifierBitmasks;
   const activeKeyboard = keyboardState.activeKeyboard;
   let Lmodifiers: number;
   if(activeKeyboard && activeKeyboard.isChiral) {
@@ -187,7 +195,7 @@ export function preprocessKeyboardEvent(e: KeyboardEvent, keyboardState: Keyboar
     Lcode: Lcode,
     Lmodifiers: Lmodifiers,
     Lstates: Lstates,
-    LmodifierChange: LmodifierChange,
+    LmodifierChange: LmodifierChanged,
     // This is based on a KeyboardEvent, so it's not considered 'synthetic' within web-core.
     isSynthetic: false
   });
@@ -210,13 +218,13 @@ export default class HardwareEventKeyboard extends HardKeyboardBase {
   // - `modStateFlags`
   // - `baseLayout`
   // - `doModifierPress()` - for modifier updates on key-up.
-  private readonly processor: KeyboardProcessor;
+  private readonly processor: JSKeyboardProcessor;
   private readonly contextManager: ContextManager;
   private domEventTracker = new DomEventTracker();
 
   private swallowKeypress: boolean = false;
 
-  constructor(hardDevice: DeviceSpec, processor: KeyboardProcessor, contextManager: ContextManager) {
+  constructor(hardDevice: DeviceSpec, processor: JSKeyboardProcessor, contextManager: ContextManager) {
     super();
     this.hardDevice = hardDevice;
     this.contextManager = contextManager;
diff --git a/web/src/app/browser/src/keyboardInterface.ts b/web/src/app/browser/src/keyboardInterface.ts
index e9b0bda379..69b1bc7447 100644
--- a/web/src/app/browser/src/keyboardInterface.ts
+++ b/web/src/app/browser/src/keyboardInterface.ts
@@ -1,11 +1,11 @@
-import { type OutputTarget } from 'keyman/engine/element-wrappers';
+import { type OutputTargetElementWrapper } from 'keyman/engine/element-wrappers';
 import { FloatingOSKView } from 'keyman/engine/osk';
-import { KeyboardInterface as KeyboardInterfaceBase } from 'keyman/engine/main';
+import { KeyboardInterfaceBase } from 'keyman/engine/main';
 
 import ContextManager from './contextManager.js';
 import { KeymanEngine } from './keymanEngine.js';
 
-export default class KeyboardInterface extends KeyboardInterfaceBase<ContextManager> {
+export class KeyboardInterface extends KeyboardInterfaceBase<ContextManager> {
   constructor(
     _jsGlobal: any,
     engine: KeymanEngine,
@@ -29,7 +29,7 @@ export default class KeyboardInterface extends KeyboardInterfaceBase<ContextMana
   /**
    * Legacy entry points (non-standard names)- included only to allow existing IME keyboards to continue to be used
    */
-  getLastActiveElement(): OutputTarget<any> {
+  getLastActiveElement(): OutputTargetElementWrapper<any> {
     return this.engine.contextManager.lastActiveTarget;
   }
 
diff --git a/web/src/app/browser/src/keymanEngine.ts b/web/src/app/browser/src/keymanEngine.ts
index 59987035cc..237eaf7b4e 100644
--- a/web/src/app/browser/src/keymanEngine.ts
+++ b/web/src/app/browser/src/keymanEngine.ts
@@ -1,13 +1,13 @@
 import { KeymanWebKeyboard } from '@keymanapp/common-types';
 import { KeymanEngineBase, DeviceDetector } from 'keyman/engine/main';
 import { getAbsoluteY } from 'keyman/engine/dom-utils';
-import { OutputTarget } from 'keyman/engine/element-wrappers';
+import { OutputTargetElementWrapper } from 'keyman/engine/element-wrappers';
 import {
   TwoStateActivator,
   VisualKeyboard
 } from 'keyman/engine/osk';
 import { ErrorStub, KeyboardStub, CloudQueryResult, toPrefixedKeyboardId as prefixed } from 'keyman/engine/keyboard-storage';
-import { DeviceSpec, Keyboard } from "keyman/engine/keyboard";
+import { DeviceSpec, JSKeyboard, Keyboard } from "keyman/engine/keyboard";
 import KeyboardObject = KeymanWebKeyboard.KeyboardObject;
 
 import * as views from './viewsAnchorpoint.js';
@@ -26,7 +26,7 @@ import { UtilApiEndpoint} from './utilApiEndpoint.js';
 import { UIModule } from './uiModuleInterface.js';
 import { HotkeyManager } from './hotkeyManager.js';
 import { BeepHandler } from './beepHandler.js';
-import KeyboardInterface from './keyboardInterface.js';
+import { KeyboardInterface } from './keyboardInterface.js';
 import { WorkerFactory } from '@keymanapp/lexical-model-layer/web';
 
 export class KeymanEngine extends KeymanEngineBase<BrowserConfiguration, ContextManager, HardwareEventKeyboard> {
@@ -76,7 +76,7 @@ export class KeymanEngine extends KeymanEngineBase<BrowserConfiguration, Context
 
     // Scrolls the document-body to ensure that a focused element remains visible after the OSK appears.
     this.contextManager.on('targetchange', (target) => {
-      const e = (target as OutputTarget<any>)?.getElement();
+      const e = (target as OutputTargetElementWrapper<any>)?.getElement();
       if(this.osk) {
         (this.osk.activationModel as TwoStateActivator<HTMLElement>).activationTrigger = e;
       }
@@ -192,11 +192,11 @@ export class KeymanEngine extends KeymanEngineBase<BrowserConfiguration, Context
     // globe key - are accessible.
     //
     // The `super` call above initializes `keyboardRequisitioner`, as needed here.
-    this.keyboardRequisitioner.cloudQueryEngine.once('unboundregister', () => {
+    this.keyboardRequisitioner.cloudQueryEngine.once('unboundregister', async () => {
       if(!this.contextManager.activeKeyboard?.keyboard) {
         // Autoselects this.keyboardRequisitioner.cache.defaultStub, which will be
         // set to an actual keyboard on mobile devices.
-        this.setActiveKeyboard('', '');
+        await this.setActiveKeyboard('', '');
       }
     });
 
@@ -277,7 +277,7 @@ export class KeymanEngine extends KeymanEngineBase<BrowserConfiguration, Context
    * Function     setKeyboardForControl
    * Scope        Public
    * @param       {Element}    Pelem    Control element
-   * @param       {string|null=}    Pkbd     Keyboard (Clears the set keyboard if set to null.)
+   * @param       {string|null=}    Pkbd     JSKeyboard (Clears the set keyboard if set to null.)
    * @param       {string|null=}     Plc      Language Code
    * Description  Set default keyboard for the control
    *
@@ -391,12 +391,12 @@ export class KeymanEngine extends KeymanEngineBase<BrowserConfiguration, Context
    * This is a public API function documented at
    * https://help.keyman.com/developer/engine/web/current-version/reference/core/getKeyboard.
    *
-   * @param       {Object}    Lstub      Keyboard stub object
-   * @param       {Object}    Lkbd       Keyboard script object
+   * @param       {Object}    Lstub      JSKeyboard stub object
+   * @param       {Object}    Lkbd       JSKeyboard script object
    * @return      {Object}               Copy of keyboard identification strings
    *
    */
-  private _GetKeyboardDetail = function(Lstub: KeyboardStub, Lkbd: Keyboard) { // I2078 - Full keyboard detail
+  private _GetKeyboardDetail = function(Lstub: KeyboardStub, Lkbd: JSKeyboard) { // I2078 - Full keyboard detail
     const Lr = {
       Name: Lstub.KN,
       InternalName: Lstub.KI,
@@ -437,13 +437,14 @@ export class KeymanEngine extends KeymanEngineBase<BrowserConfiguration, Context
       if(kbdDetail.KeyboardID){
         kbd = this.keyboardRequisitioner.cache.getKeyboard(kbdDetail.KeyboardID);
       } else {
-        kbd = new Keyboard(k0);
+        kbd = new JSKeyboard(k0);
       }
     } else {
       kbd = this.core.activeKeyboard;
     }
 
-    return kbd && kbd.isCJK;
+    // TODO-web-core: implement for KMX keyboards if needed
+    return kbd && kbd instanceof JSKeyboard && kbd.isCJK;
   }
 
   /**
@@ -459,7 +460,12 @@ export class KeymanEngine extends KeymanEngineBase<BrowserConfiguration, Context
     const stub = this.keyboardRequisitioner.cache.getStub(PInternalName, PlgCode);
     const keyboard = this.keyboardRequisitioner.cache.getKeyboardForStub(stub);
 
-    return stub && this._GetKeyboardDetail(stub, keyboard);
+    if (keyboard instanceof JSKeyboard) {
+      return stub && this._GetKeyboardDetail(stub, keyboard);
+    } else {
+      // TODO-web-core: implement for KMX keyboards if needed
+      return null;
+    }
   }
 
   /**
@@ -484,8 +490,12 @@ export class KeymanEngine extends KeymanEngineBase<BrowserConfiguration, Context
       // In Chrome, (including on Android), Array.prototype.find() requires Chrome 45.
       // This is a later version than the default on our oldest-supported Android devices.
       const Lkbd = cache.getKeyboardForStub(Lstub);
-      const Lrn = this._GetKeyboardDetail(Lstub, Lkbd);  // I2078 - Full keyboard detail
-      Lr.push(Lrn);
+      if (Lkbd instanceof JSKeyboard) {
+        const Lrn = this._GetKeyboardDetail(Lstub, Lkbd);  // I2078 - Full keyboard detail
+        Lr.push(Lrn);
+      } else {
+        // TODO-web-core: implement for KMX keyboards if needed
+      }
     }
     return Lr;
   }
@@ -682,6 +692,10 @@ export class KeymanEngine extends KeymanEngineBase<BrowserConfiguration, Context
     }
 
     PKbd = PKbd || this.core.activeKeyboard;
+    if (!(PKbd instanceof JSKeyboard)) {
+      // TODO-web-core: implement for KMX keyboards if needed
+      return null;
+    }
     const Pstub = this.keyboardRequisitioner.cache.getStub(PKbd);
 
     // help.keyman.com will set this function in place to specify the desired
diff --git a/web/src/app/browser/src/test-index.ts b/web/src/app/browser/src/test-index.ts
index 408b47cba6..83df5dc8e7 100644
--- a/web/src/app/browser/src/test-index.ts
+++ b/web/src/app/browser/src/test-index.ts
@@ -3,5 +3,5 @@ export { default as ContextManager, KeyboardCookie } from "./contextManager.js";
 export { preprocessKeyboardEvent, default as HardwareEventKeyboard } from './hardwareEventKeyboard.js';
 
 export { KeymanEngine } from './keymanEngine.js';
-export { default as KeyboardInterface } from './keyboardInterface.js';
+export { KeyboardInterface } from './keyboardInterface.js';
 export { UIModule } from './uiModuleInterface.js';
diff --git a/web/src/app/ui/build.sh b/web/src/app/ui/build.sh
index 045cdac8d0..36c6f3d4e5 100755
--- a/web/src/app/ui/build.sh
+++ b/web/src/app/ui/build.sh
@@ -64,6 +64,10 @@ compile_and_copy() {
   mkdir -p "$KEYMAN_ROOT/web/build/app/resources/ui"
   cp -R "$KEYMAN_ROOT/web/src/resources/ui/." "$KEYMAN_ROOT/web/build/app/resources/ui/"
 
+  # Copy Keyman Core build artifacts for local reference
+  cp "${KEYMAN_ROOT}/web/build/engine/core-processor/obj/import/core/"km-core.{js,wasm} "${KEYMAN_ROOT}/web/build/app/ui/debug/"
+  cp "${KEYMAN_ROOT}/web/build/engine/core-processor/obj/import/core/"km-core.{js,wasm} "${KEYMAN_ROOT}/web/build/app/ui/release/"
+
   # Update the build/publish copy of our build artifacts
   prepare
 }
diff --git a/web/src/app/ui/kmwuifloat.ts b/web/src/app/ui/kmwuifloat.ts
index 38fabb5bd7..9c9e00cc33 100644
--- a/web/src/app/ui/kmwuifloat.ts
+++ b/web/src/app/ui/kmwuifloat.ts
@@ -450,7 +450,7 @@ if(!keymanweb) {
        * @param       {Object}    e       event
        * Description  Change active keyboard in response to user selection event
        */
-      private readonly SelectKeyboardChange = async (e: Event) => {
+      private readonly SelectKeyboardChange = async (e: Event): Promise<void> => {
         keymanweb.activatingUI(true);
 
         if(this.KeyboardSelector.value != '-') {
diff --git a/web/src/app/ui/kmwuitoolbar.ts b/web/src/app/ui/kmwuitoolbar.ts
index daf1adf8ca..08bcd00a2c 100644
--- a/web/src/app/ui/kmwuitoolbar.ts
+++ b/web/src/app/ui/kmwuitoolbar.ts
@@ -820,7 +820,7 @@ if(!keymanweb) {
        * @param       {boolean} updateKeyman
        * @return      {boolean}
        **/
-      private async selectKeyboard(event: Event, lang: LanguageEntry, kbd: KeyboardDetail, updateKeyman: boolean) {
+      private async selectKeyboard(event: Event, lang: LanguageEntry, kbd: KeyboardDetail, updateKeyman: boolean): Promise<boolean> {
         keymanweb.activatingUI(true);
 
         if(this.selectedLanguage) {
@@ -943,7 +943,7 @@ if(!keymanweb) {
        * @return      {boolean}
        * Description  Update the UI when all keyboards disabled by user
        **/
-      private readonly offButtonClickEvent = async (event: Event) => {
+      private readonly offButtonClickEvent = async (event: Event): Promise<boolean> => {
         if(this.toolbarNode.className != 'kmw_controls_disabled') {
           this.hideKeyboardsForLanguage(null);
           if(this.selectedLanguage) {
diff --git a/web/src/app/webview/build.sh b/web/src/app/webview/build.sh
index 403aaec4e4..e90cddccda 100755
--- a/web/src/app/webview/build.sh
+++ b/web/src/app/webview/build.sh
@@ -60,8 +60,16 @@ compile_and_copy() {
   mkdir -p "$KEYMAN_ROOT/web/build/app/resources/osk"
   cp -R "$KEYMAN_ROOT/web/src/resources/osk/." "$KEYMAN_ROOT/web/build/app/resources/osk/"
 
+  # Copy Keyman Core build artifacts for local reference
+  cp "${KEYMAN_ROOT}/web/build/engine/core-processor/obj/import/core/"km-core.{js,wasm} "${KEYMAN_ROOT}/web/build/app/webview/debug/"
+  cp "${KEYMAN_ROOT}/web/build/engine/core-processor/obj/import/core/"km-core.{js,wasm} "${KEYMAN_ROOT}/web/build/app/webview/release/"
+
   # Clean the sourcemaps of .. and . components
   for script in "$KEYMAN_ROOT/web/build/$SUBPROJECT_NAME/debug/"*.js; do
+    if [[ "${script}" == *"/km-core.js" ]]; then
+      continue
+    fi
+
     sourcemap="$script.map"
     node "$KEYMAN_ROOT/web/build/tools/building/sourcemap-root/index.js" \
       "$script" "$sourcemap" --clean --inline
@@ -70,6 +78,9 @@ compile_and_copy() {
   # Do NOT inline sourcemaps for release builds - we don't want them to affect
   # load time.
   for script in "$KEYMAN_ROOT/web/build/$SUBPROJECT_NAME/release/"*.js; do
+    if [[ "${script}" == *"/km-core.js" ]]; then
+      continue
+    fi
     sourcemap="$script.map"
     node "$KEYMAN_ROOT/web/build/tools/building/sourcemap-root/index.js" \
       "$script" "$sourcemap" --clean
diff --git a/web/src/app/webview/src/contextManager.ts b/web/src/app/webview/src/contextManager.ts
index da441de3ff..b2c52de00e 100644
--- a/web/src/app/webview/src/contextManager.ts
+++ b/web/src/app/webview/src/contextManager.ts
@@ -1,5 +1,6 @@
-import { type Keyboard  } from 'keyman/engine/keyboard';
-import { Mock, OutputTarget, Transcription, findCommonSubstringEndIndex, isEmptyTransform, TextTransform } from 'keyman/engine/js-processor';
+import { JSKeyboard, Keyboard, OutputTargetInterface, Transcription, TextTransform } from 'keyman/engine/keyboard';
+// TODO-web-core: remove usage of OutputTargetBase, use OutputTargetInterface instead
+import { Mock, findCommonSubstringEndIndex, isEmptyTransform, OutputTargetBase } from 'keyman/engine/js-processor';
 import { KeyboardStub } from 'keyman/engine/keyboard-storage';
 import { ContextManagerBase } from 'keyman/engine/main';
 import { WebviewConfiguration } from './configuration.js';
@@ -30,7 +31,8 @@ export class ContextHost extends Mock {
       let transform: TextTransform = null;
 
       if(transcription) {
-        const preInput = transcription.preInput;
+        //TODO-web-core: shouldn't need cast in the future?
+        const preInput = transcription.preInput as Mock;
         // If our saved state matches the `preInput` from the incoming transcription, just reuse its transform.
         // Will generally not match during multitap operations, though.
         //
@@ -58,9 +60,10 @@ export class ContextHost extends Mock {
     this.savedState = Mock.from(this);
   }
 
-  restoreTo(original: OutputTarget): void {
+  restoreTo(original: OutputTargetInterface): void {
     this.savedState = Mock.from(this);
-    super.restoreTo(original);
+    // TODO-web-core
+    super.restoreTo(original as OutputTargetBase);
   }
 
   updateContext(text: string, selStart: number, selEnd: number): boolean {
@@ -117,7 +120,7 @@ export default class ContextManager extends ContextManagerBase<WebviewConfigurat
   // yet to be modularized at this time, though.)
   private _rawContext: ContextHost;
 
-  private _activeKeyboard: {keyboard: Keyboard, metadata: KeyboardStub};
+  private _activeKeyboard: {keyboard: JSKeyboard, metadata: KeyboardStub};
 
   constructor(engineConfig: WebviewConfiguration) {
     super(engineConfig);
@@ -137,7 +140,7 @@ export default class ContextManager extends ContextManagerBase<WebviewConfigurat
     return this._activeKeyboard;
   }
 
-  activateKeyboardForTarget(kbd: {keyboard: Keyboard, metadata: KeyboardStub}, target: OutputTarget) {
+  activateKeyboardForTarget(kbd: { keyboard: JSKeyboard, metadata: KeyboardStub }, target: OutputTargetInterface) {
     // `target` is irrelevant for `app/webview`, as it'll only ever use 'global' keyboard settings.
 
     // Clone the object to prevent accidental by-reference changes.
@@ -204,7 +207,10 @@ export default class ContextManager extends ContextManagerBase<WebviewConfigurat
     // That said, it's best to keep it around for now and verify later.
     if(originalKeyboard?.metadata?.id == activatingKeyboard?.metadata?.id) {
       activatingKeyboard.keyboard = activatingKeyboard.keyboard.then((kbd) => {
-        kbd.refreshLayouts()
+        // TODO-web-core: Do we need to refresh layouts for KMX keyboards also?
+        if (kbd instanceof JSKeyboard) {
+          kbd.refreshLayouts();
+        }
         return kbd;
       });
     }
diff --git a/web/src/app/webview/src/keymanEngine.ts b/web/src/app/webview/src/keymanEngine.ts
index 8db2951c1b..52b34be4fe 100644
--- a/web/src/app/webview/src/keymanEngine.ts
+++ b/web/src/app/webview/src/keymanEngine.ts
@@ -1,6 +1,5 @@
-import { DeviceSpec, DefaultRules } from 'keyman/engine/keyboard';
-import { RuleBehavior } from 'keyman/engine/js-processor';
-import { KeymanEngineBase, KeyboardInterface } from 'keyman/engine/main';
+import { DeviceSpec, DefaultRules, ProcessorAction } from 'keyman/engine/keyboard';
+import { KeymanEngineBase, KeyboardInterfaceBase } from 'keyman/engine/main';
 import { AnchoredOSKView, ViewConfiguration, StaticActivator } from 'keyman/engine/osk';
 import { getAbsoluteX, getAbsoluteY } from 'keyman/engine/dom-utils';
 import { toPrefixedKeyboardId, toUnprefixedKeyboardId } from 'keyman/engine/keyboard-storage';
@@ -18,7 +17,7 @@ export class KeymanEngine extends KeymanEngineBase<WebviewConfiguration, Context
   constructor(workerFactory: WorkerFactory, sourceUri: string) {
     const config = new WebviewConfiguration(sourceUri);  // currently set to perform device auto-detect.
 
-    config.onRuleFinalization = (ruleBehavior: RuleBehavior) => {
+    config.onRuleFinalization = (ruleBehavior: ProcessorAction) => {
       (this.context as ContextHost).updateHost(ruleBehavior.transcription);
     }
 
@@ -35,7 +34,7 @@ export class KeymanEngine extends KeymanEngineBase<WebviewConfiguration, Context
       return {
         // The `engine` parameter cannot be supplied with the constructing instance before calling
         // `super`, hence the 'fun' rigging to supply it _from_ `super` via this closure.
-        keyboardInterface: new KeyboardInterface(window, engine, config.stubNamespacer),
+        keyboardInterface: new KeyboardInterfaceBase(window, engine, config.stubNamespacer),
         defaultOutputRules: new DefaultRules()
       };
     });
diff --git a/web/src/engine/attachment/src/attachmentInfo.ts b/web/src/engine/attachment/src/attachmentInfo.ts
index 02a8111402..05811300cb 100644
--- a/web/src/engine/attachment/src/attachmentInfo.ts
+++ b/web/src/engine/attachment/src/attachmentInfo.ts
@@ -1,10 +1,10 @@
-import { OutputTarget } from 'keyman/engine/element-wrappers';
+import { OutputTargetElementWrapper } from 'keyman/engine/element-wrappers';
 
 export class AttachmentInfo {
   /**
    * Provides the core interface between the DOM and the actual keyboard.
    */
-  interface:      OutputTarget<any>;
+  interface: OutputTargetElementWrapper<any>;
 
   /**
    * Tracks the control's independent keyboard selection, when applicable.
@@ -21,7 +21,7 @@ export class AttachmentInfo {
    */
   inputMode?: string;
 
-  constructor(eleInterface: OutputTarget<any>, kbd: string, touch?: boolean) {
+  constructor(eleInterface: OutputTargetElementWrapper<any>, kbd: string, touch?: boolean) {
     this.interface = eleInterface;
     this.keyboard = kbd;
   }
diff --git a/web/src/engine/attachment/src/outputTargetForElement.ts b/web/src/engine/attachment/src/outputTargetForElement.ts
index 8939d7e92e..7ed98e9fb2 100644
--- a/web/src/engine/attachment/src/outputTargetForElement.ts
+++ b/web/src/engine/attachment/src/outputTargetForElement.ts
@@ -2,7 +2,7 @@ import { nestedInstanceOf } from "keyman/engine/element-wrappers";
 
 /**
  * Given a DOM event related to an KMW-attached element, this function determines
- * the corresponding OutputTarget.
+ * the corresponding OutputTargetInterface.
  * @param e
  * @returns
  */
@@ -13,7 +13,7 @@ export function eventOutputTarget(e: Event) {
 
 /**
  * Given a DOM event related to an KMW-attached element, this function determines
- * the corresponding OutputTarget.
+ * the corresponding OutputTargetInterface.
  * @param e
  * @returns
  */
@@ -42,7 +42,7 @@ export function outputTargetForElement(Ltarg: HTMLElement) {
     }
   }
 
-  // Step 2:  With the most likely host element determined, obtain the corresponding OutputTarget
+  // Step 2:  With the most likely host element determined, obtain the corresponding OutputTargetInterface
   // instance.
   return Ltarg._kmwAttachment?.interface;
 }
\ No newline at end of file
diff --git a/web/src/engine/core-processor/.gitignore b/web/src/engine/core-processor/.gitignore
new file mode 100644
index 0000000000..282f91762f
--- /dev/null
+++ b/web/src/engine/core-processor/.gitignore
@@ -0,0 +1 @@
+src/import/
\ No newline at end of file
diff --git a/web/src/engine/core-processor/build.sh b/web/src/engine/core-processor/build.sh
new file mode 100755
index 0000000000..c468df044a
--- /dev/null
+++ b/web/src/engine/core-processor/build.sh
@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+
+## START STANDARD BUILD SCRIPT INCLUDE
+# adjust relative paths as necessary
+THIS_SCRIPT="$(readlink -f "${BASH_SOURCE[0]}")"
+. "${THIS_SCRIPT%/*}/../../../../resources/build/builder-full.inc.sh"
+## END STANDARD BUILD SCRIPT INCLUDE
+
+SUBPROJECT_NAME=engine/core-processor
+. "$KEYMAN_ROOT/resources/build/utils.inc.sh"
+. "$KEYMAN_ROOT/resources/build/node.inc.sh"
+. "$KEYMAN_ROOT/web/common.inc.sh"
+
+# ################################ Main script ################################
+
+builder_describe "Keyman Core WASM integration" \
+  "@/core:wasm" \
+  "@/web/src/engine/common/web-utils" \
+  "clean" \
+  "configure" \
+  "build" \
+  "test" \
+  "--ci+                     Set to utilize CI-based test configurations & reporting."
+
+builder_describe_outputs \
+  configure    "/web/src/engine/core-processor/src/import/core/keymancore.d.ts" \
+  build        "/web/build/${SUBPROJECT_NAME}/lib/index.mjs"
+
+builder_parse "$@"
+
+#### Build action definitions ####
+
+do_clean() {
+  rm -rf "${KEYMAN_ROOT}/web/build/${SUBPROJECT_NAME}"
+  rm -rf "src/import/"
+}
+
+do_configure() {
+  node_select_version_and_npm_ci
+
+  mkdir -p "src/import/core/"
+  # we don't need this file for release builds, but it's nice to have
+  # for reference and auto-completion
+  cp "${KEYMAN_ROOT}/core/build/wasm/${BUILDER_CONFIGURATION}/src/keymancore.d.ts" "src/import/core/"
+}
+
+copy_deps() {
+  mkdir -p "${KEYMAN_ROOT}/web/build/${SUBPROJECT_NAME}/obj/import/core/"
+  cp "${KEYMAN_ROOT}/core/build/wasm/${BUILDER_CONFIGURATION}/src/keymancore.d.ts" "${KEYMAN_ROOT}/web/build/${SUBPROJECT_NAME}/obj/import/core/"
+  cp "${KEYMAN_ROOT}/core/build/wasm/${BUILDER_CONFIGURATION}/src/"km-core{.js,.wasm} "${KEYMAN_ROOT}/web/build/${SUBPROJECT_NAME}/obj/import/core/"
+}
+
+do_build () {
+  copy_deps
+  compile "${SUBPROJECT_NAME}"
+
+  ${BUNDLE_CMD} "${KEYMAN_ROOT}/web/build/${SUBPROJECT_NAME}/obj/index.js" \
+    --out         "${KEYMAN_ROOT}/web/build/${SUBPROJECT_NAME}/lib/index.mjs" \
+    --format esm
+}
+
+builder_run_action clean      do_clean
+builder_run_action configure  do_configure
+builder_run_action build      do_build
diff --git a/web/src/engine/core-processor/src/KM_Core.ts b/web/src/engine/core-processor/src/KM_Core.ts
new file mode 100644
index 0000000000..c8ca4a56c7
--- /dev/null
+++ b/web/src/engine/core-processor/src/KM_Core.ts
@@ -0,0 +1,43 @@
+// Keyman is copyright (C) SIL International. MIT License.
+
+import { type MainModule as KMXCoreModule } from './import/core/keymancore.js';
+
+// Unfortunately embind has an open issue with enums and typescript where it
+// only generates a type for the enum, but not the values in a usable way.
+// So we have to re-define the enum here.
+// See https://github.com/emscripten-core/emscripten/issues/18585
+// NOTE: Keep in sync with core/include/keyman/keyman_core_api.h#L311
+export enum KM_CORE_STATUS {
+  OK = 0,
+  NO_MEM = 1,
+  IO_ERROR = 2,
+  INVALID_ARGUMENT = 3,
+  KEY_ERROR = 4,
+  INSUFFICENT_BUFFER = 5,
+  INVALID_UTF = 6,
+  INVALID_KEYBOARD = 7,
+  NOT_IMPLEMENTED = 8,
+  OS_ERROR = 0x80000000
+}
+
+export class KM_Core {
+  private static km_core: KMXCoreModule = null;
+
+  static get instance(): KMXCoreModule {
+    return this.km_core;
+  }
+
+  public static async createCoreProcessor(baseurl: string): Promise<KMXCoreModule> {
+    const module = await import(baseurl + '/km-core.js');
+    const createCoreProcessor = module.default;
+    const km_core = createCoreProcessor({
+      locateFile: function (path: string, scriptDirectory: string) {
+        return baseurl + '/' + path;
+      }
+    });
+    km_core.then((core: KMXCoreModule) => {
+      this.km_core = core;
+    });
+    return km_core;
+  }
+}
\ No newline at end of file
diff --git a/web/src/engine/core-processor/src/index.ts b/web/src/engine/core-processor/src/index.ts
new file mode 100644
index 0000000000..d34471a2cc
--- /dev/null
+++ b/web/src/engine/core-processor/src/index.ts
@@ -0,0 +1,3 @@
+export { KM_Core, KM_CORE_STATUS } from './KM_Core.js';
+import { type km_core_keyboard } from './import/core/keymancore.js';
+export { km_core_keyboard };
diff --git a/web/src/engine/core-processor/tsconfig.json b/web/src/engine/core-processor/tsconfig.json
new file mode 100644
index 0000000000..a7b626029f
--- /dev/null
+++ b/web/src/engine/core-processor/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  // While the actual references themselves are headless, it compiles against the DOM-reliant OSK module.
+  "extends": "../../tsconfig.dom.json",
+
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "../../../build/engine/core-processor/obj/",
+    "tsBuildInfoFile": "../../../build/engine/core-processor/obj/tsconfig.tsbuildinfo",
+    "rootDir": "./src"
+  },
+
+  "include": [ "**/*.ts", "src/import/core/km-core.js" ],
+}
diff --git a/web/src/engine/element-wrappers/src/contentEditable.ts b/web/src/engine/element-wrappers/src/contentEditable.ts
index c4ec40460f..5b3169bc1a 100644
--- a/web/src/engine/element-wrappers/src/contentEditable.ts
+++ b/web/src/engine/element-wrappers/src/contentEditable.ts
@@ -1,4 +1,4 @@
-import OutputTarget from './outputTarget.js';
+import { OutputTargetElementWrapper } from './outputTargetElementWrapper.js';
 import { KMWString } from '@keymanapp/web-utils';
 
 class SelectionCaret {
@@ -21,7 +21,7 @@ class SelectionRange {
   }
 }
 
-export default class ContentEditable extends OutputTarget<{}> {
+export class ContentEditable extends OutputTargetElementWrapper<{}> {
   root: HTMLElement;
 
   constructor(ele: HTMLElement) {
diff --git a/web/src/engine/element-wrappers/src/designIFrame.ts b/web/src/engine/element-wrappers/src/designIFrame.ts
index 893b56c250..edf9b450cf 100644
--- a/web/src/engine/element-wrappers/src/designIFrame.ts
+++ b/web/src/engine/element-wrappers/src/designIFrame.ts
@@ -1,4 +1,4 @@
-import OutputTarget from './outputTarget.js';
+import { OutputTargetElementWrapper } from './outputTargetElementWrapper.js';
 import { KMWString } from '@keymanapp/web-utils';
 
 class SelectionCaret {
@@ -32,7 +32,7 @@ class StyleCommand {
   }
 }
 
-export default class DesignIFrame extends OutputTarget<{}> {
+export class DesignIFrame extends OutputTargetElementWrapper<{}> {
   root: HTMLIFrameElement;
   doc: Document;
   docRoot: HTMLElement;
diff --git a/web/src/engine/element-wrappers/src/index.ts b/web/src/engine/element-wrappers/src/index.ts
index 06971bdeff..1cf3e36ecf 100644
--- a/web/src/engine/element-wrappers/src/index.ts
+++ b/web/src/engine/element-wrappers/src/index.ts
@@ -1,7 +1,7 @@
-export { default as wrapElement } from './wrapElement.js';
-export { default as ContentEditable } from './contentEditable.js';
-export { default as DesignIFrame } from './designIFrame.js';
-export { default as Input } from './input.js';
-export { default as OutputTarget } from './outputTarget.js';
-export { default as TextArea } from './textarea.js';
+export { wrapElement } from './wrapElement.js';
+export { ContentEditable } from './contentEditable.js';
+export { DesignIFrame } from './designIFrame.js';
+export { Input } from './input.js';
+export { OutputTargetElementWrapper } from './outputTargetElementWrapper.js';
+export { TextArea } from './textarea.js';
 export { nestedInstanceOf } from './utils.js';
\ No newline at end of file
diff --git a/web/src/engine/element-wrappers/src/input.ts b/web/src/engine/element-wrappers/src/input.ts
index 46efd0fb0c..cae3b43398 100644
--- a/web/src/engine/element-wrappers/src/input.ts
+++ b/web/src/engine/element-wrappers/src/input.ts
@@ -1,4 +1,4 @@
-import OutputTarget from './outputTarget.js';
+import { OutputTargetElementWrapper } from './outputTargetElementWrapper.js';
 import { KMWString } from '@keymanapp/web-utils';
 
 interface EventMap  {
@@ -22,7 +22,7 @@ interface EventMap  {
   'unhandlednewline': (element: HTMLInputElement) => void
 }
 
-export default class Input extends OutputTarget<EventMap> {
+export class Input extends OutputTargetElementWrapper<EventMap> {
   root: HTMLInputElement;
 
   /**
diff --git a/web/src/engine/element-wrappers/src/outputTarget.ts b/web/src/engine/element-wrappers/src/outputTargetElementWrapper.ts
similarity index 88%
rename from web/src/engine/element-wrappers/src/outputTarget.ts
rename to web/src/engine/element-wrappers/src/outputTargetElementWrapper.ts
index 43623af781..4fd4771a60 100644
--- a/web/src/engine/element-wrappers/src/outputTarget.ts
+++ b/web/src/engine/element-wrappers/src/outputTargetElementWrapper.ts
@@ -1,7 +1,7 @@
-import { OutputTarget as OutputTargetBase } from "keyman/engine/js-processor";
+import { OutputTargetBase } from "keyman/engine/js-processor";
 import { EventEmitter } from 'eventemitter3';
 
-export default abstract class OutputTarget<EventMap extends EventEmitter.ValidEventTypes> extends OutputTargetBase {
+export abstract class OutputTargetElementWrapper<EventMap extends EventEmitter.ValidEventTypes> extends OutputTargetBase {
   // JS/TS can't do true multiple inheritance, so we maintain class events on a readonly field.
   public readonly events: EventEmitter<EventMap, this> = new EventEmitter<EventMap, this>();
 
diff --git a/web/src/engine/element-wrappers/src/textarea.ts b/web/src/engine/element-wrappers/src/textarea.ts
index 144b788d93..eeb86fbd82 100644
--- a/web/src/engine/element-wrappers/src/textarea.ts
+++ b/web/src/engine/element-wrappers/src/textarea.ts
@@ -1,7 +1,7 @@
-import OutputTarget from './outputTarget.js';
+import { OutputTargetElementWrapper } from './outputTargetElementWrapper.js';
 import { KMWString } from '@keymanapp/web-utils';
 
-export default class TextArea extends OutputTarget<{}> {
+export class TextArea extends OutputTargetElementWrapper<{}> {
   root: HTMLTextAreaElement;
 
   /**
diff --git a/web/src/engine/element-wrappers/src/wrapElement.ts b/web/src/engine/element-wrappers/src/wrapElement.ts
index 91d482e16e..dac09b30b6 100644
--- a/web/src/engine/element-wrappers/src/wrapElement.ts
+++ b/web/src/engine/element-wrappers/src/wrapElement.ts
@@ -1,11 +1,11 @@
-import type OutputTarget from './outputTarget.js';
-import Input from './input.js';
-import TextArea from './textarea.js';
-import DesignIFrame from './designIFrame.js';
-import ContentEditable from './contentEditable.js';
+import { type OutputTargetElementWrapper }  from './outputTargetElementWrapper.js';
+import { Input } from './input.js';
+import { TextArea } from './textarea.js';
+import { DesignIFrame } from './designIFrame.js';
+import { ContentEditable } from './contentEditable.js';
 import { nestedInstanceOf } from './utils.js';
 
-export default function wrapElement(e: HTMLElement): OutputTarget<any> {
+export function wrapElement(e: HTMLElement): OutputTargetElementWrapper<any> {
   // Complex type scoping is implemented here so that kmwutils.ts is not a dependency for test compilations.
 
   if(nestedInstanceOf(e, "HTMLInputElement")) {
diff --git a/web/src/engine/interfaces/src/pathConfiguration.ts b/web/src/engine/interfaces/src/pathConfiguration.ts
index 0eff8f65f7..18080374e4 100644
--- a/web/src/engine/interfaces/src/pathConfiguration.ts
+++ b/web/src/engine/interfaces/src/pathConfiguration.ts
@@ -106,6 +106,10 @@ export default class PathConfiguration implements OSKResourcePathConfiguration {
     return this._root;
   }
 
+  get basePath(): string {
+    return this.sourcePath;
+  }
+
   get resources(): string {
     return this._resources;
   }
diff --git a/web/src/engine/interfaces/src/prediction/languageProcessor.interface.ts b/web/src/engine/interfaces/src/prediction/languageProcessor.interface.ts
index eafdac2d39..d0b71f3842 100644
--- a/web/src/engine/interfaces/src/prediction/languageProcessor.interface.ts
+++ b/web/src/engine/interfaces/src/prediction/languageProcessor.interface.ts
@@ -1,6 +1,6 @@
 import { LexicalModelTypes } from '@keymanapp/common-types';
 import { EventEmitter } from "eventemitter3";
-import { OutputTarget } from "keyman/engine/keyboard";
+import { OutputTargetInterface } from "keyman/engine/keyboard";
 
 export class ReadySuggestions {
   suggestions: LexicalModelTypes.Suggestion[];
@@ -45,10 +45,10 @@ export interface LanguageProcessorEventMap {
   /**
    * Is called synchronously once suggestion application is successful and the context has been updated.
    *
-   * @param outputTarget The `OutputTarget` representation of the context the suggestion was applied to.
+   * @param outputTarget The `OutputTargetInterface` representation of the context the suggestion was applied to.
    * @returns
    */
-  'suggestionapplied': (outputTarget: OutputTarget) => boolean
+  'suggestionapplied': (outputTarget: OutputTargetInterface) => boolean
 }
 
 
@@ -56,7 +56,7 @@ export interface LanguageProcessorSpec extends EventEmitter<LanguageProcessorEve
 
   get state(): StateChangeEnum;
 
-  invalidateContext(outputTarget: OutputTarget, layerId: string): Promise<LexicalModelTypes.Suggestion[]>;
+  invalidateContext(outputTarget: OutputTargetInterface, layerId: string): Promise<LexicalModelTypes.Suggestion[]>;
 
   /**
    *
@@ -66,9 +66,9 @@ export interface LanguageProcessorSpec extends EventEmitter<LanguageProcessorEve
    *                        required because layerid can be changed by PostKeystroke
    * @returns
    */
-  applySuggestion(suggestion: LexicalModelTypes.Suggestion, outputTarget: OutputTarget, getLayerId: () => string): Promise<LexicalModelTypes.Reversion>;
+  applySuggestion(suggestion: LexicalModelTypes.Suggestion, outputTarget: OutputTargetInterface, getLayerId: () => string): Promise<LexicalModelTypes.Reversion>;
 
-  applyReversion(reversion: LexicalModelTypes.Reversion, outputTarget: OutputTarget): Promise<LexicalModelTypes.Suggestion[]>;
+  applyReversion(reversion: LexicalModelTypes.Reversion, outputTarget: OutputTargetInterface): Promise<LexicalModelTypes.Suggestion[]>;
 
   get wordbreaksAfterSuggestions(): boolean;
 
diff --git a/web/src/engine/interfaces/src/prediction/predictionContext.ts b/web/src/engine/interfaces/src/prediction/predictionContext.ts
index 902566eed2..1efe3b5615 100644
--- a/web/src/engine/interfaces/src/prediction/predictionContext.ts
+++ b/web/src/engine/interfaces/src/prediction/predictionContext.ts
@@ -4,7 +4,7 @@ import Keep = LexicalModelTypes.Keep;
 import Reversion = LexicalModelTypes.Reversion;
 import Suggestion = LexicalModelTypes.Suggestion;
 import { type LanguageProcessorSpec , ReadySuggestions, type InvalidateSourceEnum, StateChangeHandler } from './languageProcessor.interface.js';
-import { type OutputTarget } from "keyman/engine/keyboard";
+import { type OutputTargetInterface } from "keyman/engine/keyboard";
 
 interface PredictionContextEventMap {
   update: (suggestions: Suggestion[]) => void;
@@ -41,13 +41,13 @@ export default class PredictionContext extends EventEmitter<PredictionContextEve
   /**
    * Represents the active context used when requesting and applying predictive-text operations.
    */
-  private _currentTarget: OutputTarget;
+  private _currentTarget: OutputTargetInterface;
 
-  public get currentTarget(): OutputTarget {
+  public get currentTarget(): OutputTargetInterface {
     return this._currentTarget;
   }
 
-  public setCurrentTarget(target: OutputTarget): Promise<Suggestion[]> {
+  public setCurrentTarget(target: OutputTargetInterface): Promise<Suggestion[]> {
     const originalTarget = this._currentTarget;
     this._currentTarget = target;
 
diff --git a/web/src/engine/js-processor/build.sh b/web/src/engine/js-processor/build.sh
index 0fc0ef7e7a..6d5989b515 100755
--- a/web/src/engine/js-processor/build.sh
+++ b/web/src/engine/js-processor/build.sh
@@ -36,7 +36,12 @@ do_build () {
     --format esm
 }
 
+do_test() {
+  test-headless "${SUBPROJECT_NAME}" ""
+  test-headless-typescript "${SUBPROJECT_NAME}"
+}
+
 builder_run_action configure  node_select_version_and_npm_ci
 builder_run_action clean      rm -rf "${KEYMAN_ROOT}/web/build/${SUBPROJECT_NAME}"
 builder_run_action build      do_build
-builder_run_action test       test-headless "${SUBPROJECT_NAME}" ""
+builder_run_action test       do_test
diff --git a/web/src/engine/js-processor/src/index.ts b/web/src/engine/js-processor/src/index.ts
index 1755499119..8968212c2f 100644
--- a/web/src/engine/js-processor/src/index.ts
+++ b/web/src/engine/js-processor/src/index.ts
@@ -1,11 +1,8 @@
-export { default as KeyboardProcessor } from "./keyboardProcessor.js";
-export * from "./keyboardProcessor.js";
-export { default as RuleBehavior } from "./ruleBehavior.js";
-export * from './kbdInterface.js';
-export { default as KeyboardInterface } from "./kbdInterface.js";
-export * from "./systemStores.js";
+export { BeepHandler, JSKeyboardProcessor, LogMessageHandler, ProcessorInitOptions } from "./jsKeyboardProcessor.js";
+export { JSKeyboardInterface, KeyInformation, StoreNonCharEntry } from "./jsKeyboardInterface.js";
 export * from "./deadkeys.js";
-export { default as OutputTarget } from "./outputTarget.js";
-export * from "./outputTarget.js";
+export { type ComplexKeyboardStore } from "./stores.js";
+export { OutputTargetBase } from "./outputTargetBase.js";
+export * from "./outputTargetBase.js";
 export { Mock } from "./mock.js";
 export * from "./stringDivergence.js";
diff --git a/web/src/engine/js-processor/src/kbdInterface.ts b/web/src/engine/js-processor/src/jsKeyboardInterface.ts
similarity index 81%
rename from web/src/engine/js-processor/src/kbdInterface.ts
rename to web/src/engine/js-processor/src/jsKeyboardInterface.ts
index ff4fffb467..b365ecf4bc 100644
--- a/web/src/engine/js-processor/src/kbdInterface.ts
+++ b/web/src/engine/js-processor/src/jsKeyboardInterface.ts
@@ -7,12 +7,27 @@
 
 import { type DeviceSpec, KMWString } from "@keymanapp/web-utils";
 import { ModifierKeyConstants } from '@keymanapp/common-types';
-import { Codes, type KeyEvent, KeyMapping, Keyboard, KeyboardHarness, KeyboardKeymanGlobal, VariableStoreDictionary } from "keyman/engine/keyboard";
-import type OutputTarget from './outputTarget.js';
+import {
+  Codes,
+  JSKeyboard,
+  KeyboardHarness,
+  KeyboardKeymanGlobal,
+  KeyMapping,
+  MutableSystemStore,
+  SystemStore,
+  SystemStoreIDs,
+  type KeyEvent,
+  type OutputTargetInterface,
+  ProcessorAction,
+  VariableStore,
+  VariableStoreDictionary,
+  VariableStoreSerializer,
+} from "keyman/engine/keyboard";
+import { type OutputTargetBase }  from './outputTargetBase.js';
 import { type Deadkey } from './deadkeys.js';
 import { Mock } from "./mock.js";
-import RuleBehavior from "./ruleBehavior.js";
-import { ComplexKeyboardStore, type KeyboardStore, KeyboardStoreElement, SystemStoreIDs, SystemStore, MutableSystemStore, PlatformSystemStore, VariableStore, VariableStoreSerializer } from "./systemStores.js";
+import { PlatformSystemStore } from './platformSystemStore.js';
+import { ComplexKeyboardStore, type KeyboardStore, KeyboardStoreElement } from "./stores.js";
 
 //#endregion
 
@@ -165,22 +180,22 @@ class CachedContextEx {
 
 //#endregion
 
-export default class KeyboardInterface extends KeyboardHarness {
+export class JSKeyboardInterface extends KeyboardHarness {
   static readonly GLOBAL_NAME = 'KeymanWeb';
 
   cachedContext: CachedContext = new CachedContext();
   cachedContextEx: CachedContextEx = new CachedContextEx();
   ruleContextEx: CachedContextEx;
 
-  activeTargetOutput: OutputTarget;
-  ruleBehavior: RuleBehavior;
+  activeTargetOutput: OutputTargetInterface;
+  ruleBehavior: ProcessorAction;
 
   systemStores: {[storeID: number]: SystemStore};
 
   _AnyIndices:  number[] = [];    // AnyIndex - array of any/index match indices
 
   // Must be accessible to some of the keyboard API methods.
-  activeKeyboard: Keyboard;
+  activeKeyboard: JSKeyboard;
   activeDevice: DeviceSpec;
 
   variableStoreSerializer?: VariableStoreSerializer;
@@ -222,7 +237,7 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Function     registerKeyboard  KR
    * Scope        Public
-   * @param       {Object}      Pk      Keyboard  object
+   * @param       {Object}      Pk      JSKeyboard  object
    * Description  Registers a keyboard with KeymanWeb once its script has fully loaded.
    *
    *              In web-core, this also activates the keyboard; in other modules, this method
@@ -231,17 +246,17 @@ export default class KeyboardInterface extends KeyboardHarness {
   registerKeyboard(Pk: any): void {
     // NOTE:  This implementation is web-core specific and is intentionally replaced, whole-sale,
     //        by DOM-aware code.
-    const keyboard = new Keyboard(Pk);
+    const keyboard = new JSKeyboard(Pk);
     this.loadedKeyboard = keyboard;
   }
 
   /**
    * Get *cached or uncached* keyboard context for a specified range, relative to caret
    *
-   * @param       {number}      n       Number of characters to move back from caret
-   * @param       {number}      ln      Number of characters to return
-   * @param       {Object}      Pelem   Element to work with (must be currently focused element)
-   * @return      {string}              Context string
+   * @param       {number}      n             Number of characters to move back from caret
+   * @param       {number}      ln            Number of characters to return
+   * @param       {Object}      outputTarget  Element to work with (must be currently focused element)
+   * @return      {string}                    Context string
    *
    * Example     [abcdef|ghi] as INPUT, with the caret position marked by |:
    *             KC(2,1,Pelem) == "e"
@@ -249,7 +264,7 @@ export default class KeyboardInterface extends KeyboardHarness {
    *             KC(10,10,Pelem) == "abcdef"  i.e. return as much as possible of the requested string
    */
 
-  context(n: number, ln: number, outputTarget: OutputTarget): string {
+  context(n: number, ln: number, outputTarget: OutputTargetInterface): string {
     const v = this.cachedContext.get(n, ln);
     if(v !== null) {
       return v;
@@ -263,17 +278,17 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Get (uncached) keyboard context for a specified range, relative to caret
    *
-   * @param       {number}      n       Number of characters to move back from caret
-   * @param       {number}      ln      Number of characters to return
-   * @param       {Object}      Pelem   Element to work with (must be currently focused element)
-   * @return      {string}              Context string
+   * @param       {number}      n             Number of characters to move back from caret
+   * @param       {number}      ln            Number of characters to return
+   * @param       {Object}      outputTarget  Element to work with (must be currently focused element)
+   * @return      {string}                    Context string
    *
    * Example     [abcdef|ghi] as INPUT, with the caret position marked by |:
    *             KC(2,1,Pelem) == "e"
    *             KC(3,3,Pelem) == "def"
    *             KC(10,10,Pelem) == "XXXXabcdef"  i.e. return as much as possible of the requested string, where X = \uFFFE
    */
-  private KC_(n: number, ln: number, outputTarget: OutputTarget): string {
+  private KC_(n: number, ln: number, outputTarget: OutputTargetInterface): string {
     let tempContext = '';
 
     // If we have a selection, we have an empty context
@@ -289,9 +304,9 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Function     nul           KN
    * Scope        Public
-   * @param       {number}      n       Length of context to check
-   * @param       {Object}      Ptarg   Element to work with (must be currently focused element)
-   * @return      {boolean}             True if length of context is less than or equal to n
+   * @param       {number}      n             Length of context to check
+   * @param       {Object}      outputTarget  Element to work with (must be currently focused element)
+   * @return      {boolean}                   True if length of context is less than or equal to n
    * Description  Test length of context, return true if the length of the context is less than or equal to n
    *
    * Example     [abc|def] as INPUT, with the caret position marked by |:
@@ -299,7 +314,7 @@ export default class KeyboardInterface extends KeyboardHarness {
    *             KN(2,Pelem) == FALSE
    *             KN(4,Pelem) == TRUE
    */
-  nul(n: number, outputTarget: OutputTarget): boolean {
+  nul(n: number, outputTarget: OutputTargetInterface): boolean {
     const cx=this.context(n+1, 1, outputTarget);
 
     // With #31, the result will be a replacement character if context is empty.
@@ -309,31 +324,31 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Function     contextMatch  KCM
    * Scope        Public
-   * @param       {number}      n       Number of characters to move back from caret
-   * @param       {Object}      Ptarg   Focused element
-   * @param       {string}      val     String to match
-   * @param       {number}      ln      Number of characters to return
-   * @return      {boolean}             True if selected context matches val
+   * @param       {number}      n             Number of characters to move back from caret
+   * @param       {Object}      outputTarget  Focused element
+   * @param       {string}      val           String to match
+   * @param       {number}      ln            Number of characters to return
+   * @return      {boolean}                   True if selected context matches val
    * Description  Test keyboard context for match
    */
-  contextMatch(n: number, outputTarget: OutputTarget, val: string, ln: number): boolean {
+  contextMatch(n: number, outputTarget: OutputTargetInterface, val: string, ln: number): boolean {
     const cx=this.context(n, ln, outputTarget);
     if(cx === val) {
       return true; // I3318
     }
-    outputTarget.deadkeys().resetMatched(); // I3318
+    (outputTarget as OutputTargetBase).deadkeys().resetMatched(); // I3318
     return false;
   }
 
   /**
    * Builds the *cached or uncached* keyboard context for a specified range, relative to caret
    *
-   * @param       {number}      n       Number of characters to move back from caret
-   * @param       {number}      ln      Number of characters to return
-   * @param       {Object}      Pelem   Element to work with (must be currently focused element)
-   * @return      {Array}               Context array (of strings and numbers)
+   * @param       {number}      n             Number of characters to move back from caret
+   * @param       {number}      ln            Number of characters to return
+   * @param       {Object}      outputTarget  Element to work with (must be currently focused element)
+   * @return      {Array}                     Context array (of strings and numbers)
    */
-  private _BuildExtendedContext(n: number, ln: number, outputTarget: OutputTarget): CachedExEntry {
+  private _BuildExtendedContext(n: number, ln: number, outputTarget: OutputTargetBase): CachedExEntry {
     let cache: CachedExEntry = this.cachedContextEx.get(n, ln);
     if(cache !== null) {
       return cache;
@@ -382,15 +397,15 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Function       fullContextMatch    KFCM
    * Scope          Private
-   * @param         {number}    n       Number of characters to move back from caret
-   * @param         {Object}    Ptarg   Focused element
-   * @param         {Array}     rule    An array of ContextEntries to match.
-   * @return        {boolean}           True if the fully-specified rule context matches the current KMW state.
+   * @param         {number}    n             Number of characters to move back from caret
+   * @param         {Object}    outputTarget  Focused element
+   * @param         {Array}     rule          An array of ContextEntries to match.
+   * @return        {boolean}                 True if the fully-specified rule context matches the current KMW state.
    *
    * A KMW 10+ function designed to bring KMW closer to Keyman Desktop functionality,
    * near-directly modeling (externally) the compiled form of Desktop rules' context section.
    */
-  fullContextMatch(n: number, outputTarget: OutputTarget, rule: ContextEntry[]): boolean {
+  fullContextMatch(n: number, outputTarget: OutputTargetBase, rule: ContextEntry[]): boolean {
     // Stage one:  build the context index map.
     const fullContext = this._BuildExtendedContext(n, rule.length, outputTarget);
     this.ruleContextEx = this.cachedContextEx.clone();
@@ -559,7 +574,7 @@ export default class KeyboardInterface extends KeyboardHarness {
     const modifierBitmask = bitmask & Codes.modifierBitmasks["ALL"];
     const stateBitmask = bitmask & Codes.stateBitmasks["ALL"];
 
-    const eventModifiers = KeyboardInterface.matchModifiersToRuleChirality(e.Lmodifiers, Lruleshift);
+    const eventModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(e.Lmodifiers, Lruleshift);
 
     if(e.vkCode > 255) {
       keyCode = e.vkCode; // added to support extended (touch-hold) keys for mnemonic layouts
@@ -574,7 +589,7 @@ export default class KeyboardInterface extends KeyboardHarness {
       retVal = (keyCode == Lrulekey); // I3318, I3555
     }
     if(!retVal) {
-      this.activeTargetOutput.deadkeys().resetMatched();  // I3318
+      (this.activeTargetOutput as OutputTargetBase).deadkeys().resetMatched();  // I3318
     }
     return retVal; // I3318
   };
@@ -608,23 +623,23 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Function     deadkeyMatch  KDM
    * Scope        Public
-   * @param       {number}      n       offset from current cursor position
-   * @param       {Object}      Ptarg   target element
-   * @param       {number}      d       deadkey
-   * @return      {boolean}             True if deadkey found selected context matches val
+   * @param       {number}      n             offset from current cursor position
+   * @param       {Object}      outputTarget  target element
+   * @param       {number}      d             deadkey
+   * @return      {boolean}                   True if deadkey found selected context matches val
    * Description  Match deadkey at current cursor position
    */
-  deadkeyMatch(n: number, outputTarget: OutputTarget, d: number): boolean {
+  deadkeyMatch(n: number, outputTarget: OutputTargetInterface, d: number): boolean {
     return outputTarget.hasDeadkeyMatch(n, d);
   }
 
   /**
    * Function     beep          KB
    * Scope        Public
-   * @param       {Object}      Pelem     element to flash
+   * @param       {Object}      outputTarget  element to flash
    * Description  Flash body as substitute for audible beep; notify embedded device to vibrate
    */
-  beep(outputTarget: OutputTarget): void {
+  beep(outputTarget: OutputTargetInterface): void {
     this.resetContextCache();
 
     // Denote as part of the matched rule's behavior.
@@ -711,13 +726,13 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Function     indexOutput   KIO
    * Scope        Public
-   * @param       {number}      Pdn     no of character to overwrite (delete)
-   * @param       {string}      Ps      string
-   * @param       {number}      Pn      index
-   * @param       {Object}      Pelem   element to output to
+   * @param       {number}      Pdn           no of character to overwrite (delete)
+   * @param       {string}      Ps            string
+   * @param       {number}      Pn            index
+   * @param       {Object}      outputTarget  element to output to
    * Description  Output a character selected from the string according to the offset in the index array
    */
-  indexOutput(Pdn: number, Ps: KeyboardStore, Pn: number, outputTarget: OutputTarget): void {
+  indexOutput(Pdn: number, Ps: KeyboardStore, Pn: number, outputTarget: OutputTargetInterface): void {
     this.resetContextCache();
 
     const assertNever = function(x: never): never {
@@ -750,17 +765,16 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Function     deleteContext KDC
    * Scope        Public
-   * @param       {number}      dn      number of context entries to overwrite
-   * @param       {Object}      Pelem   element to output to
-   * @param       {string}      s       string to output
+   * @param       {number}      dn            number of context entries to overwrite
+   * @param       {Object}      outputTarget  element to output to
    * Description  Keyboard output
    */
-  deleteContext(dn: number, outputTarget: OutputTarget): void {
+  deleteContext(dn: number, outputTarget: OutputTargetInterface): void {
     let context: CachedExEntry;
 
     // We want to control exactly which deadkeys get removed.
     if(dn > 0) {
-      context = this._BuildExtendedContext(dn, dn, outputTarget);
+      context = this._BuildExtendedContext(dn, dn, (outputTarget as OutputTargetBase));
       let nulCount = 0;
 
       for(let i=0; i < context.valContext.length; i++) {
@@ -768,7 +782,7 @@ export default class KeyboardInterface extends KeyboardHarness {
 
         if(dk) {
           // Remove deadkey in context.
-          outputTarget.deadkeys().remove(dk);
+          (outputTarget as OutputTargetBase).deadkeys().remove(dk);
 
           // Reduce our reported context size.
           dn--;
@@ -787,7 +801,7 @@ export default class KeyboardInterface extends KeyboardHarness {
     }
 
     // If a matched deadkey hasn't been deleted, we don't WANT to delete it.
-    outputTarget.deadkeys().resetMatched();
+    (outputTarget as OutputTargetBase).deadkeys().resetMatched();
 
     // Why reinvent the wheel?  Delete the remaining characters by 'inserting a blank string'.
     this.output(dn, outputTarget, '');
@@ -796,17 +810,17 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Function     output        KO
    * Scope        Public
-   * @param       {number}      dn      number of characters to overwrite
-   * @param       {Object}      Pelem   element to output to
-   * @param       {string}      s       string to output
+   * @param       {number}      dn            number of characters to overwrite
+   * @param       {Object}      outputTarget  element to output to
+   * @param       {string}      s             string to output
    * Description  Keyboard output
    */
-  output(dn: number, outputTarget: OutputTarget, s:string): void {
+  output(dn: number, outputTarget: OutputTargetInterface, s:string): void {
     this.resetContextCache();
 
     outputTarget.saveProperties();
     outputTarget.clearSelection();
-    outputTarget.deadkeys().deleteMatched(); // I3318
+    (outputTarget as OutputTargetBase).deadkeys().deleteMatched(); // I3318
     if(dn >= 0) {
       // Automatically manages affected deadkey positions.  Does not delete deadkeys b/c legacy behavior support.
       outputTarget.deleteCharsBeforeCaret(dn);
@@ -824,11 +838,11 @@ export default class KeyboardInterface extends KeyboardHarness {
    * @alias       KCXO
    * @public
    * @param       {number}        Pdn            number of characters to delete left of cursor
-   * @param       {OutputTarget}  outputTarget   target to output to
+   * @param       {OutputTargetInterface}  outputTarget   target to output to
    * @param       {number}        contextLength  length of current rule context to retrieve
    * @param       {number}        contextOffset  offset from start of current rule context, 1-based
    */
-  contextExOutput(Pdn: number, outputTarget: OutputTarget, contextLength: number, contextOffset: number): void {
+  contextExOutput(Pdn: number, outputTarget: OutputTargetInterface, contextLength: number, contextOffset: number): void {
     this.resetContextCache();
 
     if(Pdn >= 0) {
@@ -849,12 +863,12 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * Function     deadkeyOutput KDO
    * Scope        Public
-   * @param       {number}      Pdn     no of character to overwrite (delete)
-   * @param       {Object}      Pelem   element to output to
-   * @param       {number}      Pd      deadkey id
+   * @param       {number}      Pdn           no of character to overwrite (delete)
+   * @param       {OutputTargetInterface}      outputTarget  element to output to
+   * @param       {number}      Pd            deadkey id
    * Description  Record a deadkey at current cursor position, deleting Pdn characters first
    */
-  deadkeyOutput(Pdn: number, outputTarget: OutputTarget, Pd: number): void {
+  deadkeyOutput(Pdn: number, outputTarget: OutputTargetInterface, Pd: number): void {
     this.resetContextCache();
 
     if(Pdn >= 0) {
@@ -868,12 +882,12 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * KIFS compares the content of a system store with a string value
    *
-   * @param       {number}      systemId    ID of the system store to test (only TSS_LAYER currently supported)
-   * @param       {string}      strValue    String value to compare to
-   * @param       {Object}      Pelem       Currently active element (may be needed by future tests)
-   * @return      {boolean}                 True if the test succeeds
+   * @param       {number}      systemId      ID of the system store to test (only TSS_LAYER currently supported)
+   * @param       {string}      strValue      String value to compare to
+   * @param       {OutputTargetInterface}      outputTarget  Currently active element (may be needed by future tests)
+   * @return      {boolean}                   True if the test succeeds
    */
-  ifStore(systemId: number, strValue: string, outputTarget: OutputTarget): boolean {
+  ifStore(systemId: number, strValue: string, outputTarget: OutputTargetInterface): boolean {
     let result=true;
     const store = this.systemStores[systemId];
     if(store) {
@@ -885,16 +899,16 @@ export default class KeyboardInterface extends KeyboardHarness {
   /**
    * KSETS sets the value of a system store to a string
    *
-   * @param       {number}      systemId    ID of the system store to set (only TSS_LAYER currently supported)
-   * @param       {string}      strValue    String to set as the system store content
-   * @param       {Object}      Pelem       Currently active element (may be needed in future tests)
-   * @return      {boolean}                 True if command succeeds
-   *                                        (i.e. for TSS_LAYER, if the layer is successfully selected)
+   * @param       {number}      systemId      ID of the system store to set (only TSS_LAYER currently supported)
+   * @param       {string}      strValue      String to set as the system store content
+   * @param       {OutputTargetInterface}      outputTarget  Currently active element (may be needed in future tests)
+   * @return      {boolean}                   True if command succeeds
+   *                                          (i.e. for TSS_LAYER, if the layer is successfully selected)
    *
    * Note that option/variable stores are instead set within keyboard script code, as they only
    * affect keyboard behavior.
    */
-  setStore(systemId: number, strValue: string, outputTarget: OutputTarget): boolean {
+  setStore(systemId: number, strValue: string, outputTarget: OutputTargetInterface): boolean {
     this.resetContextCache();
     // Unique case:  we only allow set(&layer) ops from keyboard rules triggered by touch OSKs.
     if(systemId == SystemStoreIDs.TSS_LAYER && this.activeDevice.touchable) {
@@ -964,7 +978,7 @@ export default class KeyboardInterface extends KeyboardHarness {
     this.cachedContextEx.reset();
   }
 
-  defaultBackspace(outputTarget: OutputTarget) {
+  defaultBackspace(outputTarget: OutputTargetInterface) {
     if(outputTarget.isSelectionEmpty()) {
       // Delete the character left of the caret
       this.output(1, outputTarget, "");
@@ -980,9 +994,9 @@ export default class KeyboardInterface extends KeyboardHarness {
    * @param       {Object}        outputTarget   The target receiving input
    * @param       {Object}        keystroke      The input keystroke (with its properties) to be mapped by the keyboard.
    * Description  Calls the keyboard's `begin newContext` group
-   * @returns     {RuleBehavior}  Record of commands and state changes that result from executing `begin NewContext`
+   * @returns     {ProcessorAction}  Record of commands and state changes that result from executing `begin NewContext`
    */
-  processNewContextEvent(outputTarget: OutputTarget, keystroke: KeyEvent): RuleBehavior {
+  processNewContextEvent(outputTarget: OutputTargetBase, keystroke: KeyEvent): ProcessorAction {
     if(!this.activeKeyboard) {
       throw "No active keyboard for keystroke processing!";
     }
@@ -995,9 +1009,9 @@ export default class KeyboardInterface extends KeyboardHarness {
    * @param       {Object}        outputTarget   The target receiving input
    * @param       {Object}        keystroke      The input keystroke with relevant properties to be mapped by the keyboard.
    * Description  Calls the keyboard's `begin postKeystroke` group
-   * @returns     {RuleBehavior}  Record of commands and state changes that result from executing `begin PostKeystroke`
+   * @returns     {ProcessorAction}  Record of commands and state changes that result from executing `begin PostKeystroke`
    */
-  processPostKeystroke(outputTarget: OutputTarget, keystroke: KeyEvent): RuleBehavior {
+  processPostKeystroke(outputTarget: OutputTargetBase, keystroke: KeyEvent): ProcessorAction {
     if(!this.activeKeyboard) {
       throw "No active keyboard for keystroke processing!";
     }
@@ -1010,16 +1024,16 @@ export default class KeyboardInterface extends KeyboardHarness {
    * @param       {Object}        outputTarget   The target receiving input
    * @param       {Object}        keystroke   The input keystroke (with its properties) to be mapped by the keyboard.
    * Description  Encapsulates calls to keyboard input processing.
-   * @returns     {RuleBehavior}  Record of commands and state changes that result from executing `begin Unicode`
+   * @returns     {ProcessorAction}  Record of commands and state changes that result from executing `begin Unicode`
    */
-  processKeystroke(outputTarget: OutputTarget, keystroke: KeyEvent): RuleBehavior {
+  processKeystroke(outputTarget: OutputTargetBase, keystroke: KeyEvent): ProcessorAction {
     if(!this.activeKeyboard) {
       throw "No active keyboard for keystroke processing!";
     }
     return this.process(this.activeKeyboard.process.bind(this.activeKeyboard), outputTarget, keystroke, false);
   }
 
-  private process(callee: (outputTarget: OutputTarget, keystroke: KeyEvent) => boolean, outputTarget: OutputTarget, keystroke: KeyEvent, readonly: boolean): RuleBehavior {
+  private process(callee: (outputTarget: OutputTargetBase, keystroke: KeyEvent) => boolean, outputTarget: OutputTargetBase, keystroke: KeyEvent, readonly: boolean): ProcessorAction {
     // Clear internal state tracking data from prior keystrokes.
     if(!outputTarget) {
       throw "No target specified for keyboard output!";
@@ -1041,7 +1055,7 @@ export default class KeyboardInterface extends KeyboardHarness {
     const cachedVariableStores = this.activeKeyboard.variableStores;
 
     // Establishes the results object, allowing corresponding commands to set values here as appropriate.
-    this.ruleBehavior = new RuleBehavior();
+    this.ruleBehavior = new ProcessorAction();
 
     // Ensure the settings are in place so that KIFS/ifState activates and deactivates
     // the appropriate rule(s) for the modeled device.
@@ -1055,7 +1069,7 @@ export default class KeyboardInterface extends KeyboardHarness {
     // Finalize the rule's results.
     this.ruleBehavior.transcription = outputTarget.buildTranscriptionFrom(preInput, keystroke, readonly);
 
-    // We always backup the changes to variable stores to the RuleBehavior, to
+    // We always backup the changes to variable stores to the ProcessorAction, to
     // be applied during finalization, then restore them to the cached initial
     // values to avoid side-effects with predictive text mocks.
     this.ruleBehavior.variableStores = this.activeKeyboard.variableStores;
@@ -1089,7 +1103,7 @@ export default class KeyboardInterface extends KeyboardHarness {
   }
 
   /**
-   * Publishes the KeyboardInterface's shorthand API names.  As this assigns the current functions
+   * Publishes the JSKeyboardInterface's shorthand API names.  As this assigns the current functions
    * held by the longform versions, note that this should be called after replacing any of them via
    * JS method extension.
    *
@@ -1100,7 +1114,7 @@ export default class KeyboardInterface extends KeyboardHarness {
     // Keyboard callbacks
     const prototype = this.prototype;
 
-    const exportKBCallback = function(miniName: string, longName: keyof KeyboardInterface) {
+    const exportKBCallback = function(miniName: string, longName: keyof JSKeyboardInterface) {
       if(prototype[longName]) {
         // @ts-ignore
         prototype[miniName] = prototype[longName];
@@ -1139,5 +1153,5 @@ export default class KeyboardInterface extends KeyboardHarness {
 
 (function() {
   // This will be the only call within the keyboard module.
-  KeyboardInterface.__publishShorthandAPI();
+  JSKeyboardInterface.__publishShorthandAPI();
 }());
diff --git a/web/src/engine/js-processor/src/keyboardProcessor.ts b/web/src/engine/js-processor/src/jsKeyboardProcessor.ts
similarity index 76%
rename from web/src/engine/js-processor/src/keyboardProcessor.ts
rename to web/src/engine/js-processor/src/jsKeyboardProcessor.ts
index 054f9b1442..a3cac3aec9 100644
--- a/web/src/engine/js-processor/src/keyboardProcessor.ts
+++ b/web/src/engine/js-processor/src/jsKeyboardProcessor.ts
@@ -9,42 +9,41 @@
 import { EventEmitter } from 'eventemitter3';
 import { ModifierKeyConstants } from '@keymanapp/common-types';
 import {
-  Codes, type Keyboard, MinimalKeymanGlobal, KeyEvent, Layouts,
-  DefaultRules, EmulationKeystrokes
+  Codes, type JSKeyboard, MinimalKeymanGlobal, KeyEvent, Layouts,
+  DefaultRules, EmulationKeystrokes, type MutableSystemStore,
+  OutputTargetInterface, ProcessorAction, SystemStoreIDs
 } from "keyman/engine/keyboard";
 import { Mock } from "./mock.js";
-import type OutputTarget from "./outputTarget.js";
-import RuleBehavior from "./ruleBehavior.js";
-import KeyboardInterface from './kbdInterface.js';
+import { type OutputTargetBase }  from "./outputTargetBase.js";
+import { JSKeyboardInterface }  from './jsKeyboardInterface.js';
 import { DeviceSpec, globalObject, KMWString } from "@keymanapp/web-utils";
-import { type MutableSystemStore, SystemStoreIDs } from "./systemStores.js";
 
 // #endregion
 
 // Also relies on @keymanapp/web-utils, which is included via tsconfig.json.
 
-export type BeepHandler = (outputTarget: OutputTarget) => void;
+export type BeepHandler = (outputTarget: OutputTargetInterface) => void;
 export type LogMessageHandler = (str: string) => void;
 
 export interface ProcessorInitOptions {
   baseLayout?: string;
-  keyboardInterface?: KeyboardInterface;
+  keyboardInterface?: JSKeyboardInterface;
   defaultOutputRules?: DefaultRules; // Takes the class def object, not an instance thereof.
 }
 
 interface EventMap {
-  statekeychange: (stateKeys: typeof KeyboardProcessor.prototype.stateKeys) => void;
+  statekeychange: (stateKeys: typeof JSKeyboardProcessor.prototype.stateKeys) => void;
 }
 
-export default class KeyboardProcessor extends EventEmitter<EventMap> {
-  public static readonly DEFAULT_OPTIONS: ProcessorInitOptions = {
+export class JSKeyboardProcessor extends EventEmitter<EventMap> {
+  private static readonly DEFAULT_OPTIONS: ProcessorInitOptions = {
     baseLayout: 'us',
     defaultOutputRules: new DefaultRules()
   };
 
   // Tracks the simulated value for supported state keys, allowing the OSK to mirror a physical keyboard for them.
   // Using the exact keyCode name from the Codes definitions will allow for certain optimizations elsewhere in the code.
-  stateKeys = {
+  public stateKeys = {
     "K_CAPS":false,
     "K_NUMLOCK":false,
     "K_SCROLL":false
@@ -53,45 +52,45 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
   // Tracks the most recent modifier state information in order to quickly detect changes
   // in keyboard state not otherwise captured by the hosting page in the browser.
   // Needed for AltGr simulation.
-  modStateFlags: number = 0;
+  public modStateFlags: number = 0;
 
-  keyboardInterface: KeyboardInterface;
+  public keyboardInterface: JSKeyboardInterface;
 
   /**
    * Indicates the device (platform) to be used for non-keystroke events,
    * such as those sent to `begin postkeystroke` and `begin newcontext`
    * entry points.
    */
-  contextDevice: DeviceSpec;
+  public contextDevice: DeviceSpec;
 
-  baseLayout: string;
+  public baseLayout: string;
 
-  defaultRules: DefaultRules;
+  public defaultRules: DefaultRules;
 
   // Callbacks for various feedback types
-  beepHandler?: BeepHandler;
-  warningLogger?: LogMessageHandler;
-  errorLogger?: LogMessageHandler;
+  public beepHandler?: BeepHandler;
+  public warningLogger?: LogMessageHandler;
+  public errorLogger?: LogMessageHandler;
 
   constructor(device: DeviceSpec, options?: ProcessorInitOptions) {
     super();
 
     if(!options) {
-      options = KeyboardProcessor.DEFAULT_OPTIONS;
+      options = JSKeyboardProcessor.DEFAULT_OPTIONS;
     }
 
     this.contextDevice = device;
 
-    this.baseLayout = options.baseLayout || KeyboardProcessor.DEFAULT_OPTIONS.baseLayout;
-    this.keyboardInterface = options.keyboardInterface || new KeyboardInterface(globalObject(), MinimalKeymanGlobal);
-    this.defaultRules = options.defaultOutputRules || KeyboardProcessor.DEFAULT_OPTIONS.defaultOutputRules;
+    this.baseLayout = options.baseLayout || JSKeyboardProcessor.DEFAULT_OPTIONS.baseLayout;
+    this.keyboardInterface = options.keyboardInterface || new JSKeyboardInterface(globalObject(), MinimalKeymanGlobal);
+    this.defaultRules = options.defaultOutputRules || JSKeyboardProcessor.DEFAULT_OPTIONS.defaultOutputRules;
   }
 
-  public get activeKeyboard(): Keyboard {
+  public get activeKeyboard(): JSKeyboard {
     return this.keyboardInterface.activeKeyboard;
   }
 
-  public set activeKeyboard(keyboard: Keyboard) {
+  public set activeKeyboard(keyboard: JSKeyboard) {
     this.keyboardInterface.activeKeyboard = keyboard;
 
     // All old deadkeys and keyboard-specific cache should immediately be invalidated
@@ -99,7 +98,7 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
     this.resetContext();
   }
 
-  get layerStore(): MutableSystemStore {
+  public get layerStore(): MutableSystemStore {
     return this.keyboardInterface.systemStores[SystemStoreIDs.TSS_LAYER] as MutableSystemStore;
   }
 
@@ -121,16 +120,17 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
   }
 
   /**
-   * Get the default RuleBehavior for the specified key, attempting to mimic standard browser defaults
+   * Get the default ProcessorAction for the specified key, attempting to mimic standard browser defaults
    * where and when appropriate.
    *
    * @param   {object}  Lkc           The pre-analyzed KeyEvent object
-   * @param   {boolean} outputTarget  The OutputTarget receiving the KeyEvent
+   * @param   {OutputTargetBase} outputTarget  The output target receiving the KeyEvent
+   * @param   {boolean}  readonly      True if the target is read-only
    * @return  {string}
    */
-  defaultRuleBehavior(Lkc: KeyEvent, outputTarget: OutputTarget, readonly: boolean): RuleBehavior {
+  private defaultRuleBehavior(Lkc: KeyEvent, outputTarget: OutputTargetBase, readonly: boolean): ProcessorAction {
     const preInput = Mock.from(outputTarget, readonly);
-    const ruleBehavior = new RuleBehavior();
+    const ruleBehavior = new ProcessorAction();
 
     let matched = false;
     let char = '';
@@ -182,7 +182,7 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
           this.keyboardInterface.output(0, outputTarget, char);
         }
       } else {
-        // No match, no default RuleBehavior.
+        // No match, no default ProcessorAction.
         return null;
       }
     }
@@ -198,20 +198,20 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
     return ruleBehavior;
   }
 
-  processNewContextEvent(device: DeviceSpec, outputTarget: OutputTarget): RuleBehavior {
+  private processNewContextEvent(device: DeviceSpec, outputTarget: OutputTargetBase): ProcessorAction {
     return this.activeKeyboard ?
       this.keyboardInterface.processNewContextEvent(outputTarget, this.activeKeyboard.constructNullKeyEvent(device, this.stateKeys)) :
       null;
   }
 
-  processPostKeystroke(device: DeviceSpec, outputTarget: OutputTarget): RuleBehavior {
+  public processPostKeystroke(device: DeviceSpec, outputTarget: OutputTargetBase): ProcessorAction {
     return this.activeKeyboard ?
       this.keyboardInterface.processPostKeystroke(outputTarget, this.activeKeyboard.constructNullKeyEvent(device, this.stateKeys)) :
       null;
   }
 
-  processKeystroke(keyEvent: KeyEvent, outputTarget: OutputTarget): RuleBehavior {
-    let matchBehavior: RuleBehavior;
+  public processKeystroke(keyEvent: KeyEvent, outputTarget: OutputTargetBase): ProcessorAction {
+    let matchBehavior: ProcessorAction;
 
     // Before keyboard rules apply, check if the left-context is empty.
     const nothingDeletable = KMWString.length(outputTarget.getTextBeforeCaret()) == 0 && outputTarget.isSelectionEmpty();
@@ -249,7 +249,7 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
         if(!matchBehavior) {
           matchBehavior = defaultBehavior;
         } else {
-          matchBehavior.mergeInDefaults(defaultBehavior);
+          this.mergeInOtherProcessorAction(matchBehavior, defaultBehavior);
         }
         matchBehavior.triggerKeyDefault = false; // We've triggered it successfully.
       } // If null, we must rely on something else (like the browser, in DOM-aware code) to fulfill the default.
@@ -267,7 +267,7 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
    * @return      {boolean}                 Always true
    * Description  Updates the current shift state within KMW, updating the OSK's visualization thereof.
    */
-  _UpdateVKShift(e: KeyEvent): boolean {
+  private _UpdateVKShift(e: KeyEvent): boolean {
     let keyShiftState=0;
 
     const lockNames  = ['CAPS', 'NUM_LOCK', 'SCROLL_LOCK'] as const;
@@ -343,7 +343,7 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
     }
   }
 
-  getLayerId(modifier: number): string {
+  private getLayerId(modifier: number): string {
     return Layouts.getLayerId(modifier);
   }
 
@@ -354,7 +354,7 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
    *  @param  {string}                    keyName     key identifier
    *  @return {boolean}                               return true if keyboard layer changed
    */
-  selectLayer(keyEvent: KeyEvent): boolean {
+  public selectLayer(keyEvent: KeyEvent): boolean {
     const keyName = keyEvent.kName;
     let nextLayer = keyEvent.kNextLayer;
     const isChiral = this.activeKeyboard && this.activeKeyboard.isChiral;
@@ -437,7 +437,7 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
    *
    * @param       {string}      id      layer id (e.g. ctrlshift)
    */
-  updateLayer(keyEvent: KeyEvent, id: string) {
+  private updateLayer(keyEvent: KeyEvent, id: string) {
     const activeLayer = this.layerId;
     let s = activeLayer;
 
@@ -539,7 +539,7 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
 
   // Returns true if the key event is a modifier press, allowing keyPress to return selectively
   // in those cases.
-  doModifierPress(Levent: KeyEvent, outputTarget: OutputTarget, isKeyDown: boolean): boolean {
+  public doModifierPress(Levent: KeyEvent, outputTarget: OutputTargetBase, isKeyDown: boolean): boolean {
     if(!this.activeKeyboard) {
       return false;
     }
@@ -570,19 +570,19 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
    * e.g. by focus change, selection change, keyboard change, etc.
    *
    * @param    {Object}   outputTarget  The OutputTarget that has focus
-   * @returns  {Object}                 A RuleBehavior object describing the cumulative effects of
+   * @returns  {Object}                 A ProcessorAction object describing the cumulative effects of
    *                                    all matched keyboard rules
    */
-  performNewContextEvent(outputTarget: OutputTarget): RuleBehavior {
+  private performNewContextEvent(outputTarget: OutputTargetBase): ProcessorAction {
     const ruleBehavior = this.processNewContextEvent(this.contextDevice, outputTarget);
 
-    if(ruleBehavior) {
-      ruleBehavior.finalize(this, outputTarget, true);
+    if (ruleBehavior) {
+      this.finalizeProcessorAction(ruleBehavior, outputTarget);
     }
     return ruleBehavior;
   }
 
-  resetContext(target?: OutputTarget) {
+  public resetContext(target?: OutputTargetBase) {
     this.layerId = 'default';
 
     // Make sure all deadkeys for the context get cleared properly.
@@ -601,7 +601,7 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
     }
   };
 
-  setNumericLayer(device: DeviceSpec) {
+  public setNumericLayer(device: DeviceSpec) {
     if (this.activeKeyboard) {
       const layout = this.activeKeyboard.layout(device.formFactor);
       if(layout.getLayer('numeric')) {
@@ -609,4 +609,76 @@ export default class KeyboardProcessor extends EventEmitter<EventMap> {
       }
     }
   };
+
+  public finalizeProcessorAction(data: ProcessorAction, outputTarget: OutputTargetInterface): void {
+    if (!data.transcription) {
+      throw "Cannot finalize a ProcessorAction with no transcription.";
+    }
+
+    if (this.beepHandler && data.beep) {
+      this.beepHandler(outputTarget);
+    }
+
+    for (const storeID in data.setStore) {
+      const sysStore = this.keyboardInterface.systemStores[storeID];
+      if (sysStore) {
+        try {
+          sysStore.set(data.setStore[storeID]);
+        } catch (error) {
+          if (this.errorLogger) {
+            this.errorLogger("Rule attempted to perform illegal operation - 'platform' may not be changed.");
+          }
+        }
+      } else if (this.warningLogger) {
+        this.warningLogger("Unknown store affected by keyboard rule: " + storeID);
+      }
+    }
+
+    this.keyboardInterface.applyVariableStores(data.variableStores);
+
+    if (this.keyboardInterface.variableStoreSerializer) {
+      for (const storeID in data.saveStore) {
+        this.keyboardInterface.variableStoreSerializer.saveStore(this.activeKeyboard.id, storeID, data.saveStore[storeID]);
+      }
+    }
+
+    if (data.triggersDefaultCommand) {
+      const keyEvent = data.transcription.keystroke;
+      this.defaultRules.applyCommand(keyEvent, outputTarget);
+    }
+
+    if (this.warningLogger && data.warningLog) {
+      this.warningLogger(data.warningLog);
+    } else if (this.errorLogger && data.errorLog) {
+      this.errorLogger(data.errorLog);
+    }
+  }
+
+  /**
+   * Merges default-related behaviors from another ProcessorAction into this one.  Assumes that the current instance
+   * "came first" chronologically.  Both RuleBehaviors must be sourced from the same keystroke.
+   *
+   * Intended use:  merging rule-based behavior with default key behavior during scenarios like those described
+   * at https://github.com/keymanapp/keyman/pull/4350#issuecomment-768753852.
+   *
+   * This function does not attempt a "complete" merge for two fully-constructed RuleBehaviors!  Things
+   * WILL break for unintended uses.
+   * @param other
+   */
+  private mergeInOtherProcessorAction(first: ProcessorAction, other: ProcessorAction): void {
+    const keystroke = first.transcription.keystroke;
+    const keyFromOther = other.transcription.keystroke;
+    if (keystroke.Lcode != keyFromOther.Lcode || keystroke.Lmodifiers != keyFromOther.Lmodifiers) {
+      throw "ProcessorAction default-merge not supported unless keystrokes are identical!";
+    }
+
+    first.triggersDefaultCommand = first.triggersDefaultCommand || other.triggersDefaultCommand;
+
+    const mergingMock = Mock.from(first.transcription.preInput, false);
+    mergingMock.apply(first.transcription.transform);
+    mergingMock.apply(other.transcription.transform);
+
+    first.transcription = mergingMock.buildTranscriptionFrom(first.transcription.preInput, keystroke, false, first.transcription.alternates);
+  }
+
 }
diff --git a/web/src/engine/js-processor/src/mock.ts b/web/src/engine/js-processor/src/mock.ts
index 9cc7aab834..fb8cc607c7 100644
--- a/web/src/engine/js-processor/src/mock.ts
+++ b/web/src/engine/js-processor/src/mock.ts
@@ -1,7 +1,8 @@
-import OutputTarget from './outputTarget.js';
+import { OutputTargetInterface } from 'keyman/engine/keyboard';
+import { OutputTargetBase } from './outputTargetBase.js';
 import { KMWString } from '@keymanapp/web-utils';
 
-export class Mock extends OutputTarget {
+export class Mock extends OutputTargetBase {
   text: string;
 
   selStart: number;
@@ -25,10 +26,18 @@ export class Mock extends OutputTarget {
     this.selForward = this.selEnd >= this.selStart;
   }
 
+  static assertIsOutputTargetBase(outputTarget: OutputTargetInterface): asserts outputTarget is OutputTargetBase {
+    if (!(outputTarget instanceof OutputTargetBase)) {
+      throw new TypeError("outputTarget is not a OutputTargetBase");
+    }
+  }
+
   // Clones the state of an existing EditableElement, creating a Mock version of its state.
-  static from(outputTarget: OutputTarget, readonly?: boolean) {
+  static from(outputTarget: OutputTargetInterface, readonly?: boolean): Mock {
     let clone: Mock;
 
+    this.assertIsOutputTargetBase(outputTarget);
+
     if (outputTarget instanceof Mock) {
       // Avoids the need to run expensive kmwstring.ts `length()`
       // calculations when deep-copying Mock instances.
@@ -56,7 +65,7 @@ export class Mock extends OutputTarget {
     }
 
     // Also duplicate deadkey state!  (Needed for fat-finger ops.)
-    clone.setDeadkeys(outputTarget.deadkeys());
+    clone.setDeadkeys((outputTarget as OutputTargetBase).deadkeys());
 
     return clone;
   }
diff --git a/web/src/engine/js-processor/src/outputTarget.ts b/web/src/engine/js-processor/src/outputTargetBase.ts
similarity index 83%
rename from web/src/engine/js-processor/src/outputTarget.ts
rename to web/src/engine/js-processor/src/outputTargetBase.ts
index 73f164e69a..eca7c6766a 100644
--- a/web/src/engine/js-processor/src/outputTarget.ts
+++ b/web/src/engine/js-processor/src/outputTargetBase.ts
@@ -1,7 +1,7 @@
 import { KMWString } from "@keymanapp/web-utils";
+import { Alternate, OutputTargetInterface, TextTransform, Transcription } from 'keyman/engine/keyboard';
 import { findCommonSubstringEndIndex } from "./stringDivergence.js";
 import { Mock } from "./mock.js";
-import { OutputTarget as OutputTargetInterface } from 'keyman/engine/keyboard';
 
 // Defines deadkey management in a manner attachable to each element interface.
 import { type KeyEvent } from 'keyman/engine/keyboard';
@@ -17,54 +17,7 @@ export function isEmptyTransform(transform: LexicalModelTypes.Transform) {
   return transform.insert === '' && transform.deleteLeft === 0 && (transform.deleteRight ?? 0) === 0;
 }
 
-export class TextTransform implements LexicalModelTypes.Transform {
-  readonly insert: string;
-  readonly deleteLeft: number;
-  readonly deleteRight: number;
-  readonly erasedSelection: boolean;
-  id: number;
-
-  constructor(insert: string, deleteLeft: number, deleteRight: number, erasedSelection: boolean) {
-    this.insert = insert;
-    this.deleteLeft = deleteLeft;
-    this.deleteRight = deleteRight;
-    this.erasedSelection = erasedSelection;
-  }
-
-  public static readonly nil = new TextTransform('', 0, 0, false);
-}
-
-export class Transcription {
-  readonly token: number;
-  readonly keystroke: KeyEvent;
-  readonly transform: TextTransform;
-  alternates: Alternate[]; // constructed after the rest of the transcription.
-  readonly preInput: Mock;
-
-  private static tokenSeed: number = 0;
-
-  constructor(keystroke: KeyEvent, transform: TextTransform, preInput: Mock, alternates?: Alternate[]/*, removedDks: Deadkey[], insertedDks: Deadkey[]*/) {
-    const token = this.token = Transcription.tokenSeed++;
-
-    this.keystroke = keystroke;
-    this.transform = transform;
-    this.alternates = alternates;
-    this.preInput = preInput;
-
-    this.transform.id = this.token;
-
-    // Assign the ID to each alternate, as well.
-    if(alternates) {
-      alternates.forEach(function(alt) {
-        alt.sample.id = token;
-      });
-    }
-  }
-}
-
-export type Alternate = LexicalModelTypes.ProbabilityMass<LexicalModelTypes.Transform>;
-
-export default abstract class OutputTarget implements OutputTargetInterface {
+export abstract class OutputTargetBase implements OutputTargetInterface {
   private _dks: DeadkeyTracker;
 
   constructor() {
@@ -122,7 +75,7 @@ export default abstract class OutputTarget implements OutputTargetInterface {
    * As such, it assumes that the caret is immediately after any inserted text.
    * @param from An output target (preferably a Mock) representing the prior state of the input/output system.
    */
-  buildTransformFrom(original: OutputTarget): TextTransform {
+  buildTransformFrom(original: OutputTargetInterface): TextTransform {
     const toLeft = this.getTextBeforeCaret();
     const fromLeft = original.getTextBeforeCaret();
 
@@ -143,7 +96,7 @@ export default abstract class OutputTarget implements OutputTargetInterface {
     return new TextTransform(insertedText, deletedLeft, deletedRight, original.getSelectedText() && !this.getSelectedText());
   }
 
-  buildTranscriptionFrom(original: OutputTarget, keyEvent: KeyEvent, readonly: boolean, alternates?: Alternate[]): Transcription {
+  buildTranscriptionFrom(original: OutputTargetInterface, keyEvent: KeyEvent, readonly: boolean, alternates?: Alternate[]): Transcription {
     const transform = this.buildTransformFrom(original);
 
     // If we ever decide to re-add deadkey tracking, this is the place for it.
@@ -155,7 +108,7 @@ export default abstract class OutputTarget implements OutputTargetInterface {
    * Restores the `OutputTarget` to the indicated state.  Designed for use with `Transcription.preInput`.
    * @param original An `OutputTarget` (usually a `Mock`).
    */
-  restoreTo(original: OutputTarget) {
+  restoreTo(original: OutputTargetBase) {
     this.clearSelection();
     // We currently do not restore selected text; the mechanism isn't supported at present for
     // all output target types - especially in regard to re-selecting the text if restored.
diff --git a/web/src/engine/js-processor/src/platformSystemStore.ts b/web/src/engine/js-processor/src/platformSystemStore.ts
new file mode 100644
index 0000000000..0b81533db3
--- /dev/null
+++ b/web/src/engine/js-processor/src/platformSystemStore.ts
@@ -0,0 +1,84 @@
+/*
+ * Keyman is copyright (C) SIL Global. MIT License.
+ *
+ * &platform system store implementation (.js keyboards)
+ */
+
+
+import { SystemStore, SystemStoreIDs, type KeyboardHarness } from 'keyman/engine/keyboard';
+
+/**
+ * Handles checks against the current platform.
+ */
+export class PlatformSystemStore extends SystemStore {
+  private readonly kbdInterface: KeyboardHarness;
+
+  constructor(keyboardInterface: KeyboardHarness) {
+    super(SystemStoreIDs.TSS_PLATFORM);
+
+    this.kbdInterface = keyboardInterface;
+  }
+
+  matches(value: string) {
+    const constraints=value.split(' ');
+    const device = this.kbdInterface.activeDevice;
+
+    for(let i=0; i<constraints.length; i++) {
+      let constraint=constraints[i].toLowerCase();
+      switch(constraint) {
+        case 'touch':
+        case 'hardware':
+          if(device.touchable != (constraint == 'touch')) {
+            return false;
+          }
+          break;
+
+        case 'macos':
+        case 'mac':
+          constraint = 'macosx';
+          // fall through
+        case 'macosx':
+        case 'windows':
+        case 'android':
+        case 'ios':
+        case 'linux':
+          if(device.OS != constraint) {
+            return false;
+          }
+          break;
+
+        case 'tablet':
+        case 'phone':
+        case 'desktop':
+          if(device.formFactor != constraint) {
+            return false;
+          }
+          break;
+
+        case 'web':
+          if(device.browser == 'native') {
+            return false; // web matches anything other than 'native'
+          }
+          break;
+
+        case 'native':
+          // This will return true for embedded KeymanWeb
+        case 'chrome':
+        case 'firefox':
+        case 'safari':
+        case 'edge':
+        case 'opera':
+          if(device.browser != constraint) {
+            return false;
+          }
+          break;
+
+        default:
+          return false;
+      }
+    }
+
+    // Everything we checked against was valid and had matches - it's a match!
+    return true;
+  }
+}
diff --git a/web/src/engine/js-processor/src/ruleBehavior.ts b/web/src/engine/js-processor/src/ruleBehavior.ts
deleted file mode 100644
index 16e11cbe55..0000000000
--- a/web/src/engine/js-processor/src/ruleBehavior.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-import KeyboardProcessor from "./keyboardProcessor.js";
-import { VariableStoreDictionary } from "keyman/engine/keyboard";
-import OutputTarget, { type Transcription } from './outputTarget.js';
-import { Mock } from "./mock.js";
-import { type VariableStore } from "./systemStores.js";
-import { LexicalModelTypes } from '@keymanapp/common-types';
-
-/**
- * Represents the commands and state changes that result from a matched keyboard rule.
- */
-export default class RuleBehavior {
-  /**
-   * The before-and-after Transform from matching a keyboard rule.  May be `null`
-   * if no keyboard rules were matched for the keystroke.
-   */
-  transcription: Transcription = null;
-
-  /**
-   * Indicates whether or not a BEEP command was issued by the matched keyboard rule.
-   */
-  beep?: boolean;
-
-  /**
-   * A set of changed store values triggered by the matched keyboard rule.
-   */
-  setStore: {[id: number]: string} = {};
-
-  /**
-   * A set of variable stores with save requests triggered by the matched keyboard rule
-   */
-  saveStore: {[name: string]: VariableStore} = {};
-
-  /**
-   * A set of variable stores with possible changes to be applied during finalization.
-   */
-    variableStores: VariableStoreDictionary = {};
-
-  /**
-   * Denotes a non-output default behavior; this should be evaluated later, against the true keystroke.
-   */
-  triggersDefaultCommand: boolean = false;
-
-  /**
-   * Denotes error log messages generated when attempting to generate this behavior.
-   */
-  errorLog?: string;
-
-  /**
-   * Denotes warning log messages generated when attempting to generate this behavior.
-   */
-  warningLog?: string;
-
-  /**
-   * If predictive text is active, contains a Promise returning predictive Suggestions.
-   */
-  predictionPromise?: Promise<LexicalModelTypes.Suggestion[]>;
-
-  /**
-   * In reference to https://github.com/keymanapp/keyman/pull/4350#issuecomment-768753852:
-   *
-   * If the final group processed is a context and keystroke group (using keys),
-   * and there is no nomatch rule, and the keystroke is not matched in the group,
-   * the keystroke's default behavior should trigger, regardless of whether or not any
-   * rules in prior groups matched.
-   */
-  triggerKeyDefault?: boolean;
-
-  finalize(processor: KeyboardProcessor, outputTarget: OutputTarget, readonly: boolean) {
-    if(!this.transcription) {
-      throw "Cannot finalize a RuleBehavior with no transcription.";
-    }
-
-    if(processor.beepHandler && this.beep) {
-      processor.beepHandler(outputTarget);
-    }
-
-    for(const storeID in this.setStore) {
-      const sysStore = processor.keyboardInterface.systemStores[storeID];
-      if(sysStore) {
-        try {
-          sysStore.set(this.setStore[storeID]);
-        } catch (error) {
-          if(processor.errorLogger) {
-            processor.errorLogger("Rule attempted to perform illegal operation - 'platform' may not be changed.");
-          }
-        }
-      } else if(processor.warningLogger) {
-        processor.warningLogger("Unknown store affected by keyboard rule: " + storeID);
-      }
-    }
-
-    processor.keyboardInterface.applyVariableStores(this.variableStores);
-
-    if(processor.keyboardInterface.variableStoreSerializer) {
-      for(const storeID in this.saveStore) {
-        processor.keyboardInterface.variableStoreSerializer.saveStore(processor.activeKeyboard.id, storeID, this.saveStore[storeID]);
-      }
-    }
-
-    if(this.triggersDefaultCommand) {
-      const keyEvent = this.transcription.keystroke;
-      processor.defaultRules.applyCommand(keyEvent, outputTarget);
-    }
-
-    if(processor.warningLogger && this.warningLog) {
-      processor.warningLogger(this.warningLog);
-    } else if(processor.errorLogger && this.errorLog) {
-      processor.errorLogger(this.errorLog);
-    }
-  }
-
-  /**
-   * Merges default-related behaviors from another RuleBehavior into this one.  Assumes that the current instance
-   * "came first" chronologically.  Both RuleBehaviors must be sourced from the same keystroke.
-   *
-   * Intended use:  merging rule-based behavior with default key behavior during scenarios like those described
-   * at https://github.com/keymanapp/keyman/pull/4350#issuecomment-768753852.
-   *
-   * This function does not attempt a "complete" merge for two fully-constructed RuleBehaviors!  Things
-   * WILL break for unintended uses.
-   * @param other
-   */
-  mergeInDefaults(other: RuleBehavior) {
-    const keystroke = this.transcription.keystroke;
-    const keyFromOther = other.transcription.keystroke;
-    if(keystroke.Lcode != keyFromOther.Lcode || keystroke.Lmodifiers != keyFromOther.Lmodifiers) {
-      throw "RuleBehavior default-merge not supported unless keystrokes are identical!";
-    }
-
-    this.triggersDefaultCommand = this.triggersDefaultCommand || other.triggersDefaultCommand;
-
-    const mergingMock = Mock.from(this.transcription.preInput, false);
-    mergingMock.apply(this.transcription.transform);
-    mergingMock.apply(other.transcription.transform);
-
-    this.transcription = mergingMock.buildTranscriptionFrom(this.transcription.preInput, keystroke, false, this.transcription.alternates);
-  }
-}
\ No newline at end of file
diff --git a/web/src/engine/js-processor/src/stores.ts b/web/src/engine/js-processor/src/stores.ts
new file mode 100644
index 0000000000..86291d8f3e
--- /dev/null
+++ b/web/src/engine/js-processor/src/stores.ts
@@ -0,0 +1,20 @@
+/*
+ * Keyman is copyright (C) SIL Global. MIT License.
+ *
+ * Definitions for basic stores (see kmn reference)
+ */
+
+import { StoreNonCharEntry } from './jsKeyboardInterface.js';
+
+/*
+* Type alias definitions to reflect the parameters of the fullContextMatch() callback (KMW 10+).
+* No constructors or methods since keyboards will not utilize the same backing prototype, and
+* property names are shorthanded to promote minification.
+*/
+type PlainKeyboardStore = string;
+
+export type KeyboardStoreElement = (string | StoreNonCharEntry);
+export type ComplexKeyboardStore = KeyboardStoreElement[];
+
+export type KeyboardStore = PlainKeyboardStore | ComplexKeyboardStore;
+
diff --git a/web/src/engine/js-processor/src/systemStores.ts b/web/src/engine/js-processor/src/systemStores.ts
deleted file mode 100644
index e191e78bd2..0000000000
--- a/web/src/engine/js-processor/src/systemStores.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-import { type KeyboardHarness } from 'keyman/engine/keyboard';
-import { StoreNonCharEntry } from './kbdInterface.js';
-
-export enum SystemStoreIDs {
-  TSS_LAYER = 33,
-  TSS_PLATFORM = 31,
-  TSS_NEWLAYER = 42,
-  TSS_OLDLAYER = 43
-}
-
-/*
-* Type alias definitions to reflect the parameters of the fullContextMatch() callback (KMW 10+).
-* No constructors or methods since keyboards will not utilize the same backing prototype, and
-* property names are shorthanded to promote minification.
-*/
-type PlainKeyboardStore = string;
-
-export type KeyboardStoreElement = (string | StoreNonCharEntry);
-export type ComplexKeyboardStore = KeyboardStoreElement[];
-
-export type KeyboardStore = PlainKeyboardStore | ComplexKeyboardStore;
-
-export type VariableStore = { [name: string]: string };
-
-export interface VariableStoreSerializer {
-  loadStore(keyboardID: string, storeName: string): VariableStore;
-  saveStore(keyboardID: string, storeName: string, storeMap: VariableStore): void;
-}
-
-/**
- * Defines common behaviors associated with system stores.
- */
-export abstract class SystemStore {
-  public readonly id: number;
-
-  constructor(id: number) {
-    this.id = id;
-  }
-
-  abstract matches(value: string): boolean;
-
-  set(value: string): void {
-    throw new Error("System store with ID " + this.id + " may not be directly set.");
-  }
-}
-
-/**
- * A handler designed to receive feedback whenever a system store's value is changed.
- * @param source    The system store being mutated, before the value change occurs.
- * @param newValue  The new value being set
- * @returns         `false` / `undefined` to allow the change, `true` to block the change.
- */
-export type SystemStoreMutationHandler = (source: MutableSystemStore, newValue: string) => boolean;
-
-export class MutableSystemStore extends SystemStore {
-  private _value: string;
-  handler?: SystemStoreMutationHandler = null;
-
-  constructor(id: number, defaultValue: string) {
-    super(id);
-    this._value = defaultValue;
-  }
-
-  get value() {
-    return this._value;
-  }
-
-  matches(value: string) {
-    return this._value == value;
-  }
-
-  set(value: string) {
-    // Even if things stay the same, we should still signal this.
-    // It's important for tracking if a rule directly set the layer
-    // versus if it passively remained.
-    if(this.handler) {
-      if(this.handler(this, value)) {
-        return;
-      }
-    }
-
-    this._value = value;
-  }
-}
-
-/**
- * Handles checks against the current platform.
- */
-export class PlatformSystemStore extends SystemStore {
-  private readonly kbdInterface: KeyboardHarness;
-
-  constructor(keyboardInterface: KeyboardHarness) {
-    super(SystemStoreIDs.TSS_PLATFORM);
-
-    this.kbdInterface = keyboardInterface;
-  }
-
-  matches(value: string) {
-    const constraints=value.split(' ');
-    const device = this.kbdInterface.activeDevice;
-
-    for(let i=0; i<constraints.length; i++) {
-      let constraint=constraints[i].toLowerCase();
-      switch(constraint) {
-        case 'touch':
-        case 'hardware':
-          if(device.touchable != (constraint == 'touch')) {
-            return false;
-          }
-          break;
-
-        case 'macos':
-        case 'mac':
-          constraint = 'macosx';
-          // fall through
-        case 'macosx':
-        case 'windows':
-        case 'android':
-        case 'ios':
-        case 'linux':
-          if(device.OS != constraint) {
-            return false;
-          }
-          break;
-
-        case 'tablet':
-        case 'phone':
-        case 'desktop':
-          if(device.formFactor != constraint) {
-            return false;
-          }
-          break;
-
-        case 'web':
-          if(device.browser == 'native') {
-            return false; // web matches anything other than 'native'
-          }
-          break;
-
-        case 'native':
-          // This will return true for embedded KeymanWeb
-        case 'chrome':
-        case 'firefox':
-        case 'safari':
-        case 'edge':
-        case 'opera':
-          if(device.browser != constraint) {
-            return false;
-          }
-          break;
-
-        default:
-          return false;
-      }
-    }
-
-    // Everything we checked against was valid and had matches - it's a match!
-    return true;
-  }
-}
diff --git a/web/src/engine/js-processor/tsconfig.json b/web/src/engine/js-processor/tsconfig.json
index a57467139b..f0e38f7bc0 100644
--- a/web/src/engine/js-processor/tsconfig.json
+++ b/web/src/engine/js-processor/tsconfig.json
@@ -9,5 +9,8 @@
     "rootDir": "./src"
   },
 
+  "references": [
+    { "path": "../keyboard"},
+  ],
   "include": [ "**/*.ts" ],
 }
diff --git a/web/src/engine/keyboard-storage/src/keyboardRequisitioner.ts b/web/src/engine/keyboard-storage/src/keyboardRequisitioner.ts
index 3a03173a8b..e1391b5698 100644
--- a/web/src/engine/keyboard-storage/src/keyboardRequisitioner.ts
+++ b/web/src/engine/keyboard-storage/src/keyboardRequisitioner.ts
@@ -115,6 +115,10 @@ export default class KeyboardRequisitioner {
     });
   }
 
+  shutdown(): void{
+    this.cache.shutdown();
+  }
+
   addKeyboardArray(x: (string|RawKeyboardMetadata)[]): Promise<(KeyboardStub | ErrorStub)[]> {
     const completeStubs: KeyboardStub[] = [];
     const incompleteStubs: KeyboardStub[] = [];
diff --git a/web/src/engine/keyboard-storage/src/stubAndKeyboardCache.ts b/web/src/engine/keyboard-storage/src/stubAndKeyboardCache.ts
index 2fc64bf252..1f26759416 100644
--- a/web/src/engine/keyboard-storage/src/stubAndKeyboardCache.ts
+++ b/web/src/engine/keyboard-storage/src/stubAndKeyboardCache.ts
@@ -1,4 +1,4 @@
-import { Keyboard, KeyboardLoaderBase as KeyboardLoader } from "keyman/engine/keyboard";
+import { type Keyboard, JSKeyboard, KeyboardLoaderBase as KeyboardLoader, KMXKeyboard } from "keyman/engine/keyboard";
 import { EventEmitter } from "eventemitter3";
 
 import KeyboardStub from "./keyboardStub.js";
@@ -52,6 +52,16 @@ export default class StubAndKeyboardCache extends EventEmitter<EventMap> {
     this.keyboardLoader = keyboardLoader;
   }
 
+  shutdown(): void {
+    for (const kbdId in this.keyboardTable) {
+      const kbd = this.keyboardTable[kbdId];
+      if (kbd instanceof KMXKeyboard) {
+        (kbd as KMXKeyboard).shutdown();
+      }
+      // TODO-web-core: do we have to do something if instanceof Promise?
+    }
+  }
+
   getKeyboardForStub(stub: KeyboardStub): Keyboard {
     return stub ? this.getKeyboard(stub.KI) : null;
   }
@@ -146,7 +156,7 @@ export default class StubAndKeyboardCache extends EventEmitter<EventMap> {
     keyboardID = prefixed(keyboardID);
 
     const cachedEntry = this.keyboardTable[keyboardID];
-    if(cachedEntry instanceof Keyboard) {
+    if(cachedEntry instanceof JSKeyboard) {
       return Promise.resolve(cachedEntry);
     } else if(cachedEntry instanceof Promise) {
       return cachedEntry;
@@ -166,7 +176,9 @@ export default class StubAndKeyboardCache extends EventEmitter<EventMap> {
 
     promise.then((kbd) => {
       // Overrides the built-in ID in case of keyboard namespacing.
-      kbd.scriptObject["KI"] = keyboardID;
+      if (kbd instanceof JSKeyboard) {
+        kbd.scriptObject["KI"] = keyboardID;
+      }
       this.addKeyboard(kbd);
     }).catch((err) => {
       delete this.keyboardTable[keyboardID];
@@ -189,12 +201,12 @@ export default class StubAndKeyboardCache extends EventEmitter<EventMap> {
   }
 
   getStub(keyboardID: string, languageID: string): KeyboardStub;
-  getStub(keyboard: Keyboard, languageID?: string): KeyboardStub;
-  getStub(arg0: string | Keyboard, arg1?: string): KeyboardStub {
+  getStub(keyboard: JSKeyboard, languageID?: string): KeyboardStub;
+  getStub(arg0: string | JSKeyboard, arg1?: string): KeyboardStub {
     let keyboardID: string;
     const languageID = arg1 || '---';
 
-    if(arg0 instanceof Keyboard) {
+    if(arg0 instanceof JSKeyboard) {
       keyboardID = arg0.id;
     } else {
       keyboardID = arg0;
@@ -221,12 +233,12 @@ export default class StubAndKeyboardCache extends EventEmitter<EventMap> {
   /**
    * Removes all metadata (stubs) associated with a specific keyboard from the cache, optionally
    * removing the cached keyboard as well.
-   * @param keyboard Either the keyboard ID or `Keyboard` instance
-   * @param purge If `true`, will also purge the `Keyboard` instance itself from the cache.
+   * @param keyboard Either the keyboard ID or `JSKeyboard` instance
+   * @param purge If `true`, will also purge the `JSKeyboard` instance itself from the cache.
    *              If `false`, only forgets the metadata (stubs).
    */
-  forgetKeyboard(keyboard: string | Keyboard, purge: boolean = false) {
-    const id: string = (keyboard instanceof Keyboard) ? keyboard.id : prefixed(keyboard);
+  forgetKeyboard(keyboard: string | JSKeyboard, purge: boolean = false) {
+    const id: string = (keyboard instanceof JSKeyboard) ? keyboard.id : prefixed(keyboard);
 
     if(this.stubSetTable[id]) {
       delete this.stubSetTable[id];
diff --git a/web/src/engine/keyboard/build.sh b/web/src/engine/keyboard/build.sh
index 7260bc5cc6..583d999276 100755
--- a/web/src/engine/keyboard/build.sh
+++ b/web/src/engine/keyboard/build.sh
@@ -23,6 +23,7 @@ builder_describe \
   "@/web/src/tools/testing/recorder-core  test" \
   "@/web/src/tools/es-bundling" \
   "@/web/src/engine/common/web-utils" \
+  "@/web/src/engine/core-processor" \
   configure \
   clean \
   build \
@@ -44,7 +45,7 @@ function do_configure() {
 
 BUILD_DIR="${KEYMAN_ROOT}/web/build/${SUBPROJECT_NAME}"
 
-function do_build() {
+do_build() {
   tsc --build "${THIS_SCRIPT_PATH}/tsconfig.all.json"
 
   # Base product - the main keyboard processor
@@ -73,7 +74,12 @@ function do_build() {
   tsc --emitDeclarationOnly --outFile "${BUILD_DIR}/lib/node-keyboard-loader.d.ts" -p src/keyboards/loaders/tsconfig.node.json
 }
 
+do_test() {
+  test-headless "${SUBPROJECT_NAME}" ""
+  test-headless-typescript "${SUBPROJECT_NAME}"
+}
+
 builder_run_action configure  do_configure
 builder_run_action clean      rm -rf "${BUILD_DIR}"
 builder_run_action build      do_build
-builder_run_action test       test-headless "${SUBPROJECT_NAME}" ""
+builder_run_action test       do_test
diff --git a/web/src/engine/keyboard/src/codes.ts b/web/src/engine/keyboard/src/codes.ts
index c94d5b7152..76c18ae5a1 100644
--- a/web/src/engine/keyboard/src/codes.ts
+++ b/web/src/engine/keyboard/src/codes.ts
@@ -6,7 +6,7 @@
 
 import { ModifierKeyConstants, USVirtualKeyCodes } from '@keymanapp/common-types';
 
-const Codes = {
+export const Codes = {
   modifierCodes: {
     // Debug-mode keyboards compiled before Keyman 18.0 referenced the `ModifierKeyConstants`
     // constants via the names established below.  We must continue to support them, as they're
@@ -143,5 +143,3 @@ const Codes = {
     return modifier;
   }
 }
-
-export default Codes;
diff --git a/web/src/engine/keyboard/src/defaultRules.ts b/web/src/engine/keyboard/src/defaultRules.ts
index c78c743e8b..98279ee94f 100644
--- a/web/src/engine/keyboard/src/defaultRules.ts
+++ b/web/src/engine/keyboard/src/defaultRules.ts
@@ -5,9 +5,9 @@
  */
 
 import { ModifierKeyConstants } from '@keymanapp/common-types';
-import Codes from './codes.js';
-import type KeyEvent from './keyEvent.js';
-import { type OutputTarget }  from './outputTarget.interface.js';
+import { Codes } from './codes.js';
+import { type KeyEvent } from './keyEvent.js';
+import { type OutputTargetInterface }  from './outputTargetInterface.js';
 
 export enum EmulationKeystrokes {
   Enter = '\n',
@@ -77,13 +77,13 @@ export default class DefaultRules {
   }
 
   /**
-   * Used when a RuleBehavior represents a non-text "command" within the Engine.  This will generally
+   * Used when a ProcessorAction represents a non-text "command" within the Engine.  This will generally
    * trigger events that require context reset - often by moving the caret or by moving what OutputTarget
    * the caret is in.  However, we let those events perform the actual context reset.
    *
    * Note:  is extended by DOM-aware KeymanWeb code.
    */
-  public applyCommand(Lkc: KeyEvent, outputTarget: OutputTarget): void {
+  public applyCommand(Lkc: KeyEvent, outputTarget: OutputTargetInterface): void {
     // Notes for potential default-handling extensions:
     //
     // switch(code) {
diff --git a/web/src/engine/keyboard/src/index.ts b/web/src/engine/keyboard/src/index.ts
index 28b6331c21..03987bceaf 100644
--- a/web/src/engine/keyboard/src/index.ts
+++ b/web/src/engine/keyboard/src/index.ts
@@ -1,14 +1,11 @@
-export * from "./keyboards/activeLayout.js";
-export * from "./keyboards/defaultLayouts.js";
-export { default as Keyboard } from "./keyboards/keyboard.js";
-export * from "./keyboards/keyboard.js";
+export { ActiveKeyBase, ActiveKey, ActiveSubKey, ActiveRow, ActiveLayer, ActiveLayout } from "./keyboards/activeLayout.js";
+export { ButtonClass, ButtonClasses, LayoutLayer, LayoutFormFactor, LayoutRow, LayoutKey, LayoutSubKey, Layouts } from "./keyboards/defaultLayouts.js";
+export { JSKeyboard, LayoutState } from "./keyboards/jsKeyboard.js";
+export { KeyboardMinimalInterface } from './keyboards/keyboardMinimalInterface.js';
+export { KMXKeyboard } from './keyboards/kmxKeyboard.js';
 export { KeyboardHarness, KeyboardKeymanGlobal, MinimalCodesInterface, MinimalKeymanGlobal } from "./keyboards/keyboardHarness.js";
-export {
-  default as KeyboardLoaderBase,
-  KeyboardLoadErrorBuilder,
-  KeyboardMissingError,
-  KeyboardScriptError
-} from "./keyboards/keyboardLoaderBase.js";
+export { Keyboard, KeyboardLoaderBase } from "./keyboards/keyboardLoaderBase.js";
+export { KeyboardLoadErrorBuilder, KeyboardMissingError, KeyboardScriptError, KeyboardDownloadError, InvalidKeyboardError } from './keyboards/keyboardLoadError.js'
 export {
   CloudKeyboardFont,
   internalizeFont,
@@ -21,17 +18,20 @@ export {
   MetadataObj as RawKeyboardMetadata,
   LanguageAPIPropertySpec
 } from "./keyboards/keyboardProperties.js";
+export { ProcessorAction as ProcessorAction } from "./keyboards/processorAction.js";
 export { default as SpacebarText } from "./keyboards/spacebarText.js";
-export { default as StateKeyMap } from "./keyboards/stateKeyMap.js";
+export { StateKeyMap } from "./keyboards/stateKeyMap.js";
+export { type Alternate, TextTransform } from "./keyboards/textTransform.js";
+export { Transcription } from "./keyboards/transcription.js";
 
-export { default as Codes } from "./codes.js";
-export * from "./codes.js";
+export { Codes } from "./codes.js";
 export { default as DefaultRules } from "./defaultRules.js";
 export * from "./defaultRules.js";
-export { default as KeyEvent } from "./keyEvent.js";
-export * from "./keyEvent.js";
+export { type KeyDistribution, KeyEventSpec, KeyEvent } from "./keyEvent.js";
 export { default as KeyMapping } from "./keyMapping.js";
-export { OutputTarget } from "./outputTarget.interface.js";
+export { OutputTargetInterface } from "./outputTargetInterface.js";
+export { type SystemStoreMutationHandler, MutableSystemStore, SystemStore, SystemStoreIDs, type SystemStoreDictionary } from "./systemStore.js";
+export { type VariableStore, VariableStoreSerializer, VariableStoreDictionary } from "./variableStore.js";
 
 export * from "@keymanapp/web-utils";
 
diff --git a/web/src/engine/keyboard/src/keyEvent.ts b/web/src/engine/keyboard/src/keyEvent.ts
index 2a8856104b..8c25c964ba 100644
--- a/web/src/engine/keyboard/src/keyEvent.ts
+++ b/web/src/engine/keyboard/src/keyEvent.ts
@@ -6,10 +6,10 @@
 // a key event.  The most straightforward way to integrate Web OSK events on other platforms is to have
 // other platforms recognize and utilize this type.
 
-import type Keyboard from "./keyboards/keyboard.js";
+import { type JSKeyboard } from "./keyboards/jsKeyboard.js";
 import { type DeviceSpec } from "@keymanapp/web-utils";
 
-import Codes from './codes.js';
+import { Codes } from './codes.js';
 import DefaultRules from "./defaultRules.js";
 import { ActiveKeyBase } from './keyboards/activeLayout.js';
 
@@ -44,7 +44,7 @@ export interface KeyEventSpec {
    * guarantee that the keyboard instance known to the handler has not changed during JS execution
    * since the user's interaction that raised the event.
    */
-  srcKeyboard?: Keyboard;
+  srcKeyboard?: JSKeyboard;
 
   // Holds a generated fat-finger distribution (when appropriate)
   keyDistribution?: KeyDistribution;
@@ -64,7 +64,7 @@ export interface KeyEventSpec {
  * This class is defined within its own file so that it can be loaded by code outside of KMW without
  * having to actually load the entirety of KMW.
  */
-export default class KeyEvent implements KeyEventSpec {
+export class KeyEvent implements KeyEventSpec {
   Lcode: number;
   Lstates: number;
   LmodifierChange?: boolean;
@@ -85,7 +85,7 @@ export default class KeyEvent implements KeyEventSpec {
    * guarantee that the keyboard instance known to the handler has not changed during JS execution
    * since the user's interaction that raised the event.
    */
-  srcKeyboard?: Keyboard;
+  srcKeyboard?: JSKeyboard;
 
   // Holds relevant event properties leading to construction of this KeyEvent.
   source?: any; // Technically, KeyEvent|MouseEvent|Touch - but those are DOM types that must be kept out of headless mode.
diff --git a/web/src/engine/keyboard/src/keyMapping.ts b/web/src/engine/keyboard/src/keyMapping.ts
index 663eb5457f..52b053de6a 100644
--- a/web/src/engine/keyboard/src/keyMapping.ts
+++ b/web/src/engine/keyboard/src/keyMapping.ts
@@ -3,7 +3,7 @@
    Copyright 2019 SIL International
 ***/
 
-import type KeyEvent from "./keyEvent.js";
+import { KeyEvent } from "./keyEvent.js";
 import { KeyEventSpec } from "./keyEvent.js";
 
 class KeyMap {
diff --git a/web/src/engine/keyboard/src/keyboards/activeLayout.ts b/web/src/engine/keyboard/src/keyboards/activeLayout.ts
index f04a22246c..44b77670d9 100644
--- a/web/src/engine/keyboard/src/keyboards/activeLayout.ts
+++ b/web/src/engine/keyboard/src/keyboards/activeLayout.ts
@@ -1,9 +1,9 @@
-import Codes from "../codes.js";
-import KeyEvent, { KeyEventSpec } from "../keyEvent.js";
+import { Codes } from "../codes.js";
+import { KeyEvent, KeyEventSpec } from "../keyEvent.js";
 import KeyMapping from "../keyMapping.js";
 import { ButtonClasses, Layouts } from "./defaultLayouts.js";
 import type { LayoutKey, LayoutSubKey, LayoutRow, LayoutLayer, LayoutFormFactor, ButtonClass } from "./defaultLayouts.js";
-import type Keyboard from "./keyboard.js";
+import { type JSKeyboard } from "./jsKeyboard.js";
 
 import { TouchLayout } from "@keymanapp/common-types";
 import TouchLayoutDefaultHint = TouchLayout.TouchLayoutDefaultHint;
@@ -774,7 +774,7 @@ export class ActiveLayout implements LayoutFormFactor{
   font: string;
   keyLabels: boolean;
   isDefault?: boolean;
-  keyboard: Keyboard;
+  keyboard: JSKeyboard;
   formFactor: DeviceSpec.FormFactor;
   defaultHint: TouchLayoutDefaultHint;
   displayUnderlying?: boolean;
@@ -849,7 +849,7 @@ export class ActiveLayout implements LayoutFormFactor{
    * @param layout
    * @param formFactor
    */
-  static polyfill(layout: TouchLayoutSpec, keyboard: Keyboard, formFactor: DeviceSpec.FormFactor): ActiveLayout {
+  static polyfill(layout: TouchLayoutSpec, keyboard: JSKeyboard, formFactor: DeviceSpec.FormFactor): ActiveLayout {
     /* c8 ignore start */
     if(layout == null) {
       throw new Error("Cannot build an ActiveLayout for a null specification.");
diff --git a/web/src/engine/keyboard/src/keyboards/defaultLayouts.ts b/web/src/engine/keyboard/src/keyboards/defaultLayouts.ts
index 4b08f4bef3..4231d1d5e8 100644
--- a/web/src/engine/keyboard/src/keyboards/defaultLayouts.ts
+++ b/web/src/engine/keyboard/src/keyboards/defaultLayouts.ts
@@ -19,8 +19,8 @@ import ButtonClasses = TouchLayout.TouchLayoutKeySp;
 
 export { ButtonClasses };
 
-import Codes from "../codes.js";
-import type Keyboard from "./keyboard.js";
+import { Codes } from "../codes.js";
+import { type JSKeyboard } from "./jsKeyboard.js";
 
 // The following types provide type definitions for the full JSON format we use for visual keyboard definitions.
 export type ButtonClass       =  0 | 1 | 2 | 3 | 4 | /*5 | 6 | 7 |*/ 8 | 9 | 10;
@@ -87,11 +87,11 @@ export class Layouts {
   * Build a default layout for keyboards with no explicit layout
   *
   * @param   {Object}  PVK         raw specifications
-  * @param   {Keyboard} keyboard   keyboard object (as loaded)
+  * @param   {JSKeyboard} keyboard   keyboard object (as loaded)
   * @param   {string} formFactor   (really utils.FormFactor)
   * @return  {LayoutFormFactor}
   */
-  static buildDefaultLayout(PVK: EncodedVisualKeyboard, keyboard: Keyboard, formFactor: string): LayoutFormFactor {
+  static buildDefaultLayout(PVK: EncodedVisualKeyboard, keyboard: JSKeyboard, formFactor: string): LayoutFormFactor {
     // Build a layout using the default for the device
     let layoutType = formFactor as keyof TouchLayout.TouchLayoutFile;
 
diff --git a/web/src/engine/keyboard/src/keyboards/keyboard.ts b/web/src/engine/keyboard/src/keyboards/jsKeyboard.ts
similarity index 95%
rename from web/src/engine/keyboard/src/keyboards/keyboard.ts
rename to web/src/engine/keyboard/src/keyboards/jsKeyboard.ts
index 09f371b734..3bdcb0ed2f 100644
--- a/web/src/engine/keyboard/src/keyboards/keyboard.ts
+++ b/web/src/engine/keyboard/src/keyboards/jsKeyboard.ts
@@ -1,9 +1,10 @@
-import Codes from "../codes.js";
+import { Codes } from "../codes.js";
 import { Layouts } from "./defaultLayouts.js";
 import { ActiveKey, ActiveLayout, ActiveSubKey } from "./activeLayout.js";
-import KeyEvent from "../keyEvent.js";
-import { type OutputTarget } from "../outputTarget.interface.js";
+import { KeyEvent } from "../keyEvent.js";
+import { type OutputTargetInterface } from "../outputTargetInterface.js";
 import { KeymanWebKeyboard, ModifierKeyConstants, TouchLayout } from "@keymanapp/common-types";
+import { VariableStoreDictionary } from "../variableStore.js";
 
 import ComplexKeyboardStore = KeymanWebKeyboard.ComplexKeyboardStore;
 import KeyboardObject = KeymanWebKeyboard.KeyboardObject;
@@ -12,7 +13,7 @@ import LayoutSpec = KeymanWebKeyboard.LayoutSpec;
 type TouchLayoutSpec = TouchLayout.TouchLayoutPlatform & { isDefault?: boolean};
 
 import { Version, DeviceSpec } from "@keymanapp/web-utils";
-import StateKeyMap from "./stateKeyMap.js";
+import { StateKeyMap } from "./stateKeyMap.js";
 
 /**
  * Stores preprocessed properties of a keyboard for quick retrieval later.
@@ -30,10 +31,6 @@ export enum LayoutState {
   POLYFILLED = 1
 }
 
-export interface VariableStoreDictionary {
-  [name: string]: string;
-};
-
 type KmwKeyboardObject = KeyboardObject & {
   /**
    * Used internally by Keyman Engine for Web to hold preprocessed stores.
@@ -51,9 +48,9 @@ type KmwKeyboardObject = KeyboardObject & {
  * and keyboard-centered functionality in an object-oriented way without modifying the
  * wrapped keyboard itself.
  */
-export default class Keyboard {
+export class JSKeyboard {
   public static DEFAULT_SCRIPT_OBJECT: KmwKeyboardObject = {
-    'gs': function(outputTarget: OutputTarget, keystroke: KeyEvent) { return false; }, // no matching rules; rely on defaultRuleOutput entirely
+    'gs': function(outputTarget: OutputTargetInterface, keystroke: KeyEvent) { return false; }, // no matching rules; rely on defaultRuleOutput entirely
     'KI': '', // The currently-existing default keyboard ID; we already have checks that focus against this.
     'KN': '',
     'KV': Layouts.DEFAULT_RAW_SPEC,
@@ -73,7 +70,7 @@ export default class Keyboard {
     if(keyboardScript) {
       this.scriptObject = keyboardScript;
     } else {
-      this.scriptObject = Keyboard.DEFAULT_SCRIPT_OBJECT;
+      this.scriptObject = JSKeyboard.DEFAULT_SCRIPT_OBJECT;
     }
     this.layoutStates = {};
   }
@@ -81,26 +78,26 @@ export default class Keyboard {
   /**
    * Calls the keyboard's `gs` function, which represents the keyboard source's begin Unicode group.
    */
-  process(outputTarget: OutputTarget, keystroke: KeyEvent): boolean {
+  process(outputTarget: OutputTargetInterface, keystroke: KeyEvent): boolean {
     return this.scriptObject['gs'](outputTarget, keystroke);
   }
 
   /**
    * Calls the keyboard's `gn` function, which represents the keyboard source's begin newContext group.
    */
-  processNewContextEvent(outputTarget: OutputTarget, keystroke: KeyEvent): boolean {
+  processNewContextEvent(outputTarget: OutputTargetInterface, keystroke: KeyEvent): boolean {
     return this.scriptObject['gn'] ? this.scriptObject['gn'](outputTarget, keystroke) : false;
   }
 
   /**
    * Calls the keyboard's `gpk` function, which represents the keyboard source's begin postKeystroke group.
    */
-  processPostKeystroke(outputTarget: OutputTarget, keystroke: KeyEvent): boolean {
+  processPostKeystroke(outputTarget: OutputTargetInterface, keystroke: KeyEvent): boolean {
     return this.scriptObject['gpk'] ? this.scriptObject['gpk'](outputTarget, keystroke) : false;
   }
 
   get isHollow(): boolean {
-    return this.scriptObject == Keyboard.DEFAULT_SCRIPT_OBJECT;
+    return this.scriptObject == JSKeyboard.DEFAULT_SCRIPT_OBJECT;
   }
 
   get id(): string {
@@ -362,7 +359,7 @@ export default class Keyboard {
    * @param       {number}    _PData        1 or 0
    * Notifies keyboard of keystroke or other event
    */
-  notify(_PCommand: number, _PTarget: OutputTarget, _PData: number) { // I2187
+  notify(_PCommand: number, _PTarget: OutputTargetInterface, _PData: number) { // I2187
     // Good example use case - the Japanese CJK-picker keyboard
     if(typeof(this.scriptObject['KNS']) == 'function') {
       this.scriptObject['KNS'](_PCommand, _PTarget, _PData);
diff --git a/web/src/engine/keyboard/src/keyboards/keyboardHarness.ts b/web/src/engine/keyboard/src/keyboards/keyboardHarness.ts
index bb2e2d5ccb..117b348e9e 100644
--- a/web/src/engine/keyboard/src/keyboards/keyboardHarness.ts
+++ b/web/src/engine/keyboard/src/keyboards/keyboardHarness.ts
@@ -1,5 +1,5 @@
-import Keyboard from "./keyboard.js";
-import Codes from "../codes.js";
+import { JSKeyboard } from "./jsKeyboard.js";
+import { Codes } from "../codes.js";
 import { DeviceSpec } from '@keymanapp/web-utils';
 
 /**
@@ -64,7 +64,7 @@ export class KeyboardHarness {
   /**
    * This field serves as the receptacle for a successfully-loaded Keyboard.
    */
-  public loadedKeyboard: Keyboard = null;
+  public loadedKeyboard: JSKeyboard = null;
 
   /**
    * Keyman keyboards register themselves into the Keyman Engine for Web by directly
@@ -84,7 +84,7 @@ export class KeyboardHarness {
     if(this.loadedKeyboard) {
       throw new Error("Unexpected state:  the most-recently loaded keyboard field was not properly reset.");
     }
-    this.loadedKeyboard = new Keyboard(scriptObject);
+    this.loadedKeyboard = new JSKeyboard(scriptObject);
   }
 
   // Is evaluated on script-load for some keyboards using variable stores.
diff --git a/web/src/engine/keyboard/src/keyboards/keyboardLoadError.ts b/web/src/engine/keyboard/src/keyboards/keyboardLoadError.ts
new file mode 100644
index 0000000000..b68f03d3a9
--- /dev/null
+++ b/web/src/engine/keyboard/src/keyboards/keyboardLoadError.ts
@@ -0,0 +1,104 @@
+import { type KeyboardStub } from './keyboardLoaderBase.js';
+
+export interface KeyboardLoadErrorBuilder {
+  scriptError(err?: Error): void;
+  missingError(err: Error): void;
+  keyboardDownloadError(err: Error): void;
+
+  invalidKeyboard(err: Error): void;
+}
+
+export class KeyboardScriptError extends Error {
+  public readonly cause;
+
+  constructor(msg: string, cause?: Error) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+
+export class KeyboardMissingError extends Error {
+  public readonly cause;
+
+  constructor(msg: string, cause?: Error) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+
+export class KeyboardDownloadError extends Error {
+  public readonly cause;
+
+  constructor(message: string, cause?: Error) {
+    super(message);
+    this.cause = cause;
+  }
+}
+
+export class InvalidKeyboardError extends Error {
+  public readonly cause;
+
+  constructor(message: string, cause?: Error) {
+    super(message);
+    this.cause = cause;
+  }
+}
+
+export class UriBasedErrorBuilder implements KeyboardLoadErrorBuilder {
+  readonly uri: string;
+
+  constructor(uri: string) {
+    this.uri = uri;
+  }
+
+  missingError(err: Error) {
+    const msg = `Cannot find the keyboard at ${this.uri}.`;
+    return new KeyboardMissingError(msg, err);
+  }
+
+  scriptError(err: Error) {
+    const msg = `Error registering the keyboard script at ${this.uri}; it may contain an error.`;
+    return new KeyboardScriptError(msg, err);
+  }
+
+  keyboardDownloadError(err: Error) {
+    const msg = `Unable to download keyboard at ${this.uri}`;
+    return new KeyboardDownloadError(msg, err);
+  }
+
+  invalidKeyboard(err: Error) {
+    const msg = `${this.uri} is not a valid keyboard file`;
+    return new InvalidKeyboardError(msg, err);
+  }
+}
+
+export class StubBasedErrorBuilder implements KeyboardLoadErrorBuilder {
+  readonly stub: KeyboardStub;
+
+  constructor(stub: KeyboardStub) {
+    this.stub = stub;
+  }
+
+  missingError(err: Error) {
+    const stub = this.stub;
+    const msg = `Cannot find the ${stub.name} keyboard for ${stub.langName} at ${stub.filename}.`;
+    return new KeyboardMissingError(msg, err);
+  }
+
+  scriptError(err: Error) {
+    const stub = this.stub;
+    const msg = `Error registering the ${stub.name} keyboard for ${stub.langName}; keyboard script at ${stub.filename} may contain an error.`;
+    return new KeyboardScriptError(msg, err);
+  }
+
+  keyboardDownloadError(err: Error) {
+    const msg = `Unable to download ${this.stub.name} keyboard for ${this.stub.langName}`;
+    return new KeyboardDownloadError(msg, err);
+  }
+
+  invalidKeyboard(err: Error) {
+    const msg = `${this.stub.name} is not a valid keyboard`;
+    return new InvalidKeyboardError(msg, err);
+  }
+}
+
diff --git a/web/src/engine/keyboard/src/keyboards/keyboardLoaderBase.ts b/web/src/engine/keyboard/src/keyboards/keyboardLoaderBase.ts
index d894eeb20c..c8a89d420f 100644
--- a/web/src/engine/keyboard/src/keyboards/keyboardLoaderBase.ts
+++ b/web/src/engine/keyboard/src/keyboards/keyboardLoaderBase.ts
@@ -1,71 +1,14 @@
-import Keyboard from "./keyboard.js";
+import { KM_Core, KM_CORE_STATUS } from 'keyman/engine/core-processor';
+import { JSKeyboard } from "./jsKeyboard.js";
+import { KMXKeyboard } from './kmxKeyboard.js';
 import { KeyboardHarness } from "./keyboardHarness.js";
 import KeyboardProperties from "./keyboardProperties.js";
+import { KeyboardLoadErrorBuilder, StubBasedErrorBuilder, UriBasedErrorBuilder } from './keyboardLoadError.js';
 
-type KeyboardStub = KeyboardProperties & { filename: string };
+export type KeyboardStub = KeyboardProperties & { filename: string };
+export type Keyboard = JSKeyboard | KMXKeyboard;
 
-export interface KeyboardLoadErrorBuilder {
-  scriptError(err?: Error): void;
-  missingError(err: Error): void;
-}
-
-export class KeyboardScriptError extends Error {
-  public readonly cause;
-
-  constructor(msg: string, cause?: Error) {
-    super(msg);
-    this.cause = cause;
-  }
-}
-
-export class KeyboardMissingError extends Error {
-  public readonly cause;
-
-  constructor(msg: string, cause?: Error) {
-    super(msg);
-    this.cause = cause;
-  }
-}
-
-class UriBasedErrorBuilder implements KeyboardLoadErrorBuilder {
-  readonly uri: string;
-
-  constructor(uri: string) {
-    this.uri = uri;
-  }
-
-  missingError(err: Error) {
-    const msg = `Cannot find the keyboard at ${this.uri}.`;
-    return new KeyboardMissingError(msg, err);
-  }
-
-  scriptError(err: Error) {
-    const msg = `Error registering the keyboard script at ${this.uri}; it may contain an error.`;
-    return new KeyboardScriptError(msg, err);
-  }
-}
-
-class StubBasedErrorBuilder implements KeyboardLoadErrorBuilder {
-  readonly stub: KeyboardStub;
-
-  constructor(stub: KeyboardStub) {
-    this.stub = stub;
-  }
-
-  missingError(err: Error) {
-    const stub = this.stub;
-    const msg = `Cannot find the ${stub.name} keyboard for ${stub.langName} at ${stub.filename}.`;
-    return new KeyboardMissingError(msg, err);
-  }
-
-  scriptError(err: Error) {
-    const stub = this.stub;
-    const msg = `Error registering the ${stub.name} keyboard for ${stub.langName}; keyboard script at ${stub.filename} may contain an error.`;
-    return new KeyboardScriptError(msg, err);
-  }
-}
-
-export default abstract class KeyboardLoaderBase {
+export abstract class KeyboardLoaderBase {
   private _harness: KeyboardHarness;
 
   public get harness(): KeyboardHarness {
@@ -76,23 +19,58 @@ export default abstract class KeyboardLoaderBase {
     this._harness = harness;
   }
 
+  /**
+   * Load a keyboard from a remote or local URI.
+   *
+   * @param uri  The URI of the keyboard to load.
+   * @returns    A Promise that resolves to the loaded keyboard.
+   */
   public loadKeyboardFromPath(uri: string): Promise<Keyboard> {
     this.harness.install();
-    const promise = this.loadKeyboardInternal(uri, new UriBasedErrorBuilder(uri));
-
-    return promise;
+    return this.loadKeyboardInternal(uri, new UriBasedErrorBuilder(uri));
   }
 
-  public loadKeyboardFromStub(stub: KeyboardStub) {
+  /**
+   * Load a keyboard from keyboard stub.
+   *
+   * @param stub  The stub of the keyboard to load.
+   * @returns     A Promise that resolves to the loaded keyboard.
+   */
+  public async loadKeyboardFromStub(stub: KeyboardStub): Promise<Keyboard> {
     this.harness.install();
-    let promise = this.loadKeyboardInternal(stub.filename, new StubBasedErrorBuilder(stub), stub.id);
-
-    return promise;
+    return this.loadKeyboardInternal(stub.filename, new StubBasedErrorBuilder(stub));
   }
 
-  protected abstract loadKeyboardInternal(
-    uri: string,
-    errorBuilder: KeyboardLoadErrorBuilder,
-    id?: string
-  ): Promise<Keyboard>;
+  private isKMXKeyboard(byteArray: Uint8Array): boolean {
+    // Check if the first 4 bytes are 'KXTS' (0x4b, 0x58, 0x54, 0x53)
+    return byteArray.length >= 4 && byteArray[0] === 0x4b &&
+      byteArray[1] === 0x58 && byteArray[2] === 0x54 && byteArray[3] === 0x53;
+  }
+
+  private async loadKeyboardInternal(uri: string, errorBuilder: KeyboardLoadErrorBuilder): Promise<Keyboard> {
+    const byteArray = await this.loadKeyboardBlob(uri, errorBuilder);
+
+    if (this.isKMXKeyboard(byteArray)) {
+      // KMX or LDML (KMX+) keyboard
+      const result = KM_Core.instance.keyboard_load_from_blob(uri, byteArray);
+      if (result.status == KM_CORE_STATUS.OK) {
+        return new KMXKeyboard(result.object);
+      }
+      return null;
+    }
+
+    let script: string;
+    try {
+      script = new TextDecoder('utf-8', { fatal: true }).decode(byteArray);
+    } catch (e) {
+      throw errorBuilder.invalidKeyboard(e);
+    }
+
+    // .js keyboard
+    return await this.loadKeyboardFromScript(script, errorBuilder);
+  }
+
+  protected abstract loadKeyboardBlob(uri: string, errorBuilder: KeyboardLoadErrorBuilder): Promise<Uint8Array>;
+
+  protected abstract loadKeyboardFromScript(scriptSrc: string, errorBuilder: KeyboardLoadErrorBuilder): Promise<JSKeyboard>;
 }
\ No newline at end of file
diff --git a/web/src/engine/keyboard/src/keyboards/keyboardMinimalInterface.ts b/web/src/engine/keyboard/src/keyboards/keyboardMinimalInterface.ts
new file mode 100644
index 0000000000..564a7b2acb
--- /dev/null
+++ b/web/src/engine/keyboard/src/keyboards/keyboardMinimalInterface.ts
@@ -0,0 +1,5 @@
+import { Keyboard } from './keyboardLoaderBase.js';
+
+export interface KeyboardMinimalInterface {
+    activeKeyboard: Keyboard;
+}
\ No newline at end of file
diff --git a/web/src/engine/keyboard/src/keyboards/kmxKeyboard.ts b/web/src/engine/keyboard/src/keyboards/kmxKeyboard.ts
new file mode 100644
index 0000000000..80ca7be638
--- /dev/null
+++ b/web/src/engine/keyboard/src/keyboards/kmxKeyboard.ts
@@ -0,0 +1,39 @@
+import { KM_Core, km_core_keyboard } from 'keyman/engine/core-processor';
+
+/**
+ * Acts as a wrapper class for KMX(+) Keyman keyboards
+ */
+export class KMXKeyboard {
+
+  constructor(private _keyboard: km_core_keyboard) {
+  }
+
+  shutdown() {
+    if (this._keyboard) {
+      KM_Core.instance.keyboard_dispose(this._keyboard);
+      this._keyboard = null;
+    }
+  }
+
+  get isMnemonic(): boolean {
+    return false;
+  }
+
+  get version(): string {
+    const attrs = KM_Core.instance.keyboard_get_attrs(this._keyboard);
+    const version = attrs.object.version_string;
+    attrs.delete();
+    return version;
+  }
+
+  get id(): string {
+    const attrs = KM_Core.instance.keyboard_get_attrs(this._keyboard);
+    const id = attrs.object.id;
+    attrs.delete();
+    return id;
+  }
+
+  get keyboard(): km_core_keyboard {
+    return this._keyboard;
+  }
+}
diff --git a/web/src/engine/keyboard/src/keyboards/loaders/domKeyboardLoader.ts b/web/src/engine/keyboard/src/keyboards/loaders/domKeyboardLoader.ts
index fcb2c764cd..7f1b0dcfdd 100644
--- a/web/src/engine/keyboard/src/keyboards/loaders/domKeyboardLoader.ts
+++ b/web/src/engine/keyboard/src/keyboards/loaders/domKeyboardLoader.ts
@@ -2,9 +2,10 @@
 
 ///<reference lib="dom" />
 
-import { Keyboard, KeyboardHarness, KeyboardLoaderBase, KeyboardLoadErrorBuilder, MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-
-import { ManagedPromise } from '@keymanapp/web-utils';
+import { JSKeyboard } from '../jsKeyboard.js';
+import { KeyboardHarness, MinimalKeymanGlobal } from '../keyboardHarness.js';
+import { KeyboardLoaderBase } from '../keyboardLoaderBase.js';
+import { KeyboardLoadErrorBuilder } from '../keyboardLoadError.js';
 
 export class DOMKeyboardLoader extends KeyboardLoaderBase {
   public readonly element: HTMLIFrameElement;
@@ -28,54 +29,44 @@ export class DOMKeyboardLoader extends KeyboardLoaderBase {
     this.performCacheBusting = cacheBust || false;
   }
 
-  protected loadKeyboardInternal(
-    uri: string,
-    errorBuilder: KeyboardLoadErrorBuilder,
-    id?: string
-  ): Promise<Keyboard> {
-    const promise = new ManagedPromise<Keyboard>();
-
-    if(this.performCacheBusting) {
+  protected async loadKeyboardBlob(uri: string, errorBuilder: KeyboardLoadErrorBuilder): Promise<Uint8Array> {
+    if (this.performCacheBusting) {
       uri = this.cacheBust(uri);
     }
 
+    let response: Response;
     try {
-      const document = this.harness._jsGlobal.document;
-      const script = document.createElement('script');
-      if(id) {
-        script.id = id;
-      }
-      document.head.appendChild(script);
-      script.onerror = (err: any) => {
-        promise.reject(errorBuilder.missingError(err));
-      }
-      script.onload = () => {
-        if(this.harness.loadedKeyboard) {
-          const keyboard = this.harness.loadedKeyboard;
-          this.harness.loadedKeyboard = null;
-          promise.resolve(keyboard);
-        } else {
-          promise.reject(errorBuilder.scriptError());
-        }
-      }
-
-      // On the oldest mobile devices we support, Promise.finally may not actually exist.
-      // Fortunately... it's not that hard of an issue to work around.
-      // Note:  es6-shim doesn't polyfill Promise.finally!
-      promise.then(() => {
-        // It is safe to remove the script once it has been run (https://stackoverflow.com/a/37393041)
-        script.remove();
-      }).catch(() => {
-        script.remove();
-      });
-
-      // Now that EVERYTHING ELSE is ready, establish the link to the keyboard's script.
-      script.src = uri;
-    } catch (err) {
-      return Promise.reject(err);
+      response = await fetch(uri);
+    } catch (e) {
+      throw errorBuilder.keyboardDownloadError(e);
     }
 
-    return promise.corePromise;
+    if (!response.ok) {
+      throw errorBuilder.keyboardDownloadError(new Error(`HTTP ${response.status} ${response.statusText}`));
+    }
+
+    let buffer: ArrayBuffer;
+    try {
+      buffer = await response.arrayBuffer();
+    } catch (e) {
+      throw errorBuilder.invalidKeyboard(e);
+    }
+    return new Uint8Array(buffer);
+  }
+
+  protected async loadKeyboardFromScript(script: string, errorBuilder: KeyboardLoadErrorBuilder): Promise<JSKeyboard> {
+    try {
+      this.evalScriptInContext(script, this.harness._jsGlobal);
+    } catch (e) {
+      throw errorBuilder.scriptError(e);
+    }
+    const keyboard = this.harness.loadedKeyboard;
+    if (!keyboard) {
+      throw errorBuilder.scriptError();
+    }
+
+    this.harness.loadedKeyboard = null;
+    return keyboard;
   }
 
   private cacheBust(uri: string) {
@@ -84,4 +75,14 @@ export class DOMKeyboardLoader extends KeyboardLoaderBase {
     // being ignored.
     return uri + "?v=" + (new Date()).getTime(); /*cache buster*/
   }
+
+  private evalScriptInContext(script: string, context: any) {
+    const f = function (s: string) {
+      // use indirect eval (eval?.() notation doesn't work because of esbuild bundling)
+      const evalFunc = eval;
+      return evalFunc(s);
+    }
+    f.call(context, script);
+  }
+
 }
\ No newline at end of file
diff --git a/web/src/engine/keyboard/src/keyboards/loaders/nodeKeyboardLoader.ts b/web/src/engine/keyboard/src/keyboards/loaders/nodeKeyboardLoader.ts
index b9f6a7cdfe..9ae64fac2c 100644
--- a/web/src/engine/keyboard/src/keyboards/loaders/nodeKeyboardLoader.ts
+++ b/web/src/engine/keyboard/src/keyboards/loaders/nodeKeyboardLoader.ts
@@ -1,9 +1,13 @@
-import { Keyboard, KeyboardHarness, KeyboardLoaderBase, KeyboardLoadErrorBuilder, MinimalKeymanGlobal } from 'keyman/engine/keyboard';
+import vm from 'node:vm';
+import { readFile } from 'node:fs/promises';
 
-import vm from 'vm';
-import fs from 'fs';
 import { globalObject } from '@keymanapp/web-utils';
 
+import { JSKeyboard } from '../jsKeyboard.js';
+import { KeyboardHarness, MinimalKeymanGlobal } from '../keyboardHarness.js';
+import { KeyboardLoaderBase } from '../keyboardLoaderBase.js';
+import { KeyboardLoadErrorBuilder } from '../keyboardLoadError.js';
+
 export class NodeKeyboardLoader extends KeyboardLoaderBase {
   constructor()
   constructor(harness: KeyboardHarness);
@@ -22,22 +26,32 @@ export class NodeKeyboardLoader extends KeyboardLoaderBase {
     }
   }
 
-  protected loadKeyboardInternal(uri: string, errorBuilder: KeyboardLoadErrorBuilder): Promise<Keyboard> {
+  protected async loadKeyboardBlob(uri: string, errorBuilder: KeyboardLoadErrorBuilder): Promise<Uint8Array> {
     // `fs` does not like 'file:///'; it IS "File System" oriented, after all, and wants a path, not a URI.
-    if(uri.indexOf('file:///') == 0) {
+    if (uri.indexOf('file:///') == 0) {
       uri = uri.substring('file:///'.length);
     }
 
+    let buffer: Buffer;
+    try {
+      buffer = await readFile(uri);
+    } catch (err) {
+      throw errorBuilder.keyboardDownloadError(err);
+    }
+    return Uint8Array.from(buffer);
+  }
+
+  protected async loadKeyboardFromScript(scriptSrc: string, errorBuilder: KeyboardLoadErrorBuilder): Promise<JSKeyboard> {
     let script;
     try {
-      script = new vm.Script(fs.readFileSync(uri).toString());
+      script = new vm.Script(scriptSrc);
     } catch (err) {
-      return Promise.reject(errorBuilder.missingError(err));
+      throw errorBuilder.invalidKeyboard(err);
     }
     try {
       script.runInContext(this.harness._jsGlobal);
     } catch (err) {
-      return Promise.reject(errorBuilder.scriptError(err));
+      throw errorBuilder.scriptError(err);
     }
 
     const keyboard = this.harness.loadedKeyboard;
diff --git a/web/src/engine/keyboard/src/keyboards/processorAction.ts b/web/src/engine/keyboard/src/keyboards/processorAction.ts
new file mode 100644
index 0000000000..e6bb3be5da
--- /dev/null
+++ b/web/src/engine/keyboard/src/keyboards/processorAction.ts
@@ -0,0 +1,68 @@
+/*
+ * Keyman is copyright (C) SIL Global. MIT License.
+ */
+import { LexicalModelTypes } from '@keymanapp/common-types';
+import { Transcription } from './transcription.js';
+import { VariableStore, VariableStoreDictionary } from '../variableStore.js';
+import { SystemStoreDictionary } from '../systemStore.js';
+
+/**
+ * Represents the commands and state changes that result from a matched keyboard rule.
+ */
+export class ProcessorAction {
+  /**
+   * The before-and-after Transform from matching a keyboard rule.  May be `null`
+   * if no keyboard rules were matched for the keystroke.
+   */
+  transcription: Transcription = null;
+
+  /**
+   * Indicates whether or not a BEEP command was issued by the matched keyboard rule.
+   */
+  beep?: boolean;
+
+  /**
+   * A set of changed store values triggered by the matched keyboard rule.
+   */
+  setStore: SystemStoreDictionary = {};
+
+  /**
+   * A set of variable stores with save requests triggered by the matched keyboard rule
+   */
+  saveStore: {[name: string]: VariableStore} = {};
+
+  /**
+   * A set of variable stores with possible changes to be applied during finalization.
+   */
+  variableStores: VariableStoreDictionary = {};
+
+  /**
+   * Denotes a non-output default behavior; this should be evaluated later, against the true keystroke.
+   */
+  triggersDefaultCommand: boolean = false;
+
+  /**
+   * Denotes error log messages generated when attempting to generate this behavior.
+   */
+  errorLog?: string;
+
+  /**
+   * Denotes warning log messages generated when attempting to generate this behavior.
+   */
+  warningLog?: string;
+
+  /**
+   * If predictive text is active, contains a Promise returning predictive Suggestions.
+   */
+  predictionPromise?: Promise<LexicalModelTypes.Suggestion[]>;
+
+  /**
+   * In reference to https://github.com/keymanapp/keyman/pull/4350#issuecomment-768753852:
+   *
+   * If the final group processed is a context and keystroke group (using keys),
+   * and there is no nomatch rule, and the keystroke is not matched in the group,
+   * the keystroke's default behavior should trigger, regardless of whether or not any
+   * rules in prior groups matched.
+   */
+  triggerKeyDefault?: boolean;
+}
\ No newline at end of file
diff --git a/web/src/engine/keyboard/src/keyboards/stateKeyMap.ts b/web/src/engine/keyboard/src/keyboards/stateKeyMap.ts
index e82ff417c4..a8123f744d 100644
--- a/web/src/engine/keyboard/src/keyboards/stateKeyMap.ts
+++ b/web/src/engine/keyboard/src/keyboards/stateKeyMap.ts
@@ -2,8 +2,8 @@
  * Provided by keyman/engine/keyboard's `KeyboardProcessor` class and utilized by the OSK
  * to provide state feedback on any corresponding keys visible in the OSK.
  */
-export default interface StateKeyMap {
+export interface StateKeyMap {
   K_CAPS: boolean,
   K_NUMLOCK: boolean,
   K_SCROLL: boolean
-}
\ No newline at end of file
+}
diff --git a/web/src/engine/keyboard/src/keyboards/textTransform.ts b/web/src/engine/keyboard/src/keyboards/textTransform.ts
new file mode 100644
index 0000000000..182c351803
--- /dev/null
+++ b/web/src/engine/keyboard/src/keyboards/textTransform.ts
@@ -0,0 +1,23 @@
+/*
+ * Keyman is copyright (C) SIL Global. MIT License.
+ */
+import { LexicalModelTypes } from '@keymanapp/common-types';
+
+export type Alternate = LexicalModelTypes.ProbabilityMass<LexicalModelTypes.Transform>;
+
+export class TextTransform implements LexicalModelTypes.Transform {
+  readonly insert: string;
+  readonly deleteLeft: number;
+  readonly deleteRight: number;
+  readonly erasedSelection: boolean;
+  id: number;
+
+  constructor(insert: string, deleteLeft: number, deleteRight: number, erasedSelection: boolean) {
+    this.insert = insert;
+    this.deleteLeft = deleteLeft;
+    this.deleteRight = deleteRight;
+    this.erasedSelection = erasedSelection;
+  }
+
+  public static readonly nil = new TextTransform('', 0, 0, false);
+}
diff --git a/web/src/engine/keyboard/src/keyboards/transcription.ts b/web/src/engine/keyboard/src/keyboards/transcription.ts
new file mode 100644
index 0000000000..8263e0c804
--- /dev/null
+++ b/web/src/engine/keyboard/src/keyboards/transcription.ts
@@ -0,0 +1,35 @@
+/*
+ * Keyman is copyright (C) SIL Global. MIT License.
+ */
+import { OutputTargetInterface } from '../outputTargetInterface.js';
+import { KeyEvent } from '../keyEvent.js';
+import { Alternate, TextTransform } from './textTransform.js';
+
+export class Transcription {
+  readonly token: number;
+  readonly keystroke: KeyEvent;
+  readonly transform: TextTransform;
+  alternates: Alternate[]; // constructed after the rest of the transcription.
+  readonly preInput: OutputTargetInterface;
+
+  private static tokenSeed: number = 0;
+
+  constructor(keystroke: KeyEvent, transform: TextTransform, preInput: OutputTargetInterface, alternates?: Alternate[]) {
+    const token = this.token = Transcription.tokenSeed++;
+
+    this.keystroke = keystroke;
+    this.transform = transform;
+    this.alternates = alternates;
+    this.preInput = preInput;
+
+    this.transform.id = this.token;
+
+    // Assign the ID to each alternate, as well.
+    if (alternates) {
+      alternates.forEach(function (alt) {
+        alt.sample.id = token;
+      });
+    }
+  }
+}
+
diff --git a/web/src/engine/keyboard/src/outputTarget.interface.ts b/web/src/engine/keyboard/src/outputTargetInterface.ts
similarity index 92%
rename from web/src/engine/keyboard/src/outputTarget.interface.ts
rename to web/src/engine/keyboard/src/outputTargetInterface.ts
index 34faa5667a..5dac4eb2cd 100644
--- a/web/src/engine/keyboard/src/outputTarget.interface.ts
+++ b/web/src/engine/keyboard/src/outputTargetInterface.ts
@@ -1,10 +1,11 @@
 /*
  * Keyman is copyright (C) SIL Global. MIT License.
  */
-export interface OutputTarget {
+export interface OutputTargetInterface {
   /**
-   * Signifies that this OutputTarget has no default key processing behaviors.  This should be false
-   * for OutputTargets backed by web elements like HTMLInputElement or HTMLTextAreaElement.
+   * Signifies that this OutputTargetInterface has no default key processing behaviors.
+   * This should be false for OutputTargets backed by web elements like HTMLInputElement
+   * or HTMLTextAreaElement.
    */
   get isSynthetic(): boolean;
 
diff --git a/web/src/engine/keyboard/src/systemStore.ts b/web/src/engine/keyboard/src/systemStore.ts
new file mode 100644
index 0000000000..f0e4b7d7f8
--- /dev/null
+++ b/web/src/engine/keyboard/src/systemStore.ts
@@ -0,0 +1,71 @@
+/*
+ * Keyman is copyright (C) SIL Global. MIT License.
+ *
+ * Declaration of a 'system store' (see kmn reference)
+ */
+
+export enum SystemStoreIDs {
+  TSS_LAYER = 33,
+  TSS_PLATFORM = 31,
+  TSS_NEWLAYER = 42,
+  TSS_OLDLAYER = 43
+}
+
+export type SystemStoreDictionary = { [id: number]: string };
+
+/**
+ * Defines common behaviors associated with system stores.
+ */
+export abstract class SystemStore {
+  public readonly id: number;
+
+  constructor(id: number) {
+    this.id = id;
+  }
+
+  abstract matches(value: string): boolean;
+
+  public set(_value: string): void {
+    throw new Error("System store with ID " + this.id + " may not be directly set.");
+  }
+}
+
+/**
+ * A handler designed to receive feedback whenever a system store's value is changed.
+ * @param source    The system store being mutated, before the value change occurs.
+ * @param newValue  The new value being set
+ * @returns         `false` / `undefined` to allow the change, `true` to block the change.
+ */
+export type SystemStoreMutationHandler = (source: MutableSystemStore, newValue: string) => boolean;
+
+export class MutableSystemStore extends SystemStore {
+  private _value: string;
+  public handler?: SystemStoreMutationHandler = null;
+
+  constructor(id: number, defaultValue: string) {
+    super(id);
+    this._value = defaultValue;
+  }
+
+  public get value() {
+    return this._value;
+  }
+
+  public matches(value: string) {
+    return this._value == value;
+  }
+
+  public set(value: string) {
+    // Even if things stay the same, we should still signal this.
+    // It's important for tracking if a rule directly set the layer
+    // versus if it passively remained.
+    if(this.handler) {
+      if(this.handler(this, value)) {
+        return;
+      }
+    }
+
+    this._value = value;
+  }
+}
+
diff --git a/web/src/engine/keyboard/src/variableStore.ts b/web/src/engine/keyboard/src/variableStore.ts
new file mode 100644
index 0000000000..29de6ececa
--- /dev/null
+++ b/web/src/engine/keyboard/src/variableStore.ts
@@ -0,0 +1,16 @@
+/*
+ * Keyman is copyright (C) SIL Global. MIT License.
+ *
+ * Definitions for variable stores (see kmn reference)
+ */
+
+export interface VariableStoreDictionary {
+  [name: string]: string;
+};
+
+export type VariableStore = { [name: string]: string; };
+
+export interface VariableStoreSerializer {
+  loadStore(keyboardID: string, storeName: string): VariableStore;
+  saveStore(keyboardID: string, storeName: string, storeMap: VariableStore): void;
+}
diff --git a/web/src/engine/keyboard/tsconfig.json b/web/src/engine/keyboard/tsconfig.json
index 84d96c8591..3e074f91c7 100644
--- a/web/src/engine/keyboard/tsconfig.json
+++ b/web/src/engine/keyboard/tsconfig.json
@@ -7,6 +7,9 @@
     "tsBuildInfoFile": "../../../build/engine/keyboard/obj/tsconfig.tsbuildinfo",
     "rootDir": "./src/"
   },
+  "references": [
+    { "path": "../core-processor"},
+  ],
   "include": [ "./src/**/*.ts"],
   "exclude": ["./src/keyboards/loaders/**/*.ts"]
 }
diff --git a/web/src/engine/main/build.sh b/web/src/engine/main/build.sh
index 6cca867d88..e0ef7c420e 100755
--- a/web/src/engine/main/build.sh
+++ b/web/src/engine/main/build.sh
@@ -15,6 +15,7 @@ SUBPROJECT_NAME=engine/main
 
 builder_describe "Builds the Keyman Engine for Web's common top-level base classes." \
   "@/common/web/keyman-version" \
+  "@/web/src/engine/core-processor" \
   "@/web/src/engine/keyboard" \
   "@/web/src/engine/interfaces build" \
   "@/web/src/engine/js-processor build" \
diff --git a/web/src/engine/main/readme.md b/web/src/engine/main/readme.md
index 219e06ad9b..0ddc392f35 100644
--- a/web/src/engine/main/readme.md
+++ b/web/src/engine/main/readme.md
@@ -1,3 +1,4 @@
-## engine/main
+# engine/main
 
-This subproject holds modularized code converted from the old, namespaced version of KMW.
\ No newline at end of file
+This subproject holds modularized code converted from the old, namespaced version of KMW.
+Previously it was called `input-processor`.
diff --git a/web/src/engine/main/src/contextManagerBase.ts b/web/src/engine/main/src/contextManagerBase.ts
index 156ba46eea..8aa7319c83 100644
--- a/web/src/engine/main/src/contextManagerBase.ts
+++ b/web/src/engine/main/src/contextManagerBase.ts
@@ -1,13 +1,13 @@
 import { EventEmitter } from 'eventemitter3';
-import { ManagedPromise, type Keyboard } from 'keyman/engine/keyboard';
-import { type KeyboardInterface, type OutputTarget } from 'keyman/engine/js-processor';
+import { ManagedPromise, type Keyboard, type OutputTargetInterface } from 'keyman/engine/keyboard';
+import { type JSKeyboardInterface } from 'keyman/engine/js-processor';
 import { StubAndKeyboardCache, type KeyboardStub } from 'keyman/engine/keyboard-storage';
 import { PredictionContext } from 'keyman/engine/interfaces';
 import { EngineConfiguration } from './engineConfiguration.js';
 
 interface EventMap {
   // target, then keyboard.
-  'targetchange': (target: OutputTarget) => boolean;
+  'targetchange': (target: OutputTargetInterface) => boolean;
 
   /**
    * This event is raised whenever a keyboard change is requested.
@@ -48,7 +48,7 @@ export interface ContextManagerConfiguration {
    *
    * Does not reset option-stores, variable-stores, etc.
    */
-  readonly resetContext: (outputTarget?: OutputTarget) => void;
+  readonly resetContext: (outputTarget?: OutputTargetInterface) => void;
 
   /**
    * A predictive-state management object that interfaces the predictive-text banner
@@ -64,7 +64,7 @@ export interface ContextManagerConfiguration {
 }
 
 interface PendingActivation {
-  target: OutputTarget,
+  target: OutputTargetInterface,
   keyboard: Promise<Keyboard>,
   stub: KeyboardStub;
 }
@@ -74,11 +74,11 @@ export abstract class ContextManagerBase<MainConfig extends EngineConfiguration>
 
   abstract initialize(): void;
 
-  abstract get activeTarget(): OutputTarget;
+  abstract get activeTarget(): OutputTargetInterface;
 
   private _predictionContext: PredictionContext;
   protected keyboardCache: StubAndKeyboardCache;
-  private _resetContext: (outputTarget?: OutputTarget) => void;
+  private _resetContext: (outputTarget?: OutputTargetInterface) => void;
 
   private pendingActivations: PendingActivation[] = [];
   protected engineConfig: MainConfig;
@@ -99,7 +99,7 @@ export abstract class ContextManagerBase<MainConfig extends EngineConfiguration>
     this.keyboardCache = config.keyboardCache;
   }
 
-  insertText(kbdInterface: KeyboardInterface, Ptext: string, PdeadKey: number) {
+  insertText(kbdInterface: JSKeyboardInterface, Ptext: string, PdeadKey: number) {
     // Find the correct output target to manipulate.
     const outputTarget = this.activeTarget;
 
@@ -135,7 +135,7 @@ export abstract class ContextManagerBase<MainConfig extends EngineConfiguration>
    * attached elements within the app/browser target.  For `app/webview`, this should
    * always return a consistent value - likely, `null`.
    */
-  protected abstract currentKeyboardSrcTarget(): OutputTarget;
+  protected abstract currentKeyboardSrcTarget(): OutputTargetInterface;
 
   /**
    * Ensures that newly activated keyboards are set correctly within managed context, possibly
@@ -143,7 +143,7 @@ export abstract class ContextManagerBase<MainConfig extends EngineConfiguration>
    * @param kbd
    * @param target
    */
-  protected abstract activateKeyboardForTarget(kbd: {keyboard: Keyboard, metadata: KeyboardStub}, target: OutputTarget): void;
+  protected abstract activateKeyboardForTarget(kbd: { keyboard: Keyboard, metadata: KeyboardStub }, target: OutputTargetInterface): void;
 
   /**
    * Checks the pending keyboard-activation array for an entry corresponding to the specified
@@ -152,7 +152,7 @@ export abstract class ContextManagerBase<MainConfig extends EngineConfiguration>
    *                May be `null`, which corresponds to the global default Keyboard.
    * @returns `true` if pending activation is still valid, `false` otherwise.
    */
-  private findAndPopActivation(target: OutputTarget): PendingActivation {
+  private findAndPopActivation(target: OutputTargetInterface): PendingActivation {
     // Array.findIndex requires Chrome 45+. :(
     let activationIndex;
     for(activationIndex = 0; activationIndex < this.pendingActivations.length; activationIndex++) {
@@ -180,7 +180,7 @@ export abstract class ContextManagerBase<MainConfig extends EngineConfiguration>
   protected async deferredKeyboardActivation(
     kbdPromise: Promise<Keyboard>,
     metadata: KeyboardStub,
-    target: OutputTarget
+    target: OutputTargetInterface
   ): Promise<PendingActivation> {
     const activation: PendingActivation = {
       target: target,
diff --git a/web/src/engine/main/src/engineConfiguration.ts b/web/src/engine/main/src/engineConfiguration.ts
index 40485c0f0f..db4a0c99fd 100644
--- a/web/src/engine/main/src/engineConfiguration.ts
+++ b/web/src/engine/main/src/engineConfiguration.ts
@@ -1,7 +1,9 @@
 import { EventEmitter } from "eventemitter3";
 
-import { DeviceSpec, KeyboardProperties, ManagedPromise, physicalKeyDeviceAlias, SpacebarText } from "keyman/engine/keyboard";
-import { OutputTarget, RuleBehavior } from 'keyman/engine/js-processor';
+import {
+  DeviceSpec, KeyboardProperties, ManagedPromise, OutputTargetInterface,
+  ProcessorAction, physicalKeyDeviceAlias, SpacebarText
+} from "keyman/engine/keyboard";
 import { PathConfiguration, PathOptionDefaults, PathOptionSpec } from "keyman/engine/interfaces";
 import { DeviceDetector } from "./headless/deviceDetector.js";
 import { KeyboardStub } from "keyman/engine/keyboard-storage";
@@ -110,7 +112,7 @@ export class EngineConfiguration extends EventEmitter<EventMap> {
    * @param ruleBehavior  The full effects of keystroke + postkeystroke rules from a processed keystroke.
    * @param outputTarget  The engine's current source for context
    */
-  onRuleFinalization(ruleBehavior: RuleBehavior, outputTarget: OutputTarget) {};
+  onRuleFinalization(ruleBehavior: ProcessorAction, outputTarget: OutputTargetInterface) {};
 }
 
 export interface InitOptionSpec extends PathOptionSpec {
diff --git a/web/src/engine/main/src/hardKeyboardBase.ts b/web/src/engine/main/src/hardKeyboardBase.ts
index a41e36023c..7c6a2c3dfc 100644
--- a/web/src/engine/main/src/hardKeyboardBase.ts
+++ b/web/src/engine/main/src/hardKeyboardBase.ts
@@ -1,6 +1,5 @@
 import { EventEmitter } from "eventemitter3";
-import { Keyboard, KeyMapping, KeyEvent, Codes } from "keyman/engine/keyboard";
-import { type RuleBehavior } from 'keyman/engine/js-processor';
+import { JSKeyboard, Keyboard, KeyMapping, KeyEvent, Codes, type ProcessorAction } from "keyman/engine/keyboard";
 import { KeyEventSourceInterface } from 'keyman/engine/osk';
 import { ModifierKeyConstants } from '@keymanapp/common-types';
 
@@ -8,52 +7,60 @@ interface EventMap {
   /**
    * Designed to pass key events off to any consuming modules/libraries.
    */
-  'keyevent': (event: KeyEvent, callback?: (result: RuleBehavior, error?: Error) => void) => void
+  'keyevent': (event: KeyEvent, callback?: (result: ProcessorAction, error?: Error) => void) => void
 }
 
 export class HardKeyboardBase extends EventEmitter<EventMap> implements KeyEventSourceInterface<EventMap> { }
 
 export function processForMnemonicsAndLegacy(s: KeyEvent, activeKeyboard: Keyboard, baseLayout: string): KeyEvent {
-  // Mnemonic handling.
-  if(activeKeyboard && activeKeyboard.isMnemonic) {
-    // The following will never set a code corresponding to a modifier key, so it's fine to do this,
-    // which may change the value of Lcode, here.
-
-    s.setMnemonicCode(!!(s.Lmodifiers & ModifierKeyConstants.K_SHIFTFLAG), !!(s.Lmodifiers & ModifierKeyConstants.CAPITALFLAG));
+  if (!activeKeyboard) {
+    return s;
   }
 
-  // Other minor physical-keyboard adjustments
-  if(activeKeyboard && !activeKeyboard.isMnemonic) {
-    // Positional Layout
+  if (activeKeyboard instanceof JSKeyboard) {
+    // Mnemonic handling.
+    if (activeKeyboard.isMnemonic) {
+      // The following will never set a code corresponding to a modifier key, so it's fine to do this,
+      // which may change the value of Lcode, here.
 
-    /* 13/03/2007 MCD: Swedish: Start mapping of keystroke to US keyboard */
-    const Lbase = KeyMapping.languageMap[baseLayout];
-    if(Lbase && Lbase['k'+s.Lcode]) {
-      s.Lcode=Lbase['k'+s.Lcode];
+      s.setMnemonicCode(!!(s.Lmodifiers & ModifierKeyConstants.K_SHIFTFLAG), !!(s.Lmodifiers & ModifierKeyConstants.CAPITALFLAG));
     }
-    /* 13/03/2007 MCD: Swedish: End mapping of keystroke to US keyboard */
+    // Other minor physical-keyboard adjustments
+    if (!activeKeyboard.isMnemonic) {
+      // Positional Layout
 
-    // The second conditional component (re 0x60):  if CTRL or ALT is held down...
-    // Do not remap for legacy keyboard compatibility, do not pass Go, do not collect $200.
-    // This effectively only permits `default` and `shift` for legacy keyboards.
-    //
-    // Third:  DO, however, track direct presses of any main modifier key.  The OSK should
-    // reflect the current modifier state even for legacy keyboards.
-    if(!activeKeyboard.definesPositionalOrMnemonic &&
-       !(s.Lmodifiers & Codes.modifierBitmasks.NON_LEGACY) &&
-       !s.isModifier) {
-      // Support version 1.0 KeymanWeb keyboards that do not define positional vs mnemonic
-      s = new KeyEvent({
-        Lcode: KeyMapping._USKeyCodeToCharCode(s),
-        Lmodifiers: 0,
-        LisVirtualKey: false,
-        vkCode: s.Lcode, // Helps to merge OSK and physical keystroke control paths.
-        Lstates: s.Lstates,
-        kName: '',
-        device: s.device,
-        isSynthetic: false
-      });
+      /* 13/03/2007 MCD: Swedish: Start mapping of keystroke to US keyboard */
+      const Lbase = KeyMapping.languageMap[baseLayout];
+      if (Lbase && Lbase['k' + s.Lcode]) {
+        s.Lcode = Lbase['k' + s.Lcode];
+      }
+      /* 13/03/2007 MCD: Swedish: End mapping of keystroke to US keyboard */
+
+      // The second conditional component (re 0x60):  if CTRL or ALT is held down...
+      // Do not remap for legacy keyboard compatibility, do not pass Go, do not collect $200.
+      // This effectively only permits `default` and `shift` for legacy keyboards.
+      //
+      // Third:  DO, however, track direct presses of any main modifier key.  The OSK should
+      // reflect the current modifier state even for legacy keyboards.
+      if (!activeKeyboard.definesPositionalOrMnemonic &&
+        !(s.Lmodifiers & Codes.modifierBitmasks.NON_LEGACY) &&
+        !s.isModifier) {
+        // Support version 1.0 KeymanWeb keyboards that do not define positional vs mnemonic
+        s = new KeyEvent({
+          Lcode: KeyMapping._USKeyCodeToCharCode(s),
+          Lmodifiers: 0,
+          LisVirtualKey: false,
+          vkCode: s.Lcode, // Helps to merge OSK and physical keystroke control paths.
+          Lstates: s.Lstates,
+          kName: '',
+          device: s.device,
+          isSynthetic: false
+        });
+      }
     }
+  } else {
+    // KMX keyboard
+    // TODO-web-core: forward to Core
   }
 
   return s;
diff --git a/web/src/engine/main/src/headless/inputProcessor.ts b/web/src/engine/main/src/headless/inputProcessor.ts
index a568eb4999..90ce1787b2 100644
--- a/web/src/engine/main/src/headless/inputProcessor.ts
+++ b/web/src/engine/main/src/headless/inputProcessor.ts
@@ -2,20 +2,29 @@
 
 import ContextWindow from "./contextWindow.js";
 import { LanguageProcessor }  from "./languageProcessor.js";
-import type { ModelSpec }  from "keyman/engine/interfaces";
+import type { ModelSpec, PathConfiguration }  from "keyman/engine/interfaces";
 import { globalObject, DeviceSpec } from "@keymanapp/web-utils";
 
-import { Codes, type Keyboard, type KeyEvent } from "keyman/engine/keyboard";
+import { KM_Core } from 'keyman/engine/core-processor';
+
 import {
   type Alternate,
-  isEmptyTransform,
-  KeyboardInterface,
-  KeyboardProcessor,
-  Mock,
-  type OutputTarget,
-  RuleBehavior,
-  type ProcessorInitOptions,
+  Codes,
+  JSKeyboard,
+  KeyboardMinimalInterface,
+  type Keyboard,
+  type KeyEvent,
+  type OutputTargetInterface,
+  ProcessorAction,
   SystemStoreIDs
+} from "keyman/engine/keyboard";
+// TODO-web-core: remove usage of OutputTargetBase
+import {
+  isEmptyTransform,
+  JSKeyboardProcessor,
+  Mock,
+  type ProcessorInitOptions,
+  OutputTargetBase
 } from 'keyman/engine/js-processor';
 
 import { TranscriptionCache } from "./transcriptionCache.js";
@@ -33,9 +42,10 @@ export class InputProcessor {
    * entry points.
    */
   private contextDevice: DeviceSpec;
-  private kbdProcessor: KeyboardProcessor;
+  private kbdProcessor: JSKeyboardProcessor;
   private lngProcessor: LanguageProcessor;
 
+
   private readonly contextCache = new TranscriptionCache();
 
   constructor(device: DeviceSpec, predictiveWorkerFactory: WorkerFactory, options?: ProcessorInitOptions) {
@@ -48,19 +58,23 @@ export class InputProcessor {
     }
 
     this.contextDevice = device;
-    this.kbdProcessor = new KeyboardProcessor(device, options);
+    this.kbdProcessor = new JSKeyboardProcessor(device, options);
     this.lngProcessor = new LanguageProcessor(predictiveWorkerFactory, this.contextCache);
   }
 
+  public async init(paths: PathConfiguration): Promise<void> {
+    await KM_Core.createCoreProcessor(paths.basePath);
+  }
+
   public get languageProcessor(): LanguageProcessor {
     return this.lngProcessor;
   }
 
-  public get keyboardProcessor(): KeyboardProcessor {
+  public get keyboardProcessor(): JSKeyboardProcessor {
     return this.kbdProcessor;
   }
 
-  public get keyboardInterface(): KeyboardInterface {
+  public get keyboardInterface(): KeyboardMinimalInterface {
     return this.keyboardProcessor.keyboardInterface;
   }
 
@@ -87,10 +101,10 @@ export class InputProcessor {
    *
    * @param       {Object}      keyEvent      The abstracted KeyEvent to use for keystroke processing
    * @param       {Object}      outputTarget  The OutputTarget receiving the KeyEvent
-   * @returns     {Object}                    A RuleBehavior object describing the cumulative effects of
+   * @returns     {Object}                    A ProcessorAction object describing the cumulative effects of
    *                                          all matched keyboard rules.
    */
-  processKeyEvent(keyEvent: KeyEvent, outputTarget: OutputTarget): RuleBehavior {
+  processKeyEvent(keyEvent: KeyEvent, outputTarget: OutputTargetInterface): ProcessorAction {
     const kbdMismatch = keyEvent.srcKeyboard && this.activeKeyboard != keyEvent.srcKeyboard;
     const trueActiveKeyboard = this.activeKeyboard;
 
@@ -108,9 +122,11 @@ export class InputProcessor {
           // Has there been a context change at any point during the multitap?  If so, we need
           // to revert it.  If not, we assume it's a layer-change multitap, in which case
           // no such reset is needed.
-          if(!isEmptyTransform(transcription.transform) || !transcription.preInput.isEqual(Mock.from(outputTarget))) {
+          // TODO-web-core
+          if(!isEmptyTransform(transcription.transform) || !(transcription.preInput as Mock).isEqual(Mock.from(outputTarget))) {
             // Restores full context, including deadkeys in their exact pre-keystroke state.
-            outputTarget.restoreTo(transcription.preInput);
+            // TODO-web-core
+            (outputTarget as OutputTargetBase).restoreTo(transcription.preInput as Mock);
           }
           /*
             else:
@@ -122,7 +138,7 @@ export class InputProcessor {
         } else {
           console.warn('The base context for the multitap could not be found!\n\n' + this.contextCache.buildLog());
           // would be lovely to report a desire for gesture debug output
-          // maybe add something to RuleBehavior?
+          // maybe add something to ProcessorAction?
         }
       }
 
@@ -142,27 +158,28 @@ export class InputProcessor {
    * @param outputTarget
    * @returns
    */
-  private _processKeyEvent(keyEvent: KeyEvent, outputTarget: OutputTarget): RuleBehavior {
+  private _processKeyEvent(keyEvent: KeyEvent, outputTarget: OutputTargetInterface): ProcessorAction {
     const formFactor = keyEvent.device.formFactor;
     const fromOSK = keyEvent.isSynthetic;
 
     // The default OSK layout for desktop devices does not include nextlayer info, relying on modifier detection here.
     // It's the OSK equivalent to doModifierPress on 'desktop' form factors.
-    if((formFactor == DeviceSpec.FormFactor.Desktop || !this.activeKeyboard || this.activeKeyboard.usesDesktopLayoutOnDevice(keyEvent.device)) && fromOSK) {
+    if((formFactor == DeviceSpec.FormFactor.Desktop || !this.activeKeyboard || (this.activeKeyboard instanceof JSKeyboard && this.activeKeyboard.usesDesktopLayoutOnDevice(keyEvent.device))) && fromOSK) {
       // If it's a desktop OSK style and this triggers a layer change,
       // a modifier key was clicked.  No output expected, so it's safe to instantly exit.
       if(this.keyboardProcessor.selectLayer(keyEvent)) {
-        return new RuleBehavior();
+        return new ProcessorAction();
       }
     }
 
     // Will handle keystroke-based non-layer change modifier & state keys, mapping them through the physical keyboard's version
     // of state management.  `doModifierPress` must always run.
-    if(this.keyboardProcessor.doModifierPress(keyEvent, outputTarget, !fromOSK)) {
+    // TODO-web-core
+    if (this.keyboardProcessor.doModifierPress(keyEvent, outputTarget as OutputTargetBase, !fromOSK)) {
       // If run on a desktop platform, we know that modifier & state key presses may not
       // produce output, so we may make an immediate return safely.
       if(!fromOSK) {
-        return new RuleBehavior();
+        return new ProcessorAction();
       }
     }
 
@@ -174,10 +191,10 @@ export class InputProcessor {
 
       // Can the suggestion UI revert a recent suggestion?  If so, do that and swallow the backspace.
       if((keyEvent.kName == "K_BKSP" || keyEvent.Lcode == Codes.keyCodes["K_BKSP"]) && this.languageProcessor.tryRevertSuggestion()) {
-        return new RuleBehavior();
+        return new ProcessorAction();
         // Can the suggestion UI accept an existing suggestion?  If so, do that and swallow the space character.
       } else if((keyEvent.kName == "K_SPACE" || keyEvent.Lcode == Codes.keyCodes["K_SPACE"]) && this.languageProcessor.tryAcceptSuggestion('space')) {
-        return new RuleBehavior();
+        return new ProcessorAction();
       }
     }
 
@@ -185,13 +202,15 @@ export class InputProcessor {
 
     // Create a "mock" backup of the current outputTarget in its pre-input state.
     // Current, long-existing assumption - it's DOM-backed.
-    const preInputMock = Mock.from(outputTarget, true);
+    // TODO-web-core
+    const preInputMock = Mock.from(outputTarget as OutputTargetBase, true);
 
     const startingLayerId = this.keyboardProcessor.layerId;
 
     // We presently need the true keystroke to run on the FULL context.  That index is still
     // needed for some indexing operations when comparing two different output targets.
-    let ruleBehavior = this.keyboardProcessor.processKeystroke(keyEvent, outputTarget);
+    // TODO-web-core
+    let ruleBehavior = this.keyboardProcessor.processKeystroke(keyEvent, outputTarget as OutputTargetBase);
 
     // Swap layer as appropriate.
     if(keyEvent.kNextLayer) {
@@ -227,7 +246,7 @@ export class InputProcessor {
 
       // Now that we've done all the keystroke processing needed, ensure any extra effects triggered
       // by the actual keystroke occur.
-      ruleBehavior.finalize(this.keyboardProcessor, outputTarget, false);
+      this.keyboardProcessor.finalizeProcessorAction(ruleBehavior, outputTarget);
 
       // -- All keystroke (and 'alternate') processing is now complete.  Time to finalize everything! --
 
@@ -236,9 +255,10 @@ export class InputProcessor {
         ruleBehavior.transcription.alternates = alternates;
       }
     } else {
-      // We need a dummy RuleBehavior for keys which have no output (e.g. Shift)
-      ruleBehavior = new RuleBehavior();
-      ruleBehavior.transcription = outputTarget.buildTranscriptionFrom(outputTarget, null, false);
+      // We need a dummy ProcessorAction for keys which have no output (e.g. Shift)
+      ruleBehavior = new ProcessorAction();
+      // TODO-web-core
+      ruleBehavior.transcription = (outputTarget as OutputTargetBase).buildTranscriptionFrom(outputTarget as OutputTargetBase, null, false);
       ruleBehavior.triggersDefaultCommand = true;
     }
 
@@ -257,9 +277,10 @@ export class InputProcessor {
     this.keyboardProcessor.newLayerStore.set(hasLayerChanged ? this.keyboardProcessor.layerId : '');
     this.keyboardProcessor.oldLayerStore.set(hasLayerChanged ? startingLayerId : '');
 
-    const postRuleBehavior = this.keyboardProcessor.processPostKeystroke(this.contextDevice, outputTarget);
-    if(postRuleBehavior) {
-      postRuleBehavior.finalize(this.keyboardProcessor, outputTarget, true);
+    // TODO-web-core
+    const postRuleBehavior = this.keyboardProcessor.processPostKeystroke(this.contextDevice, outputTarget as OutputTargetBase);
+    if (postRuleBehavior) {
+      this.keyboardProcessor.finalizeProcessorAction(postRuleBehavior, outputTarget);
     }
 
     // Yes, even for ruleBehavior.triggersDefaultCommand.  Those tend to change the context.
@@ -274,7 +295,7 @@ export class InputProcessor {
     return keepRuleBehavior ? ruleBehavior : null;
   }
 
-  private buildAlternates(ruleBehavior: RuleBehavior, keyEvent: KeyEvent, preInputMock: Mock): Alternate[] {
+  private buildAlternates(ruleBehavior: ProcessorAction, keyEvent: KeyEvent, preInputMock: Mock): Alternate[] {
     let alternates: Alternate[];
 
     // If we're performing a 'default command', it's not a standard 'typing' event - don't do fat-finger stuff.
@@ -380,9 +401,10 @@ export class InputProcessor {
     return alternates;
   }
 
-  public resetContext(outputTarget?: OutputTarget) {
+  public resetContext(outputTarget?: OutputTargetInterface) {
     // Also handles new-context events, which may modify the layer
-    this.keyboardProcessor.resetContext(outputTarget);
+    // TODO-web-core
+    this.keyboardProcessor.resetContext(outputTarget as OutputTargetBase);
     // With the layer now set, we trigger new predictions.
     this.languageProcessor.invalidateContext(outputTarget, this.keyboardProcessor.layerId);
   }
diff --git a/web/src/engine/main/src/headless/languageProcessor.ts b/web/src/engine/main/src/headless/languageProcessor.ts
index b9731c9783..f3029adf64 100644
--- a/web/src/engine/main/src/headless/languageProcessor.ts
+++ b/web/src/engine/main/src/headless/languageProcessor.ts
@@ -1,6 +1,8 @@
 import { EventEmitter } from "eventemitter3";
 import { LMLayer, WorkerFactory } from "@keymanapp/lexical-model-layer/web";
-import { OutputTarget, Transcription, Mock } from "keyman/engine/js-processor";
+// TODO-web-core: remove use of OutputTargetBase
+import { Mock, OutputTargetBase } from "keyman/engine/js-processor";
+import { Transcription, OutputTargetInterface } from 'keyman/engine/keyboard';
 import { LanguageProcessorEventMap, ModelSpec, StateChangeEnum, ReadySuggestions } from 'keyman/engine/interfaces';
 import ContextWindow from "./contextWindow.js";
 import { TranscriptionCache } from "./transcriptionCache.js";
@@ -125,7 +127,7 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
     });
   }
 
-  public invalidateContext(outputTarget: OutputTarget, layerId: string): Promise<Suggestion[]> {
+  public invalidateContext(outputTarget: OutputTargetInterface, layerId: string): Promise<Suggestion[]> {
     // If there's no active model, there can be no predictions.
     // We'll also be missing important data needed to even properly REQUEST the predictions.
     if(!this.currentModel || !this.configuration) {
@@ -142,7 +144,8 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
     this.emit('invalidatesuggestions', 'context');
 
     if(outputTarget) {
-      const transcription = outputTarget.buildTranscriptionFrom(outputTarget, null, false);
+      // TODO-web-core
+      const transcription = (outputTarget as OutputTargetBase).buildTranscriptionFrom((outputTarget as OutputTargetBase), null, false);
       return this.predict_internal(transcription, true, layerId);
     } else {
       // if there's no active context source, there's nothing to
@@ -153,12 +156,13 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
     }
   }
 
-  public wordbreak(target: OutputTarget, layerId: string): Promise<string> {
+  public wordbreak(target: OutputTargetInterface, layerId: string): Promise<string> {
     if(!this.isActive) {
       return null;
     }
 
-    const context = new ContextWindow(Mock.from(target, false), this.configuration, layerId);
+    // TODO-web-core
+    const context = new ContextWindow(Mock.from((target as OutputTargetBase), false), this.configuration, layerId);
     return this.lmEngine.wordbreak(context);
   }
 
@@ -188,9 +192,9 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
    *                        required because layerid can be changed by PostKeystroke
    * @returns
    */
-  public applySuggestion(suggestion: Suggestion, outputTarget: OutputTarget, getLayerId: ()=>string): Promise<Reversion> {
+  public applySuggestion(suggestion: Suggestion, outputTarget: OutputTargetInterface, getLayerId: ()=>string): Promise<Reversion> {
     if(!outputTarget) {
-      throw "Accepting suggestions requires a destination OutputTarget instance."
+      throw "Accepting suggestions requires a destination OutputTargetInterface instance."
     }
 
     if(!this.isActive) {
@@ -220,8 +224,10 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
       // Step 2:  build a final, master Transform that will produce the desired results from the CURRENT state.
       // In embedded mode, both Android and iOS are best served by calculating this transform and applying its
       // values as needed for use with their IME interfaces.
-      const transform = final.buildTransformFrom(outputTarget);
-      outputTarget.apply(transform);
+      // TODO-web-core
+      const transform = final.buildTransformFrom((outputTarget as OutputTargetBase));
+      // TODO-web-core
+      (outputTarget as OutputTargetBase).apply(transform);
 
       // Tell the banner that a suggestion was applied, so it can call the
       // keyboard's PostKeystroke entry point as needed
@@ -234,7 +240,7 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
 
       // Builds the reversion option according to the loaded lexical model's known
       // syntactic properties.
-      const suggestionContext = new ContextWindow(original.preInput, this.configuration, getLayerId());
+      const suggestionContext = new ContextWindow(original.preInput as Mock, this.configuration, getLayerId());
 
       // We must accept the Suggestion from its original context, which was before
       // `original.transform` was applied.
@@ -263,9 +269,9 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
     }
   }
 
-  public applyReversion(reversion: Reversion, outputTarget: OutputTarget) {
+  public applyReversion(reversion: Reversion, outputTarget: OutputTargetInterface) {
     if(!outputTarget) {
-      throw "Accepting suggestions requires a destination OutputTarget instance."
+      throw "Accepting suggestions requires a destination OutputTargetInterface instance."
     }
 
     if(!this.isActive) {
@@ -293,11 +299,13 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
     // Step 2:  build a final, master Transform that will produce the desired results from the CURRENT state.
     // In embedded mode, both Android and iOS are best served by calculating this transform and applying its
     // values as needed for use with their IME interfaces.
-    const transform = final.buildTransformFrom(outputTarget);
-    outputTarget.apply(transform);
+    // TODO-web-core
+    const transform = final.buildTransformFrom(outputTarget as OutputTargetBase);
+    // TODO-web-core
+    (outputTarget as OutputTargetBase).apply(transform);
 
     // The reason we need to preserve the additive-inverse 'transformId' property on Reversions.
-    const promise = this.currentPromise = this.lmEngine.revertSuggestion(reversion, new ContextWindow(original.preInput, this.configuration, null))
+    const promise = this.currentPromise = this.lmEngine.revertSuggestion(reversion, new ContextWindow(original.preInput as Mock, this.configuration, null))
     // If the "current Promise" is as set above, clear it.
     // If another one has been triggered since... don't.
     promise.then(() => this.currentPromise = (this.currentPromise == promise) ? null : this.currentPromise);
@@ -305,12 +313,13 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
     return promise;
   }
 
-  public predictFromTarget(outputTarget: OutputTarget, layerId: string): Promise<Suggestion[]> {
+  public predictFromTarget(outputTarget: OutputTargetInterface, layerId: string): Promise<Suggestion[]> {
     if(!this.isActive || !outputTarget) {
       return null;
     }
 
-    const transcription = outputTarget.buildTranscriptionFrom(outputTarget, null, false);
+    // TODO-web-core
+    const transcription = (outputTarget as OutputTargetBase).buildTranscriptionFrom(outputTarget as OutputTargetBase, null, false);
     return this.predict(transcription, layerId);
   }
 
@@ -324,7 +333,7 @@ export class LanguageProcessor extends EventEmitter<LanguageProcessorEventMap> {
       return null;
     }
 
-    const context = new ContextWindow(transcription.preInput, this.configuration, layerId);
+    const context = new ContextWindow(transcription.preInput as Mock, this.configuration, layerId);
     this.recordTranscription(transcription);
 
     if(resetContext) {
diff --git a/web/src/engine/main/src/headless/transcriptionCache.ts b/web/src/engine/main/src/headless/transcriptionCache.ts
index 9ecb13b317..a8fd0d4eb5 100644
--- a/web/src/engine/main/src/headless/transcriptionCache.ts
+++ b/web/src/engine/main/src/headless/transcriptionCache.ts
@@ -1,4 +1,4 @@
-import { Transcription } from "keyman/engine/js-processor";
+import { Transcription } from "keyman/engine/keyboard";
 
 const TRANSCRIPTION_BUFFER_SIZE = 10;
 
diff --git a/web/src/engine/main/src/index.ts b/web/src/engine/main/src/index.ts
index bd1f33513c..8aaaa1cacf 100644
--- a/web/src/engine/main/src/index.ts
+++ b/web/src/engine/main/src/index.ts
@@ -1,7 +1,7 @@
 export { EngineConfiguration, InitOptionDefaults, InitOptionSpec } from './engineConfiguration.js';
 export { ContextManagerBase, ContextManagerConfiguration } from './contextManagerBase.js';
 export { HardKeyboardBase, processForMnemonicsAndLegacy } from './hardKeyboardBase.js';
-export { default as KeyboardInterface } from './keyboardInterface.js';
+export { KeyboardInterfaceBase } from './keyboardInterfaceBase.js';
 export { KeymanEngineBase } from './keymanEngineBase.js';
 export { LegacyAPIEvents } from './legacyAPIEvents.js';
 export { VariableStoreCookieSerializer } from './variableStoreCookieSerializer.js';
diff --git a/web/src/engine/main/src/keyboardInterface.ts b/web/src/engine/main/src/keyboardInterfaceBase.ts
similarity index 94%
rename from web/src/engine/main/src/keyboardInterface.ts
rename to web/src/engine/main/src/keyboardInterfaceBase.ts
index 59d7c22954..746a16fa83 100644
--- a/web/src/engine/main/src/keyboardInterface.ts
+++ b/web/src/engine/main/src/keyboardInterfaceBase.ts
@@ -1,5 +1,5 @@
 import { KeymanWebKeyboard } from '@keymanapp/common-types';
-import { KeyboardInterface as KeyboardInterfaceBase } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface  } from 'keyman/engine/js-processor';
 import { KeyboardStub, RawKeyboardStub, toUnprefixedKeyboardId as unprefixed } from 'keyman/engine/keyboard-storage';
 
 import KeyboardObject = KeymanWebKeyboard.KeyboardObject;
@@ -9,7 +9,7 @@ import { VariableStoreCookieSerializer } from "./variableStoreCookieSerializer.j
 import { KeymanEngineBase } from "./keymanEngineBase.js";
 import { EngineConfiguration } from "./engineConfiguration.js";
 
-export default class KeyboardInterface<ContextManagerType extends ContextManagerBase<any>> extends KeyboardInterfaceBase {
+export class KeyboardInterfaceBase<ContextManagerType extends ContextManagerBase<any>> extends JSKeyboardInterface {
   protected readonly engine: KeymanEngineBase<EngineConfiguration, ContextManagerType, any>;
   private stubNamespacer?: (stub: RawKeyboardStub) => void;
 
@@ -122,5 +122,5 @@ export default class KeyboardInterface<ContextManagerType extends ContextManager
 }
 
 (function() {
-  KeyboardInterface.__publishShorthandAPI();
+  KeyboardInterfaceBase.__publishShorthandAPI();
 }());
\ No newline at end of file
diff --git a/web/src/engine/main/src/keymanEngineBase.ts b/web/src/engine/main/src/keymanEngineBase.ts
index 5e8804fb8b..37acf96f2a 100644
--- a/web/src/engine/main/src/keymanEngineBase.ts
+++ b/web/src/engine/main/src/keymanEngineBase.ts
@@ -1,14 +1,15 @@
-import { type KeyEvent, type Keyboard, KeyboardKeymanGlobal } from "keyman/engine/keyboard";
-import { OutputTarget, ProcessorInitOptions, RuleBehavior } from 'keyman/engine/js-processor';
+import { type KeyEvent, JSKeyboard, Keyboard, KeyboardProperties, KeyboardKeymanGlobal, ProcessorAction } from "keyman/engine/keyboard";
+// TODO-web-core: remove usage of OutputTargetBase
+import { OutputTargetBase, ProcessorInitOptions } from 'keyman/engine/js-processor';
 import { DOMKeyboardLoader as KeyboardLoader } from "keyman/engine/keyboard/dom-keyboard-loader";
 import { WorkerFactory } from "@keymanapp/lexical-model-layer/web"
 import { InputProcessor } from './headless/inputProcessor.js';
-import { OSKView } from "keyman/engine/osk";
+import { OSKView, JSKeyboardData } from "keyman/engine/osk";
 import { KeyboardRequisitioner, ModelCache, toUnprefixedKeyboardId as unprefixed } from "keyman/engine/keyboard-storage";
 import { ModelSpec, PredictionContext } from "keyman/engine/interfaces";
 
 import { EngineConfiguration, InitOptionSpec } from "./engineConfiguration.js";
-import KeyboardInterface from "./keyboardInterface.js";
+import { KeyboardInterfaceBase } from "./keyboardInterfaceBase.js";
 import { ContextManagerBase } from "./contextManagerBase.js";
 import { HardKeyboardBase } from "./hardKeyboardBase.js";
 import { LegacyAPIEvents } from "./legacyAPIEvents.js";
@@ -32,7 +33,7 @@ function determineBaseLayout(): string {
   }
 }
 
-export type KeyEventFullResultCallback = (result: RuleBehavior, error?: Error) => void;
+export type KeyEventFullResultCallback = (result: ProcessorAction, error?: Error) => void;
 export type KeyEventFullHandler = (event: KeyEvent, callback?: KeyEventFullResultCallback) => void;
 
 export class KeymanEngineBase<
@@ -42,7 +43,7 @@ export class KeymanEngineBase<
 > implements KeyboardKeymanGlobal {
   readonly config: ConfigurationT;
   contextManager: ContextManagerT;
-  interface: KeyboardInterface<ContextManagerT>;
+  interface: KeyboardInterfaceBase<ContextManagerT>;
   readonly core: InputProcessor;
   keyboardRequisitioner: KeyboardRequisitioner;
   modelCache: ModelCache;
@@ -78,7 +79,8 @@ export class KeymanEngineBase<
     outputTarget.invalidateSelection();
     // Deadkey matching continues to be troublesome.
     // Deleting matched deadkeys here seems to correct some of the issues.   (JD 6/6/14)
-    outputTarget.deadkeys().deleteMatched();      // Delete any matched deadkeys before continuing
+    // TODO-web-core
+    (outputTarget as OutputTargetBase).deadkeys().deleteMatched();      // Delete any matched deadkeys before continuing
 
     if(event.isSynthetic) {
       const oskLayer = this.osk.vkbd.layerId;
@@ -124,7 +126,7 @@ export class KeymanEngineBase<
 
     const processorConfiguration = processorConfigInitializer(this);
     processorConfiguration.baseLayout = determineBaseLayout();
-    this.interface = processorConfiguration.keyboardInterface as KeyboardInterface<ContextManagerT>;
+    this.interface = processorConfiguration.keyboardInterface as KeyboardInterfaceBase<ContextManagerT>;
     this.core = new InputProcessor(config.hostDevice, workerFactory, processorConfiguration);
 
     this.core.languageProcessor.on('statechange', (state) => {
@@ -148,11 +150,11 @@ export class KeymanEngineBase<
       });
     });
 
-    this.contextManager.on('keyboardchange', (kbd) => {
+    this.contextManager.on('keyboardchange', (kbdData: { keyboard: Keyboard, metadata: KeyboardProperties }) => {
       // Hide OSK and do not update keyboard list if using internal keyboard (desktops).
       // Condition will not be met for touch form-factors; they force selection of a
       // default keyboard.
-      if(!kbd) {
+      if(!kbdData) {
         this.osk.startHide(false);
       }
 
@@ -160,11 +162,11 @@ export class KeymanEngineBase<
         this.refreshModel();
         // Triggers context resets that can trigger layout stuff.
         // It's not the final such context-reset, though.
-        this.core.activeKeyboard = kbd?.keyboard;
+        this.core.activeKeyboard = kbdData?.keyboard;
 
         this.legacyAPIEvents.callEvent('keyboardchange', {
-          internalName: kbd?.metadata.id ?? '',
-          languageCode: kbd?.metadata.langId ?? ''
+          internalName: kbdData?.metadata.id ?? '',
+          languageCode: kbdData?.metadata.langId ?? ''
         });
       }
 
@@ -176,10 +178,10 @@ export class KeymanEngineBase<
         If possible, we want to only perform layout operations once the correct layer is
         set to active.
       */
-      if(this.osk) {
+      if(this.osk && (!kbdData || kbdData.keyboard instanceof JSKeyboard)) { // TODO-web-core: add support for OSK for KMX keyboards
         this.osk.batchLayoutAfter(() => {
           prepareKeyboardSwap();
-          this.osk.activeKeyboard = kbd;
+          this.osk.activeKeyboard = kbdData ? { keyboard: kbdData.keyboard as JSKeyboard, metadata: kbdData.metadata } : undefined;
           // Note:  when embedded within the mobile apps, the keyboard will still be visible
           // at this time.
 
@@ -276,10 +278,13 @@ export class KeymanEngineBase<
       keyboardProcessor.newLayerStore.set('');
       keyboardProcessor.oldLayerStore.set('');
       // Call the keyboard's entry point.
-      keyboardProcessor.processPostKeystroke(keyboardProcessor.contextDevice, predictionContext.currentTarget as OutputTarget)
-        // If we have a RuleBehavior as a result, run it on the target. This should
-        // only change system store and variable store values.
-        ?.finalize(keyboardProcessor, predictionContext.currentTarget as OutputTarget, true);
+      // TODO-web-core
+      const data = keyboardProcessor.processPostKeystroke(keyboardProcessor.contextDevice, predictionContext.currentTarget as OutputTargetBase)
+      // If we have a ProcessorAction as a result, run it on the target. This should
+      // only change system store and variable store values.
+      if (data) {
+        keyboardProcessor.finalizeProcessorAction(data, predictionContext.currentTarget);
+      }
     });
 
     // #region Event handler wiring
@@ -334,6 +339,8 @@ export class KeymanEngineBase<
     });
     //
     // #endregion
+
+    await this.core.init(config.paths);
   }
 
   /**
@@ -382,7 +389,7 @@ export class KeymanEngineBase<
     this.core.keyboardProcessor.contextDevice = value?.targetDevice ?? this.config.softDevice;
     if(value) {
       // Don't build an OSK if no keyboard is available yet; avoid the extra flash.
-      if(this.contextManager.activeKeyboard) {
+      if (this.contextManager.activeKeyboard && this.contextManager.activeKeyboard instanceof JSKeyboardData) { // TODO-web-core: add support for OSK for KMX keyboards
         value.activeKeyboard = this.contextManager.activeKeyboard;
       }
       value.on('keyevent', this.keyEventListener);
@@ -458,6 +465,7 @@ export class KeymanEngineBase<
   shutdown() {
     this.legacyAPIEvents.shutdown();
     this.osk?.shutdown();
+    this.keyboardRequisitioner?.shutdown();
   }
 
   // API methods
@@ -554,23 +562,30 @@ export class KeymanEngineBase<
    *
    * See https://help.keyman.com/developer/engine/web/current-version/reference/core/isChiral
    */
-  public isChiral(k0?: string | Keyboard) {
-    let kbd: Keyboard;
+  public isChiral(k0?: string | JSKeyboard) {
+    let jsKbd: JSKeyboard;
     if(k0) {
       if(typeof k0 == 'string') {
         const kbdObj = this.keyboardRequisitioner.cache.getKeyboard(k0);
-        if(!kbdObj) {
+        if (!kbdObj) {
           throw new Error(`Keyboard '${k0}' has not been loaded.`);
+        } else if (!(kbdObj instanceof JSKeyboard)) {
+          return false; // TODO-web-core: implement for KMX keyboards
         } else {
           k0 = kbdObj;
         }
       }
 
-      kbd = k0;
+      jsKbd = k0;
     } else {
-      kbd = this.core.activeKeyboard;
+      const kbd = this.core.activeKeyboard;
+      if (kbd instanceof JSKeyboard) {
+        jsKbd = kbd;
+      } else {
+        return false; // TODO-web-core: implement for KMX keyboards
+      }
     }
-    return kbd.isChiral;
+    return jsKbd.isChiral;
   }
 
   /**
diff --git a/web/src/engine/main/src/variableStoreCookieSerializer.ts b/web/src/engine/main/src/variableStoreCookieSerializer.ts
index 62c250329a..de7da7e702 100644
--- a/web/src/engine/main/src/variableStoreCookieSerializer.ts
+++ b/web/src/engine/main/src/variableStoreCookieSerializer.ts
@@ -1,4 +1,4 @@
-import { VariableStore, VariableStoreSerializer } from 'keyman/engine/js-processor';
+import { VariableStore, VariableStoreSerializer } from 'keyman/engine/keyboard';
 import { CookieSerializer } from "keyman/engine/dom-utils";
 
 // While there's little reason we couldn't store all of a keyboard's store values within
diff --git a/web/src/engine/osk/src/banner/banner.ts b/web/src/engine/osk/src/banner/banner.ts
index 43ab370356..83054af7ae 100644
--- a/web/src/engine/osk/src/banner/banner.ts
+++ b/web/src/engine/osk/src/banner/banner.ts
@@ -1,4 +1,4 @@
-import { Keyboard, KeyboardProperties } from 'keyman/engine/keyboard';
+import { JSKeyboard, KeyboardProperties } from 'keyman/engine/keyboard';
 import { createUnselectableElement } from 'keyman/engine/dom-utils';
 
 // Base class for a banner above the keyboard in the OSK
@@ -98,7 +98,7 @@ export abstract class Banner {
    * @param keyboard
    * @param keyboardProperties
    */
-  public configureForKeyboard(keyboard: Keyboard, keyboardProperties: KeyboardProperties) { }
+  public configureForKeyboard(keyboard: JSKeyboard, keyboardProperties: KeyboardProperties) { }
 
   public readonly refreshLayout?: () => void;
 
diff --git a/web/src/engine/osk/src/banner/bannerController.ts b/web/src/engine/osk/src/banner/bannerController.ts
index 2e6bdfeac1..aae9b643b8 100644
--- a/web/src/engine/osk/src/banner/bannerController.ts
+++ b/web/src/engine/osk/src/banner/bannerController.ts
@@ -6,7 +6,7 @@ import { BannerView } from './bannerView.js';
 import { Banner } from './banner.js';
 import { BlankBanner } from './blankBanner.js';
 import { HTMLBanner } from './htmlBanner.js';
-import { Keyboard, KeyboardProperties } from 'keyman/engine/keyboard';
+import { JSKeyboard, KeyboardProperties } from 'keyman/engine/keyboard';
 
 export class BannerController {
   private container: BannerView;
@@ -17,7 +17,7 @@ export class BannerController {
 
   private _inactiveBanner: Banner;
 
-  private keyboard: Keyboard;
+  private keyboard: JSKeyboard;
   private keyboardStub: KeyboardProperties;
 
   /**
@@ -105,7 +105,7 @@ export class BannerController {
    * @param keyboard
    * @param keyboardProperties
    */
-  public configureForKeyboard(keyboard: Keyboard, keyboardProperties: KeyboardProperties) {
+  public configureForKeyboard(keyboard: JSKeyboard, keyboardProperties: KeyboardProperties) {
     this.keyboard = keyboard;
     this.keyboardStub = keyboardProperties;
 
diff --git a/web/src/engine/osk/src/banner/suggestionBanner.ts b/web/src/engine/osk/src/banner/suggestionBanner.ts
index a4d852cb49..98275f9955 100644
--- a/web/src/engine/osk/src/banner/suggestionBanner.ts
+++ b/web/src/engine/osk/src/banner/suggestionBanner.ts
@@ -13,7 +13,7 @@ import {
 
 import { BANNER_GESTURE_SET } from './bannerGestureSet.js';
 
-import { DeviceSpec, Keyboard, KeyboardProperties, timedPromise } from 'keyman/engine/keyboard';
+import { DeviceSpec, JSKeyboard, KeyboardProperties, timedPromise } from 'keyman/engine/keyboard';
 import { Banner } from './banner.js';
 import { ParsedLengthStyle } from '../lengthStyle.js';
 import { getFontSizeStyle } from '../fontSizeUtils.js';
@@ -693,7 +693,7 @@ export class SuggestionBanner extends Banner {
     return result;
   }
 
-  public configureForKeyboard(keyboard: Keyboard, keyboardProperties: KeyboardProperties) {
+  public configureForKeyboard(keyboard: JSKeyboard, keyboardProperties: KeyboardProperties) {
     const rtl = keyboard.isRTL;
 
     // Removes all previous children.  (.replaceChildren requires Chrome for Android 86.)
diff --git a/web/src/engine/osk/src/components/helpPageView.ts b/web/src/engine/osk/src/components/helpPageView.ts
index e28a2d739c..415a58a7f5 100644
--- a/web/src/engine/osk/src/components/helpPageView.ts
+++ b/web/src/engine/osk/src/components/helpPageView.ts
@@ -1,15 +1,15 @@
-import { Keyboard } from 'keyman/engine/keyboard';
+import { JSKeyboard } from 'keyman/engine/keyboard';
 
 import KeyboardView from './keyboardView.interface.js';
 import { ParsedLengthStyle } from "../lengthStyle.js";
 
 export default class HelpPageView implements KeyboardView {
-  private readonly kbd: Keyboard;
+  private readonly kbd: JSKeyboard;
   public readonly element: HTMLDivElement;
 
   private static readonly ID = 'kmw-osk-help-page';
 
-  constructor(keyboard: Keyboard) {
+  constructor(keyboard: JSKeyboard) {
     this.kbd = keyboard;
 
     const Ldiv = this.element = document.createElement('div');
diff --git a/web/src/engine/osk/src/components/titleBar.ts b/web/src/engine/osk/src/components/titleBar.ts
index 67edfca876..7f863a5a83 100644
--- a/web/src/engine/osk/src/components/titleBar.ts
+++ b/web/src/engine/osk/src/components/titleBar.ts
@@ -1,6 +1,6 @@
 import { EventEmitter } from 'eventemitter3';
 
-import { Keyboard } from 'keyman/engine/keyboard';
+import { JSKeyboard } from 'keyman/engine/keyboard';
 
 import OSKViewComponent from './oskViewComponent.interface.js';
 import { ParsedLengthStyle } from '../lengthStyle.js';
@@ -102,7 +102,7 @@ export default class TitleBar extends EventEmitter<EventMap, TitleBar> implement
     this._caption.innerHTML = str;
   }
 
-  public setTitleFromKeyboard(keyboard: Keyboard) {
+  public setTitleFromKeyboard(keyboard: JSKeyboard) {
     const title = "<span style='font-weight:bold'>" + keyboard?.name + '</span>';  // I1972  // I2186
     this._caption.innerHTML = title;
   }
diff --git a/web/src/engine/osk/src/index.ts b/web/src/engine/osk/src/index.ts
index f010697d96..4140e1537d 100644
--- a/web/src/engine/osk/src/index.ts
+++ b/web/src/engine/osk/src/index.ts
@@ -1,6 +1,6 @@
-export { Codes, DeviceSpec, Keyboard, KeyboardProperties, SpacebarText } from 'keyman/engine/keyboard';
+export { Codes, DeviceSpec, JSKeyboard, KeyboardProperties, SpacebarText } from 'keyman/engine/keyboard';
 
-export { default as OSKView } from './views/oskView.js';
+export { default as OSKView, JSKeyboardData } from './views/oskView.js';
 export { default as FloatingOSKView, FloatingOSKViewConfiguration } from './views/floatingOskView.js';
 export { default as AnchoredOSKView } from './views/anchoredOskView.js';
 export { default as InlinedOSKView } from './views/inlinedOskView.js';
diff --git a/web/src/engine/osk/src/keyboard-layout/oskLayerGroup.ts b/web/src/engine/osk/src/keyboard-layout/oskLayerGroup.ts
index 89ff68c212..061dbb1d52 100644
--- a/web/src/engine/osk/src/keyboard-layout/oskLayerGroup.ts
+++ b/web/src/engine/osk/src/keyboard-layout/oskLayerGroup.ts
@@ -1,4 +1,4 @@
-import { type DeviceSpec, Keyboard, ActiveLayout, ButtonClasses } from 'keyman/engine/keyboard';
+import { type DeviceSpec, JSKeyboard, ActiveLayout, ButtonClasses } from 'keyman/engine/keyboard';
 
 import { InputSample } from '@keymanapp/gesture-recognizer';
 
@@ -24,7 +24,7 @@ export default class OSKLayerGroup {
   private _activeLayerId: string = 'default';
   private _heightPadding: number;
 
-  public constructor(vkbd: VisualKeyboard, keyboard: Keyboard, formFactor: DeviceSpec.FormFactor) {
+  public constructor(vkbd: VisualKeyboard, keyboard: JSKeyboard, formFactor: DeviceSpec.FormFactor) {
     const layout = keyboard.layout(formFactor);
     this.spec = layout;
     this.vkbd = vkbd;
diff --git a/web/src/engine/osk/src/views/keyEventSource.interface.ts b/web/src/engine/osk/src/views/keyEventSource.interface.ts
index 827a0b9af8..a8327c2ad3 100644
--- a/web/src/engine/osk/src/views/keyEventSource.interface.ts
+++ b/web/src/engine/osk/src/views/keyEventSource.interface.ts
@@ -1,8 +1,7 @@
 import { EventEmitter } from "eventemitter3";
-import { type KeyEvent } from 'keyman/engine/keyboard';
-import { type RuleBehavior } from 'keyman/engine/js-processor';
+import { type KeyEvent, type ProcessorAction } from 'keyman/engine/keyboard';
 
-export type KeyEventResultCallback = (result: RuleBehavior, error?: Error) => void;
+export type KeyEventResultCallback = (result: ProcessorAction, error?: Error) => void;
 export type KeyEventHandler = (event: KeyEvent, callback?: KeyEventResultCallback) => void;
 
 interface EventMap {
diff --git a/web/src/engine/osk/src/views/oskView.ts b/web/src/engine/osk/src/views/oskView.ts
index 1a31a1d0ff..6c08892f62 100644
--- a/web/src/engine/osk/src/views/oskView.ts
+++ b/web/src/engine/osk/src/views/oskView.ts
@@ -13,14 +13,14 @@ import { type KeyElement } from '../keyElement.js';
 import {
   Codes,
   DeviceSpec,
-  Keyboard,
+  JSKeyboard,
   KeyboardProperties,
   ManagedPromise,
-  type MinimalCodesInterface
+  type MinimalCodesInterface,
+  type MutableSystemStore, type SystemStoreMutationHandler,
 } from 'keyman/engine/keyboard';
 import { createUnselectableElement, getAbsoluteX, getAbsoluteY, StylesheetManager } from 'keyman/engine/dom-utils';
 import { EventListener, LegacyEventEmitter } from 'keyman/engine/events';
-import { type MutableSystemStore, type SystemStoreMutationHandler } from 'keyman/engine/js-processor';
 
 import Configuration from '../config/viewConfiguration.js';
 import Activator, { StaticActivator } from './activator.js';
@@ -59,6 +59,11 @@ export interface LegacyOSKEventMap {
   }): void;
 }
 
+export class JSKeyboardData {
+  keyboard: JSKeyboard;
+  metadata: KeyboardProperties;
+};
+
 /**
  * For now, these will serve as undocumented, internal events.  We need a proper
  * design round and discussion before we consider promoting them to long-term,
@@ -168,10 +173,7 @@ export default abstract class OSKView
   private _boxBaseTouchStart:       (e: TouchEvent) => boolean;
   private _boxBaseTouchEventCancel: (e: TouchEvent) => boolean;
 
-  private keyboardData: {
-    keyboard: Keyboard,
-    metadata: KeyboardProperties
-  };
+  private keyboardData: JSKeyboardData;
 
   /**
    * Provides the current parameterization for timings and distances used by
@@ -552,17 +554,11 @@ export default abstract class OSKView
     }
   }
 
-  public get activeKeyboard(): {
-    keyboard: Keyboard,
-    metadata: KeyboardProperties
-  } {
+  public get activeKeyboard(): JSKeyboardData {
     return this.keyboardData;
   }
 
-  public set activeKeyboard(keyboardData: {
-    keyboard: Keyboard,
-    metadata: KeyboardProperties
-  }) {
+  public set activeKeyboard(keyboardData: JSKeyboardData) {
     this.keyboardData = keyboardData;
     this.loadActiveKeyboard();
 
@@ -809,7 +805,7 @@ export default abstract class OSKView
     this.postKeyboardLoad();
   }
 
-  private _GenerateKeyboardView(keyboard: Keyboard, keyboardMetadata: KeyboardProperties): KeyboardView {
+  private _GenerateKeyboardView(keyboard: JSKeyboard, keyboardMetadata: KeyboardProperties): KeyboardView {
     const device = this.targetDevice;
 
     this._Box.className = "";
@@ -842,7 +838,7 @@ export default abstract class OSKView
    * @param       {Object}      keyboard    The keyboard to visualize
    * Description  Generates the visual keyboard element and attaches it to KMW
    */
-  private _GenerateVisualKeyboard(keyboard: Keyboard, keyboardMetadata: KeyboardProperties): VisualKeyboard {
+  private _GenerateVisualKeyboard(keyboard: JSKeyboard, keyboardMetadata: KeyboardProperties): VisualKeyboard {
     const device = this.targetDevice;
 
     const resourcePath = getResourcePath(this.config);
diff --git a/web/src/engine/osk/src/visualKeyboard.ts b/web/src/engine/osk/src/visualKeyboard.ts
index 000b491bf6..6985edf192 100644
--- a/web/src/engine/osk/src/visualKeyboard.ts
+++ b/web/src/engine/osk/src/visualKeyboard.ts
@@ -5,7 +5,7 @@ import {
   ActiveLayout,
   DeviceSpec,
   type InternalKeyboardFont,
-  Keyboard,
+  JSKeyboard,
   KeyboardProperties,
   KeyDistribution,
   KeyEvent,
@@ -87,7 +87,7 @@ export interface VisualKeyboardConfiguration extends CommonConfiguration {
   /**
    * The Keyman keyboard on which to base the on-screen keyboard being represented.
    */
-  keyboard: Keyboard,
+  keyboard: JSKeyboard,
 
   /**
    * Metadata about the keyboard, such as relevant fonts, display name, and language code.
@@ -242,7 +242,7 @@ export default class VisualKeyboard extends EventEmitter<EventMap> implements Ke
   public deferLayout: boolean;
 
   // The keyboard object corresponding to this VisualKeyboard.
-  public readonly layoutKeyboard: Keyboard;
+  public readonly layoutKeyboard: JSKeyboard;
   public readonly layoutKeyboardProperties: KeyboardProperties;
 
   get layerId(): string {
@@ -349,7 +349,7 @@ export default class VisualKeyboard extends EventEmitter<EventMap> implements Ke
     if (!this.layoutKeyboard) {
       // May occasionally be null in embedded contexts; have seen this when iOS engine sets
       // keyboard height during change of keyboards.
-      this.layoutKeyboard = new Keyboard(null);
+      this.layoutKeyboard = new JSKeyboard(null);
     }
 
     this.layerGroup = new OSKLayerGroup(this, this.layoutKeyboard, formFactor);
@@ -1346,7 +1346,7 @@ export default class VisualKeyboard extends EventEmitter<EventMap> implements Ke
    * Create copy of the OSK that can be used for embedding in documentation or help
    * The currently active keyboard will be returned if PInternalName is null
    *
-   *  @param  {Keyboard}           PKbd            the keyboard object to be displayed
+   *  @param  {JSKeyboard}           PKbd            the keyboard object to be displayed
    *  @param  {KeyboardProperties} kbdProperties   the metadata stub for the keyboard
    *  @param  {Object}             pathConfig      an OSK path-configuration instance
    *  @param  {string=}            argFormFactor   layout form factor, defaulting to 'desktop'
@@ -1356,7 +1356,7 @@ export default class VisualKeyboard extends EventEmitter<EventMap> implements Ke
    *  @return {Object}                            DIV object with filled keyboard layer content
    */
   static buildDocumentationKeyboard(
-    PKbd: Keyboard,
+    PKbd: JSKeyboard,
     kbdProperties: KeyboardProperties,
     pathConfig: OSKResourcePathConfiguration,
     argFormFactor: DeviceSpec.FormFactor,
diff --git a/web/src/test/auto/dom/cases/core-processor/basic.tests.ts b/web/src/test/auto/dom/cases/core-processor/basic.tests.ts
new file mode 100644
index 0000000000..ddf3bb1b74
--- /dev/null
+++ b/web/src/test/auto/dom/cases/core-processor/basic.tests.ts
@@ -0,0 +1,50 @@
+import { assert } from 'chai';
+import { KM_Core, KM_CORE_STATUS } from 'keyman/engine/core-processor';
+
+const coreurl = '/build/engine/core-processor/obj/import/core';
+
+// Test the CoreProcessor interface.
+describe('CoreProcessor', function () {
+  async function loadKeyboardBlob(uri: string) {
+    const response = await fetch(uri);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} ${response.statusText}`);
+    }
+
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+
+  it('can initialize without errors', async function () {
+    assert.isOk(await KM_Core.createCoreProcessor(coreurl));
+  });
+
+  it('can call temp function', async function () {
+    const km_core = await KM_Core.createCoreProcessor(coreurl);
+    const a = km_core.tmp_wasm_attributes();
+    assert.isOk(a);
+    assert.isNumber(a.max_context);
+    console.dir(a);
+  });
+
+  it('can load a keyboard from blob', async function () {
+    const km_core = await KM_Core.createCoreProcessor(coreurl);
+    const blob = await loadKeyboardBlob('/common/test/resources/keyboards/test_8568_deadkeys.kmx')
+    const result = km_core.keyboard_load_from_blob('test', blob);
+    assert.equal(result.status, KM_CORE_STATUS.OK);
+    assert.isOk(result.object);
+    result.delete();
+  });
+
+  it('can get version from keyboard', async function () {
+    const km_core = await KM_Core.createCoreProcessor(coreurl);
+    const blob = await loadKeyboardBlob('/common/test/resources/keyboards/test_8568_deadkeys.kmx')
+    const keyboard = km_core.keyboard_load_from_blob('test', blob);
+    const result = km_core.keyboard_get_attrs(keyboard.object);
+
+    assert.equal(result.status, KM_CORE_STATUS.OK);
+    assert.isOk(result.object);
+    assert.equal(result.object.version_string, '0.0');
+    result.delete();
+  });
+});
diff --git a/web/src/test/auto/dom/cases/keyboard/domKeyboardLoader.tests.ts b/web/src/test/auto/dom/cases/keyboard/domKeyboardLoader.tests.ts
index 507a4ad828..38db889f61 100644
--- a/web/src/test/auto/dom/cases/keyboard/domKeyboardLoader.tests.ts
+++ b/web/src/test/auto/dom/cases/keyboard/domKeyboardLoader.tests.ts
@@ -1,14 +1,15 @@
 import { assert } from 'chai';
 
 import { DOMKeyboardLoader } from 'keyman/engine/keyboard/dom-keyboard-loader';
-import { KeyboardHarness, Keyboard, MinimalKeymanGlobal, DeviceSpec, KeyboardKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface, Mock } from 'keyman/engine/js-processor';
+import { KeyboardHarness, JSKeyboard, MinimalKeymanGlobal, DeviceSpec, KeyboardKeymanGlobal, KeyboardDownloadError, KeyboardScriptError, Keyboard } from 'keyman/engine/keyboard';
+import { JSKeyboardInterface, Mock } from 'keyman/engine/js-processor';
+import { assertThrowsAsync } from 'keyman/tools/testing/test-utils';
 
 declare let window: typeof globalThis;
 // KeymanEngine from the web/ folder... when available.
 // At this level, though... we just mock it.
 declare let keyman: KeyboardKeymanGlobal;
-declare let KeymanWeb: KeyboardInterface;
+declare let KeymanWeb: JSKeyboardInterface;
 
 const device: DeviceSpec = {
   touchable: false,
@@ -24,15 +25,35 @@ describe('Keyboard loading in DOM', function() {
     }
   })
 
+  it('throws error when keyboard does not exist', async () => {
+    const harness = new JSKeyboardInterface(window, MinimalKeymanGlobal);
+    const keyboardLoader = new DOMKeyboardLoader(harness);
+    const nonExisting = '/does/not/exist.js';
+
+    await assertThrowsAsync(async () => await keyboardLoader.loadKeyboardFromPath(nonExisting),
+      KeyboardDownloadError, `Unable to download keyboard at ${nonExisting}`);
+  });
+
+  it('throws error when keyboard is invalid', async () => {
+    const harness = new JSKeyboardInterface(window, MinimalKeymanGlobal);
+    const keyboardLoader = new DOMKeyboardLoader(harness);
+    const nonKeyboardPath = '/common/test/resources/index.mjs';
+
+    await assertThrowsAsync(async () => await keyboardLoader.loadKeyboardFromPath(nonKeyboardPath),
+      KeyboardScriptError, `Error registering the keyboard script at ${nonKeyboardPath}; it may contain an error.`);
+  });
+
   it('`window`, disabled rule processing', async () => {
     const harness = new KeyboardHarness(window, MinimalKeymanGlobal);
     let keyboardLoader = new DOMKeyboardLoader(harness);
     let keyboard: Keyboard = await keyboardLoader.loadKeyboardFromPath('/common/test/resources/keyboards/khmer_angkor.js');
 
     assert.isOk(keyboard);
-    assert.equal(keyboard.id, 'Keyboard_khmer_angkor');
-    assert.isTrue(keyboard.isChiral);
-    assert.isFalse(keyboard.isCJK);
+    assert.instanceOf(keyboard, JSKeyboard);
+    const jsKeyboard = keyboard as JSKeyboard;
+    assert.equal(jsKeyboard.id, 'Keyboard_khmer_angkor');
+    assert.isTrue(jsKeyboard.isChiral);
+    assert.isFalse(jsKeyboard.isCJK);
     assert.isOk(KeymanWeb);
     assert.isOk(keyman);
     assert.isOk(keyman.osk);
@@ -43,24 +64,26 @@ describe('Keyboard loading in DOM', function() {
   });
 
   it('`window`, enabled rule processing', async () => {
-    const harness = new KeyboardInterface(window, MinimalKeymanGlobal);
-    const keyboardLoader = new DOMKeyboardLoader(harness);
+    const jsHarness = new JSKeyboardInterface(window, MinimalKeymanGlobal);
+    const keyboardLoader = new DOMKeyboardLoader(jsHarness);
     const keyboard: Keyboard = await keyboardLoader.loadKeyboardFromPath('/common/test/resources/keyboards/khmer_angkor.js');
-    harness.activeKeyboard = keyboard;
+    const jsKeyboard = keyboard as JSKeyboard;
+    jsHarness.activeKeyboard = jsKeyboard;
 
     assert.isOk(keyboard);
-    assert.equal(keyboard.id, 'Keyboard_khmer_angkor');
-    assert.isTrue(keyboard.isChiral);
-    assert.isFalse(keyboard.isCJK);
+    assert.instanceOf(keyboard, JSKeyboard);
+    assert.equal(jsKeyboard.id, 'Keyboard_khmer_angkor');
+    assert.isTrue(jsKeyboard.isChiral);
+    assert.isFalse(jsKeyboard.isCJK);
     assert.isOk(KeymanWeb);
     assert.isOk(keyman);
     assert.isOk(keyman.osk);
     assert.isOk(keyman.osk.keyCodes);
 
     // TODO:  verify actual rule processing.
-    const nullKeyEvent = keyboard.constructNullKeyEvent(device);
+    const nullKeyEvent = jsKeyboard.constructNullKeyEvent(device);
     const mock = new Mock();
-    const result = harness.processKeystroke(mock, nullKeyEvent);
+    const result = jsHarness.processKeystroke(mock, nullKeyEvent);
 
     assert.isOk(result);
     assert.isOk(KeymanWeb);
@@ -69,17 +92,19 @@ describe('Keyboard loading in DOM', function() {
     assert.isOk(keyman.osk.keyCodes);
 
     // Should be cleared post-keyboard-load.
-    assert.isNotOk(harness.loadedKeyboard);
+    assert.isNotOk(jsHarness.loadedKeyboard);
   });
 
   it('load keyboards successfully in parallel without side effects', async () => {
-    let harness = new KeyboardInterface(window, MinimalKeymanGlobal);
-    let keyboardLoader = new DOMKeyboardLoader(harness);
+    let jsHarness = new JSKeyboardInterface(window, MinimalKeymanGlobal);
+    let keyboardLoader = new DOMKeyboardLoader(jsHarness);
 
     // Preload a keyboard and make it active.
     const test_kbd: Keyboard = await keyboardLoader.loadKeyboardFromPath('/common/test/resources/keyboards/test_917.js');
-    harness.activeKeyboard = test_kbd;
-    assert.isNotOk(harness.loadedKeyboard);
+    assert.instanceOf(test_kbd, JSKeyboard);
+    const test_jskbd = test_kbd as JSKeyboard;
+    jsHarness.activeKeyboard = test_jskbd;
+    assert.isNotOk(jsHarness.loadedKeyboard);
 
     // With an active keyboard, load three keyboards but activate none of them.
     const lao_keyboard_promise = keyboardLoader.loadKeyboardFromPath('/common/test/resources/keyboards/lao_2008_basic.js');
@@ -91,8 +116,8 @@ describe('Keyboard loading in DOM', function() {
     const lao_keyboard = await lao_keyboard_promise;
     const khmer_keyboard = await khmer_keyboard_promise;
 
-    assert.strictEqual(test_kbd, harness.activeKeyboard);
-    assert.isNotOk(harness.loadedKeyboard);
+    assert.strictEqual(test_kbd, jsHarness.activeKeyboard);
+    assert.isNotOk(jsHarness.loadedKeyboard);
 
     assert.isOk(lao_keyboard);
     assert.isOk(chiral_keyboard);
@@ -103,6 +128,6 @@ describe('Keyboard loading in DOM', function() {
     assert.equal(khmer_keyboard.id, "Keyboard_khmer_angkor");
     assert.equal(chiral_keyboard.id, "Keyboard_test_chirality");
 
-    harness.activeKeyboard = lao_keyboard;
+    jsHarness.activeKeyboard = lao_keyboard as JSKeyboard;
   });
 });
diff --git a/web/src/test/auto/dom/kbdLoader.ts b/web/src/test/auto/dom/kbdLoader.ts
index b0d092c12d..a9a01dfe2c 100644
--- a/web/src/test/auto/dom/kbdLoader.ts
+++ b/web/src/test/auto/dom/kbdLoader.ts
@@ -3,15 +3,15 @@ import {
 } from 'keyman/engine/keyboard/dom-keyboard-loader';
 
 import {
-  Keyboard,
+  JSKeyboard,
   KeyboardProperties,
   MinimalKeymanGlobal
 } from 'keyman/engine/keyboard';
 
-import { KeyboardInterface } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface } from 'keyman/engine/js-processor';
 import { KeyboardStub } from 'keyman/engine/keyboard-storage';
 
-const loader = new DOMKeyboardLoader(new KeyboardInterface(window, MinimalKeymanGlobal));
+const loader = new DOMKeyboardLoader(new JSKeyboardInterface(window, MinimalKeymanGlobal));
 
 export function loadKeyboardFromPath(path: string) {
   return loader.loadKeyboardFromPath(path);
@@ -21,11 +21,11 @@ export function loadKeyboardsFromStubs(apiStubs: any, baseDir: string) {
   baseDir = baseDir || './';
   const keyboards: {
     [key: string]: {
-      keyboard: Keyboard,
+      keyboard: JSKeyboard,
       metadata: KeyboardStub
     }
   } = {};
-  let priorPromise: Promise<void | Keyboard> = Promise.resolve();
+  let priorPromise: Promise<void | JSKeyboard> = Promise.resolve();
   for(const stub of apiStubs) {
     // We are keeping this strictly sequential because we don't have sandboxed
     // loading yet; lack of sandboxing means that all loading keyboards compete
@@ -37,7 +37,12 @@ export function loadKeyboardsFromStubs(apiStubs: any, baseDir: string) {
       const overwriteLoader = (id: number, path: string) => {
         const loader = loadKeyboardFromPath(path);
         return loader.then(kbd => {
-          keyboards[stub.id].keyboard = kbd;
+          if (kbd instanceof JSKeyboard) {
+            keyboards[stub.id].keyboard = kbd;
+          } else {
+            // TODO-web-core: implement for KMX keyboards if needed
+            keyboards[stub.id].keyboard = null;
+          }
         });
       }
       keyboards[stub.id] = {
diff --git a/web/src/test/auto/dom/web-test-runner.config.mjs b/web/src/test/auto/dom/web-test-runner.config.mjs
index 701eab15a7..48a3a4f9f3 100644
--- a/web/src/test/auto/dom/web-test-runner.config.mjs
+++ b/web/src/test/auto/dom/web-test-runner.config.mjs
@@ -33,7 +33,7 @@ export default {
   nodeResolve: true,
   // Top-level, implicit 'default' group
   files: [
-    'src/test/auto/dom/init_check.tests.ts',
+    'web/src/test/auto/dom/init_check.tests.ts',
     // '**/*.tests.html'
   ],
   groups: [
@@ -41,45 +41,50 @@ export default {
       name: 'engine/attachment',
       // Relative, from the containing package.json
       files: [
-        'build/test/dom/cases/attachment/**/*.tests.html',
-        'build/test/dom/cases/attachment/**/*.tests.mjs'
+        'web/build/test/dom/cases/attachment/**/*.tests.html',
+        'web/build/test/dom/cases/attachment/**/*.tests.mjs'
       ]
     },
     {
       name: 'app/browser',
       // Relative, from the containing package.json
-      files: ['build/test/dom/cases/browser/**/*.tests.mjs']
+      files: ['web/build/test/dom/cases/browser/**/*.tests.mjs']
+    },
+    {
+      name: 'engine/core-processor',
+      // Relative, from the containing package.json
+      files: ['web/src/test/auto/dom/cases/core-processor/*.tests.ts']
     },
     {
       name: 'engine/dom-utils',
       // Relative, from the containing package.json
-      files: ['build/test/dom/cases/dom-utils/**/*.tests.mjs']
+      files: ['web/build/test/dom/cases/dom-utils/**/*.tests.mjs']
     },
     {
       name: 'engine/element-wrappers',
       // Relative, from the containing package.json
-      files: ['build/test/dom/cases/element-wrappers/**/*.tests.mjs']
+      files: ['web/build/test/dom/cases/element-wrappers/**/*.tests.mjs']
     },
     {
       name: 'engine/gesture-processor',
       // Relative, from the containing package.json
       // Note: here we use the .tests.html file in the src directory!
-      files: ['src/test/auto/dom/cases/gesture-processor/**/*.tests.html']
+      files: ['web/src/test/auto/dom/cases/gesture-processor/**/*.tests.html']
     },
     {
       name: 'engine/keyboard',
       // Relative, from the containing package.json
-      files: ['build/test/dom/cases/keyboard/**/*.tests.mjs']
+      files: ['web/build/test/dom/cases/keyboard/**/*.tests.mjs']
     },
     {
       name: 'engine/keyboard-storage',
       // Relative, from the containing package.json
-      files: ['build/test/dom/cases/keyboard-storage/**/*.tests.mjs']
+      files: ['web/build/test/dom/cases/keyboard-storage/**/*.tests.mjs']
     },
     {
       name: 'engine/osk',
       // Relative, from the containing package.json
-      files: ['build/test/dom/cases/osk/**/*.tests.mjs']
+      files: ['web/build/test/dom/cases/osk/**/*.tests.mjs']
     }
   ],
   middleware: [
@@ -87,8 +92,16 @@ export default {
     function rewriteResourcePath(context, next) {
       if(context.url.startsWith('/resources/')) {
         context.url = '/web/src/test/auto' + context.url;
+      } else if (context.url.startsWith('/build/')) {
+        context.url = '/web' + context.url;
       }
 
+      return next();
+    },
+    function rewriteWasmContentType(context, next) {
+      if (context.url.endsWith('.wasm')) {
+        context.headers['content-type'] = 'application/wasm';
+      }
       return next();
     }
   ],
diff --git a/web/src/test/auto/headless/README.md b/web/src/test/auto/headless/README.md
new file mode 100644
index 0000000000..e496cf8a2a
--- /dev/null
+++ b/web/src/test/auto/headless/README.md
@@ -0,0 +1,8 @@
+# Headless unit tests
+
+The tests in this directory will be run by the corresponding project
+under `src`.
+
+For example, `src/test/auto/headless/engine/js-processor` are the tests
+for `src/engine/js-processor` and will be run from
+`src/engine/js-processor/build.sh`.
diff --git a/web/src/test/auto/headless/app/browser/hardware-event-processing.tests.ts b/web/src/test/auto/headless/app/browser/hardware-event-processing.tests.ts
index d00425362d..0643c88a86 100644
--- a/web/src/test/auto/headless/app/browser/hardware-event-processing.tests.ts
+++ b/web/src/test/auto/headless/app/browser/hardware-event-processing.tests.ts
@@ -4,7 +4,7 @@ import { preprocessKeyboardEvent } from 'keyman/app/browser';
 import { processForMnemonicsAndLegacy } from 'keyman/engine/main';
 import { PhysicalInputEventSpec } from '@keymanapp/recorder-core';
 import { DeviceSpec } from '@keymanapp/web-utils';
-import { Codes, Keyboard, KeyEvent } from 'keyman/engine/keyboard';
+import { Codes, JSKeyboard, KeyEvent } from 'keyman/engine/keyboard';
 
 const ModifierCodes = Codes.modifierCodes;
 const KeyCodes = Codes.keyCodes;
@@ -24,7 +24,7 @@ describe("app/browser: hardware event processing", () => {
           modifierSet: PhysicalInputEventSpec.modifierCodes.Shift,
           location: 1
         }) as any as KeyboardEvent, {
-          activeKeyboard: new Keyboard({ KM: 0 }),
+          activeKeyboard: new JSKeyboard({ KM: 0 }),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -46,7 +46,7 @@ describe("app/browser: hardware event processing", () => {
           keyCode: KeyCodes.K_A,
           modifierSet: 0
         }) as any as KeyboardEvent, {
-          activeKeyboard: new Keyboard({ KM: 0 }),
+          activeKeyboard: new JSKeyboard({ KM: 0 }),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -66,7 +66,7 @@ describe("app/browser: hardware event processing", () => {
           location: 1
         }) as any as KeyboardEvent, {
           // KMBM:  Keyman Modifier BitMask
-          activeKeyboard: new Keyboard({KM: 0}),
+          activeKeyboard: new JSKeyboard({KM: 0}),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -86,7 +86,7 @@ describe("app/browser: hardware event processing", () => {
           location: 1
         }) as any as KeyboardEvent, {
           // KMBM:  Keyman Modifier BitMask
-          activeKeyboard: new Keyboard({KM: 0}),
+          activeKeyboard: new JSKeyboard({KM: 0}),
           modStateFlags: ModifierCodes.ALT,
           baseLayout: 'us'
         },
@@ -108,7 +108,7 @@ describe("app/browser: hardware event processing", () => {
           location: 1
         }) as any as KeyboardEvent, {
           // KMBM:  Keyman Modifier BitMask
-          activeKeyboard: new Keyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
+          activeKeyboard: new JSKeyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -127,7 +127,7 @@ describe("app/browser: hardware event processing", () => {
           modifierSet: 0
         }) as any as KeyboardEvent, {
           // KMBM:  Keyman Modifier BitMask
-          activeKeyboard: new Keyboard({KM: 0, KMBM: Codes.modifierBitmasks.CHIRAL}),
+          activeKeyboard: new JSKeyboard({KM: 0, KMBM: Codes.modifierBitmasks.CHIRAL}),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -147,7 +147,7 @@ describe("app/browser: hardware event processing", () => {
           location: 1
         }) as any as KeyboardEvent, {
           // KMBM:  Keyman Modifier BitMask
-          activeKeyboard: new Keyboard({KM: 0, KMBM: Codes.modifierBitmasks.CHIRAL}),
+          activeKeyboard: new JSKeyboard({KM: 0, KMBM: Codes.modifierBitmasks.CHIRAL}),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -167,7 +167,7 @@ describe("app/browser: hardware event processing", () => {
           location: 1
         }) as any as KeyboardEvent, {
           // KMBM:  Keyman Modifier BitMask
-          activeKeyboard: new Keyboard({KM: 0, KMBM: Codes.modifierBitmasks.CHIRAL}),
+          activeKeyboard: new JSKeyboard({KM: 0, KMBM: Codes.modifierBitmasks.CHIRAL}),
           modStateFlags: ModifierCodes.LALT,
           baseLayout: 'us'
         },
@@ -188,7 +188,7 @@ describe("app/browser: hardware event processing", () => {
           modifierSet: PhysicalInputEventSpec.modifierCodes.Shift,
           location: 1
         }) as any as KeyboardEvent, {
-          activeKeyboard: new Keyboard({ KM: 1 }),
+          activeKeyboard: new JSKeyboard({ KM: 1 }),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -206,7 +206,7 @@ describe("app/browser: hardware event processing", () => {
           keyCode: KeyCodes.K_A,
           modifierSet: 0
         }) as any as KeyboardEvent, {
-          activeKeyboard: new Keyboard({ KM: 1 }),
+          activeKeyboard: new JSKeyboard({ KM: 1 }),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -227,7 +227,7 @@ describe("app/browser: hardware event processing", () => {
           modifierSet: PhysicalInputEventSpec.modifierCodes.Shift,
           location: 1
         }) as any as KeyboardEvent, {
-          activeKeyboard: new Keyboard({ KM: undefined }),
+          activeKeyboard: new JSKeyboard({ KM: undefined }),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -245,7 +245,7 @@ describe("app/browser: hardware event processing", () => {
           keyCode: KeyCodes.K_A,
           modifierSet: 0
         }) as any as KeyboardEvent, {
-          activeKeyboard: new Keyboard({ KM: undefined }),
+          activeKeyboard: new JSKeyboard({ KM: undefined }),
           modStateFlags: 0,
           baseLayout: 'us'
         },
@@ -264,7 +264,7 @@ describe("app/browser: hardware event processing", () => {
           modifierSet: PhysicalInputEventSpec.modifierCodes.Alt,
           location: 0
         }) as any as KeyboardEvent, {
-          activeKeyboard: new Keyboard({ KM: undefined }),
+          activeKeyboard: new JSKeyboard({ KM: undefined }),
           // Internally assumes that the ALT-press event was previously handled, with this as
           // the resulting modifier state at the time of key-press.
           modStateFlags: ModifierCodes.LALT,
@@ -298,7 +298,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM: 0}),
+          new JSKeyboard({KM: 0}),
           'us'
         );
 
@@ -317,7 +317,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM: 0}),
+          new JSKeyboard({KM: 0}),
           'us'
         );
 
@@ -336,7 +336,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM: 0}),
+          new JSKeyboard({KM: 0}),
           'us'
         );
 
@@ -355,7 +355,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM: 0}),
+          new JSKeyboard({KM: 0}),
           'us'
         );
 
@@ -376,7 +376,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
+          new JSKeyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
           'us'
         );
 
@@ -395,7 +395,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
+          new JSKeyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
           'us'
         );
 
@@ -414,7 +414,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
+          new JSKeyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
           'us'
         );
 
@@ -433,7 +433,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
+          new JSKeyboard({KM:0, KMBM: Codes.modifierBitmasks.CHIRAL}),
           'us'
         );
 
@@ -454,7 +454,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:1}),
+          new JSKeyboard({KM:1}),
           'us'
         );
 
@@ -477,7 +477,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:1}),
+          new JSKeyboard({KM:1}),
           'us'
         );
 
@@ -503,7 +503,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:undefined}),
+          new JSKeyboard({KM:undefined}),
           'us'
         );
 
@@ -527,7 +527,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:undefined}),
+          new JSKeyboard({KM:undefined}),
           'us'
         );
 
@@ -551,7 +551,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:undefined}),
+          new JSKeyboard({KM:undefined}),
           'us'
         );
 
@@ -578,7 +578,7 @@ describe("app/browser: hardware event processing", () => {
 
         const finalKeyEvent = processForMnemonicsAndLegacy(
           baseKeyEvent,
-          new Keyboard({KM:undefined}),
+          new JSKeyboard({KM:undefined}),
           'us'
         );
 
diff --git a/web/src/test/auto/headless/engine/js-processor/basic-engine.tests.js b/web/src/test/auto/headless/engine/js-processor/basic-engine.tests.js
index 09780444d9..123d6c2340 100644
--- a/web/src/test/auto/headless/engine/js-processor/basic-engine.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/basic-engine.tests.js
@@ -6,7 +6,7 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import { MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 import { KeyboardTest, NodeProctor } from '@keymanapp/recorder-core';
 
@@ -28,7 +28,7 @@ describe('Engine - Basic Simulation', function() {
 
   before(async function() {
     // -- START: Standard Recorder-based unit test loading boilerplate --
-    let keyboardLoader = new NodeKeyboardLoader(new KeyboardInterface({}, MinimalKeymanGlobal));
+    let keyboardLoader = new NodeKeyboardLoader(new JSKeyboardInterface({}, MinimalKeymanGlobal));
     let keyboard = await keyboardLoader.loadKeyboardFromPath(KEYMAN_ROOT + '/common/test/' + testSuite.keyboard.filename);
     keyboardWithHarness = keyboardLoader.harness;
     keyboardWithHarness.activeKeyboard = keyboard;
diff --git a/web/src/test/auto/headless/engine/js-processor/basic-init.tests.js b/web/src/test/auto/headless/engine/js-processor/basic-init.tests.js
index 2c0e6ee2f2..15b42dd8f8 100644
--- a/web/src/test/auto/headless/engine/js-processor/basic-init.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/basic-init.tests.js
@@ -3,23 +3,23 @@ import { assert } from 'chai';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
-import { KeyboardProcessor } from 'keyman/engine/js-processor';
+import { JSKeyboardProcessor } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 
 global.keyman = {}; // So that keyboard-based checks against the global `keyman` succeed.
                     // 10.0+ dependent keyboards, like khmer_angkor, will otherwise fail to load.
 
-// Test the KeyboardProcessor interface.
-describe('KeyboardProcessor', function() {
+// Test the JSKeyboardProcessor interface.
+describe('JSKeyboardProcessor', function() {
   describe('[[constructor]]', function () {
     it('should initialize without errors', function () {
-      let kp = new KeyboardProcessor();
+      let kp = new JSKeyboardProcessor();
       assert.isNotNull(kp);
     });
 
     it('has expected default values after initialization', function () {
-      let kp = new KeyboardProcessor();
-      assert.equal('us', kp.baseLayout, 'KeyboardProcessor has unexpected base layout')
+      let kp = new JSKeyboardProcessor();
+      assert.equal('us', kp.baseLayout, 'JSKeyboardProcessor has unexpected base layout')
       assert.isNotNull(global.KeymanWeb, 'KeymanWeb global was not automatically installed');
       assert.equal('default', kp.layerId, 'Default layer is not set to "default"');
       assert.isUndefined(kp.activeKeyboard, 'Initialized with already-active keyboard');
@@ -28,7 +28,7 @@ describe('KeyboardProcessor', function() {
 
   describe('activeKeyboard', function() {
     it('is automatically set (in headless) on keyboard load', async function () {
-      let kp = new KeyboardProcessor();
+      let kp = new JSKeyboardProcessor();
 
       // These two lines will load a keyboard from its file; headless-mode `registerKeyboard` will
       // automatically set the keyboard as active.
diff --git a/web/src/test/auto/headless/engine/js-processor/bundled-module.tests.js b/web/src/test/auto/headless/engine/js-processor/bundled-module.tests.js
index a78f8a6cda..8b7c4d9588 100644
--- a/web/src/test/auto/headless/engine/js-processor/bundled-module.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/bundled-module.tests.js
@@ -15,9 +15,9 @@ var toSupplementaryPairString = function(code){
 let u = toSupplementaryPairString;
 
 describe('Bundled ES Module for js-processor', function() {
-  describe('KeyboardProcessor', function () {
+  describe('JSKeyboardProcessor', function () {
     it('should initialize without errors', function () {
-      let kp = new Package.KeyboardProcessor();
+      let kp = new Package.JSKeyboardProcessor();
       assert.isNotNull(kp);
     });
   });
@@ -45,7 +45,7 @@ describe('Bundled ES Module for js-processor', function() {
 describe('Bundled ES Module for keyboard', function () {
   describe('Keyboard', function () {
     it('should initialize without errors', function () {
-      let kp = new Package2.Keyboard();
+      let kp = new Package2.JSKeyboard();
       assert.isNotNull(kp);
     });
   });
diff --git a/web/src/test/auto/headless/engine/js-processor/chirality.tests.js b/web/src/test/auto/headless/engine/js-processor/chirality.tests.js
index e8a3e30f9e..591b112392 100644
--- a/web/src/test/auto/headless/engine/js-processor/chirality.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/chirality.tests.js
@@ -5,7 +5,7 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import { MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 import { KeyboardTest, NodeProctor } from '@keymanapp/recorder-core';
 import { ModifierKeyConstants } from '@keymanapp/common-types';
@@ -28,7 +28,7 @@ describe('Engine - Chirality', function() {
 
   before(async function() {
     // -- START: Standard Recorder-based unit test loading boilerplate --
-    let keyboardLoader = new NodeKeyboardLoader(new KeyboardInterface({}, MinimalKeymanGlobal));
+    let keyboardLoader = new NodeKeyboardLoader(new JSKeyboardInterface({}, MinimalKeymanGlobal));
     let keyboard = await keyboardLoader.loadKeyboardFromPath(KEYMAN_ROOT + '/common/test/' + testSuite.keyboard.filename);
     keyboardWithHarness = keyboardLoader.harness;
     keyboardWithHarness.activeKeyboard = keyboard;
@@ -53,7 +53,7 @@ describe('Engine - Chirality', function() {
         await set.test(proctor);
       });
     } else {
-      it.skip(set.toTestName() + " - modifier state simulation for OSK not yet supported in headless KeyboardProcessor");
+      it.skip(set.toTestName() + " - modifier state simulation for OSK not yet supported in headless JSKeyboardProcessor");
     }
   }
 
@@ -73,16 +73,16 @@ describe('Engine - Chirality', function() {
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE);
       assert.equal(targetModifiers, mappedModifiers);
 
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | CTRL_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | CTRL_CODE);
       assert.equal(targetModifiers, mappedModifiers);
 
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LCTRL_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LCTRL_CODE);
       assert.equal(targetModifiers, mappedModifiers);
 
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | RCTRL_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | RCTRL_CODE);
       assert.equal(targetModifiers, mappedModifiers);
     });
 
@@ -92,16 +92,16 @@ describe('Engine - Chirality', function() {
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE);
       assert.equal(targetModifiers, mappedModifiers);
 
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | ALT_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | ALT_CODE);
       assert.equal(targetModifiers, mappedModifiers);
 
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE);
       assert.equal(targetModifiers, mappedModifiers);
 
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | RALT_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | RALT_CODE);
       assert.equal(targetModifiers, mappedModifiers);
     });
 
@@ -111,27 +111,27 @@ describe('Engine - Chirality', function() {
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE);
       assert.equal(targetModifiers, mappedModifiers);
 
       let ctrlPlusAlt = ALT_CODE | CTRL_CODE;
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | ctrlPlusAlt);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | ctrlPlusAlt);
       assert.equal(targetModifiers, mappedModifiers);
 
       let leftVariant = LALT_CODE | LCTRL_CODE;
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | leftVariant);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | leftVariant);
       assert.equal(targetModifiers, mappedModifiers);
 
       let rightVariant = RALT_CODE | RCTRL_CODE;
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | rightVariant);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | rightVariant);
       assert.equal(targetModifiers, mappedModifiers);
 
       let mixedVariant1 = LALT_CODE | CTRL_CODE;
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | mixedVariant1);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | mixedVariant1);
       assert.equal(targetModifiers, mappedModifiers);
 
       let mixedVariant2 = ALT_CODE | RCTRL_CODE;
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | mixedVariant2);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | mixedVariant2);
       assert.equal(targetModifiers, mappedModifiers);
     });
 
@@ -142,14 +142,14 @@ describe('Engine - Chirality', function() {
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialCtrlModifiers1, VIRTUAL_KEY_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialCtrlModifiers1, VIRTUAL_KEY_CODE);
       assert.equal(ctrlTargetModifiers, mappedModifiers);
 
       let initialCtrlModifiers2   =  VIRTUAL_KEY_CODE | RCTRL_CODE;
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialCtrlModifiers2, VIRTUAL_KEY_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialCtrlModifiers2, VIRTUAL_KEY_CODE);
       assert.equal(ctrlTargetModifiers, mappedModifiers);
 
       let altTargetModifiers   = VIRTUAL_KEY_CODE | ALT_CODE;
@@ -158,14 +158,14 @@ describe('Engine - Chirality', function() {
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialAltModifiers1, VIRTUAL_KEY_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialAltModifiers1, VIRTUAL_KEY_CODE);
       assert.equal(altTargetModifiers, mappedModifiers);
 
       let initialAltModifiers2 = VIRTUAL_KEY_CODE | RALT_CODE;
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialAltModifiers2, VIRTUAL_KEY_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialAltModifiers2, VIRTUAL_KEY_CODE);
       assert.equal(altTargetModifiers, mappedModifiers);
     });
 
@@ -176,14 +176,14 @@ describe('Engine - Chirality', function() {
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialCtrlModifiers1, VIRTUAL_KEY_CODE | CTRL_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialCtrlModifiers1, VIRTUAL_KEY_CODE | CTRL_CODE);
       assert.equal(ctrlTargetModifiers, mappedModifiers);
 
       let initialCtrlModifiers2 = VIRTUAL_KEY_CODE | RCTRL_CODE;
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialCtrlModifiers2, VIRTUAL_KEY_CODE | CTRL_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialCtrlModifiers2, VIRTUAL_KEY_CODE | CTRL_CODE);
       assert.equal(ctrlTargetModifiers, mappedModifiers);
 
       let altTargetModifiers   = VIRTUAL_KEY_CODE | ALT_CODE;
@@ -192,14 +192,14 @@ describe('Engine - Chirality', function() {
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialAltModifiers1, VIRTUAL_KEY_CODE | ALT_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialAltModifiers1, VIRTUAL_KEY_CODE | ALT_CODE);
       assert.equal(altTargetModifiers, mappedModifiers);
 
       let initialAltModifiers2 = VIRTUAL_KEY_CODE | RALT_CODE;
 
       // We should get the same results whether or not there actually is a corresponding modifier
       // expected by the rule we're examining.
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialAltModifiers2, VIRTUAL_KEY_CODE | ALT_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialAltModifiers2, VIRTUAL_KEY_CODE | ALT_CODE);
       assert.equal(altTargetModifiers, mappedModifiers);
     });
 
@@ -208,10 +208,10 @@ describe('Engine - Chirality', function() {
 
       let targetModifiers  = VIRTUAL_KEY_CODE | ALT_CODE | CTRL_CODE;
 
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE | LCTRL_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE | LCTRL_CODE);
       assert.equal(targetModifiers, mappedModifiers);
 
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | RALT_CODE | RCTRL_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | RALT_CODE | RCTRL_CODE);
       assert.equal(targetModifiers, mappedModifiers);
     });
 
@@ -220,10 +220,10 @@ describe('Engine - Chirality', function() {
 
       let targetModifiers  = VIRTUAL_KEY_CODE | LALT_CODE | LCTRL_CODE;
 
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE | LCTRL_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE | LCTRL_CODE);
       assert.equal(targetModifiers, mappedModifiers);
 
-      mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | RALT_CODE | RCTRL_CODE);
+      mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | RALT_CODE | RCTRL_CODE);
       assert.equal(targetModifiers, mappedModifiers);
     });
 
@@ -232,7 +232,7 @@ describe('Engine - Chirality', function() {
 
       let modifierTarget   = VIRTUAL_KEY_CODE | LALT_CODE |  CTRL_CODE;
 
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE | CTRL_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE | CTRL_CODE);
       assert.equal(modifierTarget, mappedModifiers);
     });
 
@@ -241,7 +241,7 @@ describe('Engine - Chirality', function() {
 
       let modifierTarget   = VIRTUAL_KEY_CODE |  ALT_CODE | LCTRL_CODE;
 
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | ALT_CODE | RCTRL_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | ALT_CODE | RCTRL_CODE);
       assert.equal(modifierTarget, mappedModifiers);
     });
 
@@ -250,7 +250,7 @@ describe('Engine - Chirality', function() {
 
       let modifierTarget   = VIRTUAL_KEY_CODE | ALT_CODE | LCTRL_CODE | SHIFT_CODE;
 
-      let mappedModifiers = KeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE | RCTRL_CODE);
+      let mappedModifiers = JSKeyboardInterface.matchModifiersToRuleChirality(initialModifiers, VIRTUAL_KEY_CODE | LALT_CODE | RCTRL_CODE);
       assert.equal(modifierTarget, mappedModifiers);
     });
   });
diff --git a/web/src/test/auto/headless/engine/js-processor/deadkeys.tests.js b/web/src/test/auto/headless/engine/js-processor/deadkeys.tests.js
index 007a4ec9ec..25ae78abde 100644
--- a/web/src/test/auto/headless/engine/js-processor/deadkeys.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/deadkeys.tests.js
@@ -5,7 +5,7 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import { MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 import { KeyboardTest, NodeProctor } from '@keymanapp/recorder-core';
 
@@ -27,7 +27,7 @@ describe('Engine - Deadkeys', function() {
 
   before(async function() {
     // -- START: Standard Recorder-based unit test loading boilerplate --
-    let keyboardLoader = new NodeKeyboardLoader(new KeyboardInterface({}, MinimalKeymanGlobal));
+    let keyboardLoader = new NodeKeyboardLoader(new JSKeyboardInterface({}, MinimalKeymanGlobal));
     let keyboard = await keyboardLoader.loadKeyboardFromPath(KEYMAN_ROOT + '/common/test/' + testSuite.keyboard.filename);
     keyboardWithHarness = keyboardLoader.harness;
     keyboardWithHarness.activeKeyboard = keyboard;
diff --git a/web/src/test/auto/headless/engine/js-processor/engine/context.tests.js b/web/src/test/auto/headless/engine/js-processor/engine/context.tests.js
index b09a20c01e..4469194a6d 100644
--- a/web/src/test/auto/headless/engine/js-processor/engine/context.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/engine/context.tests.js
@@ -4,7 +4,7 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import { MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface, KeyboardProcessor, Mock } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface, JSKeyboardProcessor, Mock } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 
 import { NodeProctor, RecordedKeystrokeSequence } from '@keymanapp/recorder-core';
@@ -16,7 +16,7 @@ const NUL = '\uFFFE';
  * ---------------------
  *
  * This suite contains two types of tests, both designed to test all possible variations
- * of behaviors that `KeyboardInterface.fullContextMatch` may be expected to handle.
+ * of behaviors that `JSKeyboardInterface.fullContextMatch` may be expected to handle.
  *
  * Type 1:  White-box tests for validity of the generated context-cache
  * - uses only the `baseSequence` of each test spec definition; does not
@@ -65,7 +65,7 @@ function runEngineRuleSet(ruleSet, defaultNoun) {
       ruleSeq.test(proctor, target);
 
       // Now for the real test!
-      let processor = new KeyboardProcessor(device);
+      let processor = new JSKeyboardProcessor(device);
       processor.keyboardInterface = keyboardWithHarness;
       var res = processor.keyboardInterface.fullContextMatch(ruleDef.n, target, ruleDef.rule);
 
@@ -1101,7 +1101,7 @@ var NOTANY_NUL_RULE_SET = [ NOTANY_NUL_TEST_1, NOTANY_NUL_TEST_2, NOTANY_NUL_TES
 
 describe('Engine - Context Matching', function() {
   before(async function() {
-    let keyboardLoader = new NodeKeyboardLoader(new KeyboardInterface({}, MinimalKeymanGlobal));
+    let keyboardLoader = new NodeKeyboardLoader(new JSKeyboardInterface({}, MinimalKeymanGlobal));
     const keyboard = await keyboardLoader.loadKeyboardFromPath(require.resolve('@keymanapp/common-test-resources/keyboards/test_simple_deadkeys.js'));
     keyboardWithHarness = keyboardLoader.harness;
     keyboardWithHarness.activeKeyboard = keyboard;
@@ -1122,7 +1122,7 @@ describe('Engine - Context Matching', function() {
       ruleSeq.test(proctor, target);
 
       // Now for the real test!
-      let processor = new KeyboardProcessor(device);
+      let processor = new JSKeyboardProcessor(device);
       processor.keyboardInterface = keyboardWithHarness;
       var res = processor.keyboardInterface._BuildExtendedContext(ruleDef.n, ruleDef.ln, target);
 
diff --git a/web/src/test/auto/headless/engine/js-processor/engine/notany_context.tests.js b/web/src/test/auto/headless/engine/js-processor/engine/notany_context.tests.js
index 2d414e2aef..8264de4efe 100644
--- a/web/src/test/auto/headless/engine/js-processor/engine/notany_context.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/engine/notany_context.tests.js
@@ -4,7 +4,7 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import { MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface, Mock } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface, Mock } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 import { NodeProctor, RecordedKeystrokeSequence } from '@keymanapp/recorder-core';
 
@@ -52,7 +52,7 @@ function runStringRuleSet(input, output) {
 
 describe('Engine - notany() and context()', function() {
   before(async function() {
-    let keyboardLoader = new NodeKeyboardLoader(new KeyboardInterface({}, MinimalKeymanGlobal));
+    let keyboardLoader = new NodeKeyboardLoader(new JSKeyboardInterface({}, MinimalKeymanGlobal));
     const keyboard = await keyboardLoader.loadKeyboardFromPath(require.resolve('@keymanapp/common-test-resources/keyboards/test_917.js'));
     keyboardWithHarness = keyboardLoader.harness;
     keyboardWithHarness.activeKeyboard = keyboard;
diff --git a/web/src/test/auto/headless/engine/js-processor/engine/stores.tests.js b/web/src/test/auto/headless/engine/js-processor/engine/stores.tests.js
index eb1ad139eb..55a86ba036 100644
--- a/web/src/test/auto/headless/engine/js-processor/engine/stores.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/engine/stores.tests.js
@@ -1,7 +1,7 @@
 import { assert } from 'chai';
 
-import { Keyboard, KMWString } from 'keyman/engine/keyboard';
-import { KeyboardProcessor } from 'keyman/engine/js-processor';
+import { JSKeyboard, KMWString } from 'keyman/engine/keyboard';
+import { JSKeyboardProcessor } from 'keyman/engine/js-processor';
 
 let device = {
   formFactor: 'desktop',
@@ -18,10 +18,10 @@ describe('Engine - Stores', function() {
   }
 
   it('Store \'Explosion\'', function() {
-    let processor = new KeyboardProcessor(device);
+    let processor = new JSKeyboardProcessor(device);
     // A 'hollow' Keyboard that only follows default rules.  That said, we need a Keyboard
     // instance to host cache data for our exploded store tests.
-    processor.activeKeyboard = new Keyboard();
+    processor.activeKeyboard = new JSKeyboard();
 
     // Function defined at top of file; creates supplementary pairs for extended Unicode codepoints.
     var u = toSupplementaryPairString;
diff --git a/web/src/test/auto/headless/engine/js-processor/engine/unmatched_final_group.tests.js b/web/src/test/auto/headless/engine/js-processor/engine/unmatched_final_group.tests.js
index fd2536ec22..83936da36f 100644
--- a/web/src/test/auto/headless/engine/js-processor/engine/unmatched_final_group.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/engine/unmatched_final_group.tests.js
@@ -5,7 +5,7 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import { MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 import { KeyboardTest, NodeProctor } from '@keymanapp/recorder-core';
 
@@ -26,7 +26,7 @@ describe('Engine - Unmatched Final Groups', function() {
 
   before(async function() {
     // -- START: Standard Recorder-based unit test loading boilerplate --
-    let keyboardLoader = new NodeKeyboardLoader(new KeyboardInterface({}, MinimalKeymanGlobal));
+    let keyboardLoader = new NodeKeyboardLoader(new JSKeyboardInterface({}, MinimalKeymanGlobal));
     const keyboard = await keyboardLoader.loadKeyboardFromPath(KEYMAN_ROOT + '/common/test/' + testSuite.keyboard.filename);
     keyboardWithHarness = keyboardLoader.harness;
     keyboardWithHarness.activeKeyboard = keyboard;
diff --git a/web/src/test/auto/headless/engine/js-processor/kbdInterface.tests.js b/web/src/test/auto/headless/engine/js-processor/kbdInterface.tests.ts
similarity index 64%
rename from web/src/test/auto/headless/engine/js-processor/kbdInterface.tests.js
rename to web/src/test/auto/headless/engine/js-processor/kbdInterface.tests.ts
index 0d08496442..b8a68dd55c 100644
--- a/web/src/test/auto/headless/engine/js-processor/kbdInterface.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/kbdInterface.tests.ts
@@ -3,30 +3,31 @@ import { assert } from 'chai';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
-import { MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface, Mock } from 'keyman/engine/js-processor';
+import { DeviceSpec, JSKeyboard, MinimalKeymanGlobal } from 'keyman/engine/keyboard';
+import { JSKeyboardInterface, Mock } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 
 describe('Headless keyboard loading', function () {
   const laoPath = require.resolve('@keymanapp/common-test-resources/keyboards/lao_2008_basic.js');
   const khmerPath = require.resolve('@keymanapp/common-test-resources/keyboards/khmer_angkor.js');
   const nonKeyboardPath = require.resolve('@keymanapp/common-test-resources/index.mjs');
-  const ipaPath = require.resolve('@keymanapp/common-test-resources/keyboards/sil_ipa.js');
+  // const ipaPath = require.resolve('@keymanapp/common-test-resources/keyboards/sil_ipa.js');
   // Common test suite setup.
 
-  let device = {
-    formFactor: 'desktop',
-    OS: 'windows',
-    browser: 'native'
+  const device = {
+    formFactor: DeviceSpec.FormFactor.Desktop,
+    OS: DeviceSpec.OperatingSystem.Windows,
+    browser: DeviceSpec.Browser.Native,
+    touchable: false
   }
 
   describe('Full harness loading', () => {
     it('successfully loads', async function () {
       // -- START: Standard Recorder-based unit test loading boilerplate --
-      let harness = new KeyboardInterface({}, MinimalKeymanGlobal);
-      let keyboardLoader = new NodeKeyboardLoader(harness);
-      let keyboard = await keyboardLoader.loadKeyboardFromPath(laoPath);
-      harness.activeKeyboard = keyboard;
+      const jsHarness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
+      const keyboardLoader = new NodeKeyboardLoader(jsHarness);
+      const keyboard = await keyboardLoader.loadKeyboardFromPath(laoPath);
+      jsHarness.activeKeyboard = keyboard as JSKeyboard;
       // --  END:  Standard Recorder-based unit test loading boilerplate --
 
       // This part provides assurance that the keyboard properly loaded.
@@ -35,19 +36,19 @@ describe('Headless keyboard loading', function () {
 
     it('can evaluate rules', async function () {
       // -- START: Standard Recorder-based unit test loading boilerplate --
-      let harness = new KeyboardInterface({}, MinimalKeymanGlobal);
-      let keyboardLoader = new NodeKeyboardLoader(harness);
-      let keyboard = await keyboardLoader.loadKeyboardFromPath(laoPath);
-      harness.activeKeyboard = keyboard;
+      const harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
+      const keyboardLoader = new NodeKeyboardLoader(harness);
+      const keyboard = await keyboardLoader.loadKeyboardFromPath(laoPath);
+      harness.activeKeyboard = keyboard as JSKeyboard;
       // --  END:  Standard Recorder-based unit test loading boilerplate --
 
       // Runs a blank KeyEvent through the keyboard's rule processing.
-      harness.processKeystroke(new Mock(), keyboard.constructNullKeyEvent(device));
+      harness.processKeystroke(new Mock(), (keyboard as JSKeyboard).constructNullKeyEvent(device));
     });
 
     it('does not change the active kehboard', async function () {
-      let harness = new KeyboardInterface({}, MinimalKeymanGlobal);
-      let keyboardLoader = new NodeKeyboardLoader(harness);
+      const harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
+      const keyboardLoader = new NodeKeyboardLoader(harness);
       const lao_keyboard = await keyboardLoader.loadKeyboardFromPath(laoPath);
       assert.isNotOk(harness.activeKeyboard);
       assert.isOk(lao_keyboard);
@@ -55,7 +56,7 @@ describe('Headless keyboard loading', function () {
       // This part provides assurance that the keyboard properly loaded.
       assert.equal(lao_keyboard.id, "Keyboard_lao_2008_basic");
 
-      harness.activeKeyboard = lao_keyboard;
+      harness.activeKeyboard = lao_keyboard as JSKeyboard;
 
       const khmer_keyboard = await keyboardLoader.loadKeyboardFromPath(khmerPath);
       assert.strictEqual(lao_keyboard, harness.activeKeyboard);
@@ -66,8 +67,8 @@ describe('Headless keyboard loading', function () {
     it('throws distinct errors', async function () {
       const invalidPath = 'totally_invalid_path.js';
 
-      let harness = new KeyboardInterface({}, MinimalKeymanGlobal);
-      let keyboardLoader = new NodeKeyboardLoader(harness);
+      const harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
+      const keyboardLoader = new NodeKeyboardLoader(harness);
       let missingError;
       try {
         await keyboardLoader.loadKeyboardFromPath(invalidPath);
diff --git a/web/src/test/auto/headless/engine/js-processor/non-positional-rules.tests.js b/web/src/test/auto/headless/engine/js-processor/non-positional-rules.tests.js
index a65cec6708..1d320e0b93 100644
--- a/web/src/test/auto/headless/engine/js-processor/non-positional-rules.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/non-positional-rules.tests.js
@@ -5,7 +5,7 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import { Codes, KeyEvent, MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface, Mock } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface, Mock } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 
 // Compare and contrast the unit tests here with those for app/browser key-event unit testing
@@ -27,7 +27,7 @@ describe('Engine - rule processing', function() {
 
     before(async () => {
       // -- START: Standard keyboard unit test loading boilerplate --
-      let harness = new KeyboardInterface({}, MinimalKeymanGlobal);
+      let harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
       let keyboardLoader = new NodeKeyboardLoader(harness);
       let keyboard = await keyboardLoader.loadKeyboardFromPath(ipaPath);
       // --  END:  Standard keyboard unit test loading boilerplate --
@@ -106,7 +106,7 @@ describe('Engine - rule processing', function() {
 
     before(async () => {
       // -- START: Standard keyboard unit test loading boilerplate --
-      let harness = new KeyboardInterface({}, MinimalKeymanGlobal);
+      let harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
       let keyboardLoader = new NodeKeyboardLoader(harness);
       let keyboard = await keyboardLoader.loadKeyboardFromPath(armenianPath);
       // --  END:  Standard keyboard unit test loading boilerplate --
diff --git a/web/src/test/auto/headless/engine/js-processor/specialized-backspace.tests.js b/web/src/test/auto/headless/engine/js-processor/specialized-backspace.tests.js
index 005a197b0f..0d573ad370 100644
--- a/web/src/test/auto/headless/engine/js-processor/specialized-backspace.tests.js
+++ b/web/src/test/auto/headless/engine/js-processor/specialized-backspace.tests.js
@@ -6,7 +6,7 @@ const require = createRequire(import.meta.url);
 
 import { KMWString } from '@keymanapp/web-utils';
 import { Codes, KeyEvent, MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface, KeyboardProcessor, Mock } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface, JSKeyboardProcessor, Mock } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 import { ModifierKeyConstants } from '@keymanapp/common-types';
 
@@ -81,7 +81,7 @@ describe('Engine - specialized backspace handling', function() {
 
   before(async () => {
     // -- START: Standard keyboard unit test loading boilerplate --
-    let harness = new KeyboardInterface({}, MinimalKeymanGlobal);
+    let harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
     let keyboardLoader = new NodeKeyboardLoader(harness);
     let keyboard = await keyboardLoader.loadKeyboardFromPath(ipaPath);
     // --  END:  Standard keyboard unit test loading boilerplate --
@@ -95,7 +95,7 @@ describe('Engine - specialized backspace handling', function() {
     // --------------
 
     // -- START: Standard keyboard unit test loading boilerplate --
-    harness = new KeyboardInterface({}, MinimalKeymanGlobal);
+    harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
     keyboardLoader = new NodeKeyboardLoader(harness);
     keyboard = await keyboardLoader.loadKeyboardFromPath(angkorPath);
     // --  END:  Standard keyboard unit test loading boilerplate --
@@ -108,7 +108,7 @@ describe('Engine - specialized backspace handling', function() {
 
     // --------------
 
-    harness = new KeyboardInterface(globalThis, MinimalKeymanGlobal);
+    harness = new JSKeyboardInterface(globalThis, MinimalKeymanGlobal);
     harness.install();
     // Sets the keyboard as the harness's "loaded" keyboard, but not "active".
     harness.KR(new DUMMIED_KEYS_KEYBOARD_SCRIPT());
@@ -118,7 +118,7 @@ describe('Engine - specialized backspace handling', function() {
 
     // --------------
 
-    harness = new KeyboardInterface(globalThis, MinimalKeymanGlobal);
+    harness = new JSKeyboardInterface(globalThis, MinimalKeymanGlobal);
     harness.install();
     // Sets the keyboard as the harness's "loaded" keyboard, but not "active".
     harness.KR(new DOUBLED_BKSP_KEYBOARD_SCRIPT());
@@ -139,7 +139,7 @@ describe('Engine - specialized backspace handling', function() {
       device: device
     });
 
-    const processor = new KeyboardProcessor(TEST_DEVICE, {
+    const processor = new JSKeyboardProcessor(TEST_DEVICE, {
       keyboardInterface: angkorWithHarness
     });
     const result = processor.processKeystroke(event, contextSource);
@@ -170,7 +170,7 @@ describe('Engine - specialized backspace handling', function() {
     // A specialized test keyboard that handles keys without emitting any content.
     // We want to ensure error cases without output, on null context, don't act
     // like backspaces.
-    const processor = new KeyboardProcessor(TEST_DEVICE, {
+    const processor = new JSKeyboardProcessor(TEST_DEVICE, {
       keyboardInterface: dummiedWithHarness
     });
     const result = processor.processKeystroke(event, contextSource);
@@ -202,7 +202,7 @@ describe('Engine - specialized backspace handling', function() {
       device: device
     });
 
-    const processor = new KeyboardProcessor(TEST_DEVICE, {
+    const processor = new JSKeyboardProcessor(TEST_DEVICE, {
       keyboardInterface: angkorWithHarness
     });
     const result = processor.processKeystroke(event, contextSource);
@@ -237,7 +237,7 @@ describe('Engine - specialized backspace handling', function() {
       device: device
     });
 
-    const processor = new KeyboardProcessor(TEST_DEVICE, {
+    const processor = new JSKeyboardProcessor(TEST_DEVICE, {
       keyboardInterface: angkorWithHarness
     });
     const result = processor.processKeystroke(event, contextSource);
@@ -265,7 +265,7 @@ describe('Engine - specialized backspace handling', function() {
       device: device
     });
 
-    const processor = new KeyboardProcessor(TEST_DEVICE, {
+    const processor = new JSKeyboardProcessor(TEST_DEVICE, {
       keyboardInterface: ipaWithHarness
     });
     const result = processor.processKeystroke(event, contextSource);
@@ -296,7 +296,7 @@ describe('Engine - specialized backspace handling', function() {
     // A specialized test keyboard that duplicates backspaces when sufficient
     // context exists.
 
-    const processor = new KeyboardProcessor(TEST_DEVICE, {
+    const processor = new JSKeyboardProcessor(TEST_DEVICE, {
       keyboardInterface: bksp2xWithHarness
     });
     const result = processor.processKeystroke(event, contextSource);
@@ -331,7 +331,7 @@ describe('Engine - specialized backspace handling', function() {
     // A specialized test keyboard that handles keys without emitting any content.
     // We want to ensure error cases without output, on null context, don't act
     // like backspaces.
-    const processor = new KeyboardProcessor(TEST_DEVICE, {
+    const processor = new JSKeyboardProcessor(TEST_DEVICE, {
       keyboardInterface: dummiedWithHarness
     });
     const result = processor.processKeystroke(event, contextSource);
diff --git a/web/src/test/auto/headless/engine/keyboard-storage/stubAndKeyboardCache.tests.js b/web/src/test/auto/headless/engine/keyboard-storage/stubAndKeyboardCache.tests.js
index 7260b9982e..d8b52dea37 100644
--- a/web/src/test/auto/headless/engine/keyboard-storage/stubAndKeyboardCache.tests.js
+++ b/web/src/test/auto/headless/engine/keyboard-storage/stubAndKeyboardCache.tests.js
@@ -62,7 +62,7 @@ describe('StubAndKeyboardCache', function () {
     assert.strictEqual(cache.defaultStub, galaxie_stub);
   });
 
-  it('loads & caches `Keyboard`s, `Keyboard` promise pending resolution', async () => {
+  it('loads & caches `JSKeyboard`s, `JSKeyboard` promise pending resolution', async () => {
     let keyboardLoader = new NodeKeyboardLoader(new KeyboardHarness({}, MinimalKeymanGlobal));
     const cache = new StubAndKeyboardCache(keyboardLoader);
 
diff --git a/web/src/test/auto/headless/engine/keyboard/keyboard-loading.tests.js b/web/src/test/auto/headless/engine/keyboard/keyboard-loading.tests.js
index 0dd89a3614..f319b20731 100644
--- a/web/src/test/auto/headless/engine/keyboard/keyboard-loading.tests.js
+++ b/web/src/test/auto/headless/engine/keyboard/keyboard-loading.tests.js
@@ -4,7 +4,7 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import { KeyboardHarness, MinimalKeymanGlobal } from 'keyman/engine/keyboard';
-import { KeyboardInterface, Mock } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface, Mock } from 'keyman/engine/js-processor';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 
 describe('Headless keyboard loading', function() {
@@ -58,7 +58,7 @@ describe('Headless keyboard loading', function() {
 
       // Runs a blank KeyEvent through the keyboard's rule processing...
       // but via separate harness configured with a different captured global.
-      let ruleHarness = new KeyboardInterface({}, MinimalKeymanGlobal);
+      let ruleHarness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
       ruleHarness.activeKeyboard = keyboard;
       try {
         ruleHarness.processKeystroke(new Mock(), keyboard.constructNullKeyEvent(device));
diff --git a/web/src/test/auto/headless/engine/keyboard/keyboard.tests.ts b/web/src/test/auto/headless/engine/keyboard/keyboard.tests.ts
new file mode 100644
index 0000000000..3ebeaaa58f
--- /dev/null
+++ b/web/src/test/auto/headless/engine/keyboard/keyboard.tests.ts
@@ -0,0 +1,35 @@
+import { assert } from 'chai';
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+import { KeyboardHarness, MinimalKeymanGlobal, DeviceSpec, JSKeyboard } from 'keyman/engine/keyboard';
+import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
+
+
+describe('Keyboard tests', function () {
+  const khmerPath = require.resolve('@keymanapp/common-test-resources/keyboards/khmer_angkor.js');
+
+  it('accurately determines layout properties', async () => {
+    // -- START: Standard Recorder-based unit test loading boilerplate --
+    const harness = new KeyboardHarness({}, MinimalKeymanGlobal);
+    const keyboardLoader = new NodeKeyboardLoader(harness);
+    const keyboard = await keyboardLoader.loadKeyboardFromPath(khmerPath);
+    const km_keyboard = keyboard as JSKeyboard;
+    // --  END:  Standard Recorder-based unit test loading boilerplate --
+
+    // `khmer_angkor` - supports longpresses, but not flicks or multitaps.
+
+    // Phone supports longpress if the keyboard supports it.
+    const mobileLayout = km_keyboard.layout(DeviceSpec.FormFactor.Phone);
+    assert.isTrue(mobileLayout.hasLongpresses);
+    assert.isFalse(mobileLayout.hasFlicks);
+    assert.isFalse(mobileLayout.hasMultitaps);
+
+    // Desktop doesn't support longpress even if the keyboard supports it.
+    const desktopLayout = km_keyboard.layout(DeviceSpec.FormFactor.Desktop);
+    assert.isFalse(desktopLayout.hasLongpresses);
+    assert.isFalse(desktopLayout.hasFlicks);
+    assert.isFalse(desktopLayout.hasMultitaps);
+  });
+});
diff --git a/web/src/test/auto/headless/engine/keyboard/keyboardLoaderBase.tests.ts b/web/src/test/auto/headless/engine/keyboard/keyboardLoaderBase.tests.ts
new file mode 100644
index 0000000000..76d5fdc1b1
--- /dev/null
+++ b/web/src/test/auto/headless/engine/keyboard/keyboardLoaderBase.tests.ts
@@ -0,0 +1,90 @@
+import { assert } from 'chai';
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+import { KeyboardHarness, MinimalKeymanGlobal, KeyboardDownloadError, DeviceSpec, InvalidKeyboardError, JSKeyboard } from 'keyman/engine/keyboard';
+import { JSKeyboardInterface, Mock } from 'keyman/engine/js-processor';
+import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
+import { assertThrowsAsync, assertThrows } from 'keyman/tools/testing/test-utils';
+
+describe('Headless keyboard loading', function() {
+  const laoPath = require.resolve('@keymanapp/common-test-resources/keyboards/lao_2008_basic.js');
+  const nonKeyboardPath = require.resolve('@keymanapp/common-test-resources/index.mjs');
+  const ipaPath = require.resolve('@keymanapp/common-test-resources/keyboards/sil_ipa.js');
+  const nonExisting = '/does/not/exist.js';
+  // Common test suite setup.
+
+  const device = {
+    formFactor: DeviceSpec.FormFactor.Desktop,
+    OS: DeviceSpec.OperatingSystem.Windows,
+    browser: DeviceSpec.Browser.Native,
+    touchable: false
+  }
+
+  describe('Minimal harness loading', () => {
+    it('successfully loads a single keyboard from filesystem', async ()  => {
+      // -- START: Standard Recorder-based unit test loading boilerplate --
+      const harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
+      const keyboardLoader = new NodeKeyboardLoader(harness);
+      const keyboard = await keyboardLoader.loadKeyboardFromPath(laoPath);
+      // --  END:  Standard Recorder-based unit test loading boilerplate --
+
+      // Asserts that the harness's loading field is cleared once the load is complete.
+      assert.isNotOk(harness.loadedKeyboard);
+
+      // Asserts that the `activeKeyboard` field was not set by the operation.
+      assert.isNotOk(harness.activeKeyboard);
+
+      // This part provides assurance that the keyboard properly loaded.
+      assert.equal(keyboard.id, "Keyboard_lao_2008_basic");
+    });
+
+    it('throws error when keyboard does not exist', async () => {
+      const harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
+      const keyboardLoader = new NodeKeyboardLoader(harness);
+
+      await assertThrowsAsync(async () => await keyboardLoader.loadKeyboardFromPath(nonExisting),
+        KeyboardDownloadError, `Unable to download keyboard at ${nonExisting}`);
+    });
+
+    it('throws error when keyboard is invalid', async () => {
+      const harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
+      const keyboardLoader = new NodeKeyboardLoader(harness);
+
+      await assertThrowsAsync(async () => await keyboardLoader.loadKeyboardFromPath(nonKeyboardPath),
+        InvalidKeyboardError, `${nonKeyboardPath} is not a valid keyboard file`);
+    });
+
+    it('successfully loads (has variable stores)', async () => {
+      // -- START: Standard Recorder-based unit test loading boilerplate --
+      const harness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
+      const keyboardLoader = new NodeKeyboardLoader(harness);
+      const keyboard = await keyboardLoader.loadKeyboardFromPath(ipaPath);
+      // --  END:  Standard Recorder-based unit test loading boilerplate --
+
+      // This part provides extra assurance that the keyboard properly loaded.
+      assert.equal(keyboard.id, "Keyboard_sil_ipa");
+    });
+
+    // TODO-WEB-CORE: figure out what the purpose of this test is
+    // TODO-WEB-CORE: move to kbdInterface.tests.ts
+    it('cannot evaluate rules', async function() {
+      // -- START: Standard Recorder-based unit test loading boilerplate --
+      const harness = new KeyboardHarness({}, MinimalKeymanGlobal);
+      const keyboardLoader = new NodeKeyboardLoader(harness);
+      const keyboard = await keyboardLoader.loadKeyboardFromPath(laoPath);
+      // --  END:  Standard Recorder-based unit test loading boilerplate --
+
+      assert.instanceOf(keyboard, JSKeyboard);
+      // Runs a blank KeyEvent through the keyboard's rule processing...
+      // but via separate harness configured with a different captured global.
+      // This shows an important detail: the 'global' object is effectively
+      // closure-captured. (Similar constraints may occur when experimenting with
+      // 'sandboxed' keyboard loading in the DOM!)
+      const ruleHarness = new JSKeyboardInterface({}, MinimalKeymanGlobal);
+      ruleHarness.activeKeyboard = keyboard as JSKeyboard;
+      assertThrows(() => ruleHarness.processKeystroke(new Mock(), (keyboard as JSKeyboard).constructNullKeyEvent(device)), 'k.KKM is not a function');
+    });
+  });
+});
diff --git a/web/src/test/auto/headless/engine/main/headless/inputProcessor.tests.js b/web/src/test/auto/headless/engine/main/headless/inputProcessor.tests.js
index 39db5d8c6e..eafd740ced 100644
--- a/web/src/test/auto/headless/engine/main/headless/inputProcessor.tests.js
+++ b/web/src/test/auto/headless/engine/main/headless/inputProcessor.tests.js
@@ -5,7 +5,7 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import { InputProcessor } from 'keyman/engine/main';
-import { KeyboardInterface, Mock } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface, Mock } from 'keyman/engine/js-processor';
 import { MinimalKeymanGlobal } from 'keyman/engine/keyboard';
 import { NodeKeyboardLoader } from 'keyman/engine/keyboard/node-keyboard-loader';
 import { KeyboardTest } from '@keymanapp/recorder-core';
@@ -27,7 +27,7 @@ let device = {
 // Initialize supplementary plane string extensions
 KMWString.enableSupplementaryPlane(false);
 
-// Test the KeyboardProcessor interface.
+// Test the JSKeyboardProcessor interface.
 describe('InputProcessor', function() {
   describe('[[constructor]]', function () {
     it('should initialize without errors', function () {
@@ -51,7 +51,7 @@ describe('InputProcessor', function() {
 
         // These checks are lifted from the keyboard init checks found in
         // web/src/test/auto/headless/engine/js-processor/basic-init.js.
-        assert.equal('us', core.keyboardProcessor.baseLayout, 'KeyboardProcessor has unexpected base layout')
+        assert.equal('us', core.keyboardProcessor.baseLayout, 'JSKeyboardProcessor has unexpected base layout')
         assert.isNotNull(global.KeymanWeb, 'KeymanWeb global was not automatically installed');
         assert.equal('default', core.keyboardProcessor.layerId, 'Default layer is not set to "default"');
         assert.isUndefined(core.keyboardProcessor.activeKeyboard, 'Initialized with already-active keyboard');
@@ -94,7 +94,7 @@ describe('InputProcessor', function() {
       }
 
       // Load the keyboard.
-      let keyboardLoader = new NodeKeyboardLoader(new KeyboardInterface({}, MinimalKeymanGlobal));
+      let keyboardLoader = new NodeKeyboardLoader(new JSKeyboardInterface({}, MinimalKeymanGlobal));
       const keyboard = await keyboardLoader.loadKeyboardFromPath(require.resolve('@keymanapp/common-test-resources/keyboards/test_chirality.js'));
       keyboardWithHarness = keyboardLoader.harness;
       keyboardWithHarness.activeKeyboard = keyboard;
@@ -184,12 +184,12 @@ describe('InputProcessor', function() {
     let keyboardWithHarness;
     let testJSONtext = fs.readFileSync(require.resolve('@keymanapp/common-test-resources/json/engine_tests/8568_deadkeys.json'));
     // For convenience we define the key sequence in a test file although we don't use the
-    // rest of the recorder stuff since it uses only KeyboardProcessor, not InputProcessor.
+    // rest of the recorder stuff since it uses only JSKeyboardProcessor, not InputProcessor.
     let testDefinitions = new KeyboardTest(JSON.parse(testJSONtext));
 
     before(async function () {
       // Load the keyboard.
-      let keyboardLoader = new NodeKeyboardLoader(new KeyboardInterface({}, MinimalKeymanGlobal));
+      let keyboardLoader = new NodeKeyboardLoader(new JSKeyboardInterface({}, MinimalKeymanGlobal));
       const keyboard = await keyboardLoader.loadKeyboardFromPath(require.resolve('@keymanapp/common-test-resources/keyboards/test_8568_deadkeys.js'));
       keyboardWithHarness = keyboardLoader.harness;
       keyboardWithHarness.activeKeyboard = keyboard;
diff --git a/web/src/test/auto/headless/engine/main/headless/languageProcessor.tests.js b/web/src/test/auto/headless/engine/main/headless/languageProcessor.tests.js
index 6d866ef8ed..5707fb31f7 100644
--- a/web/src/test/auto/headless/engine/main/headless/languageProcessor.tests.js
+++ b/web/src/test/auto/headless/engine/main/headless/languageProcessor.tests.js
@@ -19,7 +19,7 @@ const KEYMAN_ROOT = env.KEYMAN_ROOT;
 global.keyman = {}; // So that keyboard-based checks against the global `keyman` succeed.
                     // 10.0+ dependent keyboards, like khmer_angkor, will otherwise fail to load.
 
-// Test the KeyboardProcessor interface.
+// Test the JSKeyboardProcessor interface.
 describe('LanguageProcessor', function() {
   let languageProcessor;
   const callbacks = new TestCompilerCallbacks();
diff --git a/web/src/test/auto/headless/engine/osk/visualKeyboard.tests.ts b/web/src/test/auto/headless/engine/osk/visualKeyboard.tests.ts
index 991c4be98b..bbd7c7d93c 100644
--- a/web/src/test/auto/headless/engine/osk/visualKeyboard.tests.ts
+++ b/web/src/test/auto/headless/engine/osk/visualKeyboard.tests.ts
@@ -7,7 +7,7 @@ import sinon from 'sinon';
 import { JSDOM } from 'jsdom';
 
 import { VisualKeyboard } from 'keyman/engine/osk';
-import { ActiveLayout, Keyboard, KeyboardProperties } from 'keyman/engine/keyboard';
+import { ActiveLayout, JSKeyboard, KeyboardProperties } from 'keyman/engine/keyboard';
 import { StylesheetManager } from 'keyman/engine/dom-utils';
 import { DeviceSpec } from "@keymanapp/web-utils";
 
@@ -23,7 +23,7 @@ describe('VisualKeyboard', () => {
     const mockDevice = { browser: DeviceSpec.Browser.Chrome, formFactor: DeviceSpec.FormFactor.Desktop, OS: DeviceSpec.OperatingSystem.Windows, touchable: false };
     const mockLayout = sinon.createStubInstance(ActiveLayout) as any;
 
-    const keyboard = sinon.createStubInstance(Keyboard) as any;
+    const keyboard = sinon.createStubInstance(JSKeyboard) as any;
     keyboard.layout.returns(mockLayout);
     sinon.stub(keyboard, 'isRTL').get(() => false);
     sinon.stub(keyboard, 'id').get(() => 'test');
diff --git a/web/src/test/auto/integrated/cases/basics.tests.ts b/web/src/test/auto/integrated/cases/basics.tests.ts
index 6103701fd8..b44907f243 100644
--- a/web/src/test/auto/integrated/cases/basics.tests.ts
+++ b/web/src/test/auto/integrated/cases/basics.tests.ts
@@ -20,7 +20,7 @@ describe('Basic KeymanWeb', function() {
     assert.isFalse(DEVICE_DETECT_FAILURE, "Cannot run due to device detection failure.");
   })
 
-  beforeEach(function() {
+  beforeEach(async function(): Promise<any> {
     this.timeout(baseTimeout);
 
     const singleton = document.createElement('input');
@@ -55,7 +55,7 @@ if(!device.touchable) {
   describe('Basic Toggle UI', function() {
     this.timeout(baseTimeout);
 
-    beforeEach(async function() {
+    beforeEach(async function(): Promise<any> {
       this.timeout(baseTimeout);
 
       const singleton = document.createElement('input');
@@ -77,7 +77,7 @@ if(!device.touchable) {
       // UI-module specific typings are currently not available.
       const ui = keyman.ui as any;
 
-      assert(ui.initialized, 'Initialization flag is set to false!');
+      assert.isTrue(ui.initialized, 'Initialization flag is set to false!');
       assert.isNotNull(ui.controller, 'Failed to create the controller element!');
 
       var divs = document.getElementsByTagName("div");
@@ -95,7 +95,7 @@ if(!device.touchable) {
 
   describe('Basic Button UI', function() {
 
-    beforeEach(async function() {
+    beforeEach(async function(): Promise<any> {
       this.timeout(baseTimeout);
 
       const singleton = document.createElement('input');
@@ -123,7 +123,7 @@ if(!device.touchable) {
 
   describe('Basic Float UI', function() {
 
-    beforeEach(async function() {
+    beforeEach(async function(): Promise<any> {
       this.timeout(baseTimeout);
 
       const singleton = document.createElement('input');
@@ -164,7 +164,7 @@ if(!device.touchable) {
 
   describe('Basic Toolbar UI', function() {
 
-    beforeEach(async function() {
+    beforeEach(async function(): Promise<any> {
       this.timeout(baseTimeout);
 
       const singleton = document.createElement('input');
diff --git a/web/src/test/auto/integrated/test_utils.ts b/web/src/test/auto/integrated/test_utils.ts
index 9cacb46cb0..585fac8084 100644
--- a/web/src/test/auto/integrated/test_utils.ts
+++ b/web/src/test/auto/integrated/test_utils.ts
@@ -24,9 +24,9 @@ try {
   DEVICE_DETECT_FAILURE = true;
 }
 
-// // Keyman test suite utility methods
+// Keyman test suite utility methods
 
-export function setupKMW(kmwOptions: BrowserInitOptionSpec | string, timeout: number) {
+export async function setupKMW(kmwOptions: BrowserInitOptionSpec | string, timeout: number): Promise<any> {
   let ui: string;
 
   if(typeof(kmwOptions) == 'string' || typeof(kmwOptions) == 'undefined' || kmwOptions == null) {
@@ -69,13 +69,13 @@ export function setupKMW(kmwOptions: BrowserInitOptionSpec | string, timeout: nu
     compositePromise = Promise.all([kmwPromise, uiPromise]);
   }
 
-  return compositePromise.then(() => {
-    if(window[keyman_window]) {
-      return window[keyman_window].init(kmwOptions);
-    } else {
-      return Promise.reject();
-    }
-  });
+  await compositePromise;
+
+  if(window[keyman_window]) {
+    return window[keyman_window].init(kmwOptions);
+  } else {
+    return Promise.reject();
+  }
 }
 
 /**
diff --git a/web/src/test/auto/integrated/web-test-runner.config.mjs b/web/src/test/auto/integrated/web-test-runner.config.mjs
index 8d937f55af..72ebce8f99 100644
--- a/web/src/test/auto/integrated/web-test-runner.config.mjs
+++ b/web/src/test/auto/integrated/web-test-runner.config.mjs
@@ -24,7 +24,7 @@ export default {
   concurrency: 10,
   nodeResolve: true,
   files: [
-    'build/test/integrated//**/*.tests.mjs',
+    'web/build/test/integrated/**/*.tests.mjs',
     // '**/*.tests.html'
   ],
   middleware: [
@@ -34,6 +34,12 @@ export default {
         context.url = '/common/test' + context.url;
       }
 
+      return next();
+    },
+    function rewriteWasmContentType(context, next) {
+      if (context.url.endsWith('.wasm')) {
+        context.headers['content-type'] = 'application/wasm';
+      }
       return next();
     }
   ],
diff --git a/web/src/test/manual/README.md b/web/src/test/manual/README.md
new file mode 100644
index 0000000000..b875c61710
--- /dev/null
+++ b/web/src/test/manual/README.md
@@ -0,0 +1,10 @@
+# Manual tests
+
+To run the the manual tests, start the test web server with:
+
+```bash
+cd "$KEYMAN_ROOT"
+web/build.sh start
+```
+
+Then open <http://localhost:3000> in your browser.
diff --git a/web/src/test/manual/build.sh b/web/src/test/manual/build.sh
index b2eed53d0a..0278a8a0d7 100755
--- a/web/src/test/manual/build.sh
+++ b/web/src/test/manual/build.sh
@@ -52,4 +52,4 @@ function do_copy() {
 }
 
 builder_run_action clean rm -rf "$KEYMAN_ROOT/$DEST" && rm -rf "$GESTURE_PROCESSOR_TARGET"
-builder_run_action build do_copy
\ No newline at end of file
+builder_run_action build do_copy
diff --git a/web/src/test/manual/web/core/load-keyboard-blob.js b/web/src/test/manual/web/core/load-keyboard-blob.js
new file mode 100644
index 0000000000..527f0e7203
--- /dev/null
+++ b/web/src/test/manual/web/core/load-keyboard-blob.js
@@ -0,0 +1,9 @@
+export async function loadKeyboardBlob(uri) {
+  const response = await fetch(uri);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText}`);
+  }
+
+  const buffer = await response.arrayBuffer();
+  return new Uint8Array(buffer);
+}
diff --git a/web/src/test/manual/web/core/paths.js b/web/src/test/manual/web/core/paths.js
new file mode 100644
index 0000000000..5b595711fa
--- /dev/null
+++ b/web/src/test/manual/web/core/paths.js
@@ -0,0 +1 @@
+export const CORE_WASM = '../../../../../build/engine/core-processor/obj/import/core';
diff --git a/web/src/test/manual/web/core/stress.html b/web/src/test/manual/web/core/stress.html
new file mode 100644
index 0000000000..fed4dfeaa0
--- /dev/null
+++ b/web/src/test/manual/web/core/stress.html
@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8" />
+
+  <!-- Set the viewport width to match phone and tablet device widths -->
+  <meta name="viewport" content="width=device-width,user-scalable=no" />
+
+  <title>KeymanWeb Core Stress Test</title>
+
+  <!--
+    Import map defines where we can find KeymanWeb compiled modules; this must
+    be specified inline.
+  -->
+  <script type="importmap">
+    {
+      "imports": {
+        "keyman/": "../../../../../build/"
+      }
+    }
+  </script>
+
+  <script module="es6" type="module">
+    import { KM_Core } from 'keyman/engine/core-processor/lib/index.mjs';
+    import { CORE_WASM } from './paths.js';
+    import { loadKeyboardBlob } from './load-keyboard-blob.js';
+
+    let intervalId = null;
+
+    function stress() {
+      if (intervalId) {
+        window.clearInterval(intervalId);
+        intervalId = null;
+        console.log('Stopping stress');
+        return;
+      }
+      intervalId = window.setInterval(doStress, 10);
+    }
+
+    async function doStress() {
+      console.log('Starting to stress');
+      const km_core = await KM_Core.createCoreProcessor(CORE_WASM);
+      const blob = await loadKeyboardBlob('./test_8568_deadkeys.kmx')
+      const result = km_core.keyboard_load_from_blob('test', blob);
+      result.delete();
+    }
+
+    window.addEventListener('load', function () {
+      document.getElementById('stress').addEventListener('click', stress);
+    });
+
+  </script>
+</head>
+
+<body>
+  <h2>KeymanWeb Sample Page - Core Testing</h2>
+  <p>This page is designed to stress-test the loading a KMX keyboard from blob. It will repeatedly load a .kmx using the KM_Core loader.</p>
+  <p>Be sure to reference the developer console for additional feedback. </p>
+  <button id="stress">Stress Test</button>
+  <hr />
+  <h3><a href="../index.html">Return to testing home page</a></h3>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/web/src/test/manual/web/core/test_8568_deadkeys.kmx b/web/src/test/manual/web/core/test_8568_deadkeys.kmx
new file mode 100644
index 0000000000..88f00e8baf
Binary files /dev/null and b/web/src/test/manual/web/core/test_8568_deadkeys.kmx differ
diff --git a/web/src/test/manual/web/index.html b/web/src/test/manual/web/index.html
index 6d608b08d3..04ad2a84fc 100644
--- a/web/src/test/manual/web/index.html
+++ b/web/src/test/manual/web/index.html
@@ -45,6 +45,9 @@
   <h2><a href="./issue62/index.html">Light test for touch-based MutationObserver functionality</a></h2>
   <h2><a href="./issue63/index.html">Test/stress-test touch-based MutationObserver functionality</a></h2>
 
+  <h1>Keyman Core tests</h1>
+  <h2><a href="./core/stress.html">Stress-test kmx blob loader</a></h2>
+
   <h1>Issue Testing</h1>
   <h2><a href="./empty-row/index.html">Tests OSK handling of empty rows</a></h2>
   <h2><a href="./keyboard-errors/index.html">Tests keyboard error-handling functionality</a></h2>
diff --git a/web/src/test/manual/web/keyboard-errors/errorhdr.js b/web/src/test/manual/web/keyboard-errors/errorhdr.js
index b784f6a476..9a0ad75939 100644
--- a/web/src/test/manual/web/keyboard-errors/errorhdr.js
+++ b/web/src/test/manual/web/keyboard-errors/errorhdr.js
@@ -1,17 +1,15 @@
-// JavaScript Document samplehdr.js: Keyboard management for KeymanWeb demonstration pages
-
-/* 
+/*
     This script is designed to test KeymanWeb error message handling.
 */
 
-  function loadKeyboards() 
-  { 
+  function loadKeyboards()
+  {
     var kmw=keyman;
-    
+
     // We start by adding a keyboard correctly.  It's best to include a 'control' in our experiment.
     kmw.addKeyboards({id:'us',name:'English',languages:{id:'en',name:'English'},
       filename:'../us-1.0.js'});
-      
+
     // Insert a keyboard that cannot be found.
     kmw.addKeyboards({id:'lao_2008_basic',name:'wrong-filename',
       languages:{
@@ -19,9 +17,9 @@
         font:{family:'LaoWeb',source:['../font/saysettha_web.ttf','../font/saysettha_web.woff','../font/saysettha_web.eot']}
         },
       filename:'./missing_file.js' // Intentional error - the file doesn't exist, so the <script> tag will raise an error event.
-      });   
-	  
-	// Insert a keyboard that will generate a timing error.  
+    });
+
+    // Insert a keyboard that will generate a timing error.
     kmw.addKeyboards({id:'unparsable',name:'non-parsable',
       languages:{
         id:'lo',name:'debugging',region:'Asia',
@@ -29,14 +27,16 @@
         },
       filename:'./unparsable.js' // Intentional error - the file has no parsable keyboard, so while the <script> tag will load,
         // registration will fail.
-      });
+    });
 
-	// Insert a keyboard that will generate a timing error.  
+    // Insert a keyboard that will generate a timing error. `timeout.js` doesn't
+    // exist, but the test server (web/src/tools/testing/test-server/index.cjs)
+    // has special handling for that URL and times out after 10 seconds.
     kmw.addKeyboards({id:'timeout',name:'timeout',
       languages:{
         id:'lo',name:'debugging',region:'Asia',
         font:{family:'LaoWeb',source:['../font/saysettha_web.ttf','../font/saysettha_web.woff','../font/saysettha_web.eot']}
         },
       filename:'./timeout.js' // Intentional (simulated) error - the file never loads, simulating a server timeout.
-      }); 
+    });
   }
diff --git a/web/src/test/manual/web/keyboard-errors/index.html b/web/src/test/manual/web/keyboard-errors/index.html
index 011c996472..7114d77636 100644
--- a/web/src/test/manual/web/keyboard-errors/index.html
+++ b/web/src/test/manual/web/keyboard-errors/index.html
@@ -65,9 +65,32 @@
     <h3>or in this input field:</h3>
     <input class='test' value='' placeholder='or here'/>
 
+    <h2>Expected error messages:</h2>
+    <ul>
+      <li><i>wrong-filename</i> keyboard: "Unable to download wrong-filename keyboard for debugging"</li>
+      <li><i>non-parsable</i> keyboard: "Error registering the non-parsable keyboard for debugging; keyboard script at ./unparsable.js may contain an error."</li>
+      <li><i>timeout</i> keyboard: "Sorry, the timeout keyboard for debugging is not currently available."</li>
+    </ul>
+
     <h3><a href="../index.html">Return to testing home page</a></h3>
   </div>
 
+    <script>
+      if (!window.location.href.startsWith('http://localhost:3000')) {
+        const body = document.getElementsByTagName('body')[0];
+        body.innerHTML = `<h1>KeymanWeb Sample Page - Error Testing page</h1>
+        <h2>Unable to load this test page!</h2>
+        <p>This page has to be loaded through the local test server.</p>
+        <p>Do the following:</p>
+        <ol>
+          <li>Open a terminal and navigate to the Keyman source root directory</li>
+          <li>Start the test server with <code>web/build.sh start</code></li>
+          <li>Open <a href="http://localhost:3000/src/test/manual/web/keyboard-errors/index.html">http://localhost:3000/src/test/manual/web/keyboard-errors/index.html</a> in a browser</li>
+        </ol>
+        `;
+      }
+    </script>
+
   </body>
 
   <!--
diff --git a/web/src/test/manual/web/keyboard-errors/timeout.js b/web/src/test/manual/web/keyboard-errors/timeout.js
deleted file mode 100644
index d4e21179df..0000000000
--- a/web/src/test/manual/web/keyboard-errors/timeout.js
+++ /dev/null
@@ -1,21 +0,0 @@
-(function() {
-  var me = document.currentScript;
-  console.log(me);
-
-  var onload = me.onload;
-  if(onload) {
-    me.onload = null;
-  }
-
-  document.body.addEventListener('load', function(e) {
-    // Prevent the element's onload event from firing
-    if(e.srcElement == me || e.target == me) {
-      e.cancelBubble = true;
-    }
-  }, {capture: true});
-
-  window.setTimeout(function () {
-    // Restores the function after a slight delay.
-    me.onload = onload;
-  }, 1);
-})();
\ No newline at end of file
diff --git a/web/src/tools/build.sh b/web/src/tools/build.sh
index 6572cc7e26..246a9a0f00 100755
--- a/web/src/tools/build.sh
+++ b/web/src/tools/build.sh
@@ -22,7 +22,8 @@ builder_describe "Builds the Keyman Engine for Web's development & unit-testing
   ":bulk_rendering=testing/bulk_rendering   Builds the bulk-rendering tool used to validate changes to OSK display code" \
   ":es-bundling                             Builds code used to esbundle Web engine artifacts for browser consumption" \
   ":recorder=testing/recorder               Builds the KMW recorder tool used for development of unit-test resources" \
-  ":sourcemap-root=building/sourcemap-root  Builds the sourcemap-cleaning tool used during minification of app/ builds"
+  ":sourcemap-root=building/sourcemap-root  Builds the sourcemap-cleaning tool used during minification of app/ builds" \
+  ":test-utils=testing/test-utils           Builds the test-utils module"
 
 builder_parse "$@"
 
diff --git a/web/src/tools/testing/bulk_rendering/renderer_core.ts b/web/src/tools/testing/bulk_rendering/renderer_core.ts
index 50c5ca2494..5bdd1527d1 100644
--- a/web/src/tools/testing/bulk_rendering/renderer_core.ts
+++ b/web/src/tools/testing/bulk_rendering/renderer_core.ts
@@ -3,7 +3,7 @@ import { DeviceDetector } from 'keyman/engine/main';
 import { type DeviceSpec } from '@keymanapp/web-utils';
 
 import type { KeymanEngine } from 'keyman/app/browser';
-import type { FloatingOSKView } from 'keyman/engine/osk';
+import { JSKeyboard, type FloatingOSKView } from 'keyman/engine/osk';
 
 declare var keyman: KeymanEngine;
 
@@ -114,19 +114,23 @@ export class BatchRenderer {
       eleDescription.appendChild(document.createElement('br'));
 
       const keyboard = keyman.core.activeKeyboard;
-      // Some keyboards, such as sil_euro_latin and sil_ipa, no longer specify this property.
-      if(keyboard['_legacyLayoutSpec']) {
-        eleDescription.appendChild(document.createTextNode('Font:  ' + keyboard['_legacyLayoutSpec'].F));
-      } else {
-        // They instead specify only the post-KMW-10 touch-layout format.
-        const layout = keyboard.layout(formFactor);
-        if(!layout) {
-          eleDescription.appendChild(document.createTextNode('Keyboard is help-text based'));
+      if (keyboard instanceof JSKeyboard) {
+        // Some keyboards, such as sil_euro_latin and sil_ipa, no longer specify this property.
+        if (keyboard['_legacyLayoutSpec']) {
+          eleDescription.appendChild(document.createTextNode('Font:  ' + keyboard['_legacyLayoutSpec'].F));
         } else {
-          eleDescription.appendChild(document.createTextNode('Font:  ' + layout.font));
+          // They instead specify only the post-KMW-10 touch-layout format.
+          const layout = keyboard.layout(formFactor);
+          if (!layout) {
+            eleDescription.appendChild(document.createTextNode('Keyboard is help-text based'));
+          } else {
+            eleDescription.appendChild(document.createTextNode('Font:  ' + layout.font));
+          }
         }
+      } else {
+        // TODO-web-core: implement for KMX keyboards
+        eleDescription.appendChild(document.createTextNode('Keyboard is help-text based'));
       }
-
     } else {
       eleDescription.appendChild(document.createTextNode('Unable to load this keyboard!'));
     }
@@ -168,7 +172,7 @@ export class BatchRenderer {
 
       // Uses 'private' APIs that may be subject to change in the future.  Keep it updated!
       let layers: string[];
-      if(!isMobile) {
+      if(!isMobile && keyman.core.activeKeyboard instanceof JSKeyboard) {
         // The desktop OSK will be overpopulated, with a number of blank layers to display in most cases.
         // We instead rely upon the KLS definition to ensure we keep the renders sparse.
         //
diff --git a/web/src/tools/testing/recorder-core/src/index.ts b/web/src/tools/testing/recorder-core/src/index.ts
index 2a73971023..60ab11a843 100644
--- a/web/src/tools/testing/recorder-core/src/index.ts
+++ b/web/src/tools/testing/recorder-core/src/index.ts
@@ -1,5 +1,5 @@
-import { Mock, type OutputTarget } from "keyman/engine/js-processor";
-import { KeyDistribution, KeyEvent } from "keyman/engine/keyboard";
+import { Mock } from "keyman/engine/js-processor";
+import { KeyDistribution, KeyEvent, type OutputTargetInterface } from "keyman/engine/keyboard";
 
 import Proctor from "./proctor.js";
 
@@ -217,7 +217,7 @@ export abstract class TestSequence<KeyRecord extends RecordedKeystroke | InputEv
 
   abstract hasOSKInteraction(): boolean;
 
-  async test(proctor: Proctor, target?: OutputTarget): Promise<{success: boolean, result: string}> {
+  async test(proctor: Proctor, target?: OutputTargetInterface): Promise<{success: boolean, result: string}> {
     // Start with an empty OutputTarget and a fresh KeyboardProcessor.
     if(!target) {
       target = new Mock();
diff --git a/web/src/tools/testing/recorder-core/src/nodeProctor.ts b/web/src/tools/testing/recorder-core/src/nodeProctor.ts
index 204ef21939..72980a528f 100644
--- a/web/src/tools/testing/recorder-core/src/nodeProctor.ts
+++ b/web/src/tools/testing/recorder-core/src/nodeProctor.ts
@@ -8,10 +8,11 @@ import {
   RecordedSyntheticKeystroke
 } from "./index.js";
 
-import { KeyEvent, KeyEventSpec, KeyboardHarness } from "keyman/engine/keyboard";
-import { Mock, type OutputTarget } from "keyman/engine/js-processor";
+import { KeyEvent, KeyEventSpec, KeyboardHarness, type OutputTargetInterface } from "keyman/engine/keyboard";
+// TODO-web-core: remove usage of OutputTargetBase, use OutputTargetInterface instead
+import { Mock, OutputTargetBase } from 'keyman/engine/js-processor';
 import { DeviceSpec } from "@keymanapp/web-utils";
-import { KeyboardInterface, KeyboardProcessor } from 'keyman/engine/js-processor';
+import { JSKeyboardInterface, JSKeyboardProcessor } from 'keyman/engine/js-processor';
 
 export default class NodeProctor extends Proctor {
   private keyboardWithHarness: KeyboardHarness;
@@ -49,15 +50,15 @@ export default class NodeProctor extends Proctor {
     return true;
   }
 
-  async simulateSequence(sequence: TestSequence<any>, target?: OutputTarget): Promise<string> {
+  async simulateSequence(sequence: TestSequence<any>, target?: OutputTargetInterface): Promise<string> {
     // Start with an empty OutputTarget and a fresh KeyboardProcessor.
     if(!target) {
       target = new Mock();
     }
 
     // Establish a fresh processor, setting its keyboard appropriately for the test.
-    let processor = new KeyboardProcessor(this.device);
-    processor.keyboardInterface = this.keyboardWithHarness as KeyboardInterface;
+    let processor = new JSKeyboardProcessor(this.device);
+    processor.keyboardInterface = this.keyboardWithHarness as JSKeyboardInterface;
     const keyboard = processor.activeKeyboard;
 
     if(sequence instanceof RecordedKeystrokeSequence) {
@@ -88,7 +89,8 @@ export default class NodeProctor extends Proctor {
         // We don't care too much about particularities of per-keystroke behavior yet.
         // ... we _could_ if we wanted to, though.  The framework is mostly in place;
         // it's a matter of actually adding the feature.
-        let ruleBehavior = processor.processKeystroke(new KeyEvent(keyEvent), target);
+        // TODO-web-core
+        const ruleBehavior = processor.processKeystroke(new KeyEvent(keyEvent), (target as OutputTargetBase));
 
         if (this.debugMode) {
           console.log("Processing %d:", keyEvent.Lcode);
diff --git a/web/src/tools/testing/recorder-core/src/proctor.ts b/web/src/tools/testing/recorder-core/src/proctor.ts
index ec4f584b04..533648e88c 100644
--- a/web/src/tools/testing/recorder-core/src/proctor.ts
+++ b/web/src/tools/testing/recorder-core/src/proctor.ts
@@ -1,5 +1,5 @@
 import { type DeviceSpec } from "@keymanapp/web-utils";
-import { type OutputTarget } from "keyman/engine/js-processor";
+import { type OutputTargetInterface } from "keyman/engine/keyboard";
 
 import type { KeyboardTest, TestSet, TestSequence } from "./index.js";
 
@@ -49,5 +49,5 @@ export default abstract class Proctor {
    * Simulates the specified test sequence for use in testing.
    * @param sequence The recorded sequence, generally provided by a test set.
    */
-  abstract simulateSequence(sequence: TestSequence<any>, target?: OutputTarget): Promise<string>;
+  abstract simulateSequence(sequence: TestSequence<any>, target?: OutputTargetInterface): Promise<string>;
 }
\ No newline at end of file
diff --git a/web/src/tools/testing/recorder/browserProctor.ts b/web/src/tools/testing/recorder/browserProctor.ts
index f0e486d035..cc81b89cea 100644
--- a/web/src/tools/testing/recorder/browserProctor.ts
+++ b/web/src/tools/testing/recorder/browserProctor.ts
@@ -4,7 +4,7 @@
 
 import { type DeviceSpec } from "@keymanapp/web-utils";
 
-import { type OutputTarget } from "keyman/engine/js-processor";
+import { type OutputTargetInterface } from "keyman/engine/keyboard";
 
 import { type KeymanEngine } from 'keyman/app/browser';
 
@@ -81,7 +81,7 @@ export class BrowserProctor extends Proctor {
 
   // Execution of a test sequence depends on the testing environment; this handles
   // the browser-specific aspects.
-  async simulateSequence(sequence: TestSequence<any>, outputTarget?: OutputTarget): Promise<string> {
+  async simulateSequence(sequence: TestSequence<any>, outputTarget?: OutputTargetInterface): Promise<string> {
     const driver = new BrowserDriver(this.target);
 
     // For the version 10.0 spec
diff --git a/web/src/tools/testing/test-server/index.cjs b/web/src/tools/testing/test-server/index.cjs
new file mode 100644
index 0000000000..810b6632dc
--- /dev/null
+++ b/web/src/tools/testing/test-server/index.cjs
@@ -0,0 +1,25 @@
+const express = require('express')
+const path = require('path')
+const app = express()
+const port = 3000
+
+app.use(express.static(path.join(__dirname, '../../../../')))
+
+// for testing timeout error in web/src/test/manual/web/keyboard-errors
+const router = express.Router()
+router.get('/src/test/manual/web/keyboard-errors/timeout.js', async (req, res, next) => {
+  console.log('timeout.js requested')
+  return new Promise(() => {
+    setTimeout(() => {
+      res.set('Content-Type', 'application/json');
+      res.status(200);
+
+      next();
+    }, 10500); // > ContextManagerBase.TIMEOUT_THRESHOLD (10 seconds)
+  });
+})
+app.use(router)
+
+app.listen(port, () => {
+  console.log(`Keyman test app listening on port ${port}`)
+})
diff --git a/web/src/tools/testing/test-utils/build.sh b/web/src/tools/testing/test-utils/build.sh
new file mode 100755
index 0000000000..d31795b07e
--- /dev/null
+++ b/web/src/tools/testing/test-utils/build.sh
@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+#
+# Compile KeymanWeb's automated js/ts test utilities
+
+## START STANDARD BUILD SCRIPT INCLUDE
+# adjust relative paths as necessary
+THIS_SCRIPT="$(readlink -f "${BASH_SOURCE[0]}")"
+. "${THIS_SCRIPT%/*}/../../../../../resources/build/builder-full.inc.sh"
+## END STANDARD BUILD SCRIPT INCLUDE
+
+SUBPROJECT_NAME=tools/testing/test-utils
+. "$KEYMAN_ROOT/resources/build/utils.inc.sh"
+. "$KEYMAN_ROOT/resources/build/node.inc.sh"
+. "$KEYMAN_ROOT/web/common.inc.sh"
+
+################################ Main script ################################
+
+builder_describe "Automated js/ts test utilities for KeymanWeb" \
+  "clean" \
+  "configure" \
+  "build"
+
+builder_describe_outputs \
+  configure  /node_modules \
+  build      "/web/build/${SUBPROJECT_NAME}/obj/index.js"
+
+builder_parse "$@"
+
+do_build ( ) {
+  compile "${SUBPROJECT_NAME}"
+}
+
+builder_run_action configure  node_select_version_and_npm_ci
+builder_run_action clean      rm -rf "../../../../build/${SUBPROJECT_NAME}/"
+builder_run_action build      do_build
\ No newline at end of file
diff --git a/web/src/tools/testing/test-utils/index.ts b/web/src/tools/testing/test-utils/index.ts
new file mode 100644
index 0000000000..79f98d1a3b
--- /dev/null
+++ b/web/src/tools/testing/test-utils/index.ts
@@ -0,0 +1,31 @@
+import { assert } from 'chai';
+
+// export async function assertThrowsAsync(fn: () => Promise<any>, message?: string): Promise<void>;
+export async function assertThrowsAsync(fn: () => Promise<any>, type?: any, message?: string): Promise<void> {
+  assert(!!type || !!message, 'at least one of type or message must be specified');
+  if (typeof(type) === 'string') {
+    message = type;
+    type = undefined;
+  }
+  try {
+    await fn();
+    assert.fail('Expected function to throw an error, but it did not.');
+  } catch (err) {
+    if (type) {
+      assert.isTrue(err instanceof type, `Expected error to be of type ${type.name}, but got ${err.constructor.name}`);
+    }
+    if (message) {
+      assert.equal((err as Error).message, message);
+    }
+  }
+}
+
+export function assertThrows(fn: () => any, message?: string): void;
+export function assertThrows(fn: () => any, type?: any, message?: string): void {
+  assert(!!type || !!message, 'at least one of type or message must be specified');
+  if (typeof(type) === 'string') {
+    message = type;
+    type = undefined;
+  }
+  assert.throws(fn, type, message);
+}
diff --git a/web/src/tools/testing/test-utils/tsconfig.json b/web/src/tools/testing/test-utils/tsconfig.json
new file mode 100644
index 0000000000..65dfe3a9bf
--- /dev/null
+++ b/web/src/tools/testing/test-utils/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "extends": "../../../tsconfig.dom.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "../../../../build/tools/testing/test-utils/obj/",
+    "rootDir": ".",
+    "tsBuildInfoFile": "../../../../build/tools/testing/test-utils/obj/tsconfig.tsbuildinfo"
+  },
+
+  "include": [ "*.ts" ],
+}
diff --git a/web/test.sh b/web/test.sh
index b65af498df..e1133f826c 100755
--- a/web/test.sh
+++ b/web/test.sh
@@ -40,6 +40,8 @@ fi
 
 # End common configs.
 
-builder_run_action test:dom web-test-runner --config "src/test/auto/dom/web-test-runner${WTR_CONFIG}.config.mjs" ${WTR_INSPECT}
+cd "${KEYMAN_ROOT}"
 
-builder_run_action test:integrated web-test-runner --config "src/test/auto/integrated/web-test-runner${WTR_CONFIG}.config.mjs" ${WTR_INSPECT}
+builder_run_action test:dom web-test-runner --config "web/src/test/auto/dom/web-test-runner${WTR_CONFIG}.config.mjs" ${WTR_INSPECT}
+
+builder_run_action test:integrated web-test-runner --config "web/src/test/auto/integrated/web-test-runner${WTR_CONFIG}.config.mjs" ${WTR_INSPECT}