Rename the library to wsap_vtcore

ncurses installs <term.h> and defines struct term. In a file that
includes both headers, an ncurses TERMINAL * and this library's terminal
are silently the same type. The name wsap_vtcore avoids the clash.

The public header is now <wsap_vtcore/wsap_vtcore.h>. Every global
symbol uses the wsap_vtcore_ prefix, every macro uses WSAP_VTCORE_, and
the shared library is libwsap_vtcore.so.0. The default terminal name is
now "wsap_vtcore". The ISA override variable is WSAP_VTCORE_ISA.

No other behavior changes. The amalgamation writes wsap_vtcore.c and
wsap_vtcore.h.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>

1 files changed, 224 insertions, 224 deletions

diff --git a/tests/input_test.c b/tests/input_test.c
index e3a6b8b..59223d2 100644
--- a/tests/input_test.c
+++ b/tests/input_test.c
@@ -1,29 +1,29 @@
-#include "term/term.h"
+#include "wsap_vtcore/wsap_vtcore.h"
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-static struct term_keyboard_state st;
-static struct term_modes m;
+static struct wsap_vtcore_keyboard_state st;
+static struct wsap_vtcore_modes m;
 static char out[128];
 static size_t out_len;
 
 static void mode(unsigned kitty_flags)
 {
-    st = (struct term_keyboard_state){0};
-    m = (struct term_modes){ .keyboard = kitty_flags, .grid = { .x = 80, .y = 24 } };
+    st = (struct wsap_vtcore_keyboard_state){0};
+    m = (struct wsap_vtcore_modes){ .keyboard = kitty_flags, .grid = { .x = 80, .y = 24 } };
 }
 
-static void enc(struct term_key_event ev)
+static void enc(struct wsap_vtcore_key_event ev)
 {
-    if (!ev.action) ev.action = TERM_KEY_PRESS;
-    term_keyboard_update(&st, &ev);
-    struct term_input_result r =
-        term_input_encode_key(&st, &ev, &m, out, sizeof(out));
+    if (!ev.action) ev.action = WSAP_VTCORE_KEY_PRESS;
+    wsap_vtcore_keyboard_update(&st, &ev);
+    struct wsap_vtcore_input_result r =
+        wsap_vtcore_input_encode_key(&st, &ev, &m, out, sizeof(out));
     out_len = r.len;
 }
-#define K(...) enc((struct term_key_event){ __VA_ARGS__ })
+#define K(...) enc((struct wsap_vtcore_key_event){ __VA_ARGS__ })
 
 static void typed(uint32_t cp, unsigned mods)
 {
@@ -31,16 +31,16 @@ static void typed(uint32_t cp, unsigned mods)
 }
 
 static bool consumed;
-static void enc_mouse(struct term_mouse_event ev)
+static void enc_mouse(struct wsap_vtcore_mouse_event ev)
 {
     if (ev.pixel.x == 0 && ev.pixel.y == 0)
         ev.pixel = ev.pos;
-    struct term_input_result r =
-        term_input_encode_mouse(&ev, &m, out, sizeof(out));
+    struct wsap_vtcore_input_result r =
+        wsap_vtcore_input_encode_mouse(&ev, &m, out, sizeof(out));
     out_len = r.len;
-    consumed = r.status != TERM_INPUT_UNHANDLED;
+    consumed = r.status != WSAP_VTCORE_INPUT_UNHANDLED;
 }
-#define MOUSE(x_, y_, ...) enc_mouse((struct term_mouse_event){ .pos = { .x = (x_), .y = (y_) }, __VA_ARGS__ })
+#define MOUSE(x_, y_, ...) enc_mouse((struct wsap_vtcore_mouse_event){ .pos = { .x = (x_), .y = (y_) }, __VA_ARGS__ })
 
 static void expect_at(const char *s, int line)
 {
@@ -55,343 +55,343 @@ static void expect_at(const char *s, int line)
 int main(void)
 {
     mode(0);
-    K(.key = TERM_KEY_UP); expect("\033[A");
-    K(.key = TERM_KEY_HOME); expect("\033[H");
-    K(.key = TERM_KEY_DELETE); expect("\033[3~");
-    K(.key = TERM_KEY_PAGE_UP); expect("\033[5~");
-    K(.key = TERM_KEY_F1); expect("\033OP");
-    K(.key = TERM_KEY_F5); expect("\033[15~");
-    K(.key = TERM_KEY_F12); expect("\033[24~");
-    K(.key = TERM_KEY_RETURN); expect("\r");
-    K(.key = TERM_KEY_ESCAPE); expect("\033");
-    K(.key = TERM_KEY_TAB); expect("\t");
-    K(.key = TERM_KEY_TAB, .mods = TERM_MOD_SHIFT); expect("\033[Z");
-    K(.key = TERM_KEY_BACKSPACE); expect("\177");
-    K(.key = TERM_KEY_RIGHT, .mods = TERM_MOD_CTRL); expect("\033[1;5C");
-    K(.key = TERM_KEY_F5, .mods = TERM_MOD_SHIFT); expect("\033[15;2~");
-    K(.key = TERM_KEY_DELETE, .mods = TERM_MOD_CTRL); expect("\033[3;5~");
+    K(.key = WSAP_VTCORE_KEY_UP); expect("\033[A");
+    K(.key = WSAP_VTCORE_KEY_HOME); expect("\033[H");
+    K(.key = WSAP_VTCORE_KEY_DELETE); expect("\033[3~");
+    K(.key = WSAP_VTCORE_KEY_PAGE_UP); expect("\033[5~");
+    K(.key = WSAP_VTCORE_KEY_F1); expect("\033OP");
+    K(.key = WSAP_VTCORE_KEY_F5); expect("\033[15~");
+    K(.key = WSAP_VTCORE_KEY_F12); expect("\033[24~");
+    K(.key = WSAP_VTCORE_KEY_RETURN); expect("\r");
+    K(.key = WSAP_VTCORE_KEY_ESCAPE); expect("\033");
+    K(.key = WSAP_VTCORE_KEY_TAB); expect("\t");
+    K(.key = WSAP_VTCORE_KEY_TAB, .mods = WSAP_VTCORE_MOD_SHIFT); expect("\033[Z");
+    K(.key = WSAP_VTCORE_KEY_BACKSPACE); expect("\177");
+    K(.key = WSAP_VTCORE_KEY_RIGHT, .mods = WSAP_VTCORE_MOD_CTRL); expect("\033[1;5C");
+    K(.key = WSAP_VTCORE_KEY_F5, .mods = WSAP_VTCORE_MOD_SHIFT); expect("\033[15;2~");
+    K(.key = WSAP_VTCORE_KEY_DELETE, .mods = WSAP_VTCORE_MOD_CTRL); expect("\033[3;5~");
 
     m.backarrow_bs = true;
-    K(.key = TERM_KEY_BACKSPACE); expect("\010");
+    K(.key = WSAP_VTCORE_KEY_BACKSPACE); expect("\010");
     m.backarrow_bs = false;
 
     m.app_cursor = true;
-    K(.key = TERM_KEY_UP); expect("\033OA");
-    K(.key = TERM_KEY_END); expect("\033OF");
+    K(.key = WSAP_VTCORE_KEY_UP); expect("\033OA");
+    K(.key = WSAP_VTCORE_KEY_END); expect("\033OF");
 
-    K(.key = TERM_KEY_UP, .mods = TERM_MOD_CTRL); expect("\033[1;5A");
+    K(.key = WSAP_VTCORE_KEY_UP, .mods = WSAP_VTCORE_MOD_CTRL); expect("\033[1;5A");
     m.app_cursor = false;
 
     typed('a', 0); expect("a");
     typed(0x00E9, 0); expect("\xc3\xa9");
     K(.codepoint = 'a', .shifted = 'A', .base = 'a', .text = 'A',
-      .mods = TERM_MOD_SHIFT); expect("A");
-    K(.action = TERM_KEY_RELEASE, .codepoint = 'a', .text = 'a'); expect("");
+      .mods = WSAP_VTCORE_MOD_SHIFT); expect("A");
+    K(.action = WSAP_VTCORE_KEY_RELEASE, .codepoint = 'a', .text = 'a'); expect("");
 
-    typed('c', TERM_MOD_CTRL); expect("\003");
-    typed('a', TERM_MOD_CTRL); expect("\001");
-    typed('\\', TERM_MOD_CTRL); expect("\034");
-    typed(' ', TERM_MOD_CTRL); assert(out_len == 1 && out[0] == 0);
+    typed('c', WSAP_VTCORE_MOD_CTRL); expect("\003");
+    typed('a', WSAP_VTCORE_MOD_CTRL); expect("\001");
+    typed('\\', WSAP_VTCORE_MOD_CTRL); expect("\034");
+    typed(' ', WSAP_VTCORE_MOD_CTRL); assert(out_len == 1 && out[0] == 0);
 
     K(.codepoint = '2', .shifted = '@', .base = '2', .text = '@',
-      .mods = TERM_MOD_CTRL | TERM_MOD_SHIFT);
+      .mods = WSAP_VTCORE_MOD_CTRL | WSAP_VTCORE_MOD_SHIFT);
     assert(out_len == 1 && out[0] == 0);
 
-    typed('b', TERM_MOD_ALT); expect("\033b");
-    typed('b', TERM_MOD_ALT | TERM_MOD_CTRL); expect("\033\002");
-    K(.key = TERM_KEY_BACKSPACE, .mods = TERM_MOD_ALT); expect("\033\177");
-    K(.key = TERM_KEY_RETURN, .mods = TERM_MOD_ALT); expect("\033\r");
-    K(.key = TERM_KEY_TAB, .mods = TERM_MOD_ALT); expect("\033\t");
-    K(.key = TERM_KEY_TAB, .mods = TERM_MOD_ALT | TERM_MOD_SHIFT); expect("\033[Z");
-    K(.key = TERM_KEY_ESCAPE, .mods = TERM_MOD_ALT); expect("\033");
+    typed('b', WSAP_VTCORE_MOD_ALT); expect("\033b");
+    typed('b', WSAP_VTCORE_MOD_ALT | WSAP_VTCORE_MOD_CTRL); expect("\033\002");
+    K(.key = WSAP_VTCORE_KEY_BACKSPACE, .mods = WSAP_VTCORE_MOD_ALT); expect("\033\177");
+    K(.key = WSAP_VTCORE_KEY_RETURN, .mods = WSAP_VTCORE_MOD_ALT); expect("\033\r");
+    K(.key = WSAP_VTCORE_KEY_TAB, .mods = WSAP_VTCORE_MOD_ALT); expect("\033\t");
+    K(.key = WSAP_VTCORE_KEY_TAB, .mods = WSAP_VTCORE_MOD_ALT | WSAP_VTCORE_MOD_SHIFT); expect("\033[Z");
+    K(.key = WSAP_VTCORE_KEY_ESCAPE, .mods = WSAP_VTCORE_MOD_ALT); expect("\033");
 
-    K(.key = TERM_KEY_LEFT, .mods = TERM_MOD_ALT); expect("\033[1;3D");
+    K(.key = WSAP_VTCORE_KEY_LEFT, .mods = WSAP_VTCORE_MOD_ALT); expect("\033[1;3D");
 
     {
         char b_null[16];
-        struct term_input_result r = term_input_encode_key(
+        struct wsap_vtcore_input_result r = wsap_vtcore_input_encode_key(
             NULL,
-            &(struct term_key_event){ .key = TERM_KEY_UP, .action = TERM_KEY_PRESS },
-            &(struct term_modes){0},
+            &(struct wsap_vtcore_key_event){ .key = WSAP_VTCORE_KEY_UP, .action = WSAP_VTCORE_KEY_PRESS },
+            &(struct wsap_vtcore_modes){0},
             b_null, sizeof(b_null));
-        assert(r.status == TERM_INPUT_BYTES && r.len == 3 && !memcmp(b_null, "\033[A", 3));
+        assert(r.status == WSAP_VTCORE_INPUT_BYTES && r.len == 3 && !memcmp(b_null, "\033[A", 3));
     }
 
     K(.codepoint = 'b', .base = 'b', .text = 0x222B, .text_deferred = true);
     expect("");
 
-    K(.key = TERM_KEY_KP_DELETE, .keypad = TERM_KEY_KP_DECIMAL); expect("\033[3~");
-    K(.key = TERM_KEY_KP_ENTER, .keypad = TERM_KEY_KP_ENTER); expect("\r");
-    K(.key = TERM_KEY_KP_LEFT, .keypad = TERM_KEY_KP_4); expect("\033[D");
+    K(.key = WSAP_VTCORE_KEY_KP_DELETE, .keypad = WSAP_VTCORE_KEY_KP_DECIMAL); expect("\033[3~");
+    K(.key = WSAP_VTCORE_KEY_KP_ENTER, .keypad = WSAP_VTCORE_KEY_KP_ENTER); expect("\r");
+    K(.key = WSAP_VTCORE_KEY_KP_LEFT, .keypad = WSAP_VTCORE_KEY_KP_4); expect("\033[D");
 
     m.app_keypad = true;
-    K(.key = TERM_KEY_KP_END, .keypad = TERM_KEY_KP_1); expect("\033Oq");
-    K(.key = TERM_KEY_KP_ENTER, .keypad = TERM_KEY_KP_ENTER); expect("\033OM");
-    K(.key = TERM_KEY_KP_ADD, .keypad = TERM_KEY_KP_ADD); expect("\033Ok");
+    K(.key = WSAP_VTCORE_KEY_KP_END, .keypad = WSAP_VTCORE_KEY_KP_1); expect("\033Oq");
+    K(.key = WSAP_VTCORE_KEY_KP_ENTER, .keypad = WSAP_VTCORE_KEY_KP_ENTER); expect("\033OM");
+    K(.key = WSAP_VTCORE_KEY_KP_ADD, .keypad = WSAP_VTCORE_KEY_KP_ADD); expect("\033Ok");
     m.app_keypad = false;
 
     mode(1);
-    K(.key = TERM_KEY_ESCAPE); expect("\033[27u");
-    K(.key = TERM_KEY_DELETE); expect("\033[3~");
-    K(.key = TERM_KEY_F3); expect("\033[13~");
-    K(.key = TERM_KEY_KP_ENTER, .keypad = TERM_KEY_KP_ENTER); expect("\033[57414u");
-    typed('i', TERM_MOD_CTRL); expect("\033[105;5u");
-    K(.key = TERM_KEY_RETURN, .mods = TERM_MOD_CTRL); expect("\033[13;5u");
+    K(.key = WSAP_VTCORE_KEY_ESCAPE); expect("\033[27u");
+    K(.key = WSAP_VTCORE_KEY_DELETE); expect("\033[3~");
+    K(.key = WSAP_VTCORE_KEY_F3); expect("\033[13~");
+    K(.key = WSAP_VTCORE_KEY_KP_ENTER, .keypad = WSAP_VTCORE_KEY_KP_ENTER); expect("\033[57414u");
+    typed('i', WSAP_VTCORE_MOD_CTRL); expect("\033[105;5u");
+    K(.key = WSAP_VTCORE_KEY_RETURN, .mods = WSAP_VTCORE_MOD_CTRL); expect("\033[13;5u");
 
     typed('a', 0); expect("a");
-    K(.key = TERM_KEY_RETURN); expect("\r");
+    K(.key = WSAP_VTCORE_KEY_RETURN); expect("\r");
 
-    K(.key = TERM_KEY_UP, .action = TERM_KEY_RELEASE); expect("");
-    K(.key = TERM_KEY_LSHIFT); expect("");
+    K(.key = WSAP_VTCORE_KEY_UP, .action = WSAP_VTCORE_KEY_RELEASE); expect("");
+    K(.key = WSAP_VTCORE_KEY_LSHIFT); expect("");
 
     mode(1 | 4);
     K(.codepoint = 'a', .shifted = 'A', .base = 'a', .text = 'A',
-      .mods = TERM_MOD_CTRL | TERM_MOD_SHIFT); expect("\033[97:65;6u");
+      .mods = WSAP_VTCORE_MOD_CTRL | WSAP_VTCORE_MOD_SHIFT); expect("\033[97:65;6u");
 
     mode(1 | 2 | 8);
-    K(.key = TERM_KEY_ESCAPE); expect("\033[27;1u");
-    K(.key = TERM_KEY_ESCAPE, .action = TERM_KEY_REPEAT); expect("\033[27;1:2u");
-    K(.key = TERM_KEY_ESCAPE, .action = TERM_KEY_RELEASE); expect("\033[27;1:3u");
-    K(.key = TERM_KEY_UP, .action = TERM_KEY_REPEAT); expect("\033[1;1:2A");
+    K(.key = WSAP_VTCORE_KEY_ESCAPE); expect("\033[27;1u");
+    K(.key = WSAP_VTCORE_KEY_ESCAPE, .action = WSAP_VTCORE_KEY_REPEAT); expect("\033[27;1:2u");
+    K(.key = WSAP_VTCORE_KEY_ESCAPE, .action = WSAP_VTCORE_KEY_RELEASE); expect("\033[27;1:3u");
+    K(.key = WSAP_VTCORE_KEY_UP, .action = WSAP_VTCORE_KEY_REPEAT); expect("\033[1;1:2A");
 
     mode(31);
     K(.codepoint = 1092, .base = 'a', .text = 1092);
     expect("\033[1092::97;1;1092u");
     K(.codepoint = 'a', .shifted = 'A', .base = 'a', .text = 'A',
-      .mods = TERM_MOD_SHIFT); expect("\033[97:65;2;65u");
+      .mods = WSAP_VTCORE_MOD_SHIFT); expect("\033[97:65;2;65u");
 
-    K(.action = TERM_KEY_RELEASE, .codepoint = 'a', .base = 'a', .text = 'a');
+    K(.action = WSAP_VTCORE_KEY_RELEASE, .codepoint = 'a', .base = 'a', .text = 'a');
     expect("\033[97;1:3u");
 
     mode(1 | 2 | 8);
-    K(.key = TERM_KEY_LSHIFT, .mods = TERM_MOD_SHIFT); expect("\033[57441;2u");
-    K(.key = TERM_KEY_RSHIFT, .mods = TERM_MOD_SHIFT); expect("\033[57447;2u");
-    K(.key = TERM_KEY_LSHIFT, .action = TERM_KEY_RELEASE, .mods = TERM_MOD_SHIFT);
+    K(.key = WSAP_VTCORE_KEY_LSHIFT, .mods = WSAP_VTCORE_MOD_SHIFT); expect("\033[57441;2u");
+    K(.key = WSAP_VTCORE_KEY_RSHIFT, .mods = WSAP_VTCORE_MOD_SHIFT); expect("\033[57447;2u");
+    K(.key = WSAP_VTCORE_KEY_LSHIFT, .action = WSAP_VTCORE_KEY_RELEASE, .mods = WSAP_VTCORE_MOD_SHIFT);
     expect("\033[57441;2:3u");
-    K(.key = TERM_KEY_RSHIFT, .action = TERM_KEY_RELEASE, .mods = TERM_MOD_SHIFT);
+    K(.key = WSAP_VTCORE_KEY_RSHIFT, .action = WSAP_VTCORE_KEY_RELEASE, .mods = WSAP_VTCORE_MOD_SHIFT);
     expect("\033[57447;1:3u");
 
-    K(.key = TERM_KEY_ISO_LEVEL3_SHIFT); expect("\033[57453;1u");
-    K(.key = TERM_KEY_ISO_LEVEL5_SHIFT); expect("\033[57454;1u");
-    K(.key = TERM_KEY_CAPS_LOCK); expect("\033[57358;65u");
+    K(.key = WSAP_VTCORE_KEY_ISO_LEVEL3_SHIFT); expect("\033[57453;1u");
+    K(.key = WSAP_VTCORE_KEY_ISO_LEVEL5_SHIFT); expect("\033[57454;1u");
+    K(.key = WSAP_VTCORE_KEY_CAPS_LOCK); expect("\033[57358;65u");
 
     mode(1 | 2 | 4);
-    K(.key = TERM_KEY_CAPS_LOCK); expect("");
-    K(.key = TERM_KEY_CAPS_LOCK, .action = TERM_KEY_RELEASE); expect("");
+    K(.key = WSAP_VTCORE_KEY_CAPS_LOCK); expect("");
+    K(.key = WSAP_VTCORE_KEY_CAPS_LOCK, .action = WSAP_VTCORE_KEY_RELEASE); expect("");
 
     mode(1 | 2 | 4 | 8);
-    K(.key = TERM_KEY_CAPS_LOCK); expect("\033[57358;65u");
-    K(.key = TERM_KEY_CAPS_LOCK, .action = TERM_KEY_RELEASE,
-      .mods = TERM_MOD_CAPS); expect("\033[57358;65:3u");
+    K(.key = WSAP_VTCORE_KEY_CAPS_LOCK); expect("\033[57358;65u");
+    K(.key = WSAP_VTCORE_KEY_CAPS_LOCK, .action = WSAP_VTCORE_KEY_RELEASE,
+      .mods = WSAP_VTCORE_MOD_CAPS); expect("\033[57358;65:3u");
 
     mode(1);
-    K(.key = TERM_KEY_LEFT, .mods = TERM_MOD_NUM); expect("\033[1;129D");
-    K(.key = TERM_KEY_LEFT); expect("\033[D");
-    K(.key = TERM_KEY_F1, .mods = TERM_MOD_CAPS); expect("\033[1;65P");
-    K(.codepoint = 'a', .base = 'a', .mods = TERM_MOD_CTRL | TERM_MOD_CAPS);
+    K(.key = WSAP_VTCORE_KEY_LEFT, .mods = WSAP_VTCORE_MOD_NUM); expect("\033[1;129D");
+    K(.key = WSAP_VTCORE_KEY_LEFT); expect("\033[D");
+    K(.key = WSAP_VTCORE_KEY_F1, .mods = WSAP_VTCORE_MOD_CAPS); expect("\033[1;65P");
+    K(.codepoint = 'a', .base = 'a', .mods = WSAP_VTCORE_MOD_CTRL | WSAP_VTCORE_MOD_CAPS);
     expect("\033[97;69u");
-    K(.codepoint = 'a', .base = 'a', .mods = TERM_MOD_CTRL);
+    K(.codepoint = 'a', .base = 'a', .mods = WSAP_VTCORE_MOD_CTRL);
     expect("\033[97;5u");
-    K(.codepoint = 'a', .base = 'a', .text = 'A', .mods = TERM_MOD_CAPS);
+    K(.codepoint = 'a', .base = 'a', .text = 'A', .mods = WSAP_VTCORE_MOD_CAPS);
     expect("A");
-    K(.key = TERM_KEY_RETURN, .mods = TERM_MOD_CAPS); expect("\r");
+    K(.key = WSAP_VTCORE_KEY_RETURN, .mods = WSAP_VTCORE_MOD_CAPS); expect("\r");
 
     mode(1 | 8);
-    K(.codepoint = 'a', .base = 'a', .text = 'A', .mods = TERM_MOD_CAPS);
+    K(.codepoint = 'a', .base = 'a', .text = 'A', .mods = WSAP_VTCORE_MOD_CAPS);
     expect("\033[97;65u");
-    K(.key = TERM_KEY_RETURN, .mods = TERM_MOD_CAPS); expect("\033[13;65u");
+    K(.key = WSAP_VTCORE_KEY_RETURN, .mods = WSAP_VTCORE_MOD_CAPS); expect("\033[13;65u");
 
     mode(0);
-    K(.key = TERM_KEY_LEFT, .mods = TERM_MOD_NUM); expect("\033[D");
-    K(.key = TERM_KEY_F1, .mods = TERM_MOD_CAPS); expect("\033OP");
-    K(.codepoint = 'a', .base = 'a', .mods = TERM_MOD_CTRL | TERM_MOD_CAPS);
+    K(.key = WSAP_VTCORE_KEY_LEFT, .mods = WSAP_VTCORE_MOD_NUM); expect("\033[D");
+    K(.key = WSAP_VTCORE_KEY_F1, .mods = WSAP_VTCORE_MOD_CAPS); expect("\033OP");
+    K(.codepoint = 'a', .base = 'a', .mods = WSAP_VTCORE_MOD_CTRL | WSAP_VTCORE_MOD_CAPS);
     expect("\001");
 
     mode(0);
-    MOUSE(2, 1, .kind = TERM_MOUSE_PRESS);
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_PRESS);
     assert(out_len == 0 && !consumed);
 
-    m.mouse = TERM_MOUSE_NORMAL;
-    MOUSE(2, 1, .kind = TERM_MOUSE_PRESS); expect("\033[M\040\043\042");
-    MOUSE(2, 1, .kind = TERM_MOUSE_RELEASE); expect("\033[M\043\043\042");
-    MOUSE(2, 1, .kind = TERM_MOUSE_MOTION); expect("");
+    m.mouse = WSAP_VTCORE_MOUSE_NORMAL;
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_PRESS); expect("\033[M\040\043\042");
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_RELEASE); expect("\033[M\043\043\042");
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_MOTION); expect("");
 
-    MOUSE(2, 1, .mods = TERM_MOD_SHIFT);
+    MOUSE(2, 1, .mods = WSAP_VTCORE_MOD_SHIFT);
     assert(out_len == 0 && !consumed);
 
-    MOUSE(200, 99, .kind = TERM_MOUSE_PRESS);
+    MOUSE(200, 99, .kind = WSAP_VTCORE_MOUSE_PRESS);
     assert(out_len == 0 && consumed);
 
-    m.mouse_encoding = TERM_MOUSE_ENC_SGR;
-    MOUSE(2, 1, .kind = TERM_MOUSE_PRESS); expect("\033[<0;3;2M");
-    MOUSE(2, 1, .kind = TERM_MOUSE_RELEASE); expect("\033[<0;3;2m");
-    MOUSE(2, 1, .mods = TERM_MOD_CTRL); expect("\033[<16;3;2M");
-    MOUSE(2, 1, .button = TERM_MOUSE_WHEEL_UP); expect("\033[<64;3;2M");
-    m.mouse_encoding = TERM_MOUSE_ENC_SGR_PIXELS;
+    m.mouse_encoding = WSAP_VTCORE_MOUSE_ENC_SGR;
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_PRESS); expect("\033[<0;3;2M");
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_RELEASE); expect("\033[<0;3;2m");
+    MOUSE(2, 1, .mods = WSAP_VTCORE_MOD_CTRL); expect("\033[<16;3;2M");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_WHEEL_UP); expect("\033[<64;3;2M");
+    m.mouse_encoding = WSAP_VTCORE_MOUSE_ENC_SGR_PIXELS;
     MOUSE(2, 1, .pixel = { .x = 25, .y = 17 }); expect("\033[<0;26;18M");
-    m.mouse_encoding = TERM_MOUSE_ENC_URXVT;
-    MOUSE(2, 1, .kind = TERM_MOUSE_PRESS); expect("\033[32;3;2M");
-    m.mouse_encoding = TERM_MOUSE_ENC_X10;
+    m.mouse_encoding = WSAP_VTCORE_MOUSE_ENC_URXVT;
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_PRESS); expect("\033[32;3;2M");
+    m.mouse_encoding = WSAP_VTCORE_MOUSE_ENC_X10;
 
-    m.mouse = TERM_MOUSE_BUTTON;
-    MOUSE(2, 1, .kind = TERM_MOUSE_MOTION, .button = TERM_MOUSE_BUTTON_NONE); expect("");
-    MOUSE(2, 1, .kind = TERM_MOUSE_MOTION, .button = TERM_MOUSE_BUTTON_PRIMARY);
+    m.mouse = WSAP_VTCORE_MOUSE_BUTTON;
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_MOTION, .button = WSAP_VTCORE_MOUSE_BUTTON_NONE); expect("");
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_MOTION, .button = WSAP_VTCORE_MOUSE_BUTTON_PRIMARY);
     expect("\033[M\100\043\042");
-    m.mouse_encoding = TERM_MOUSE_ENC_SGR;
-    MOUSE(2, 1, .kind = TERM_MOUSE_MOTION, .button = TERM_MOUSE_BUTTON_NONE); expect("");
-    MOUSE(2, 1, .kind = TERM_MOUSE_MOTION, .button = TERM_MOUSE_BUTTON_PRIMARY, .mods = TERM_MOD_CTRL);
+    m.mouse_encoding = WSAP_VTCORE_MOUSE_ENC_SGR;
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_MOTION, .button = WSAP_VTCORE_MOUSE_BUTTON_NONE); expect("");
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_MOTION, .button = WSAP_VTCORE_MOUSE_BUTTON_PRIMARY, .mods = WSAP_VTCORE_MOD_CTRL);
     expect("\033[<48;3;2M");
-    m.mouse = TERM_MOUSE_ANY;
-    MOUSE(2, 1, .kind = TERM_MOUSE_MOTION, .button = TERM_MOUSE_BUTTON_NONE); expect("\033[<35;3;2M");
-    m.mouse_encoding = TERM_MOUSE_ENC_X10;
-    MOUSE(2, 1, .button = TERM_MOUSE_WHEEL_UP); expect("\033[M\140\043\042");
+    m.mouse = WSAP_VTCORE_MOUSE_ANY;
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_MOTION, .button = WSAP_VTCORE_MOUSE_BUTTON_NONE); expect("\033[<35;3;2M");
+    m.mouse_encoding = WSAP_VTCORE_MOUSE_ENC_X10;
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_WHEEL_UP); expect("\033[M\140\043\042");
 
-    m.mouse = TERM_MOUSE_X10;
-    MOUSE(2, 1, .kind = TERM_MOUSE_PRESS); expect("\033[M\040\043\042");
-    MOUSE(2, 1, .kind = TERM_MOUSE_RELEASE); expect("");
+    m.mouse = WSAP_VTCORE_MOUSE_X10;
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_PRESS); expect("\033[M\040\043\042");
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_RELEASE); expect("");
 
     {
-        struct term_keyboard_state s2 = {0};
-        struct term_modes m2 = { .keyboard = 1 | 2 | 8, .grid = { .x = 80, .y = 24 } };
+        struct wsap_vtcore_keyboard_state s2 = {0};
+        struct wsap_vtcore_modes m2 = { .keyboard = 1 | 2 | 8, .grid = { .x = 80, .y = 24 } };
         char b2[64];
 
-        struct term_key_event sh = {
-            .key = TERM_KEY_LSHIFT, .action = TERM_KEY_PRESS,
-            .mods = TERM_MOD_SHIFT,
+        struct wsap_vtcore_key_event sh = {
+            .key = WSAP_VTCORE_KEY_LSHIFT, .action = WSAP_VTCORE_KEY_PRESS,
+            .mods = WSAP_VTCORE_MOD_SHIFT,
         };
-        term_keyboard_update(&s2, &sh);
-        struct term_key_event rsh = {
-            .key = TERM_KEY_RSHIFT, .action = TERM_KEY_PRESS,
-            .mods = TERM_MOD_SHIFT,
+        wsap_vtcore_keyboard_update(&s2, &sh);
+        struct wsap_vtcore_key_event rsh = {
+            .key = WSAP_VTCORE_KEY_RSHIFT, .action = WSAP_VTCORE_KEY_PRESS,
+            .mods = WSAP_VTCORE_MOD_SHIFT,
         };
-        term_keyboard_update(&s2, &rsh);
+        wsap_vtcore_keyboard_update(&s2, &rsh);
 
-        struct term_key_event rel = {
-            .key = TERM_KEY_LSHIFT, .action = TERM_KEY_RELEASE,
-            .mods = TERM_MOD_SHIFT,
+        struct wsap_vtcore_key_event rel = {
+            .key = WSAP_VTCORE_KEY_LSHIFT, .action = WSAP_VTCORE_KEY_RELEASE,
+            .mods = WSAP_VTCORE_MOD_SHIFT,
         };
-        term_keyboard_update(&s2, &rel);
-        struct term_input_result r =
-            term_input_encode_key(&s2, &rel, &m2, b2, sizeof(b2));
-        assert(r.status == TERM_INPUT_BYTES);
+        wsap_vtcore_keyboard_update(&s2, &rel);
+        struct wsap_vtcore_input_result r =
+            wsap_vtcore_input_encode_key(&s2, &rel, &m2, b2, sizeof(b2));
+        assert(r.status == WSAP_VTCORE_INPUT_BYTES);
         assert(!memcmp(b2, "\033[57441;2:3u", r.len));
 
-        struct term_key_event rrel = {
-            .key = TERM_KEY_RSHIFT, .action = TERM_KEY_RELEASE,
-            .mods = TERM_MOD_SHIFT,
+        struct wsap_vtcore_key_event rrel = {
+            .key = WSAP_VTCORE_KEY_RSHIFT, .action = WSAP_VTCORE_KEY_RELEASE,
+            .mods = WSAP_VTCORE_MOD_SHIFT,
         };
-        term_keyboard_update(&s2, &rrel);
-        r = term_input_encode_key(&s2, &rrel, &m2, b2, sizeof(b2));
+        wsap_vtcore_keyboard_update(&s2, &rrel);
+        r = wsap_vtcore_input_encode_key(&s2, &rrel, &m2, b2, sizeof(b2));
         assert(!memcmp(b2, "\033[57447;1:3u", r.len));
     }
 
     {
         char tiny[4];
-        struct term_input_result r = term_input_encode_key(
+        struct wsap_vtcore_input_result r = wsap_vtcore_input_encode_key(
             &st,
-            &(struct term_key_event){
-                .key = TERM_KEY_DELETE, .action = TERM_KEY_PRESS,
-                .mods = TERM_MOD_CTRL | TERM_MOD_ALT | TERM_MOD_SHIFT,
+            &(struct wsap_vtcore_key_event){
+                .key = WSAP_VTCORE_KEY_DELETE, .action = WSAP_VTCORE_KEY_PRESS,
+                .mods = WSAP_VTCORE_MOD_CTRL | WSAP_VTCORE_MOD_ALT | WSAP_VTCORE_MOD_SHIFT,
             },
-            &(struct term_modes){ .grid = { .x = 80, .y = 24 } },
+            &(struct wsap_vtcore_modes){ .grid = { .x = 80, .y = 24 } },
             tiny, sizeof(tiny));
-        assert(r.status == TERM_INPUT_BUFFER_FULL && r.len == 0);
+        assert(r.status == WSAP_VTCORE_INPUT_BUFFER_FULL && r.len == 0);
     }
 
     {
-        struct term_keyboard_state s5 = {0};
-        struct term_key_event bad = {
-            .key = UINT16_MAX, .action = TERM_KEY_PRESS,
+        struct wsap_vtcore_keyboard_state s5 = {0};
+        struct wsap_vtcore_key_event bad = {
+            .key = UINT16_MAX, .action = WSAP_VTCORE_KEY_PRESS,
         };
-        term_keyboard_update(&s5, &bad);
-        assert(!term_keyboard_key_down(&s5, TERM_KEY_LSHIFT));
-        struct term_input_result r =
-            term_input_encode_key(&s5, &bad, &m, out, sizeof(out));
-        assert(r.status == TERM_INPUT_UNHANDLED && r.len == 0);
-
-        struct term_key_event bad_kp = {
-            .key = TERM_KEY_KP_1, .keypad = UINT16_MAX,
-            .action = TERM_KEY_PRESS,
+        wsap_vtcore_keyboard_update(&s5, &bad);
+        assert(!wsap_vtcore_keyboard_key_down(&s5, WSAP_VTCORE_KEY_LSHIFT));
+        struct wsap_vtcore_input_result r =
+            wsap_vtcore_input_encode_key(&s5, &bad, &m, out, sizeof(out));
+        assert(r.status == WSAP_VTCORE_INPUT_UNHANDLED && r.len == 0);
+
+        struct wsap_vtcore_key_event bad_kp = {
+            .key = WSAP_VTCORE_KEY_KP_1, .keypad = UINT16_MAX,
+            .action = WSAP_VTCORE_KEY_PRESS,
         };
         m.app_keypad = true;
-        r = term_input_encode_key(&s5, &bad_kp, &m, out, sizeof(out));
+        r = wsap_vtcore_input_encode_key(&s5, &bad_kp, &m, out, sizeof(out));
         assert(r.len == 0);
         m.app_keypad = false;
     }
 
     {
-        struct term_key_event deferred = {
-            .action = TERM_KEY_PRESS, .codepoint = 'a', .text = 'a',
+        struct wsap_vtcore_key_event deferred = {
+            .action = WSAP_VTCORE_KEY_PRESS, .codepoint = 'a', .text = 'a',
             .text_deferred = true,
         };
-        struct term_input_result r = term_input_encode_key(
-            &st, &deferred, &(struct term_modes){0}, out, sizeof(out));
-        assert(r.status == TERM_INPUT_UNHANDLED && r.len == 0);
-        struct term_modes kitty = { .keyboard = TERM_KEYBOARD_ALL_KEYS };
-        r = term_input_encode_key(&st, &deferred, &kitty, out, sizeof(out));
-        assert(r.status == TERM_INPUT_BYTES && r.len == strlen("\033[97u"));
+        struct wsap_vtcore_input_result r = wsap_vtcore_input_encode_key(
+            &st, &deferred, &(struct wsap_vtcore_modes){0}, out, sizeof(out));
+        assert(r.status == WSAP_VTCORE_INPUT_UNHANDLED && r.len == 0);
+        struct wsap_vtcore_modes kitty = { .keyboard = WSAP_VTCORE_KEYBOARD_ALL_KEYS };
+        r = wsap_vtcore_input_encode_key(&st, &deferred, &kitty, out, sizeof(out));
+        assert(r.status == WSAP_VTCORE_INPUT_BYTES && r.len == strlen("\033[97u"));
         assert(!memcmp(out, "\033[97u", r.len));
-        deferred.action = TERM_KEY_RELEASE;
-        r = term_input_encode_key(&st, &deferred, &kitty, out, sizeof(out));
-        assert(r.status == TERM_INPUT_CONSUMED && r.len == 0);
+        deferred.action = WSAP_VTCORE_KEY_RELEASE;
+        r = wsap_vtcore_input_encode_key(&st, &deferred, &kitty, out, sizeof(out));
+        assert(r.status == WSAP_VTCORE_INPUT_CONSUMED && r.len == 0);
     }
-    m.mouse = TERM_MOUSE_ANY;
-    m.mouse_encoding = TERM_MOUSE_ENC_SGR;
-    MOUSE(2, 1, .button = TERM_MOUSE_BUTTON_EXTRA_1); expect("\033[<128;3;2M");
-    MOUSE(2, 1, .button = TERM_MOUSE_BUTTON_EXTRA_2); expect("\033[<129;3;2M");
-    MOUSE(2, 1, .button = TERM_MOUSE_BUTTON_EXTRA_3); expect("\033[<130;3;2M");
-    MOUSE(2, 1, .button = TERM_MOUSE_BUTTON_EXTRA_4); expect("\033[<131;3;2M");
-    MOUSE(2, 1, .button = TERM_MOUSE_WHEEL_LEFT); expect("\033[<66;3;2M");
-    MOUSE(2, 1, .button = TERM_MOUSE_WHEEL_RIGHT); expect("\033[<67;3;2M");
+    m.mouse = WSAP_VTCORE_MOUSE_ANY;
+    m.mouse_encoding = WSAP_VTCORE_MOUSE_ENC_SGR;
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_BUTTON_EXTRA_1); expect("\033[<128;3;2M");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_BUTTON_EXTRA_2); expect("\033[<129;3;2M");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_BUTTON_EXTRA_3); expect("\033[<130;3;2M");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_BUTTON_EXTRA_4); expect("\033[<131;3;2M");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_WHEEL_LEFT); expect("\033[<66;3;2M");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_WHEEL_RIGHT); expect("\033[<67;3;2M");
 
     /* Ensure Alt modifier does not collide with extra buttons */
-    MOUSE(2, 1, .button = TERM_MOUSE_BUTTON_PRIMARY, .mods = TERM_MOD_ALT); expect("\033[<8;3;2M");
-    MOUSE(2, 1, .button = TERM_MOUSE_BUTTON_EXTRA_1, .mods = TERM_MOD_ALT); expect("\033[<136;3;2M");
-    MOUSE(2, 1, .button = TERM_MOUSE_BUTTON_MIDDLE, .mods = TERM_MOD_ALT); expect("\033[<9;3;2M");
-    MOUSE(2, 1, .button = TERM_MOUSE_BUTTON_EXTRA_2, .mods = TERM_MOD_ALT); expect("\033[<137;3;2M");
-    MOUSE(2, 1, .kind = TERM_MOUSE_RELEASE, .button = TERM_MOUSE_BUTTON_EXTRA_1); expect("\033[<128;3;2m");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_BUTTON_PRIMARY, .mods = WSAP_VTCORE_MOD_ALT); expect("\033[<8;3;2M");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_BUTTON_EXTRA_1, .mods = WSAP_VTCORE_MOD_ALT); expect("\033[<136;3;2M");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_BUTTON_MIDDLE, .mods = WSAP_VTCORE_MOD_ALT); expect("\033[<9;3;2M");
+    MOUSE(2, 1, .button = WSAP_VTCORE_MOUSE_BUTTON_EXTRA_2, .mods = WSAP_VTCORE_MOD_ALT); expect("\033[<137;3;2M");
+    MOUSE(2, 1, .kind = WSAP_VTCORE_MOUSE_RELEASE, .button = WSAP_VTCORE_MOUSE_BUTTON_EXTRA_1); expect("\033[<128;3;2m");
 
     {
         /* A host sizes the paste buffer from the text alone. */
         static const char text[] = "ls\r\n\033[31m\u202erm\x7f\t\xe4\xb8\xad";
         static const char want[] = "\033[200~ls\r[31mrm\t\xe4\xb8\xad\033[201~";
-        char buf[sizeof(text) - 1 + TERM_PASTE_EXTRA];
-        struct term_modes bracketed = { .bracketed_paste = true };
-        struct term_input_result r =
-            term_input_encode_paste(&bracketed, text, sizeof(text) - 1, buf, sizeof(buf));
-        assert(r.status == TERM_INPUT_BYTES && r.len == sizeof(want) - 1);
+        char buf[sizeof(text) - 1 + WSAP_VTCORE_PASTE_EXTRA];
+        struct wsap_vtcore_modes bracketed = { .bracketed_paste = true };
+        struct wsap_vtcore_input_result r =
+            wsap_vtcore_input_encode_paste(&bracketed, text, sizeof(text) - 1, buf, sizeof(buf));
+        assert(r.status == WSAP_VTCORE_INPUT_BYTES && r.len == sizeof(want) - 1);
         assert(!memcmp(buf, want, r.len));
 
-        r = term_input_encode_paste(&bracketed, text, sizeof(text) - 1, buf, r.len - 1);
-        assert(r.status == TERM_INPUT_BUFFER_FULL && r.len == 0);
+        r = wsap_vtcore_input_encode_paste(&bracketed, text, sizeof(text) - 1, buf, r.len - 1);
+        assert(r.status == WSAP_VTCORE_INPUT_BUFFER_FULL && r.len == 0);
 
-        r = term_input_encode_paste(&bracketed, "\033\a\u2066", 5, buf, sizeof(buf));
-        assert(r.status == TERM_INPUT_CONSUMED && r.len == 0);
+        r = wsap_vtcore_input_encode_paste(&bracketed, "\033\a\u2066", 5, buf, sizeof(buf));
+        assert(r.status == WSAP_VTCORE_INPUT_CONSUMED && r.len == 0);
 
-        struct term_modes plain = {0};
-        r = term_input_encode_paste(&plain, "a\nb", 3, buf, 3);
-        assert(r.status == TERM_INPUT_BYTES && r.len == 3 && !memcmp(buf, "a\rb", 3));
+        struct wsap_vtcore_modes plain = {0};
+        r = wsap_vtcore_input_encode_paste(&plain, "a\nb", 3, buf, 3);
+        assert(r.status == WSAP_VTCORE_INPUT_BYTES && r.len == 3 && !memcmp(buf, "a\rb", 3));
     }
     {
-        mode(TERM_KEYBOARD_ALL_KEYS | TERM_KEYBOARD_EVENT_TYPES);
-        K(.key = TERM_KEY_NUM_LOCK); expect("\033[57360;129u");
-        K(.key = TERM_KEY_NUM_LOCK, .action = TERM_KEY_REPEAT,
-          .mods = TERM_MOD_NUM); expect("\033[57360;129:2u");
-        K(.key = TERM_KEY_NUM_LOCK, .action = TERM_KEY_RELEASE,
-          .mods = TERM_MOD_NUM); expect("\033[57360;129:3u");
-        K(.key = TERM_KEY_NUM_LOCK, .mods = TERM_MOD_NUM); expect("\033[57360;1u");
-        K(.key = TERM_KEY_SCROLL_LOCK); expect("\033[57359;1u");
+        mode(WSAP_VTCORE_KEYBOARD_ALL_KEYS | WSAP_VTCORE_KEYBOARD_EVENT_TYPES);
+        K(.key = WSAP_VTCORE_KEY_NUM_LOCK); expect("\033[57360;129u");
+        K(.key = WSAP_VTCORE_KEY_NUM_LOCK, .action = WSAP_VTCORE_KEY_REPEAT,
+          .mods = WSAP_VTCORE_MOD_NUM); expect("\033[57360;129:2u");
+        K(.key = WSAP_VTCORE_KEY_NUM_LOCK, .action = WSAP_VTCORE_KEY_RELEASE,
+          .mods = WSAP_VTCORE_MOD_NUM); expect("\033[57360;129:3u");
+        K(.key = WSAP_VTCORE_KEY_NUM_LOCK, .mods = WSAP_VTCORE_MOD_NUM); expect("\033[57360;1u");
+        K(.key = WSAP_VTCORE_KEY_SCROLL_LOCK); expect("\033[57359;1u");
     }
 
     {
         /* UTF-8 writes must report overflow without crossing the capacity. */
-        struct term_key_event key = { .action = TERM_KEY_PRESS, .text = 0x4e2d };
-        struct term_mouse_event mouse = {
-            .kind = TERM_MOUSE_PRESS, .button = TERM_MOUSE_BUTTON_PRIMARY,
+        struct wsap_vtcore_key_event key = { .action = WSAP_VTCORE_KEY_PRESS, .text = 0x4e2d };
+        struct wsap_vtcore_mouse_event mouse = {
+            .kind = WSAP_VTCORE_MOUSE_PRESS, .button = WSAP_VTCORE_MOUSE_BUTTON_PRIMARY,
             .pos = { .x = 190, .y = 95 },
         };
-        struct term_modes modes = {
-            .mouse = TERM_MOUSE_ANY, .mouse_encoding = TERM_MOUSE_ENC_UTF8,
+        struct wsap_vtcore_modes modes = {
+            .mouse = WSAP_VTCORE_MOUSE_ANY, .mouse_encoding = WSAP_VTCORE_MOUSE_ENC_UTF8,
             .grid = { .x = 256, .y = 128 },
         };
         static const char *const want[] = { "\xe4\xb8\xad", "\033[M \xc3\x9f\xc2\x80" };
@@ -400,14 +400,14 @@ int main(void)
             size_t len = strlen(want[which]);
             for (size_t cap = 0; cap <= len + 1; cap++) {
                 memset(buf, '!', sizeof(buf));
-                struct term_input_result r = which == 0
-                    ? term_input_encode_key(NULL, &key, &modes, buf, cap)
-                    : term_input_encode_mouse(&mouse, &modes, buf, cap);
+                struct wsap_vtcore_input_result r = which == 0
+                    ? wsap_vtcore_input_encode_key(NULL, &key, &modes, buf, cap)
+                    : wsap_vtcore_input_encode_mouse(&mouse, &modes, buf, cap);
                 assert(buf[cap] == '!');
                 if (cap < len) {
-                    assert(r.status == TERM_INPUT_BUFFER_FULL && r.len == 0);
+                    assert(r.status == WSAP_VTCORE_INPUT_BUFFER_FULL && r.len == 0);
                 } else {
-                    assert(r.status == TERM_INPUT_BYTES && r.len == len);
+                    assert(r.status == WSAP_VTCORE_INPUT_BYTES && r.len == len);
                     assert(!memcmp(buf, want[which], len));
                 }
             }