basic.c

/*
 *
 *    _____ ____  __  __        ____           _____ _____ _____ 
 *   / ____|  _ \|  \/  |      |  _ \   /\    / ____|_   _/ ____|
 *  | |    | |_) | \  / |______| |_) | /  \  | (___   | || |     
 *  | |    |  _ <| |\/| |______|  _ < / /\ \  \___ \  | || |     
 *  | |____| |_) | |  | |      | |_) / ____ \ ____) |_| || |____ 
 *   \_____|____/|_|  |_|      |____/_/    \_\_____/|_____\_____|                                                           
 *  .............................................................
 *
 *  [Version 0.1.0]
 * 
 * BASIC interpreter targeting CBM BASIC v2 style programs.
 * Copyright (C) 2024  Davepl with various AI assists
 *
 * Based on the original by David Plummer:
 * https://github.com/davepl/pdpsrc/tree/main/bsd/basic
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * BASIC banner: implements a minimal 6502 Microsoft/CBM BASIC v2 compatible
 * interpreter (PRINT, INPUT, IF/THEN, FOR/NEXT, GOTO, GOSUB, DIM, etc.).
 */

#if (defined(__unix__) || defined(__linux__) || defined(__APPLE__) || defined(__MACH__)) && !defined(_POSIX_C_SOURCE) && !defined(_GNU_SOURCE)
#define _POSIX_C_SOURCE 200809L
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <time.h>
#include <stdint.h>
#include "petscii.h"

#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#include <emscripten/em_js.h>
#endif

/* Last HTTP response status from HTTP$ (set on Emscripten; 0 otherwise). */
static int http_last_status;

#ifdef __EMSCRIPTEN__
/*
 * Async fetch for HTTP$ (EM_ASYNC_JS → Asyncify.handleAsync; no manual ASYNCIFY_IMPORTS).
 * Writes response body into out; sets *status_out to HTTP status (0 on network error).
 */
EM_ASYNC_JS(int, wasm_js_http_fetch_async, (const char *url, const char *method, const char *body, int body_len, char *out, int out_cap, int *status_out), {
  var urlJs = UTF8ToString(url);
  var methodJs = method ? UTF8ToString(method) : "GET";
  var init = { method: methodJs };
  if (body && body_len > 0) {
    init.body = HEAPU8.subarray(body, body + body_len >>> 0);
  }
  try {
    const resp = await fetch(urlJs, init);
    HEAP32[status_out >> 2] = resp.status;
    const text = await resp.text();
    stringToUTF8(text, out, out_cap);
  } catch (e) {
    HEAP32[status_out >> 2] = 0;
    if (out_cap > 0) HEAPU8[out] = 0;
  }
  return 0;
});

static void wasm_http_fetch_emscripten(const char *url, const char *method, const char *body, int body_len,
    char *out, size_t out_size, int *status_out)
{
    const char *m = (method && method[0]) ? method : "GET";
    if (out_size == 0) {
        return;
    }
    out[0] = '\0';
    if (status_out) {
        *status_out = 0;
    }
    if (!url || !url[0] || !status_out) {
        return;
    }
    wasm_js_http_fetch_async(url, m, body, body_len, out, (int)out_size, status_out);
}
#endif

#ifdef GFX_VIDEO
#include "gfx_video.h"
#include "gfx_charrom.h"
#include "gfx_gamepad.h"
#include "basic_api.h"
#if defined(__EMSCRIPTEN__)
#include "gfx_canvas.h"
#include "gfx_software_sprites.h"
#endif
/* Video state pointer; must precede __EMSCRIPTEN__ key helpers that reference gfx_vs. */
static GfxVideoState *gfx_vs = NULL;

/* Virtual POKE/PEEK bases for gfx builds (defaults: C64-style). #OPTION memory / screen / … */
static uint16_t gfx_mem_base_text = GFX_TEXT_BASE;
static uint16_t gfx_mem_base_color = GFX_COLOR_BASE;
static uint16_t gfx_mem_base_char = GFX_CHAR_BASE;
static uint16_t gfx_mem_base_key = GFX_KEY_BASE;
static uint16_t gfx_mem_base_bitmap = GFX_BITMAP_BASE;
/* Baseline after CLI parsing; restored at each load so #OPTION starts from CLI layout. */
static uint16_t gfx_mem_init_text = GFX_TEXT_BASE;
static uint16_t gfx_mem_init_color = GFX_COLOR_BASE;
static uint16_t gfx_mem_init_char = GFX_CHAR_BASE;
static uint16_t gfx_mem_init_key = GFX_KEY_BASE;
static uint16_t gfx_mem_init_bitmap = GFX_BITMAP_BASE;

static void gfx_mem_bases_restore_from_init(void)
{
    gfx_mem_base_text = gfx_mem_init_text;
    gfx_mem_base_color = gfx_mem_init_color;
    gfx_mem_base_char = gfx_mem_init_char;
    gfx_mem_base_key = gfx_mem_init_key;
    gfx_mem_base_bitmap = gfx_mem_init_bitmap;
}

static int gfx_mem_bases_apply_to_video(void)
{
    if (!gfx_vs) {
        return 0;
    }
    return gfx_video_set_memory_bases(gfx_vs,
        gfx_mem_base_text, gfx_mem_base_color, gfx_mem_base_char,
        gfx_mem_base_key, gfx_mem_base_bitmap);
}

static void gfx_mem_bases_copy_to_state(GfxVideoState *s)
{
    s->mem_text = gfx_mem_base_text;
    s->mem_color = gfx_mem_base_color;
    s->mem_char = gfx_mem_base_char;
    s->mem_key = gfx_mem_base_key;
    s->mem_bitmap = gfx_mem_base_bitmap;
}

/* Parse 1024, $400, or 0x400 into 16-bit address. */
static int parse_gfx_addr_u16(const char *value, uint16_t *out)
{
    char *end;
    unsigned long v;
    const char *p;
    if (!value || !value[0] || !out) return -1;
    p = value;
    if (p[0] == '$') {
        p++;
        v = strtoul(p, &end, 16);
    } else {
        v = strtoul(p, &end, 0);
    }
    if (end == p || *end != '\0' || v > 0xFFFFul) return -1;
    *out = (uint16_t)v;
    return 0;
}

static int gfx_mem_try_preset(const char *value)
{
    GfxVideoState tmp;
    gfx_video_init(&tmp);
    gfx_mem_bases_copy_to_state(&tmp);
    if (gfx_video_apply_memory_preset(&tmp, value) != 0) {
        return -1;
    }
    gfx_mem_base_text = tmp.mem_text;
    gfx_mem_base_color = tmp.mem_color;
    gfx_mem_base_char = tmp.mem_char;
    gfx_mem_base_key = tmp.mem_key;
    gfx_mem_base_bitmap = tmp.mem_bitmap;
    if (gfx_vs) {
        return gfx_mem_bases_apply_to_video();
    }
    return 0;
}

static int gfx_mem_try_set_region(GfxMemRegion region, uint32_t base)
{
    GfxVideoState tmp;
    gfx_video_init(&tmp);
    gfx_mem_bases_copy_to_state(&tmp);
    if (gfx_video_set_memory_base(&tmp, region, base) != 0) {
        return -1;
    }
    gfx_mem_base_text = tmp.mem_text;
    gfx_mem_base_color = tmp.mem_color;
    gfx_mem_base_char = tmp.mem_char;
    gfx_mem_base_key = tmp.mem_key;
    gfx_mem_base_bitmap = tmp.mem_bitmap;
    if (gfx_vs) {
        return gfx_mem_bases_apply_to_video();
    }
    return 0;
}

static void gfx_mem_snapshot_init(void)
{
    gfx_mem_init_text = gfx_mem_base_text;
    gfx_mem_init_color = gfx_mem_base_color;
    gfx_mem_init_char = gfx_mem_base_char;
    gfx_mem_init_key = gfx_mem_base_key;
    gfx_mem_init_bitmap = gfx_mem_base_bitmap;
}

#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
/* Canvas WASM: TI/TI$ from high-res clock (tight GOTO loops have no SLEEP). */
static double wasm_gfx_ti_epoch_ms;
/* Canvas WASM: trek.bas-style lines pack many ':' statements; yield inside long PRINT too. */
static unsigned wasm_gfx_put_budget;
/* Yield every few execute_statement calls — LET/GOTO/IF on one line skip gfx_put_byte. */
static unsigned wasm_gfx_stmt_exec_budget;
/* Trek SRS: thousands of MID$/LEFT$/RIGHT$ per PRINT — yield every N builtin calls. */
static unsigned wasm_str_builtin_budget;
/* Q$=LEFT$+A$+RIGHT$ (eval_addsub): separate budget so FOR/NEXT tests are not slowed. */
static unsigned wasm_str_concat_budget;
#endif
#endif
#if defined(__EMSCRIPTEN__)
/* Browser: no termios, no Windows API */
#elif defined(_WIN32)
#include <windows.h>
#include <conio.h>
#else
#if defined(__unix__) || defined(__APPLE__) || defined(__MACH__)
#include <unistd.h>
#include <termios.h>
#endif
#ifndef HAVE_USLEEP
#include <sys/types.h>
#include <sys/times.h>
#include <sys/param.h>
#include <sys/time.h>
#endif
#ifndef HAVE_USLEEP
#if defined(__APPLE__) || defined(__MACH__) || defined(__linux__) || defined(_POSIX_VERSION)
#define HAVE_USLEEP 1
#endif
#endif
#endif

/* Helper structures for token expansion inside BASIC strings
 * (e.g., translating {RED} to CHR$(28) at source level).
 */
typedef struct {
    char *buf;
    size_t len;
    size_t cap;
} StrBuf;

typedef struct {
    const char *name;
    int code;
} TokenMap;

static int is_ident_char(int c)
{
    return isalpha((unsigned char)c) || isdigit((unsigned char)c) || c == '$' || c == '_';
}

/* Token map: C64 control/color codes. See docs/c64-color-codes.md for reference.
 * Multiple names may map to the same code (case-insensitive). */
static const TokenMap token_map[] = {
    /* Colors (full names) */
    {"WHITE", 5},
    {"RED", 28},
    {"CYAN", 159},
    {"PURPLE", 156},
    {"GREEN", 30},
    {"BLUE", 31},
    {"YELLOW", 158},
    {"ORANGE", 129},
    {"BROWN", 149},
    {"PINK", 150},
    {"BLACK", 144},
    /* Colors (abbreviations) */
    {"WHT", 5},
    {"BLK", 144},
    {"CYN", 159},
    {"PUR", 156},
    {"GRN", 30},
    {"BLU", 31},
    {"YEL", 158},
    /* Greys */
    {"GRAY1", 151},
    {"GREY1", 151},
    {"DARKGREY", 151},
    {"DARKGRAY", 151},
    {"GRAY2", 152},
    {"GREY2", 152},
    {"GREY", 152},
    {"GRAY", 152},
    {"GRAY3", 155},
    {"GREY3", 155},
    {"LIGHTGREY", 155},
    {"LIGHTGRAY", 155},
    {"LIGHTGREEN", 153},
    {"LIGHT GREEN", 153},
    {"LIGHTBLUE", 154},
    {"LIGHT BLUE", 154},
    {"LIGHT-RED", 150},

    /* Screen/control */
    {"HOME", 19},
    {"DOWN", 17},
    {"UP", 145},
    {"LEFT", 157},
    {"RIGHT", 29},
    {"DEL", 20},
    {"DELETE", 20},
    {"INS", 148},
    {"INST", 148},
    {"INSERT", 148},
    {"CLR", 147},
    {"CLEAR", 147},
    {"SPACE", 32},
    {"RETURN", 13},
    {"SHIFT RETURN", 141},
    /* Cursor variants */
    {"CURSOR UP", 145},
    {"CURSOR DOWN", 17},
    {"CURSOR LEFT", 157},
    {"CURSOR RIGHT", 29},
    {"CRSR UP", 145},
    {"CRSR DOWN", 17},
    {"CRSR LEFT", 157},
    {"CRSR RIGHT", 29},
    /* Reverse video */
    {"RVS", 18},
    {"RVS ON", 18},
    {"RVSON", 18},
    {"REVERSE ON", 18},
    {"RVS OFF", 146},
    {"RVSOFF", 146},
    {"REVERSE OFF", 146},
    /* Function keys */
    {"F1", 133},
    {"F2", 137},
    {"F3", 134},
    {"F4", 138},
    {"F5", 135},
    {"F6", 139},
    {"F7", 136},
    {"F8", 140},
    /* Symbol */
    {"PI", 126},
    /* ANSI reset (terminal only): resets colors/attributes to default. No C64 equivalent. */
    {"RESET", 256},
    {"DEFAULT", 256},

    {NULL, 0}
};

/* PETSCII/ANSI mode (set by -petscii, #OPTION); declared early for gfx_put_byte. */
static int petscii_mode = 0;

static void sb_init(StrBuf *sb)
{
    sb->cap = 256;
    sb->len = 0;
    sb->buf = (char *)malloc(sb->cap);
    if (!sb->buf) {
        fprintf(stderr, "Out of memory\n");
        exit(1);
    }
    sb->buf[0] = '\0';
}

static void sb_reserve(StrBuf *sb, size_t extra)
{
    if (sb->len + extra + 1 <= sb->cap) {
        return;
    }
    while (sb->len + extra + 1 > sb->cap) {
        sb->cap *= 2;
    }
    {
        char *newbuf = (char *)realloc(sb->buf, sb->cap);
        if (!newbuf) {
            free(sb->buf);
            fprintf(stderr, "Out of memory\n");
            exit(1);
        }
        sb->buf = newbuf;
    }
}

static void sb_append_char(StrBuf *sb, char c)
{
    sb_reserve(sb, 1);
    sb->buf[sb->len++] = c;
    sb->buf[sb->len] = '\0';
}

static void sb_append_mem(StrBuf *sb, const char *s, size_t n)
{
    sb_reserve(sb, n);
    memcpy(sb->buf + sb->len, s, n);
    sb->len += n;
    sb->buf[sb->len] = '\0';
}

static void sb_append_str(StrBuf *sb, const char *s)
{
    sb_append_mem(sb, s, strlen(s));
}

static char *dup_upper_trim(const char *src, size_t len)
{
    char *out;
    size_t i;

    while (len > 0 && isspace((unsigned char)*src)) {
        src++;
        len--;
    }
    while (len > 0 && isspace((unsigned char)src[len - 1])) {
        len--;
    }

    out = (char *)malloc(len + 1);
    if (!out) {
        fprintf(stderr, "Out of memory\n");
        exit(1);
    }

    for (i = 0; i < len; i++) {
        out[i] = (char)toupper((unsigned char)src[i]);
    }
    out[len] = '\0';
    return out;
}

static int lookup_token_code(const char *token, int *code_out)
{
    char *endptr = NULL;
    long n;

    /* Decimal: {147} */
    n = strtol(token, &endptr, 10);
    if (*token != '\0' && *endptr == '\0') {
        if (n >= 0 && n <= 255) {
            *code_out = (int)n;
            return 1;
        }
        return 0;
    }

    /* Hex: {$93} or {0x93} */
    if (*token == '$') {
        n = strtol(token + 1, &endptr, 16);
        if (endptr && *endptr == '\0' && n >= 0 && n <= 255) {
            *code_out = (int)n;
            return 1;
        }
    }
    if ((token[0] == '0' && (token[1] == 'x' || token[1] == 'X'))) {
        n = strtol(token + 2, &endptr, 16);
        if (endptr && *endptr == '\0' && n >= 0 && n <= 255) {
            *code_out = (int)n;
            return 1;
        }
    }

    /* Binary: {%10010011} */
    if (*token == '%') {
        n = strtol(token + 1, &endptr, 2);
        if (endptr && *endptr == '\0' && n >= 0 && n <= 255) {
            *code_out = (int)n;
            return 1;
        }
    }

    {
        int i;
        for (i = 0; token_map[i].name != NULL; i++) {
            if (strcmp(token, token_map[i].name) == 0) {
                *code_out = token_map[i].code;
                return 1;
            }
        }
    }

    return 0;
}

static void append_quoted(StrBuf *out, const char *text, size_t len)
{
    sb_append_char(out, '\"');
    sb_append_mem(out, text, len);
    sb_append_char(out, '\"');
}

/* Transform a BASIC source line so that tokens inside quoted strings of the form
 *   "HELLO {RED}WORLD"
 * are expanded to:
 *   "HELLO ";CHR$(28);"WORLD"
 * Tokens map either to explicit numeric CHR$ codes or to named PETSCII
 * control/color names in token_map[].
 */
static char *transform_basic_line(const char *input)
{
    StrBuf out;
    int in_string = 0;
    const char *segment_start = NULL;
    int piece_count = 0;
    size_t i;

    sb_init(&out);

    for (i = 0; input[i] != '\0'; i++) {
        char c = input[i];

        if (!in_string) {
            if (c == '\"') {
                in_string = 1;
                segment_start = input + i + 1;
                piece_count = 0;
            } else {
                sb_append_char(&out, c);
            }
            continue;
        }

        if (c == '{') {
            size_t j = i + 1;
            while (input[j] != '\0' && input[j] != '}') {
                j++;
            }

            if (input[j] == '}') {
                char *token = dup_upper_trim(input + i + 1, j - (i + 1));
                int code = 0;

                if (lookup_token_code(token, &code)) {
                    size_t seg_len = (size_t)((input + i) - segment_start);

                    if (seg_len > 0) {
                        if (piece_count > 0) {
                            sb_append_char(&out, '+');
                        }
                        append_quoted(&out, segment_start, seg_len);
                        piece_count++;
                    }

                    if (piece_count > 0) {
                        sb_append_char(&out, '+');
                    }

                    if (code == 256) {
                        /* ANSI reset: ESC [ 0 m — resets terminal to default colors/attributes */
                        sb_append_str(&out, "CHR$(27)+\"[0m\"");
                    } else {
                        char tmp[32];
                        sprintf(tmp, "CHR$(%d)", code);
                        sb_append_str(&out, tmp);
                    }
                    piece_count++;

                    segment_start = input + j + 1;
                    i = j;
                    free(token);
                    continue;
                }

                free(token);
            }

            continue;
        }

        if (c == '\"') {
            size_t seg_len = (size_t)((input + i) - segment_start);

            if (seg_len > 0 || piece_count == 0) {
                if (piece_count > 0) {
                    sb_append_char(&out, '+');
                }
                append_quoted(&out, segment_start, seg_len);
            }

            in_string = 0;
            segment_start = NULL;
            piece_count = 0;
            continue;
        }
    }

    if (in_string) {
        sb_append_char(&out, '\"');
        if (segment_start) {
            sb_append_str(&out, segment_start);
        }
    }

    return out.buf;
}

/* Normalize certain keywords in a BASIC source line to restore
 * CBM-style whitespace that may have been stripped, e.g.:
 *   IFB3<1THENIFE>10ORD(7)=0THEN GOTO 890
 * becomes:
 *   IF B3<1 THEN IF E>10 OR D(7)=0 THEN GOTO 890
 * The transformation is applied only outside of quoted strings.
 */
static char *normalize_keywords_line(const char *input)
{
    StrBuf out;
    int in_string = 0;
    size_t i = 0;

    sb_init(&out);

    while (input[i] != '\0') {
        char c = input[i];

        if (c == '\"') {
            in_string = !in_string;
            sb_append_char(&out, c);
            i++;
            continue;
        }

        if (!in_string) {
            char c1 = (char)toupper((unsigned char)c);
            char c2 = (char)toupper((unsigned char)input[i + 1]);
            char c3 = (char)toupper((unsigned char)input[i + 2]);
            char c4 = (char)toupper((unsigned char)input[i + 3]);

            /* IF followed immediately by identifier/digit without space */
            /* Do not split JIFFIES_*, DIFF*, etc. — same prev_ident guard as FOR (PLATFORM). */
            if (c1 == 'I' && c2 == 'F') {
                char next = input[i + 2];
                int prev_ident = (i > 0 && (isalnum((unsigned char)input[i - 1]) || input[i - 1] == '$' || input[i - 1] == '_'));
                if (!prev_ident && next != '\0' && !isspace((unsigned char)next) && next != ':' ) {
                    /* Insert space before IF if needed */
                    if (out.len > 0) {
                        char prev = out.buf[out.len - 1];
                        if (!isspace((unsigned char)prev) && prev != ':' && prev != '(') {
                            sb_append_char(&out, ' ');
                        }
                    }
                    sb_append_str(&out, "IF");
                    i += 2;
                    /* Ensure space after IF */
                    sb_append_char(&out, ' ');
                    continue;
                }
            }

            /* FOR followed immediately by identifier/digit: FORI=1TO9 -> FOR I=1TO9 */
            /* Do not split PLATFORM, BEFORE, etc. — only when FOR is a whole word. */
            if (c1 == 'F' && c2 == 'O' && c3 == 'R') {
                char next = input[i + 3];
                int prev_ident = (i > 0 && (isalnum((unsigned char)input[i-1]) || input[i-1] == '$' || input[i-1] == '_'));
                if (!prev_ident && next != '\0' && !isspace((unsigned char)next) && next != ':' ) {
                    if (out.len > 0) {
                        char prev = out.buf[out.len - 1];
                        if (!isspace((unsigned char)prev) && prev != ':' && prev != '(') {
                            sb_append_char(&out, ' ');
                        }
                    }
                    sb_append_str(&out, "FOR");
                    i += 3;
                    sb_append_char(&out, ' ');
                    continue;
                }
            }

            /* GOTO followed immediately by digit: GOTO410 -> GOTO 410 */
            if (c1 == 'G' && c2 == 'O' && c3 == 'T' && (char)toupper((unsigned char)input[i + 3]) == 'O') {
                char next = input[i + 4];
                if (next != '\0' && !isspace((unsigned char)next) && next != ':' ) {
                    if (out.len > 0) {
                        char prev = out.buf[out.len - 1];
                        if (!isspace((unsigned char)prev) && prev != ':' && prev != '(') {
                            sb_append_char(&out, ' ');
                        }
                    }
                    sb_append_str(&out, "GOTO");
                    i += 4;
                    sb_append_char(&out, ' ');
                    continue;
                }
            }

            /* GOSUB followed immediately by digit: GOSUB410 -> GOSUB 410 */
            if (c1 == 'G' && c2 == 'O' && c3 == 'S' && c4 == 'U' &&
                (char)toupper((unsigned char)input[i + 4]) == 'B') {
                char next = input[i + 5];
                if (next != '\0' && !isspace((unsigned char)next) && next != ':' ) {
                    if (out.len > 0) {
                        char prev = out.buf[out.len - 1];
                        if (!isspace((unsigned char)prev) && prev != ':' && prev != '(') {
                            sb_append_char(&out, ' ');
                        }
                    }
                    sb_append_str(&out, "GOSUB");
                    i += 5;
                    sb_append_char(&out, ' ');
                    continue;
                }
            }

            /* NEXT followed immediately by identifier: NEXTI -> NEXT I */
            if (c1 == 'N' && c2 == 'E' && c3 == 'X' && c4 == 'T') {
                char next = input[i + 4];
                if (out.len > 0) {
                    char prev = out.buf[out.len - 1];
                    if (!isspace((unsigned char)prev) && prev != ':' && prev != '(') {
                        sb_append_char(&out, ' ');
                    }
                }
                sb_append_str(&out, "NEXT");
                i += 4;
                if (next != '\0' && !isspace((unsigned char)next) && next != ':' ) {
                    sb_append_char(&out, ' ');
                }
                continue;
            }

            /* THEN */
            if (c1 == 'T' && c2 == 'H' && c3 == 'E' && c4 == 'N') {
                /* Insert space before THEN if needed */
                if (out.len > 0) {
                    char prev = out.buf[out.len - 1];
                    if (!isspace((unsigned char)prev) && prev != ':' && prev != '(') {
                        sb_append_char(&out, ' ');
                    }
                }
                sb_append_str(&out, "THEN");
                i += 4;
                /* Skip any existing spaces after THEN */
                while (isspace((unsigned char)input[i])) {
                    i++;
                }
                /* Ensure one space after THEN if next char is non-separator */
                if (input[i] != '\0' && input[i] != ':' && !isspace((unsigned char)input[i])) {
                    sb_append_char(&out, ' ');
                }
                continue;
            }

            /* TO inside numeric ranges: 1TO9 -> 1 TO 9, but never split GOTO. */
            if (c1 == 'T' && c2 == 'O') {
                size_t j;
                char prev_ns = ' ';
                char next_ns = '\0';

                /* Skip if this is the TO in GOTO (e.g. ...GOTO 100). */
                if (i >= 2) {
                    char g = (char)toupper((unsigned char)input[i - 2]);
                    char o = (char)toupper((unsigned char)input[i - 1]);
                    if (g == 'G' && o == 'O') {
                        /* fall through to normal character handling */
                    } else {
                        /* Find previous non-space character. */
                        j = i;
                        while (j > 0) {
                            j--;
                            if (!isspace((unsigned char)input[j])) {
                                prev_ns = input[j];
                                break;
                            }
                        }
                        /* Find next non-space character after TO. */
                        j = i + 2;
                        while (input[j] != '\0' && isspace((unsigned char)input[j])) {
                            j++;
                        }
                        next_ns = input[j];

                        /* Treat as TO only when between numeric-ish tokens, like 1TO9. */
                        if ((isdigit((unsigned char)prev_ns) || prev_ns == ')') &&
                            (isdigit((unsigned char)next_ns) || next_ns == '+' || next_ns == '-')) {
                            if (out.len > 0) {
                                char prev = out.buf[out.len - 1];
                                if (!isspace((unsigned char)prev) && prev != '(') {
                                    sb_append_char(&out, ' ');
                                }
                            }
                            sb_append_str(&out, "TO");
                            i += 2;
                            if (next_ns != '\0' && !isspace((unsigned char)next_ns) &&
                                next_ns != ':' && next_ns != ')') {
                                sb_append_char(&out, ' ');
                            }
                            continue;
                        }
                    }
                }
            }

            /* AND / OR infix operators without spaces.
             * Only treat as operators when they are not embedded in identifiers
             * (e.g., avoid splitting FOR into F OR, or ORD into OR D).
             */
            if (c1 == 'A' && c2 == 'N' && c3 == 'D') {
                char prev_in = (i > 0) ? input[i - 1] : ' ';
                char next_in = input[i + 3];
                if (!is_ident_char(prev_in) && !is_ident_char(next_in)) {
                    /* Surround AND with spaces */
                    if (out.len > 0) {
                        char prev = out.buf[out.len - 1];
                        if (!isspace((unsigned char)prev) && prev != '(') {
                            sb_append_char(&out, ' ');
                        }
                    }
                    sb_append_str(&out, "AND");
                    i += 3;
                    if (input[i] != '\0' && !isspace((unsigned char)input[i]) && input[i] != ')') {
                        sb_append_char(&out, ' ');
                    }
                    continue;
                }
            }
            if (c1 == 'O' && c2 == 'R') {
                char prev_in = (i > 0) ? input[i - 1] : ' ';
                char next_in = (input[i + 2] != '\0') ? input[i + 2] : ' ';
                if (!is_ident_char(prev_in) && !is_ident_char(next_in)) {
                    if (out.len > 0) {
                        char prev = out.buf[out.len - 1];
                        if (!isspace((unsigned char)prev) && prev != '(') {
                            sb_append_char(&out, ' ');
                        }
                    }
                    sb_append_str(&out, "OR");
                    i += 2;
                    if (input[i] != '\0' && !isspace((unsigned char)input[i]) && input[i] != ')') {
                        sb_append_char(&out, ' ');
                    }
                    continue;
                }
            }
            if (c1 == 'M' && c2 == 'O' && (input[i + 2] == 'D' || input[i + 2] == 'd')) {
                char prev_in = (i > 0) ? input[i - 1] : ' ';
                char next_in = (input[i + 3] != '\0') ? input[i + 3] : ' ';
                if (!isalpha((unsigned char)prev_in) && !isalpha((unsigned char)next_in)) {
                    if (out.len > 0) {
                        char prev = out.buf[out.len - 1];
                        if (!isspace((unsigned char)prev) && prev != '(') {
                            sb_append_char(&out, ' ');
                        }
                    }
                    sb_append_str(&out, "MOD");
                    i += 3;
                    if (input[i] != '\0' && !isspace((unsigned char)input[i]) && input[i] != ')') {
                        sb_append_char(&out, ' ');
                    }
                    continue;
                }
            }
            if (c1 == 'X' && c2 == 'O' && (input[i + 2] == 'R' || input[i + 2] == 'r')) {
                char prev_in = (i > 0) ? input[i - 1] : ' ';
                char next_in = input[i + 3];
                if (!is_ident_char(prev_in) && !is_ident_char(next_in)) {
                    if (out.len > 0) {
                        char prev = out.buf[out.len - 1];
                        if (!isspace((unsigned char)prev) && prev != '(') {
                            sb_append_char(&out, ' ');
                        }
                    }
                    sb_append_str(&out, "XOR");
                    i += 3;
                    if (input[i] != '\0' && !isspace((unsigned char)input[i]) && input[i] != ')') {
                        sb_append_char(&out, ' ');
                    }
                    continue;
                }
            }
        }

        sb_append_char(&out, c);
        i++;
    }

    return out.buf;
}

/* Platform-specific handling for ANSI escape sequences.
 * On Unix-like systems (macOS/Linux), standard ANSI escapes work in most terminals.
 * On Windows, we enable virtual terminal processing where available so that
 * ANSI color/control sequences render correctly instead of being printed literally. */
#if defined(__EMSCRIPTEN__) || defined(_WIN32)
#if defined(_WIN32)
static int ansi_enabled = 0;
#endif
static void init_console_ansi(void)
{
#if defined(__EMSCRIPTEN__)
    /* Browser: no console mode to configure; stdout goes to Module.print */
#elif defined(_WIN32)
    HANDLE hOut;
    DWORD mode;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE || hOut == NULL) {
        return;
    }
    if (!GetConsoleMode(hOut, &mode)) {
        return;
    }
    mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    if (!SetConsoleMode(hOut, mode)) {
        return;
    }
    ansi_enabled = 1;
#endif
}
#else
static void init_console_ansi(void)
{
    /* Standard ANSI escapes are generally supported on macOS/Linux terminals. */
}
#endif

// DEFINES

#define MAX_LINES 65536  /* 64K; classic BASIC line-number range; trek.bas ~680 lines */
#define MAX_LINE_LEN 256
/* Source lines when loading from disk (UTF-8 PETSCII art can exceed 256 bytes). */
#define MAX_LINE_LEN_LOAD 65536
#define MAX_INCLUDE_DEPTH 16
#define MAX_INCLUDE_PATH  512

static char include_path_store[MAX_INCLUDE_DEPTH][MAX_INCLUDE_PATH];
#define MAX_VARS 128
#define VAR_NAME_MAX 32
#define MAX_GOSUB 64
#define MAX_FOR 32
#define MAX_STR_LEN 4096  /* default max; #OPTION maxstr N can reduce for C64 compatibility */
#define DEFAULT_ARRAY_SIZE 11
#define DEFAULT_PRINT_WIDTH 40
#ifndef TICKS_PER_SEC_FALLBACK
#ifdef HZ
#define TICKS_PER_SEC_FALLBACK HZ
#else
#define TICKS_PER_SEC_FALLBACK 60
#endif
#endif

enum value_type { VAL_NUM = 0, VAL_STR = 1 };

struct value {
    int type;
    double num;
    char str[MAX_STR_LEN];
};

struct line {
    int number;
    char *text;
};

#define MAX_DIMS 3

struct var {
    char name[VAR_NAME_MAX];
    int is_string;
    int is_array;
    int dims;                      /* 0 for scalar, >=1 for arrays */
    int dim_sizes[MAX_DIMS];       /* per-dimension sizes */
    int size;                      /* total number of elements (product of dim_sizes) */
    struct value scalar;
    struct value *array;           /* flat buffer of length size */
};

struct gosub_frame {
    int line_index;
    char *position;
};

struct for_frame {
    char name[VAR_NAME_MAX];
    int is_string;
    double end_value;
    double step;
    int line_index;
    char *resume_pos;
    struct value *var;
    /* GOSUB depth when this FOR was entered; RETURN unwinds FOR frames above the new depth (CBM-style). */
    int gosub_depth_at_entry;
};

static struct line *program_lines[MAX_LINES];
static int line_count = 0;

static struct var vars[MAX_VARS];
static int var_count = 0;

static struct gosub_frame gosub_stack[MAX_GOSUB];
static int gosub_top = 0;

static struct for_frame for_stack[MAX_FOR];
static int for_top = 0;

static void for_unwind_after_return(int new_gosub_top)
{
    while (for_top > 0 && for_stack[for_top - 1].gosub_depth_at_entry > new_gosub_top) {
        for_top--;
    }
}

/* IF ELSE END IF block stack */
#define MAX_IF_DEPTH 16
struct if_block {
    int took_then;    /* 1 if we executed THEN branch, 0 if we skipped to ELSE/END IF */
};
static struct if_block if_stack[MAX_IF_DEPTH];
static int if_depth = 0;

/* WHILE WEND block stack */
#define MAX_WHILE_DEPTH 16
struct while_frame {
    int line_index;
    char *position;
};
static struct while_frame while_stack[MAX_WHILE_DEPTH];
static int while_top = 0;

/* DO LOOP block stack */
#define MAX_DO_DEPTH 16
struct do_frame {
    int line_index;
    char *position;
};
static struct do_frame do_stack[MAX_DO_DEPTH];
static int do_top = 0;

#define MAX_UDF_PARAMS 16
#define MAX_UDF_FUNCS  32
#define MAX_UDF_DEPTH  16

struct udf_func {
    char name[VAR_NAME_MAX];
    int param_count;
    char param_names[MAX_UDF_PARAMS][VAR_NAME_MAX];
    int param_is_string[MAX_UDF_PARAMS];
    int body_line;
    char *body_pos;
};

static struct udf_func udf_funcs[MAX_UDF_FUNCS];
static int udf_func_count = 0;

static int udf_call_depth = 0;
static struct value udf_return_value;
static int udf_returned = 0;

struct udf_call_frame {
    int func_index;
    int saved_line;
    char *saved_pos;
    struct value saved_params[MAX_UDF_PARAMS];
};

static struct udf_call_frame udf_call_stack[MAX_UDF_DEPTH];

/* User-defined functions created with DEF FN. */
#define MAX_USER_FUNCS 32

struct user_func {
    char name[8];           /* Function name, e.g. "FNY" (uppercased) */
    char param_name[8];     /* Parameter variable name, e.g. "X" (uppercased) */
    int param_is_string;    /* Non-zero if parameter is string type */
    char *body;             /* Duplicated expression text after '=' */
};

static struct user_func user_funcs[MAX_USER_FUNCS];
static int user_func_count = 0;

/* DATA/READ support */
#define MAX_DATA_ITEMS 4096
#define MAX_DATA_LINES 128
static struct value data_items[MAX_DATA_ITEMS];
static int data_count = 0;
static int data_index = 0;
static int data_line_count = 0;
static int data_line_numbers[MAX_DATA_LINES];
static int data_line_start_index[MAX_DATA_LINES];

/* File I/O: logical file numbers 1-255, CBM-style OPEN/CLOSE/PRINT#/INPUT#/GET#.
 * Device 1 = disk/file (filename required). Secondary: 0=read, 1=write, 2=append.
 * ST (status) is updated after INPUT#/GET#: 0=ok, 64=EOF, 1=error/not open. */
#define MAX_OPEN_FILES 16
static FILE *open_files[256];   /* 1-based; [0] unused; NULL = closed */
static void set_io_status(int st);

static int current_line = 0;
static char *statement_pos = NULL;
static volatile int halted = 0;
static int print_col = 0;

#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
static int wasm_canvas_debug_flag = 0;
static int wasm_canvas_debug_trace_for = 0;

static void wasm_canvas_debug_log_cstr(const char *s)
{
    EM_ASM({ console.log(UTF8ToString($0)); }, s);
}

static void wasm_canvas_debug_dump_stacks(const char *tag)
{
    int gi, fi;
    char buf[384];

    EM_ASM({
        console.log('[rgc-basic canvas] browser:', {
            userAgent: (typeof navigator !== 'undefined' && navigator.userAgent) ? navigator.userAgent : '',
            language: (typeof navigator !== 'undefined' && navigator.language) ? navigator.language : '',
            platform: (typeof navigator !== 'undefined' && navigator.platform) ? navigator.platform : '',
            wasmStopRequested: (typeof Module !== 'undefined' && Module['wasmStopRequested']) ? Module['wasmStopRequested'] : 0
        });
    });
    snprintf(buf, sizeof(buf), "[rgc-basic canvas] --- %s ---",
        tag ? tag : "stack dump");
    wasm_canvas_debug_log_cstr(buf);
    snprintf(buf, sizeof(buf),
        "[rgc-basic canvas] summary: gosub_top=%d for_top=%d current_line_idx=%d halted=%d line_count=%d",
        gosub_top, for_top, current_line, halted, line_count);
    wasm_canvas_debug_log_cstr(buf);
    for (gi = gosub_top - 1; gi >= 0; gi--) {
        int li = gosub_stack[gi].line_index;
        int lnum = (li >= 0 && li < line_count && program_lines[li]) ? program_lines[li]->number : -1;
        snprintf(buf, sizeof(buf),
            "[rgc-basic canvas]   gosub[%d] resume_line_idx=%d BASIC_line=%d",
            gi, li, lnum);
        wasm_canvas_debug_log_cstr(buf);
    }
    for (fi = for_top - 1; fi >= 0; fi--) {
        int li = for_stack[fi].line_index;
        int lnum = (li >= 0 && li < line_count && program_lines[li]) ? program_lines[li]->number : -1;
        struct value *vp = for_stack[fi].var;
        double vnum = (vp && vp->type == VAL_NUM) ? vp->num : -1.0;
        int vok = (vp && vp->type == VAL_NUM) ? 1 : 0;
        snprintf(buf, sizeof(buf),
            "[rgc-basic canvas]   for[%d] name=%s gosubDepthAtEntry=%d line_idx=%d BASIC_line=%d var=%p numOk=%d val=%.6g",
            fi, for_stack[fi].name, for_stack[fi].gosub_depth_at_entry, li, lnum,
            (void *)vp, vok, vnum);
        wasm_canvas_debug_log_cstr(buf);
    }
}

EMSCRIPTEN_KEEPALIVE void wasm_canvas_set_debug(int on)
{
    wasm_canvas_debug_flag = on ? 1 : 0;
}

EMSCRIPTEN_KEEPALIVE void wasm_canvas_set_debug_trace_for(int on)
{
    wasm_canvas_debug_trace_for = on ? 1 : 0;
}

EMSCRIPTEN_KEEPALIVE const char *wasm_canvas_build_stamp(void)
{
    return "rgc-basic canvas " __DATE__ " " __TIME__;
}

EMSCRIPTEN_KEEPALIVE void wasm_debug_log_stacks(void)
{
    wasm_canvas_debug_dump_stacks("wasm_debug_log_stacks (manual ccall)");
}
#endif /* __EMSCRIPTEN__ && GFX_VIDEO */

#if defined(__EMSCRIPTEN__) && !defined(GFX_VIDEO)
/* Terminal WASM: libc batches stdout so PRINT newlines never reach Module.print until exit.
 * Buffer bytes and call Module.print once per logical line (at '\n'). */
#define WASM_STDOUT_BUF 4096
static char wasm_stdout_buf[WASM_STDOUT_BUF];
static int wasm_stdout_len;

static void wasm_stdout_flush_partial(void)
{
    if (wasm_stdout_len <= 0) {
        return;
    }
    wasm_stdout_buf[wasm_stdout_len] = '\0';
    EM_ASM({
        if (typeof Module !== 'undefined' && Module['print']) {
            Module['print'](UTF8ToString($0));
        }
    }, wasm_stdout_buf);
    wasm_stdout_len = 0;
}

static void wasm_stdout_putc(int c)
{
    unsigned char uc = (unsigned char)c;
    if (uc == '\n') {
        wasm_stdout_buf[wasm_stdout_len] = '\0';
        EM_ASM({
            if (typeof Module !== 'undefined' && Module['print']) {
                /* Include newline so index.html split sees each PRINT as its own line. */
                Module['print'](UTF8ToString($0) + '\n');
            }
        }, wasm_stdout_buf);
        wasm_stdout_len = 0;
        return;
    }
    if (wasm_stdout_len >= WASM_STDOUT_BUF - 1) {
        wasm_stdout_flush_partial();
    }
    wasm_stdout_buf[wasm_stdout_len++] = (char)uc;
}

static void wasm_stdout_puts(const char *s)
{
    if (!s) {
        return;
    }
    while (*s) {
        wasm_stdout_putc((unsigned char)*s++);
    }
}

static void wasm_stdout_before_cstdio(void)
{
    wasm_stdout_flush_partial();
}

#define OUTC(c) wasm_stdout_putc(c)
#define OUTS(s) wasm_stdout_puts(s)
#define OUTFLUSH() wasm_stdout_flush_partial()
#define BEFORE_CSTDIO() wasm_stdout_before_cstdio()
#else
#define OUTC(c) fputc((c), stdout)
#define OUTS(s) fputs((s), stdout)
#define OUTFLUSH() fflush(stdout)
#define BEFORE_CSTDIO() ((void)0)
#endif

#ifdef __EMSCRIPTEN__
/* Ring buffer for single-key reads (GET, INKEY$) from JS (wasm_push_key). */
#define WASM_KEY_RING 512
static unsigned char wasm_key_ring[WASM_KEY_RING];
static int wasm_key_head = 0;
static int wasm_key_tail = 0;

static int wasm_key_push_byte(unsigned char b)
{
    int next = (wasm_key_tail + 1) % WASM_KEY_RING;
    if (next == wasm_key_head) {
        return 0;
    }
    wasm_key_ring[wasm_key_tail] = b;
    wasm_key_tail = next;
    return 1;
}

#ifdef GFX_VIDEO
static void wasm_push_key_to_gfx_queue(unsigned char b)
{
    GfxVideoState *vs = gfx_vs;
    uint8_t next;
    if (!vs) {
        return;
    }
    next = (uint8_t)(vs->key_q_tail + 1);
    if (next >= (uint8_t)sizeof(vs->key_queue)) {
        next = 0;
    }
    if (next == vs->key_q_head) {
        return;
    }
    vs->key_queue[vs->key_q_tail] = b;
    vs->key_q_tail = next;
}
#endif

#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
/* Keys from keydown: JS writes into this ring in linear memory (DataView only).
 * No ccall and no EM_ASM while Asyncify is suspended — both can deadlock. */
#define WASM_JS_KEY_CAP 512
typedef struct {
    uint32_t head;
    uint32_t tail;
    uint8_t data[WASM_JS_KEY_CAP];
} WasmJsKeyRing;
static WasmJsKeyRing wasm_js_key_ring;

EMSCRIPTEN_KEEPALIVE int wasm_js_key_ring_mem(void)
{
    return (int)(uintptr_t)(void *)&wasm_js_key_ring;
}

EMSCRIPTEN_KEEPALIVE void wasm_js_key_ring_reset(void)
{
    wasm_js_key_ring.head = 0;
    wasm_js_key_ring.tail = 0;
}

static int wasm_js_heap_key_try_pop(unsigned char *out)
{
    uint32_t h = wasm_js_key_ring.head;
    uint32_t t = wasm_js_key_ring.tail;
    if (h == t) {
        return 0;
    }
    *out = wasm_js_key_ring.data[h];
    wasm_js_key_ring.head = (h + 1u) % WASM_JS_KEY_CAP;
    return 1;
}

static int wasm_js_heap_key_peek(void)
{
    uint32_t h = wasm_js_key_ring.head;
    uint32_t t = wasm_js_key_ring.tail;
    if (h == t) {
        return -1;
    }
    return (int)wasm_js_key_ring.data[h];
}
#endif

static int wasm_key_pop_byte(unsigned char *out)
{
#ifdef GFX_VIDEO
    if (gfx_vs) {
#if defined(__EMSCRIPTEN__)
        if (wasm_js_heap_key_try_pop(out)) {
            return 1;
        }
#endif
        GfxVideoState *vs = gfx_vs;
        uint8_t head = vs->key_q_head;
        if (head != vs->key_q_tail) {
            *out = vs->key_queue[head];
            head++;
            if (head >= (uint8_t)sizeof(vs->key_queue)) {
                head = 0;
            }
            vs->key_q_head = head;
            return 1;
        }
    }
#endif
    if (wasm_key_head == wasm_key_tail) {
        return 0;
    }
    *out = wasm_key_ring[wasm_key_head];
    wasm_key_head = (wasm_key_head + 1) % WASM_KEY_RING;
    return 1;
}

static int wasm_key_peek_byte(void)
{
#ifdef GFX_VIDEO
    if (gfx_vs) {
#if defined(__EMSCRIPTEN__)
        {
            int jp = wasm_js_heap_key_peek();
            if (jp >= 0) {
                return jp;
            }
        }
#endif
        uint8_t h = gfx_vs->key_q_head;
        if (h != gfx_vs->key_q_tail) {
            return (int)gfx_vs->key_queue[h];
        }
    }
#endif
    if (wasm_key_head == wasm_key_tail) {
        return -1;
    }
    return (int)wasm_key_ring[wasm_key_head];
}

/* wasm_push_key: non-GFX emscripten build only (canvas build defines below in GFX_VIDEO). */
#if !defined(GFX_VIDEO)
EMSCRIPTEN_KEEPALIVE void wasm_push_key(unsigned int code)
{
    unsigned char b = (unsigned char)(code & 0xFF);
#ifdef GFX_VIDEO
    if (gfx_vs) {
        wasm_push_key_to_gfx_queue(b);
        return;
    }
#endif
    wasm_key_push_byte(b);
}
#endif

static void wasm_browser_pause_point(void);

/* Asyncify: wait until JS delivers one byte (GET blocking, or line-feed for INPUT). */
static void wasm_yield_until_key(void)
{
    EM_ASM({ if (typeof Module !== 'undefined') { Module['wasmWaitingKey'] = 1; } });
    emscripten_sleep(1);
    while (wasm_key_peek_byte() < 0) {
        wasm_browser_pause_point();
        if (halted) {
            EM_ASM({ if (typeof Module !== 'undefined') { Module['wasmWaitingKey'] = 0; } });
            return;
        }
        emscripten_sleep(16);
    }
    EM_ASM({ if (typeof Module !== 'undefined') { Module['wasmWaitingKey'] = 0; } });
}

/* Blocking read of one byte for GET (after raw key available). */
static int wasm_read_key_blocking(void)
{
    unsigned char b;
    wasm_yield_until_key();
    if (halted) {
        return EOF;
    }
    wasm_key_pop_byte(&b);
    return (int)b;
}

/* INPUT: label text for the inline field (INPUT "prompt"; ...). */
static void wasm_set_input_prompt_for_js(const char *prompt)
{
    if (!prompt) {
        prompt = "";
    }
    EM_ASM({
        var s = UTF8ToString($0);
        if (typeof Module !== 'undefined') {
            Module['wasmInputLabel'] = s.length ? s : 'INPUT';
        }
    }, prompt);
}

#if defined(GFX_VIDEO)
static void wasm_gfx_refresh_js(void);
#endif

/* Terminal + canvas: JS sets Module.wasmPaused; yield until cleared or stop. */
static void wasm_browser_pause_point(void)
{
    for (;;) {
        if (EM_ASM_INT({ return (typeof Module !== 'undefined' && Module['wasmStopRequested']) ? 1 : 0; })) {
            halted = 1;
            return;
        }
        if (!EM_ASM_INT({ return (typeof Module !== 'undefined' && Module['wasmPaused']) ? 1 : 0; })) {
            return;
        }
#if defined(GFX_VIDEO)
        wasm_gfx_refresh_js();
#endif
        emscripten_sleep(16);
    }
}

/* INPUT: JS sets Module.wasmInputLineReady and Module.wasmInputLineText (UTF-8). */
static void wasm_read_input_line_blocking(char *buf, size_t cap)
{
    if (cap == 0) {
        return;
    }
    EM_ASM({
        if (typeof Module !== 'undefined') {
            Module['wasmNeedInputLine'] = 1;
            if (Module['onWasmNeedInputLine']) {
                Module['onWasmNeedInputLine']();
            }
        }
    });
    emscripten_sleep(5);
    while (!EM_ASM_INT({ return (typeof Module !== 'undefined' && Module['wasmInputLineReady']) ? 1 : 0; })) {
        wasm_browser_pause_point();
        if (halted) {
            buf[0] = '\0';
            EM_ASM({
                if (typeof Module !== 'undefined') {
                    Module['wasmNeedInputLine'] = 0;
                }
            });
            return;
        }
        emscripten_sleep(16);
    }
    {
        static const char wasm_empty_js[] = "";
        EM_ASM_({
            var mod = typeof Module !== 'undefined' ? Module : null;
            var s = (mod && mod['wasmInputLineText']) ? mod['wasmInputLineText'] : UTF8ToString($1);
            stringToUTF8(s, $0, $2);
            if (mod) {
                mod['wasmInputLineReady'] = 0;
                mod['wasmNeedInputLine'] = 0;
            }
        }, buf, wasm_empty_js, (int)cap);
    }
    buf[cap - 1] = '\0';
}
#endif /* __EMSCRIPTEN__ */

#ifdef GFX_VIDEO

#if defined(__EMSCRIPTEN__)
static void wasm_maybe_yield_loop(void);
static void wasm_canvas_sync_charset_from_options(void);
#endif

#if defined(__EMSCRIPTEN__)
EMSCRIPTEN_KEEPALIVE void wasm_push_key(unsigned int code)
{
    unsigned char b = (unsigned char)(code & 0xFF);
    /* Canvas: GET uses gfx key queue only. Pushing to wasm_key_ring too would
     * deliver the same key twice (queue first, then ring in read_single_char_nonblock). */
    if (gfx_vs) {
        uint8_t next = (uint8_t)(gfx_vs->key_q_tail + 1);
        if (next >= (uint8_t)sizeof(gfx_vs->key_queue)) {
            next = 0;
        }
        if (next != gfx_vs->key_q_head) {
            gfx_vs->key_queue[gfx_vs->key_q_tail] = b;
            gfx_vs->key_q_tail = next;
        }
    } else {
        wasm_key_push_byte(b);
    }
}
#endif

void basic_set_gfx_window_title(const char *);  /* forward, for #OPTION gfx_title */
void basic_set_gfx_border(int);                 /* forward, for #OPTION border */
void basic_set_gfx_border_color(int);           /* forward, for #OPTION border */

/* GFX text output state (mirrors a C64-like 40x25 text screen). */
#define GFX_ROWS 25

/* Columns per row (40 or 80). Set by basic_set_video from print_width / #OPTION columns. */
static inline int gfx_cols(void) {
    return (gfx_vs && gfx_vs->cols) ? (int)gfx_vs->cols : 40;
}
static int gfx_x = 0;
static int gfx_y = 0;
static uint8_t gfx_fg = 14;      /* default light blue */
static uint8_t gfx_bg = 6;       /* default blue background */
static int gfx_reverse = 0;
static int gfx_raw_screen_codes = 0;  /* when set, bytes 0–255 are screen codes */

static uint8_t gfx_ascii_to_screencode(unsigned char c)
{
    if (c >= 'A' && c <= 'Z') return (uint8_t)(c - 'A' + 1);
    if (c >= 'a' && c <= 'z') return (uint8_t)(c - 'a' + 1);
    if (c == '@') return 0;
    if (c >= ' ' && c <= '?') return (uint8_t)c;
    return 32;
}

/* With gfx_canvas_load_default_charrom lowercase layout: sc 1-26 = a-z, 65-90 = A-Z,
 * 32 = space, etc. String literals are ASCII, not PETSCII — petscii_to_screencode()
 * is wrong here (e.g. ASCII space 32 → sc 33 → "!" in upper ROM). */
static uint8_t gfx_ascii_to_screencode_lowcharset(unsigned char c)
{
    if (c >= 'a' && c <= 'z') {
        return (uint8_t)(c - 'a' + 1);
    }
    if (c >= 'A' && c <= 'Z') {
        return (uint8_t)(c - 'A' + 65);
    }
    if (c == '@') {
        return 0;
    }
    if (c >= ' ' && c <= '?') {
        return (uint8_t)c;
    }
    if (c >= '[' && c <= '_') {
        return (uint8_t)c;
    }
    if (c == '`') {
        return 64;
    }
    if (c >= '{' && c <= '~') {
        return (uint8_t)(c - '{' + 91);
    }
    return 32;
}

static void gfx_scroll_up(void)
{
    int row;
    if (!gfx_vs) return;
    {
        int c = gfx_cols();
        for (row = 0; row < GFX_ROWS - 1; row++) {
            memcpy(&gfx_vs->screen[row * c],
                   &gfx_vs->screen[(row + 1) * c],
                   c);
            memcpy(&gfx_vs->color[row * c],
                   &gfx_vs->color[(row + 1) * c],
                   c);
        }
        memset(&gfx_vs->screen[(GFX_ROWS - 1) * c], 32, c);
        memset(&gfx_vs->color[(GFX_ROWS - 1) * c], gfx_fg, c);
    }
}

static void gfx_newline(void)
{
    gfx_x = 0;
    gfx_y++;
    if (gfx_y >= GFX_ROWS) {
        gfx_scroll_up();
        gfx_y = GFX_ROWS - 1;
    }
    print_col = gfx_x;
}

static void gfx_clear_screen(void)
{
    if (!gfx_vs) return;
    memset(gfx_vs->screen, 32, GFX_TEXT_SIZE);
    memset(gfx_vs->color, gfx_fg, GFX_COLOR_SIZE);
    gfx_x = 0;
    gfx_y = 0;
    print_col = 0;
}

static int gfx_apply_control_code(unsigned char code)
{
    /* Return non-zero if the code was handled as control/state. */
    switch (code) {
    case 14:  /* switch to lowercase/uppercase charset */
        if (gfx_vs) {
            gfx_vs->charset_lowercase = 1;
            /* Reload 8x8 glyph bitmaps (canvas WASM has no render loop; Raylib also refreshes each frame). */
            gfx_load_default_charrom(gfx_vs);
        }
        petscii_set_lowercase(1);
        return 1;
    case 142: /* switch to uppercase/graphics charset */
        if (gfx_vs) {
            gfx_vs->charset_lowercase = 0;
            gfx_load_default_charrom(gfx_vs);
        }
        petscii_set_lowercase(0);
        return 1;
    case 13: /* CR */
    case 10: /* LF */
        /* Avoid double newline: gfx_put_byte already wraps at col 40, so when
         * the viewer sends CR after wrapping, we're already at col 0. */
        if (gfx_x != 0) gfx_newline();
        return 1;
    case 19: /* HOME */
        gfx_x = 0;
        gfx_y = 0;
        print_col = 0;
        return 1;
    case 147: /* CLR */
        gfx_clear_screen();
        return 1;
    case 17:  /* down */
        if (gfx_y < GFX_ROWS - 1) gfx_y++;
        return 1;
    case 145: /* up */
        if (gfx_y > 0) gfx_y--;
        return 1;
    case 29:  /* right */
        if (gfx_x < gfx_cols() - 1) gfx_x++;
        print_col = gfx_x;
        return 1;
    case 157: /* left */
        if (gfx_x > 0) gfx_x--;
        print_col = gfx_x;
        return 1;
    case 18:  /* reverse on */
        gfx_reverse = 1;
        return 1;
    case 146: /* reverse off */
        gfx_reverse = 0;
        return 1;
    case 20:  /* DEL: backspace — cursor left and erase (like C64) */
        if (gfx_x > 0 && gfx_vs) {
            int del_idx;
            gfx_x--;
            del_idx = gfx_y * gfx_cols() + gfx_x;
            if (del_idx >= 0 && del_idx < (int)GFX_TEXT_SIZE) {
                gfx_vs->screen[del_idx] = 32;
                gfx_vs->color[del_idx] = (uint8_t)(gfx_fg & 0x0F);
            }
            print_col = gfx_x;
        }
        return 1;
    /* PETSCII colour control codes -> set current foreground colour index. */
    case 144: gfx_fg = 0;  return 1; /* black */
    case 5:   gfx_fg = 1;  return 1; /* white */
    case 28:  gfx_fg = 2;  return 1; /* red */
    case 159: gfx_fg = 3;  return 1; /* cyan */
    case 156: gfx_fg = 4;  return 1; /* purple */
    case 30:  gfx_fg = 5;  return 1; /* green */
    case 31:  gfx_fg = 6;  return 1; /* blue */
    case 158: gfx_fg = 7;  return 1; /* yellow */
    case 129: gfx_fg = 8;  return 1; /* orange */
    case 149: gfx_fg = 9;  return 1; /* brown */
    case 150: gfx_fg = 10; return 1; /* light red */
    case 151: gfx_fg = 11; return 1; /* dark gray */
    case 152: gfx_fg = 12; return 1; /* medium gray */
    case 153: gfx_fg = 13; return 1; /* light green */
    case 154: gfx_fg = 14; return 1; /* light blue */
    case 155: gfx_fg = 15; return 1; /* light gray */
    default:
        break;
    }
    return 0;
}

/* Decode one UTF-8 character from *s, advance *s, return Unicode codepoint or -1. */
static int gfx_decode_utf8(const char **s)
{
    unsigned char c = (unsigned char)**s;
    int u;
    if (c < 0x80) {
        u = c;
        (*s)++;
        return u;
    }
    if ((c & 0xE0) == 0xC0 && (*s)[1]) {
        u = ((c & 0x1F) << 6) | ((*s)[1] & 0x3F);
        *s += 2;
        return u;
    }
    if ((c & 0xF0) == 0xE0 && (*s)[1] && (*s)[2]) {
        u = ((c & 0x0F) << 12) | (((*s)[1] & 0x3F) << 6) | ((*s)[2] & 0x3F);
        *s += 3;
        return u;
    }
    if ((c & 0xF8) == 0xF0 && (*s)[1] && (*s)[2] && (*s)[3]) {
        u = ((c & 0x07) << 18) | (((*s)[1] & 0x3F) << 12) | (((*s)[2] & 0x3F) << 6) | ((*s)[3] & 0x3F);
        *s += 4;
        return u;
    }
    (*s)++;
    return -1;
}

/* Unicode box-drawing, £, \ → PETSCII (for UTF-8 source like trek.bas).
 * Must match petscii.c petscii_to_utf8 reverse mapping so GFX glyphs
 * match terminal output (clean │─┌┐└┘├┤┬┴┼, not wavy/control chars). */
static int unicode_to_petscii(int u)
{
    switch (u) {
    case 0x005C: return 109;   /* \ → CHR$(109) */
    case 0x00A3: return 109;  /* £ → backslash (user preference for trek) */
    case 0x2500: return 0x60;  /* ─ */
    case 0x2502: return 0x7D;  /* │ (was 0x9E: control range, wrong glyph) */
    case 0x250C: return 0xB0;  /* ┌ (176) */
    case 0x2510: return 0xAE;  /* ┐ (174) */
    case 0x2514: return 0xAD;  /* └ (173) */
    case 0x2518: return 0xBD;  /* ┘ (189) */
    case 0x251C: return 0xAB;  /* ├ (171) */
    case 0x2524: return 0xB3;  /* ┤ (179) */
    case 0x252C: return 0xB2;  /* ┬ (178) */
    case 0x2534: return 0xB1;  /* ┴ (177) */
    case 0x253C: return 0x7B;  /* ┼ (was 0x9B: control range, wrong glyph) */
    default:     return -1;
    }
}

static void gfx_put_byte(unsigned char b)
{
    int idx;
    uint8_t sc;

    if (!gfx_vs) return;
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    wasm_gfx_put_budget++;
    if ((wasm_gfx_put_budget & 127u) == 0u) {
        wasm_browser_pause_point();
        if (halted) {
            return;
        }
        wasm_gfx_refresh_js();
        emscripten_sleep(0);
    }
#endif
    if (gfx_apply_control_code(b)) return;

    /* Byte 92 (0x5C): In ASCII it's backslash; in C64 PETSCII it's £.
     * Terminal outputs raw bytes so 92→\. GFX uses C64 font so 92→£.
     * Use screen code 109 (diagonal glyph) so GFX matches terminal. */
    if (b == 0x5C) {
        sc = 109;
    } else if (gfx_raw_screen_codes) {
        sc = petscii_to_screencode(b);
    } else if (gfx_vs && gfx_vs->charset_lowercase && b >= 32 && b <= 126) {
        /* Lowercase char ROM: quoted text in the editor is ASCII — map A–Z/a–z only.
         * CHR$(n) emits a raw byte n: petscii_to_screencode would map PETSCII 65→sc 1
         * (wrong; user expects CHR$(65) to show the same as "A" → screen 65). */
        if ((b >= 'A' && b <= 'Z') || (b >= 'a' && b <= 'z')) {
            sc = gfx_ascii_to_screencode_lowcharset(b);
        } else {
            sc = (uint8_t)b;
        }
    } else if (petscii_mode) {
        sc = petscii_to_screencode(b);
    } else if (b >= 32 && b <= 126) {
        sc = gfx_ascii_to_screencode(b);
    } else {
        sc = (uint8_t)b;
    }

    if (gfx_reverse && sc < 128) {
        sc |= 0x80;
    }

    if (gfx_x < 0) gfx_x = 0;
    if (gfx_x >= gfx_cols()) gfx_newline();
    if (gfx_y < 0) gfx_y = 0;
    if (gfx_y >= GFX_ROWS) gfx_y = GFX_ROWS - 1;

    idx = gfx_y * gfx_cols() + gfx_x;
    if (idx >= 0 && idx < (int)GFX_TEXT_SIZE) {
        gfx_vs->screen[idx] = sc;
        gfx_vs->color[idx]  = (uint8_t)(gfx_fg & 0x0F);
    }

    gfx_x++;
    if (gfx_x >= gfx_cols()) {
        gfx_newline();
    } else {
        print_col = gfx_x;
    }
}

static int gfx_keyq_pop(uint8_t *out)
{
    uint8_t head;
    if (!gfx_vs) return 0;
#if defined(__EMSCRIPTEN__)
    if (wasm_js_heap_key_try_pop(out)) {
        return 1;
    }
#endif
    head = gfx_vs->key_q_head;
    if (head == gfx_vs->key_q_tail) {
        return 0; /* empty */
    }
    *out = gfx_vs->key_queue[head];
    head++;
    if (head >= (uint8_t)sizeof(gfx_vs->key_queue)) head = 0;
    gfx_vs->key_q_head = head;
    return 1;
}
#endif

/* PETSCII/ANSI configuration (petscii_mode declared earlier for gfx_put_byte) */
/* When set, do not output ANSI (color/reverse/cursor); output is paste-friendly, no extra bytes. */
static int petscii_plain = 0;
/* When set (e.g. stdout is a pipe), do not insert newlines at print_width. */
static int petscii_no_wrap = 0;
/* Configurable print width (columns); default 40. #OPTION columns N / -columns N. */
static int print_width = DEFAULT_PRINT_WIDTH;
/* When set, do not wrap at print_width; let terminal handle line length. #OPTION nowrap / -nowrap. */
static int terminal_no_wrap = 0;

enum {
    PALETTE_ANSI = 0,       /* Standard ANSI SGR colors */
    PALETTE_C64_8BIT = 1    /* 8-bit palette approximating C64 colors */
};

static int palette_mode = PALETTE_ANSI;
static int cursor_hidden = 0;
static int petscii_lowercase_opt = 0;
static int petscii_lowercase_cli = 0; /* Restored at each load_program so #OPTION can override per file. */
/* 0 = C64 PETSCII ROM (default), 1 = PET-style alt glyphs from pet_*.64c (-charset pet-*). */
static int charrom_family_opt = 0;
static int charrom_family_cli = 0;
/* Max string length (1..MAX_STR_LEN); default 4096; #OPTION maxstr 255 for C64 compatibility. */
static int max_str_limit = 4096;

/* Case-insensitive string compare. */
static int str_eq_ci(const char *a, const char *b)
{
    if (!a || !b) return (a == b);
    while (*a && *b) {
        if (toupper((unsigned char)*a) != toupper((unsigned char)*b)) return 0;
        a++; b++;
    }
    return (*a == *b);
}

/* Apply option from #OPTION directive (file overrides CLI). Returns 0 on success, -1 on error. */
static int apply_option_directive(const char *name, const char *value)
{
    if (!name || !name[0]) return -1;
    if (str_eq_ci(name, "petscii")) {
        petscii_mode = 1;
        petscii_plain = 0;
        petscii_no_wrap = 1;
        return 0;
    }
    if (str_eq_ci(name, "petscii-plain")) {
        petscii_mode = 1;
        petscii_plain = 1;
        petscii_no_wrap = 1;
        return 0;
    }
    if (str_eq_ci(name, "charset")) {
        if (!value || !value[0]) return -1;
        if (str_eq_ci(value, "upper") || str_eq_ci(value, "uc")
            || str_eq_ci(value, "c64-upper") || str_eq_ci(value, "c64-uppercase")) {
            charrom_family_opt = 0;
            petscii_lowercase_opt = 0;
            petscii_set_lowercase(0);
#ifdef GFX_VIDEO
            if (gfx_vs) {
                gfx_vs->charrom_family = 0;
                gfx_vs->charset_lowercase = 0;
                gfx_load_default_charrom(gfx_vs);
            }
#if defined(__EMSCRIPTEN__)
            wasm_canvas_sync_charset_from_options();
#endif
#endif
            return 0;
        }
        if (str_eq_ci(value, "lower") || str_eq_ci(value, "lc")
            || str_eq_ci(value, "c64-lower") || str_eq_ci(value, "c64-lowercase")) {
            charrom_family_opt = 0;
            petscii_lowercase_opt = 1;
            petscii_set_lowercase(1);
#ifdef GFX_VIDEO
            if (gfx_vs) {
                gfx_vs->charrom_family = 0;
                gfx_vs->charset_lowercase = 1;
                gfx_load_default_charrom(gfx_vs);
            }
#if defined(__EMSCRIPTEN__)
            wasm_canvas_sync_charset_from_options();
#endif
#endif
            return 0;
        }
        if (str_eq_ci(value, "pet-upper") || str_eq_ci(value, "pet-uppercase")
            || str_eq_ci(value, "pet-graphics")) {
            charrom_family_opt = 1;
            petscii_lowercase_opt = 0;
            petscii_set_lowercase(0);
#ifdef GFX_VIDEO
            if (gfx_vs) {
                gfx_vs->charrom_family = 1;
                gfx_vs->charset_lowercase = 0;
                gfx_load_default_charrom(gfx_vs);
            }
#if defined(__EMSCRIPTEN__)
            wasm_canvas_sync_charset_from_options();
#endif
#endif
            return 0;
        }
        if (str_eq_ci(value, "pet-lower") || str_eq_ci(value, "pet-lowercase")
            || str_eq_ci(value, "pet-text")) {
            charrom_family_opt = 1;
            petscii_lowercase_opt = 1;
            petscii_set_lowercase(1);
#ifdef GFX_VIDEO
            if (gfx_vs) {
                gfx_vs->charrom_family = 1;
                gfx_vs->charset_lowercase = 1;
                gfx_load_default_charrom(gfx_vs);
            }
#if defined(__EMSCRIPTEN__)
            wasm_canvas_sync_charset_from_options();
#endif
#endif
            return 0;
        }
        return -1;
    }
    if (str_eq_ci(name, "palette")) {
        if (!value || !value[0]) return -1;
        if (str_eq_ci(value, "ansi")) {
            palette_mode = PALETTE_ANSI;
            return 0;
        }
        if (str_eq_ci(value, "c64") || str_eq_ci(value, "c64-8bit")) {
            palette_mode = PALETTE_C64_8BIT;
            return 0;
        }
        return -1;
    }
    if (str_eq_ci(name, "maxstr")) {
        int n;
        char *end;
        if (!value || !value[0]) return -1;
        n = (int)strtol(value, &end, 10);
        if (end == value || *end != '\0' || n < 1 || n > MAX_STR_LEN) return -1;
        max_str_limit = n;
        return 0;
    }
    if (str_eq_ci(name, "columns")) {
        int n;
        char *end;
        if (!value || !value[0]) return -1;
        n = (int)strtol(value, &end, 10);
        if (end == value || *end != '\0' || n < 1 || n > 255) return -1;
        print_width = n;
#ifdef GFX_VIDEO
        if (gfx_vs) {
            gfx_vs->cols = (print_width >= 80) ? 80 : 40;
        }
#endif
        return 0;
    }
    if (str_eq_ci(name, "nowrap")) {
        terminal_no_wrap = 1;
        return 0;
    }
#ifdef GFX_VIDEO
    if (str_eq_ci(name, "gfx_title") || str_eq_ci(name, "gfx-title")) {
        if (!value) return -1;
        /* Strip surrounding quotes if present */
        while (*value == '"' || *value == '\'') value++;
        {
            size_t len = strlen(value);
            while (len > 0 && (value[len - 1] == '"' || value[len - 1] == '\'')) len--;
            if (len > 127) len = 127;
            {
                char buf[128];
                memcpy(buf, value, len);
                buf[len] = '\0';
                basic_set_gfx_window_title(buf);
            }
        }
        return 0;
    }
    if (str_eq_ci(name, "border")) {
        int n, cidx = -1;
        char *end, buf[64];
        if (!value || !value[0]) return -1;
        n = (int)strtol(value, &end, 10);
        if (n < 0 || n > 256) return -1;
        basic_set_gfx_border(n);
        while (*end == ' ' || *end == '\t' || *end == ',') end++;
        if (*end) {
            size_t j = 0;
            while (*end && j < sizeof(buf) - 1) buf[j++] = (char)*end++;
            buf[j] = '\0';
            if (buf[0] >= '0' && buf[0] <= '9') {
                char *e2;
                cidx = (int)strtol(buf, &e2, 10);
                if (cidx < 0 || cidx > 15) cidx = -1;
            } else {
                static const struct { const char *name; int idx; } bc[] = {
                    {"black", 0}, {"white", 1}, {"red", 2}, {"cyan", 3},
                    {"purple", 4}, {"green", 5}, {"blue", 6}, {"yellow", 7},
                    {"orange", 8}, {"brown", 9}, {"pink", 10}, {"light red", 10},
                    {"dark gray", 11}, {"grey1", 11}, {"gray1", 11},
                    {"medium gray", 12}, {"grey2", 12}, {"gray2", 12},
                    {"light green", 13}, {"light blue", 14},
                    {"light gray", 15}, {"grey3", 15}, {"gray3", 15},
                    {NULL, -1}
                };
                int k;
                for (k = 0; bc[k].name; k++) {
                    if (str_eq_ci(buf, bc[k].name)) { cidx = bc[k].idx; break; }
                }
            }
            basic_set_gfx_border_color(cidx);
        } else {
            basic_set_gfx_border_color(-1);
        }
        return 0;
    }
    if (str_eq_ci(name, "memory")) {
        if (!value || !value[0]) return -1;
        return gfx_mem_try_preset(value);
    }
    if (str_eq_ci(name, "screen")) {
        uint16_t a;
        if (!value || !value[0]) return -1;
        if (parse_gfx_addr_u16(value, &a) != 0) return -1;
        return gfx_mem_try_set_region(GFX_MEM_TEXT, a);
    }
    if (str_eq_ci(name, "colorram") || str_eq_ci(name, "colourram")) {
        uint16_t a;
        if (!value || !value[0]) return -1;
        if (parse_gfx_addr_u16(value, &a) != 0) return -1;
        return gfx_mem_try_set_region(GFX_MEM_COLOR, a);
    }
    if (str_eq_ci(name, "charmem") || str_eq_ci(name, "charrom") || str_eq_ci(name, "charsetmem")) {
        uint16_t a;
        if (!value || !value[0]) return -1;
        if (parse_gfx_addr_u16(value, &a) != 0) return -1;
        return gfx_mem_try_set_region(GFX_MEM_CHAR, a);
    }
    if (str_eq_ci(name, "keymatrix") || str_eq_ci(name, "keyboard") || str_eq_ci(name, "keybase")) {
        uint16_t a;
        if (!value || !value[0]) return -1;
        if (parse_gfx_addr_u16(value, &a) != 0) return -1;
        return gfx_mem_try_set_region(GFX_MEM_KEY, a);
    }
    if (str_eq_ci(name, "bitmap") || str_eq_ci(name, "hires")) {
        uint16_t a;
        if (!value || !value[0]) return -1;
        if (parse_gfx_addr_u16(value, &a) != 0) return -1;
        return gfx_mem_try_set_region(GFX_MEM_BITMAP, a);
    }
#endif
    return -1;
}

/* Command-line arguments for the running script (after options and program path). */
static const char *script_path = NULL;   /* path to the .bas file */
static int script_argc = 0;              /* number of arguments after script path */
static char **script_argv = NULL;        /* argv entries after script path */

/* Run a shell command; returns exit status (0 = success, non-zero = failure). */
static int do_system(const char *cmd)
{
#ifdef __EMSCRIPTEN__
    (void)cmd;
    return -1;  /* Not available in browser */
#elif defined(_WIN32)
    return system(cmd);  /* MSVC: runs via cmd.exe */
#else
    return system(cmd);
#endif
}

/* Run a shell command and return its stdout (up to MAX_STR_LEN-1 chars). */
static void do_exec(const char *cmd, char *out, size_t out_size)
{
#ifdef __EMSCRIPTEN__
    (void)cmd;
    if (out_size > 0) out[0] = '\0';
    return;  /* Not available in browser */
#else
    FILE *fp;
    size_t n;
    if (out_size == 0) return;
    out[0] = '\0';
#if defined(_WIN32)
    fp = _popen(cmd, "rt");
#else
    fp = popen(cmd, "r");
#endif
    if (!fp) return;
    n = fread(out, 1, out_size - 1, fp);
    out[n] = '\0';
    /* Trim trailing newline if present */
    while (n > 0 && (out[n-1] == '\n' || out[n-1] == '\r')) { out[--n] = '\0'; }
#if defined(_WIN32)
    _pclose(fp);
#else
    pclose(fp);
#endif
#endif
}

static void runtime_error(const char *msg);
static void runtime_error_hint(const char *msg, const char *hint);
static void load_program(const char *path);
static void run_program(const char *script_path_arg, int nargs, char **args);
static int find_line_index(int number);
static void build_label_table(void);
static void build_udf_table(void);
static int find_label_line(const char *name);
static int udf_lookup(const char *name, int param_count);
static int starts_with_kw(char *p, const char *kw);
static void skip_spaces(char **p);
static int parse_number_literal(char **p, double *out);
static int read_identifier(char **p, char *buf, int buf_size);
static void uppercase_name(const char *src, char *dest, int dest_size, int *is_string);
static char *dupstr_local(const char *s);
static struct value eval_expr(char **p);
static int eval_condition(char **p);
static void execute_statement(char **p);
static struct value *get_var_reference(char **p, int *is_array_out, int *is_string_out, char *name_out);
static struct value make_num(double v);
static struct value make_str(const char *s);
static struct var *find_or_create_var(const char *name, int is_string, int want_array, int dims, const int *dim_sizes, int total_size);
static struct value eval_function(const char *name, char **p);
static int user_func_lookup(const char *name);
static void collect_data_from_program(void);
static void statement_read(char **p);
static void statement_load(char **p);
static void statement_memset(char **p);
static void statement_memcpy(char **p);
static void print_value(struct value *v);
static void print_spaces(int count);
static void statement_sleep(char **p);
static void statement_textat(char **p);
static void statement_def(char **p);
static void statement_get(char **p);
static void do_sleep_ticks(double ticks);
static void statement_locate(char **p);
static void statement_on(char **p);
static void statement_clr(char **p);
static void statement_sort(char **p);
static void statement_split(char **p);
static void statement_join(char **p);
static void statement_open(char **p);
static void statement_close(char **p);
static void statement_print_hash(char **p);
static void statement_input_hash(char **p);
static void statement_get_hash(char **p);
static int function_lookup(const char *name, int len);
static void statement_cursor(char **p);
static void statement_color(char **p);
static void statement_background(char **p);
static void statement_screencodes(char **p);
static void statement_pset(char **p, int preset);
static void statement_line(char **p);
#ifdef GFX_VIDEO
static void statement_loadsprite(char **p);
static void statement_drawsprite(char **p);
static void statement_spritevisible(char **p);
static void statement_spritemodulate(char **p);
#endif
static void statement_unloadsprite(char **p);  /* basic-gfx only; terminal errors */
static void statement_else(char **p);
static void statement_end_if(char **p);
static void statement_return(char **p);
static void statement_end_function(char **p);
static void skip_function_block(char **p);
static void statement_while(char **p, char *while_pos);
static void statement_wend(char **p);
static void statement_do(char **p);
static void statement_loop(char **p);
static void statement_exit_do(char **p);
static void skip_if_block_to_target(char **p, int want_else);
static void skip_while_to_wend(char **p);
static void skip_do_to_after_loop(char **p);

enum func_code {
    FN_NONE = 0,
    FN_SIN = 1,
    FN_COS = 2,
    FN_TAN = 3,
    FN_ABS = 4,
    FN_INT = 5,
    FN_SQR = 6,
    FN_SGN = 7,
    FN_EXP = 8,
    FN_LOG = 9,
    FN_RND = 10,
    FN_LEN = 11,
    FN_STR = 12,
    FN_CHR = 13,
    FN_ASC = 14,
    FN_VAL = 15,
    FN_TAB = 16,
    FN_SPC = 17,
    FN_MID = 18,
    FN_LEFT = 19,
    FN_RIGHT = 20,
    FN_UCASE = 21,
    FN_LCASE = 22,
    FN_SYSTEM = 23,
    FN_EXEC = 24,
    FN_ARGC = 25,
    FN_ARG = 26,
    FN_INSTR = 27,
    FN_DEC = 28,
    FN_HEX = 29,
    FN_STRINGFN = 30,
    FN_PEEK = 31,
    FN_INKEY = 32,
    FN_REPLACE = 33,
    FN_TRIM = 34,
    FN_LTRIM = 35,
    FN_RTRIM = 36,
    FN_FIELD = 37,
    FN_INDEXOF = 38,
    FN_LASTINDEXOF = 39,
    FN_ENV = 40,
    FN_PLATFORM = 41,
    FN_JSON = 42,
    FN_EVAL = 43,
    FN_SPRITEW = 44,
    FN_SPRITEH = 45,
    FN_SPRITECOLLIDE = 46,
    FN_JOY = 47,
    FN_JOYAXIS = 48,
    FN_SPRITETILES = 49,
    FN_SPRITEFRAME = 50,
    FN_SCROLLX = 51,
    FN_SCROLLY = 52,
    FN_HTTP = 53,
    FN_HTTPSTATUS = 54
};

/* Report an error and halt further execution.
 * If possible, include the BASIC line number (if present) and the
 * original source text with a caret pointing near the error location.
 * Optional hint gives a short fix suggestion (shown on its own line).
 */
static void runtime_error_hint(const char *msg, const char *hint)
{
    int line_no = 0;
    const char *line_text = NULL;

    if (current_line >= 0 && current_line < line_count &&
        program_lines[current_line] != NULL) {
        line_no = program_lines[current_line]->number;
        line_text = program_lines[current_line]->text;
    }

#if defined(__EMSCRIPTEN__)
    /* Browser: each fprintf(stderr) becomes a separate Module.printErr call.
     * canvas.html overwrites the log each time, so multi-line errors showed
     * only the last line (often "^" alone). Emit one string. */
    {
        char buf[MAX_LINE_LEN + 512];
        int n;

        if (line_no > 0) {
            if (hint && hint[0]) {
                n = snprintf(buf, sizeof(buf), "Error on line %d: %s\n  Hint: %s\n", line_no, msg, hint);
            } else {
                n = snprintf(buf, sizeof(buf), "Error on line %d: %s\n", line_no, msg);
            }
        } else {
            if (hint && hint[0]) {
                n = snprintf(buf, sizeof(buf), "Error: %s\n  Hint: %s\n", msg, hint);
            } else {
                n = snprintf(buf, sizeof(buf), "Error: %s\n", msg);
            }
        }
        if (n < 0) {
            n = 0;
        }
        if ((size_t)n >= sizeof(buf)) {
            n = (int)sizeof(buf) - 1;
        }

        if (line_text && *line_text && (size_t)n < sizeof(buf) - 1) {
            size_t rem = sizeof(buf) - (size_t)n;
            int m = snprintf(buf + n, rem, "  %s\n", line_text);
            if (m < 0) {
                m = 0;
            }
            if ((size_t)m >= rem) {
                n = (int)sizeof(buf) - 1;
                buf[n] = '\0';
            } else {
                n += m;
            }

            if (statement_pos &&
                statement_pos >= line_text &&
                statement_pos <= line_text + (int)strlen(line_text)) {
                const char *p = line_text;
                int col = 0;
                while (p < statement_pos && *p) {
                    col++;
                    p++;
                }
                if (col > 120) {
                    col = 120;
                }
                if ((size_t)n < sizeof(buf) - (size_t)(4 + col)) {
                    char *out = buf + n;
                    int cap = (int)(sizeof(buf) - (size_t)n);
                    int pos = 0;
                    if (pos + 2 < cap) {
                        out[pos++] = ' ';
                        out[pos++] = ' ';
                    }
                    for (int i = 0; i < col && pos < cap - 3; i++) {
                        out[pos++] = ' ';
                    }
                    if (pos < cap - 2) {
                        out[pos++] = '^';
                        out[pos++] = '\n';
                        out[pos] = '\0';
                        n += pos;
                    }
                }
            }
        }
        fprintf(stderr, "%s", buf);
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
        if (wasm_canvas_debug_flag) {
            wasm_canvas_debug_dump_stacks(msg);
        }
#endif
    }
#else
    if (line_no > 0) {
        fprintf(stderr, "Error on line %d: %s\n", line_no, msg);
    } else {
        fprintf(stderr, "Error: %s\n", msg);
    }
    if (hint && hint[0]) {
        fprintf(stderr, "  Hint: %s\n", hint);
    }

    if (line_text && *line_text) {
        /* Print the full source line for context. */
        fprintf(stderr, "  %s\n", line_text);

        /* If we know roughly where in the line we are (statement_pos),
         * print a caret pointing near that column.
         */
        if (statement_pos &&
            statement_pos >= line_text &&
            statement_pos <= line_text + (int)strlen(line_text)) {
            const char *p = line_text;
            int col = 0;
            while (p < statement_pos && *p) {
                /* Treat tabs as a single column for simplicity. */
                col++;
                p++;
            }
            fprintf(stderr, "  ");
            /* Cap the number of spaces so very long lines do not spam. */
            if (col > 120) {
                col = 120;
            }
            for (int i = 0; i < col; i++) {
                fputc(' ', stderr);
            }
            fprintf(stderr, "^\n");
        }
    }
#endif

    halted = 1;
}

static void runtime_error(const char *msg)
{
    runtime_error_hint(msg, NULL);
}

/* Strip trailing newline from a buffer if present. */
static void trim_newline(char *s)
{
    size_t len;
    len = strlen(s);
    while (len > 0 && (s[len - 1] == '\n' || s[len - 1] == '\r')) {
        s[--len] = '\0';
    }
}

/* Advance pointer past spaces/tabs. */
static void skip_spaces(char **p)
{
    while (**p == ' ' || **p == '\t') {
        (*p)++;
    }
}

/* Parse a numeric literal from the character stream. */
static int parse_number_literal(char **p, double *out)
{
    char buf[64];
    char *s;
    char *q;
    int len;
    s = *p;
    q = s;
    if (*q == '+' || *q == '-') {
        q++;
    }
    while (isdigit((unsigned char)*q)) {
        q++;
    }
    if (*q == '.') {
        q++;
        while (isdigit((unsigned char)*q)) {
            q++;
        }
    }
    if (*q == 'e' || *q == 'E') {
        char *e;
        e = q + 1;
        if (*e == '+' || *e == '-') {
            e++;
        }
        if (isdigit((unsigned char)*e)) {
            q = e;
            while (isdigit((unsigned char)*q)) {
                q++;
            }
        }
    }
    if (q == s || (s + 1 == q && (s[0] == '+' || s[0] == '-'))) {
        return 0;
    }
    len = q - s;
    if (len >= (int)sizeof(buf)) {
        len = sizeof(buf) - 1;
    }
    strncpy(buf, s, len);
    buf[len] = '\0';
    *out = atof(buf);
    *p = q;
    return 1;
}

/* Duplicate a string into heap memory. */
static char *dupstr_local(const char *s)
{
    size_t len;
    char *p;
    len = strlen(s) + 1;
    p = (char *)malloc(len);
    if (!p) {
        runtime_error_hint("Out of memory", "The interpreter could not allocate memory; try a smaller program or restart.");
        return NULL;
    }
    memcpy(p, s, len);
    return p;
}

/* Reserved words: identifiers that cannot be used as variable or label names. */
static const char *const reserved_words[] = {
    "AND", "ARG", "ARGC", "ASC", "BACKGROUND", "CHR", "CLOSE", "CLR", "COLOR",
    "COLOUR", "COS", "CURSOR", "DATA", "DEC", "DEF", "DIM", "DOWN", "END", "FUNCTION",
    "ELSE", "ENV", "EVAL", "EXEC", "EXP", "FN", "FOR", "GET", "GOSUB", "GOTO", "HEX", "IF", "INK",
    "INKEY", "INPUT", "INSTR", "INT", "INDEXOF", "JSON", "LEFT", "LEN", "LET", "LINE", "LOAD", "LOADSPRITE", "LOCATE", "LOG",
    "LASTINDEXOF", "LCASE", "FIELD", "LTRIM", "MEMCPY", "MEMSET", "MID", "MOD", "NEXT", "OFF", "ON", "OPEN", "OR", "PEEK", "POKE", "PLATFORM", "PRESET", "PSET", "PRINT",
    "XOR",
    "READ", "REM", "REPLACE", "RESTORE", "RETURN", "RIGHT", "RND", "RTRIM", "RVS", "SCROLL", "SCREEN", "SCREENCODES", "SPRITECOLLIDE", "SPRITEFRAME", "SPRITEMODULATE", "SPRITETILES", "SPRITEVISIBLE",
    "JOIN",
    "SGN", "SIN", "SLEEP", "SORT", "SPC", "SPLIT", "SPRITEH", "SPRITEW", "SQR", "STEP", "STOP", "STR", "STRING",
    "DRAWSPRITE", "DRAWSPRITETILE", "HTTP", "HTTPSTATUS", "JOY", "JOYAXIS", "JOYSTICK", "SCROLLX", "SCROLLY", "SYSTEM", "TAB", "TAN", "TEXTAT", "THEN", "TI", "TO", "TRIM", "UCASE", "UNLOADSPRITE", "VAL", "WEND", "WHILE",
    "DO", "LOOP", "UNTIL", "EXIT",
    NULL
};

static int is_reserved_word(const char *name)
{
    int i;
    char up[VAR_NAME_MAX];
    size_t len;
    if (!name || !name[0]) return 0;
    len = strlen(name);
    if (len >= VAR_NAME_MAX) return 0;
    for (i = 0; (unsigned char)name[i]; i++) {
        up[i] = (char)toupper((unsigned char)name[i]);
    }
    up[i] = '\0';
    for (i = 0; reserved_words[i]; i++) {
        if (strcmp(up, reserved_words[i]) == 0) return 1;
    }
    return 0;
}

/* Check if the input starts with the keyword (case-insensitive). */
static int starts_with_kw(char *p, const char *kw)
{
    int i;
    for (i = 0; kw[i]; i++) {
        if (toupper((unsigned char)p[i]) != kw[i]) {
            return 0;
        }
    }
    if (p[i] == '\0' || p[i] == ' ' || p[i] == '\t' || p[i] == ':' || p[i] == '(' || p[i] == '$' || p[i] == '\"' || p[i] == '#') {
        return 1;
    }
    /* Do not treat a longer identifier as this keyword (e.g. HTTP vs HTTPSTATUS). */
    if (isalnum((unsigned char)p[i]) || p[i] == '_') {
        return 0;
    }
    return 1;
}

/* Construct a numeric value wrapper. */
static struct value make_num(double v)
{
    struct value out;
    out.type = VAL_NUM;
    out.num = v;
    out.str[0] = '\0';
    return out;
}

/* Construct a string value wrapper. */
static struct value make_str(const char *s)
{
    struct value out;
    size_t lim;
    out.type = VAL_STR;
    out.num = 0.0;
    lim = (size_t)max_str_limit;
    if (lim > MAX_STR_LEN - 1) lim = MAX_STR_LEN - 1;
    {
        size_t len = strlen(s);
        if (len > lim) len = lim;
        memcpy(out.str, s, len);
        out.str[len] = '\0';
    }
    return out;
}

/* Ensure the value is numeric or raise a runtime error. */
static void ensure_num(struct value *v)
{
    if (v->type != VAL_NUM) {
        runtime_error_hint("Numeric value required", "Use a number here, or VAL(...) to convert a string.");
    }
}

/* Ensure the value is string; auto-convert numeric to string when needed. */
static void ensure_str(struct value *v)
{
    if (v->type == VAL_STR) {
        return;
    }
    if (v->type == VAL_NUM) {
        char buf[64];
        sprintf(buf, "%g", v->num);
        *v = make_str(buf);
        return;
    }
    runtime_error_hint("String value required", "Use a string expression, or STR$(...) to convert a number.");
}

/* Emit spaces and track current print column. */
static void print_spaces(int count)
{
    int i;
    for (i = 0; i < count; i++) {
#ifdef GFX_VIDEO
        if (gfx_vs) {
            gfx_put_byte(' ');
            continue;
        }
#endif
        OUTC(' ');
        print_col++;
        if (print_col >= print_width && !petscii_no_wrap && !terminal_no_wrap) {
            OUTC('\n');
            print_col = 0;
        }
    }
}

/* Parse a DEF FN user-defined function definition. */
static void statement_def(char **p)
{
    char namebuf[8];
    char param_buf[8];
    int i;
    int idx;
    struct user_func *uf;
    char *body_start;

    skip_spaces(p);
    if (!isalpha((unsigned char)**p)) {
        runtime_error_hint("Expected function name after DEF", "Use DEF FNname(x) = expression — the name must start with FN.");
        return;
    }
    /* Read function name (e.g. FNY) and uppercase it */
    read_identifier(p, namebuf, sizeof(namebuf));
    for (i = 0; namebuf[i]; i++) {
        namebuf[i] = (char)toupper((unsigned char)namebuf[i]);
    }

    /* Require that the function name begins with FN, per classic BASIC. */
    if (!(namebuf[0] == 'F' && namebuf[1] == 'N')) {
        runtime_error_hint("Function name must start with FN", "Classic BASIC uses names like FNY for DEF FNY(X) = X+1.");
        return;
    }

    skip_spaces(p);
    if (**p != '(') {
        runtime_error_hint("DEF FN requires parameter list", "Add parentheses: DEF FNY(X) = X * 2");
        return;
    }
    (*p)++;
    skip_spaces(p);
    if (!isalpha((unsigned char)**p)) {
        runtime_error_hint("Expected parameter name", "Put one variable inside the parentheses, e.g. DEF FNY(X) = X+1 or FNA$(S$).");
        return;
    }
    read_identifier(p, param_buf, sizeof(param_buf));
    for (i = 0; param_buf[i]; i++) {
        param_buf[i] = (char)toupper((unsigned char)param_buf[i]);
    }
    skip_spaces(p);
    if (**p != ')') {
        runtime_error_hint("Missing ')' in DEF FN", "Close the parameter list before '=' : DEF FNY(X) = …");
        return;
    }
    (*p)++;
    skip_spaces(p);
    if (**p != '=') {
        runtime_error_hint("DEF FN missing '='", "After the closing ')' use '=' then the expression: DEF FNY(X) = X+1");
        return;
    }
    (*p)++;
    body_start = *p;
    while (*body_start == ' ' || *body_start == '\t') {
        body_start++;
    }
    if (*body_start == '\0') {
        runtime_error_hint("Empty function body in DEF FN", "Write an expression after '=' on the same line.");
        return;
    }

    /* Find or create function entry */
    idx = user_func_lookup(namebuf);
    if (idx < 0) {
        if (user_func_count >= MAX_USER_FUNCS) {
            runtime_error_hint("Function table full", "Too many DEF FN definitions; remove unused functions or split the program.");
            return;
        }
        idx = user_func_count++;
    }
    uf = &user_funcs[idx];
    if (uf->body) {
        free(uf->body);
    }
    strncpy(uf->name, namebuf, sizeof(uf->name) - 1);
    uf->name[sizeof(uf->name) - 1] = '\0';
    strncpy(uf->param_name, param_buf, sizeof(uf->param_name) - 1);
    uf->param_name[sizeof(uf->param_name) - 1] = '\0';
    uf->param_is_string = (param_buf[strlen(param_buf) - 1] == '$');
    uf->body = dupstr_local(body_start);

    /* DEF FN is a complete statement; skip to end of line. */
    *p += strlen(*p);
}

/* READ statement: READ A, B$, ... pulls from DATA pool */
static void statement_read(char **p)
{
    for (;;) {
        struct value *vp;
        int is_array;
        int is_string;

        skip_spaces(p);
        if (**p == '\0' || **p == ':') {
            break;
        }
        if (!isalpha((unsigned char)**p)) {
            runtime_error_hint("Expected variable in READ",
                                 "READ needs variables matching DATA order: READ A, B$ after DATA lines.");
            return;
        }
        vp = get_var_reference(p, &is_array, &is_string, NULL);
        if (!vp) {
            return;
        }
        if (data_index >= data_count) {
            runtime_error_hint("Out of DATA",
                                 "Add more DATA values or RESTORE; READ ran past the last DATA item.");
            return;
        }
        {
            struct value src = data_items[data_index++];
            if (is_string) {
                if (src.type != VAL_STR) {
                    char buf[64];
                    sprintf(buf, "%g", src.num);
                    *vp = make_str(buf);
                } else {
                    *vp = src;
                }
            } else {
                if (src.type != VAL_NUM) {
                    double num = atof(src.str);
                    *vp = make_num(num);
                } else {
                    *vp = src;
                }
            }
        }
        skip_spaces(p);
        if (**p == ',') {
            (*p)++;
            continue;
        }
        break;
    }
}

/* Lookup a DEF FN user-defined function by name (already uppercased). */
static int user_func_lookup(const char *name)
{
    int i;
    for (i = 0; i < user_func_count; i++) {
        if (strcmp(user_funcs[i].name, name) == 0) {
            return i;
        }
    }
    return -1;
}

/* Simple label table for optional label-based GOTO/GOSUB.
 * A label is defined by writing it at the start of a line followed by ':'.
 * For example:
 *   START: PRINT "HELLO": GOTO START
 *
 * Labels are resolved to line indices after the program is loaded.
 */

#define MAX_LABELS 256

struct label_entry {
    char name[32];
    int line_index; /* index into program_lines[] */
};

static struct label_entry label_table[MAX_LABELS];
static int label_count = 0;

/* Build the label table by scanning program lines for leading "NAME:".
 * The label text is stripped from the stored line so execution sees only statements.
 */
static void build_label_table(void)
{
    int i;
    label_count = 0;
    for (i = 0; i < line_count; i++) {
        char *text;
        char *p;
        char *q;
        size_t len;

        if (!program_lines[i] || !program_lines[i]->text) {
            continue;
        }
        text = program_lines[i]->text;
        p = text;
        while (*p == ' ' || *p == '\t') {
            p++;
        }
        /* Label must start with a letter and consist of letters/digits/$,
         * immediately followed by ':' (optionally after spaces). This avoids
         * misinterpreting expressions like 'LB$=CHR$(154):' as labels.
         */
        if (!isalpha((unsigned char)*p)) {
            continue;
        }
        q = p;
        while (isalpha((unsigned char)*q) || isdigit((unsigned char)*q) || *q == '$' || *q == '_') {
            q++;
        }
        /* Skip optional spaces/tabs between label and ':' */
        {
            char *r = q;
            char *label_end = q;  /* end of identifier only, not including spaces */
            while (*r == ' ' || *r == '\t') {
                r++;
            }
            if (*r != ':') {
                continue;
            }
            len = (size_t)(label_end - p);
            q = r; /* q now points at ':' */
        }

        /* We have LABEL: at start of line. Extract the name. */
        if (len >= sizeof(label_table[0].name)) {
            len = sizeof(label_table[0].name) - 1;
        }
        if (label_count >= MAX_LABELS) {
            /* Too many labels; ignore extras. */
            continue;
        }
        /* Keywords like PRINT/CLR followed by ':' are statements, not labels. */
        {
            char tmp[32];
            size_t k;
            if (len >= sizeof(tmp)) tmp[sizeof(tmp)-1] = '\0';
            memcpy(tmp, p, len);
            tmp[len] = '\0';
            if (is_reserved_word(tmp)) {
                continue;
            }
            for (k = 0; k < len; k++) tmp[k] = (char)toupper((unsigned char)tmp[k]);
            for (k = 0; k < (size_t)label_count; k++) {
                if (strcmp(label_table[k].name, tmp) == 0) {
                    fprintf(stderr, "Duplicate label '%.*s' in program\n", (int)len, p);
                    fprintf(stderr, "  Hint: Rename one label or remove the duplicate @name: definition.\n");
                    exit(1);
                }
            }
        }
        memcpy(label_table[label_count].name, p, len);
        label_table[label_count].name[len] = '\0';
        /* Normalize to uppercase for case-insensitive matching. */
        {
            size_t k;
            for (k = 0; k < len; k++) {
                label_table[label_count].name[k] =
                    (char)toupper((unsigned char)label_table[label_count].name[k]);
            }
        }
        /* Labels may share names with keywords (e.g. CLR: in trek.bas); context is unambiguous. */
        label_table[label_count].line_index = i;
        label_count++;

        /* Strip the label from the stored line so execution sees only the statement. */
        q++; /* skip ':' */
        while (*q == ' ' || *q == '\t') {
            q++;
        }
        /* Duplicate the remainder into a new buffer. */
        {
            char *new_text = dupstr_local(q);
            if (new_text) {
                free(program_lines[i]->text);
                program_lines[i]->text = new_text;
            }
        }
    }
}

/* Find the line index for a given label name, or -1 if not found. */
static int find_label_line(const char *name)
{
    int i;
    char tmp[32];
    size_t len;

    if (!name || !*name) {
        return -1;
    }
    /* Uppercase a copy for case-insensitive comparison. */
    len = strlen(name);
    if (len >= sizeof(tmp)) {
        len = sizeof(tmp) - 1;
    }
    memcpy(tmp, name, len);
    tmp[len] = '\0';
    for (i = 0; tmp[i]; i++) {
        tmp[i] = (char)toupper((unsigned char)tmp[i]);
    }

    for (i = 0; i < label_count; i++) {
        if (strcmp(label_table[i].name, tmp) == 0) {
            return label_table[i].line_index;
        }
    }
    return -1;
}

/* Lookup UDF by name (uppercased) and param count. */
static int udf_lookup(const char *name, int param_count)
{
    int i;
    for (i = 0; i < udf_func_count; i++) {
        if (strcmp(udf_funcs[i].name, name) == 0 && udf_funcs[i].param_count == param_count) {
            return i;
        }
    }
    return -1;
}

/* Scan program for FUNCTION...END FUNCTION and build udf_funcs table. */
static void build_udf_table(void)
{
    int i, j, nesting;
    char *p, *q;
    char namebuf[VAR_NAME_MAX];
    int param_count;
    char *body_start;
    int body_line;

    udf_func_count = 0;
    for (i = 0; i < line_count && udf_func_count < MAX_UDF_FUNCS; i++) {
        if (!program_lines[i] || !program_lines[i]->text) continue;
        p = program_lines[i]->text;
        for (;;) {
            while (*p == ' ' || *p == '\t') p++;
            if (!*p) break;
            if ((toupper((unsigned char)p[0])=='F' && toupper((unsigned char)p[1])=='U' &&
                 toupper((unsigned char)p[2])=='N' && toupper((unsigned char)p[3])=='C' &&
                 toupper((unsigned char)p[4])=='T' && toupper((unsigned char)p[5])=='I' &&
                 toupper((unsigned char)p[6])=='O' && toupper((unsigned char)p[7])=='N') &&
                (p[8]=='\0' || p[8]==' ' || p[8]=='\t')) {
                q = p + 8;
                while (*q == ' ' || *q == '\t') q++;
                if (!isalpha((unsigned char)*q)) {
                    { char *n = strchr(p, ':'); p = n ? n + 1 : p + strlen(p); }
                    continue;
                }
                read_identifier((char**)&q, namebuf, sizeof(namebuf));
                { int k; for (k = 0; namebuf[k]; k++) namebuf[k] = (char)toupper((unsigned char)namebuf[k]); }
                while (*q == ' ' || *q == '\t') q++;
                param_count = 0;
                if (*q == '(') {
                    q++;
                    while (*q && *q != ')') {
                        while (*q == ' ' || *q == '\t') q++;
                        if (!isalpha((unsigned char)*q)) break;
                        if (param_count < MAX_UDF_PARAMS) {
                            read_identifier((char**)&q, udf_funcs[udf_func_count].param_names[param_count], VAR_NAME_MAX);
                            { int k; for (k = 0; udf_funcs[udf_func_count].param_names[param_count][k]; k++)
                                udf_funcs[udf_func_count].param_names[param_count][k] =
                                    (char)toupper((unsigned char)udf_funcs[udf_func_count].param_names[param_count][k]); }
                            udf_funcs[udf_func_count].param_is_string[param_count] =
                                (strlen(udf_funcs[udf_func_count].param_names[param_count]) > 0 &&
                                 udf_funcs[udf_func_count].param_names[param_count][strlen(udf_funcs[udf_func_count].param_names[param_count])-1] == '$');
                            param_count++;
                        }
                        while (*q == ' ' || *q == '\t') q++;
                        if (*q == ',') q++;
                    }
                    if (*q == ')') q++;
                }
                while (*q == ' ' || *q == '\t') q++;
                if (*q == ':') {
                    q++;
                    while (*q == ' ' || *q == '\t') q++;
                    body_start = q;
                    body_line = i;
                } else {
                    body_line = i + 1;
                    body_start = NULL;
                }
                /* Find matching END FUNCTION */
                nesting = 1;
                for (j = (body_start && *body_start) ? i : i + 1; j < line_count && nesting > 0; j++) {
                    char *r = (j == i && body_start) ? body_start : program_lines[j]->text;
                    if (!r) continue;
                    for (;;) {
                        while (r && (*r == ' ' || *r == '\t')) r++;
                        if (!r || !*r) break;
                        if ((toupper((unsigned char)r[0])=='F' && toupper((unsigned char)r[1])=='U' &&
                             toupper((unsigned char)r[2])=='N' && toupper((unsigned char)r[3])=='C' &&
                             toupper((unsigned char)r[4])=='T' && toupper((unsigned char)r[5])=='I' &&
                             toupper((unsigned char)r[6])=='O' && toupper((unsigned char)r[7])=='N') &&
                            (r[8]=='\0' || r[8]==' ' || r[8]=='\t')) {
                            nesting++;
                            r += 8;
                            while (*r && *r != ':') r++;
                            if (*r) r++;
                            continue;
                        }
                        if (toupper((unsigned char)r[0])=='E' && toupper((unsigned char)r[1])=='N' &&
                            toupper((unsigned char)r[2])=='D' && (r[3]=='\0' || r[3]==' ' || r[3]=='\t')) {
                            char *ef = r + 3;
                            while (*ef == ' ' || *ef == '\t') ef++;
                            if (toupper((unsigned char)ef[0])=='F' && toupper((unsigned char)ef[1])=='U' &&
                                toupper((unsigned char)ef[2])=='N' && toupper((unsigned char)ef[3])=='C' &&
                                toupper((unsigned char)ef[4])=='T' && toupper((unsigned char)ef[5])=='I' &&
                                toupper((unsigned char)ef[6])=='O' && toupper((unsigned char)ef[7])=='N' &&
                                (ef[8]=='\0' || ef[8]==' ' || ef[8]=='\t' || ef[8]==':')) {
                            nesting--;
                            if (nesting == 0) {
                                struct udf_func *uf = &udf_funcs[udf_func_count];
                                strncpy(uf->name, namebuf, VAR_NAME_MAX - 1);
                                uf->name[VAR_NAME_MAX - 1] = '\0';
                                uf->param_count = param_count;
                                uf->body_line = body_line;
                                uf->body_pos = body_start ? body_start : (program_lines[body_line] ? program_lines[body_line]->text : NULL);
                                udf_func_count++;
                                goto next_statement;
                            }
                            r = ef + 8;
                            while (*r && *r != ':') r++;
                            if (*r) r++;
                            continue;
                            }
                        }
                        {
                            char *next = strchr(r, ':');
                            if (!next) break;
                            r = next + 1;
                        }
                    }
                }
                fprintf(stderr, "FUNCTION %s: END FUNCTION not found\n", namebuf);
                fprintf(stderr, "  Hint: Add END FUNCTION after the function body, before the next top-level line.\n");
next_statement:
                { char *n = strchr(p, ':'); p = n ? n + 1 : p + strlen(p); }
                continue;
            }
            { char *n = strchr(p, ':'); p = n ? n + 1 : p + strlen(p); }
        }
    }
}

/* Scan all program lines and collect DATA items into data_items[] */
static void collect_data_from_program(void)
{
    int i;
    data_count = 0;
    data_index = 0;
    data_line_count = 0;
    for (i = 0; i < line_count && data_count < MAX_DATA_ITEMS; i++) {
        char *p;
        if (!program_lines[i] || !program_lines[i]->text) {
            continue;
        }
        p = program_lines[i]->text;
        while (*p == ' ' || *p == '\t') {
            p++;
        }
        if (!starts_with_kw(p, "DATA")) {
            continue;
        }
        if (data_line_count < MAX_DATA_LINES) {
            data_line_numbers[data_line_count] = program_lines[i]->number;
            data_line_start_index[data_line_count] = data_count;
            data_line_count++;
        }
        p += 4;
        for (;;) {
            struct value v;
            char token[MAX_STR_LEN];
            int tlen = 0;

            while (*p == ' ' || *p == '\t') {
                p++;
            }
            if (*p == '\0') {
                break;
            }
            if (*p == '\"') {
                /* Quoted string */
                p++;
                while (*p && *p != '\"' && tlen < (int)sizeof(token) - 1) {
                    token[tlen++] = *p++;
                }
                token[tlen] = '\0';
                if (*p == '\"') {
                    p++;
                }
                v = make_str(token);
            } else {
                /* Unquoted token up to comma or end */
                while (*p && *p != ',' && *p != ':' && tlen < (int)sizeof(token) - 1) {
                    token[tlen++] = *p++;
                }
                token[tlen] = '\0';
                /* Trim trailing spaces */
                while (tlen > 0 && (token[tlen - 1] == ' ' || token[tlen - 1] == '\t')) {
                    token[--tlen] = '\0';
                }
                if (tlen == 0) {
                    v = make_str("");
                } else {
                    char *endptr;
                    double num = strtod(token, &endptr);
                    if (endptr != token && *endptr == '\0') {
                        v = make_num(num);
                    } else {
                        v = make_str(token);
                    }
                }
            }
            if (data_count < MAX_DATA_ITEMS) {
                data_items[data_count++] = v;
            }
            while (*p == ' ' || *p == '\t') {
                p++;
            }
            if (*p == ',') {
                p++;
                continue;
            }
            break;
        }
    }
}

/* Emit a value (number or string) updating column tracking. */
static void print_value(struct value *v)
{
    if (v->type == VAL_STR) {
        char *s;
        s = v->str;
        while (*s) {
            unsigned char c = (unsigned char)*s;
#ifdef GFX_VIDEO
            if (gfx_vs) {
                /* Decode UTF-8 so Unicode box-drawing (┌─┐ etc.) and £
                 * from trek.bas and similar sources map to C64 PETSCII. */
                if (c >= 0xC2 && c <= 0xF4) {
                    int u = gfx_decode_utf8((const char **)&s);
                    if (u >= 0) {
                        int pet = unicode_to_petscii(u);
                        if (pet >= 0) {
                            /* Route through gfx_put_byte so charset_lower / PETSCII / CHR$ rules match. */
                            gfx_put_byte((unsigned char)pet);
                            continue;
                        }
                        /* Unknown Unicode: output space to avoid garbage */
                        gfx_put_byte(' ');
                    } else {
                        /* UTF-8 decode failed (e.g. lone 0xDD from CHR$(221));
                         * output raw byte as PETSCII. */
                        gfx_put_byte(c);
                    }
                    continue;
                }
                /* Consume ANSI escape sequences (e.g. {RESET} -> ESC[0m); don't render as glyphs. */
                if (c == 0x1b) {
                    s++;
                    if (*s == '[') {
                        s++;
                        while (*s && (*s < 0x40 || *s > 0x7E)) s++;
                        if (*s == 'm') {
                            /* SGR sequence — treat [0m as reset to default */
                            gfx_fg = 1;  /* white */
                            gfx_reverse = 0;
                        }
                        if (*s) s++;
                    } else if (*s) {
                        s++;  /* skip one byte for non-CSI escape */
                    }
                    continue;
                }
                gfx_put_byte(c);
                s++;
                continue;
            }
#endif
            /* Handle ANSI escape sequences specially so column tracking matches
             * what the terminal actually does. Most sequences are treated as
             * zero-width; cursor-right (C) / cursor-left (D) adjust print_col.
             */
            if (petscii_mode && c == 0x1b) {
                OUTC(c);
                s++;
                if (!*s) {
                    break;
                }
                unsigned char d = (unsigned char)*s;
                OUTC(d);
                if (d == '[') {
                    int n = 0;
                    int have_num = 0;
                    s++;
                    while (*s) {
                        d = (unsigned char)*s;
                        OUTC(d);
                        if (d >= '0' && d <= '9') {
                            n = n * 10 + (d - '0');
                            have_num = 1;
                            s++;
                            continue;
                        }
                        if (d == ';' || d == '?' || d == ' ') {
                            s++;
                            continue;
                        }
                        /* Final byte of CSI sequence. */
                        if (!have_num) {
                            n = 1;
                        }
                        if (d == 'C') {
                            /* Cursor right */
                            print_col += n;
                            if (print_col >= print_width && !petscii_no_wrap && !terminal_no_wrap) {
                                OUTC('\n');
                                print_col = 0;
                            }
                        } else if (d == 'D') {
                            /* Cursor left */
                            print_col -= n;
                            if (print_col < 0) {
                                print_col = 0;
                            }
                        } else if (d == 'H' || d == 'f') {
                            /* Cursor home/position: we don't track row, just reset column. */
                            print_col = 0;
                        }
                        s++;
                        break;
                    }
                } else {
                    /* Non-CSI escape; just emit next byte and treat as zero-width. */
                    s++;
                }
                continue;
            }
            OUTC(c);
            if (c == '\n') {
                print_col = 0;
            } else {
                /* Count one column per UTF-8 character (glyph), not per byte, so
                 * wrap happens at 40 visible columns and we don't break mid-char. */
                if (c < 0x80 || (c & 0xC0) != 0x80) {
                    print_col++;
                    if (print_col >= print_width && !petscii_no_wrap && !terminal_no_wrap) {
                        OUTC('\n');
                        print_col = 0;
                    }
                }
            }
            s++;
        }
    } else {
        char buf[64];
        sprintf(buf, "%g", v->num);
#ifdef GFX_VIDEO
        if (gfx_vs) {
            char *s = buf;
            while (*s) {
                gfx_put_byte((unsigned char)*s++);
            }
            return;
        }
#endif
        OUTS(buf);
        print_col += (int)strlen(buf);
    }
}

/* Map function name to a small integer code for fast dispatch. */
static int function_lookup(const char *name, int len)
{
    char c1;
    c1 = name[0];
    switch (c1) {
    case 'S':
        if (len == 3 && name[0] == 'S' && name[1] == 'I' && name[2] == 'N') return FN_SIN;
        if (len == 3 && name[0] == 'S' && name[1] == 'G' && name[2] == 'N') return FN_SGN;
        if (len == 3 && name[0] == 'S' && name[1] == 'Q' && name[2] == 'R') return FN_SQR;
        if ((len == 3 && name[0] == 'S' && name[1] == 'T' && name[2] == 'R') ||
            (len == 4 && name[0] == 'S' && name[1] == 'T' && name[2] == 'R' && name[3] == '$')) return FN_STR;
        if (len == 3 && name[0] == 'S' && name[1] == 'P' && name[2] == 'C') return FN_SPC;
        if ((len == 6 && name[0] == 'S' && name[1] == 'T' && name[2] == 'R' && name[3] == 'I' && name[4] == 'N' && name[5] == 'G') ||
            (len == 7 && name[0] == 'S' && name[1] == 'T' && name[2] == 'R' && name[3] == 'I' && name[4] == 'N' && name[5] == 'G' && name[6] == '$'))
            return FN_STRINGFN;
        if (len == 6 && name[0] == 'S' && name[1] == 'Y' && name[2] == 'S' && name[3] == 'T' && name[4] == 'E' && name[5] == 'M') return FN_SYSTEM;
        if (len == 7 && name[0] == 'S' && name[1] == 'P' && name[2] == 'R' && name[3] == 'I' &&
            name[4] == 'T' && name[5] == 'E' && name[6] == 'W') return FN_SPRITEW;
        if (len == 7 && name[0] == 'S' && name[1] == 'P' && name[2] == 'R' && name[3] == 'I' &&
            name[4] == 'T' && name[5] == 'E' && name[6] == 'H') return FN_SPRITEH;
        if (len == 13 && name[0] == 'S' && name[1] == 'P' && name[2] == 'R' && name[3] == 'I' &&
            name[4] == 'T' && name[5] == 'E' && name[6] == 'C' && name[7] == 'O' && name[8] == 'L' &&
            name[9] == 'L' && name[10] == 'I' && name[11] == 'D' && name[12] == 'E') return FN_SPRITECOLLIDE;
        if (len == 11 && name[0] == 'S' && name[1] == 'P' && name[2] == 'R' && name[3] == 'I' &&
            name[4] == 'T' && name[5] == 'E' && name[6] == 'T' && name[7] == 'I' && name[8] == 'L' &&
            name[9] == 'E' && name[10] == 'S') return FN_SPRITETILES;
        if (len == 11 && name[0] == 'S' && name[1] == 'P' && name[2] == 'R' && name[3] == 'I' &&
            name[4] == 'T' && name[5] == 'E' && name[6] == 'F' && name[7] == 'R' && name[8] == 'A' &&
            name[9] == 'M' && name[10] == 'E') return FN_SPRITEFRAME;
        if (len == 7 && name[0] == 'S' && name[1] == 'C' && name[2] == 'R' && name[3] == 'O' &&
            name[4] == 'L' && name[5] == 'L' && name[6] == 'X') return FN_SCROLLX;
        if (len == 7 && name[0] == 'S' && name[1] == 'C' && name[2] == 'R' && name[3] == 'O' &&
            name[4] == 'L' && name[5] == 'L' && name[6] == 'Y') return FN_SCROLLY;
        return FN_NONE;
    case 'C':
        if ((len == 3 && name[0] == 'C' && name[1] == 'H' && name[2] == 'R') ||
            (len == 4 && name[0] == 'C' && name[1] == 'H' && name[2] == 'R' && name[3] == '$')) return FN_CHR;
        if (len == 3 && name[0] == 'C' && name[1] == 'O' && name[2] == 'S') return FN_COS;
        return FN_NONE;
    case 'T':
        if (len == 3 && name[0] == 'T' && name[1] == 'A' && name[2] == 'N') return FN_TAN;
        if (len == 3 && name[0] == 'T' && name[1] == 'A' && name[2] == 'B') return FN_TAB;
        if ((len == 4 && name[0] == 'T' && name[1] == 'R' && name[2] == 'I' && name[3] == 'M') ||
            (len == 5 && name[0] == 'T' && name[1] == 'R' && name[2] == 'I' && name[3] == 'M' && name[4] == '$'))
            return FN_TRIM;
        return FN_NONE;
    case 'A':
        if (len == 3 && name[0] == 'A' && name[1] == 'B' && name[2] == 'S') return FN_ABS;
        if (len == 3 && name[0] == 'A' && name[1] == 'S' && name[2] == 'C') return FN_ASC;
        if (len == 4 && name[0] == 'A' && name[1] == 'R' && name[2] == 'G' && name[3] == 'C') return FN_ARGC;
        if ((len == 3 && name[0] == 'A' && name[1] == 'R' && name[2] == 'G') ||
            (len == 4 && name[0] == 'A' && name[1] == 'R' && name[2] == 'G' && name[3] == '$')) return FN_ARG;
        return FN_NONE;
    case 'J':
        if ((len == 4 && name[0] == 'J' && name[1] == 'S' && name[2] == 'O' && name[3] == 'N') ||
            (len == 5 && name[0] == 'J' && name[1] == 'S' && name[2] == 'O' && name[3] == 'N' && name[4] == '$'))
            return FN_JSON;
        if (len == 3 && name[0] == 'J' && name[1] == 'O' && name[2] == 'Y') return FN_JOY;
        if (len == 8 && name[0] == 'J' && name[1] == 'O' && name[2] == 'Y' && name[3] == 'S' &&
            name[4] == 'T' && name[5] == 'I' && name[6] == 'C' && name[7] == 'K') return FN_JOY;
        if (len == 7 && name[0] == 'J' && name[1] == 'O' && name[2] == 'Y' && name[3] == 'A' &&
            name[4] == 'X' && name[5] == 'I' && name[6] == 'S') return FN_JOYAXIS;
        return FN_NONE;
    case 'I':
        if (len == 3 && name[0] == 'I' && name[1] == 'N' && name[2] == 'T') return FN_INT;
        if (len == 5 && name[0] == 'I' && name[1] == 'N' && name[2] == 'S' && name[3] == 'T' && name[4] == 'R') return FN_INSTR;
        if (len == 7 && name[0] == 'I' && name[1] == 'N' && name[2] == 'D' && name[3] == 'E' && name[4] == 'X' && name[5] == 'O' && name[6] == 'F') return FN_INDEXOF;
        if (len == 5 && name[0] == 'I' && name[1] == 'N' && name[2] == 'K' && name[3] == 'E' && name[4] == 'Y') return FN_INKEY;
        if (len == 6 && name[0] == 'I' && name[1] == 'N' && name[2] == 'K' && name[3] == 'E' && name[4] == 'Y' && name[5] == '$') return FN_INKEY;
        return FN_NONE;
    case 'E':
        if (len == 4 && name[0] == 'E' && name[1] == 'V' && name[2] == 'A' && name[3] == 'L') return FN_EVAL;
        if (len == 3 && name[0] == 'E' && name[1] == 'X' && name[2] == 'P') return FN_EXP;
        if ((len == 4 && name[0] == 'E' && name[1] == 'N' && name[2] == 'V') ||
            (len == 5 && name[0] == 'E' && name[1] == 'N' && name[2] == 'V' && name[3] == '$'))
            return FN_ENV;
        if ((len == 4 && name[0] == 'E' && name[1] == 'X' && name[2] == 'E' && name[3] == 'C') ||
            (len == 5 && name[0] == 'E' && name[1] == 'X' && name[2] == 'E' && name[3] == 'C' && name[4] == '$'))
            return FN_EXEC;
        return FN_NONE;
    case 'L':
        if (len == 11 && name[0] == 'L' && name[1] == 'A' && name[2] == 'S' && name[3] == 'T' && name[4] == 'I' && name[5] == 'N' && name[6] == 'D' && name[7] == 'E' && name[8] == 'X' && name[9] == 'O' && name[10] == 'F') return FN_LASTINDEXOF;
        if (len == 3 && name[0] == 'L' && name[1] == 'O' && name[2] == 'G') return FN_LOG;
        if (len == 3 && name[0] == 'L' && name[1] == 'E' && name[2] == 'N') return FN_LEN;
        if ((len == 4 && name[0] == 'L' && name[1] == 'E' && name[2] == 'F' && name[3] == 'T') ||
            (len == 5 && name[0] == 'L' && name[1] == 'E' && name[2] == 'F' && name[3] == 'T' && name[4] == '$'))
            return FN_LEFT;
        if ((len == 5 && name[0] == 'L' && name[1] == 'C' && name[2] == 'A' && name[3] == 'S' && name[4] == 'E') ||
            (len == 6 && name[0] == 'L' && name[1] == 'C' && name[2] == 'A' && name[3] == 'S' && name[4] == 'E' && name[5] == '$'))
            return FN_LCASE;
        if ((len == 5 && name[0] == 'L' && name[1] == 'T' && name[2] == 'R' && name[3] == 'I' && name[4] == 'M') ||
            (len == 6 && name[0] == 'L' && name[1] == 'T' && name[2] == 'R' && name[3] == 'I' && name[4] == 'M' && name[5] == '$'))
            return FN_LTRIM;
        return FN_NONE;
    case 'M':
        if ((len == 3 && name[0] == 'M' && name[1] == 'I' && name[2] == 'D') ||
            (len == 4 && name[0] == 'M' && name[1] == 'I' && name[2] == 'D' && name[3] == '$'))
            return FN_MID;
        return FN_NONE;
    case 'R':
        if (len == 3 && name[0] == 'R' && name[1] == 'N' && name[2] == 'D') return FN_RND;
        if ((len == 5 && name[0] == 'R' && name[1] == 'I' && name[2] == 'G' && name[3] == 'H' && name[4] == 'T') ||
            (len == 6 && name[0] == 'R' && name[1] == 'I' && name[2] == 'G' && name[3] == 'H' && name[4] == 'T' && name[5] == '$'))
            return FN_RIGHT;
        if ((len == 7 && name[0] == 'R' && name[1] == 'E' && name[2] == 'P' && name[3] == 'L' && name[4] == 'A' && name[5] == 'C' && name[6] == 'E') ||
            (len == 8 && name[0] == 'R' && name[1] == 'E' && name[2] == 'P' && name[3] == 'L' && name[4] == 'A' && name[5] == 'C' && name[6] == 'E' && name[7] == '$'))
            return FN_REPLACE;
        if ((len == 5 && name[0] == 'R' && name[1] == 'T' && name[2] == 'R' && name[3] == 'I' && name[4] == 'M') ||
            (len == 6 && name[0] == 'R' && name[1] == 'T' && name[2] == 'R' && name[3] == 'I' && name[4] == 'M' && name[5] == '$'))
            return FN_RTRIM;
        return FN_NONE;
    case 'V':
        if (len == 3 && name[0] == 'V' && name[1] == 'A' && name[2] == 'L') return FN_VAL;
        return FN_NONE;
    case 'D':
        if (len == 3 && name[0] == 'D' && name[1] == 'E' && name[2] == 'C') return FN_DEC;
        return FN_NONE;
    case 'H':
        if ((len == 4 && name[0] == 'H' && name[1] == 'T' && name[2] == 'T' && name[3] == 'P') ||
            (len == 5 && name[0] == 'H' && name[1] == 'T' && name[2] == 'T' && name[3] == 'P' && name[4] == '$'))
            return FN_HTTP;
        if (len == 10 && name[0] == 'H' && name[1] == 'T' && name[2] == 'T' && name[3] == 'P' &&
            name[4] == 'S' && name[5] == 'T' && name[6] == 'A' && name[7] == 'T' && name[8] == 'U' &&
            name[9] == 'S')
            return FN_HTTPSTATUS;
        if ((len == 3 && name[0] == 'H' && name[1] == 'E' && name[2] == 'X') ||
            (len == 4 && name[0] == 'H' && name[1] == 'E' && name[2] == 'X' && name[3] == '$'))
            return FN_HEX;
        return FN_NONE;
    case 'P':
        if (len == 4 && name[0] == 'P' && name[1] == 'E' && name[2] == 'E' && name[3] == 'K') return FN_PEEK;
        if ((len == 8 && name[0] == 'P' && name[1] == 'L' && name[2] == 'A' && name[3] == 'T' && name[4] == 'F' && name[5] == 'O' && name[6] == 'R' && name[7] == 'M') ||
            (len == 9 && name[0] == 'P' && name[1] == 'L' && name[2] == 'A' && name[3] == 'T' && name[4] == 'F' && name[5] == 'O' && name[6] == 'R' && name[7] == 'M' && name[8] == '$'))
            return FN_PLATFORM;
        return FN_NONE;
    case 'U':
        if ((len == 5 && name[0] == 'U' && name[1] == 'C' && name[2] == 'A' && name[3] == 'S' && name[4] == 'E') ||
            (len == 6 && name[0] == 'U' && name[1] == 'C' && name[2] == 'A' && name[3] == 'S' && name[4] == 'E' && name[5] == '$'))
            return FN_UCASE;
        return FN_NONE;
    case 'F':
        if ((len == 5 && name[0] == 'F' && name[1] == 'I' && name[2] == 'E' && name[3] == 'L' && name[4] == 'D') ||
            (len == 6 && name[0] == 'F' && name[1] == 'I' && name[2] == 'E' && name[3] == 'L' && name[4] == 'D' && name[5] == '$'))
            return FN_FIELD;
        return FN_NONE;
    default:
        return FN_NONE;
    }
}

#if defined(__EMSCRIPTEN__)
/* WHILE/FOR/DO jump back inside one run_program "statement" — yield here too. */
static void wasm_maybe_yield_loop(void)
{
    wasm_browser_pause_point();
    if (halted) {
        return;
    }
    if (EM_ASM_INT({ return (typeof Module !== 'undefined' && Module['wasmStopRequested']) ? 1 : 0; })) {
        halted = 1;
        return;
    }
#if defined(GFX_VIDEO)
    wasm_gfx_refresh_js();
#endif
    emscripten_sleep(0);
}

/* Browser: use emscripten_sleep to yield to event loop. */
static void do_sleep_ticks(double ticks)
{
    int ms;
    wasm_browser_pause_point();
    if (halted) {
        return;
    }
    if (EM_ASM_INT({ return (typeof Module !== 'undefined' && Module['wasmStopRequested']) ? 1 : 0; })) {
        halted = 1;
        return;
    }
    if (ticks <= 0.0) return;
    ms = (int)(ticks * (1000.0 / 60.0) + 0.5);
    /* Asyncify needs a real sleep; rounding to 0 would busy-spin (e.g. fractional ticks). */
    if (ms < 1) {
        ms = 1;
    }
    emscripten_sleep(ms);
}
#elif defined(_WIN32)
/* Windows: sleep using Sleep() in milliseconds derived from 60Hz ticks. */
static void do_sleep_ticks(double ticks)
{
    DWORD ms;
    if (ticks <= 0.0) {
        return;
    }
    ms = (DWORD)(ticks * (1000.0 / 60.0) + 0.5);
    if (ms == 0) {
        return;
    }
    Sleep(ms);
}
#else
/* POSIX/Unix: select-based implementation for 60Hz ticks (no usleep dependency). */
static void do_sleep_ticks(double ticks)
{
    long usec;
    unsigned int sec;
    if (ticks <= 0.0) {
        return;
    }
    usec = (long)(ticks * (1000000.0 / 60.0) + 0.5);
    if (usec <= 0) {
        return;
    }
    sec = (unsigned int)(usec / 1000000L);
    usec = usec % 1000000L;
    /* Use select() for sub-second delay if available */
    {
        struct timeval tv;
        if (sec > 0) {
            sleep(sec);
        }
        if (usec > 0) {
            tv.tv_sec = 0;
            tv.tv_usec = usec;
            select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
        }
    }
}
#endif

/* Parse SLEEP statement and pause execution. */
static void statement_sleep(char **p)
{
    struct value v;
#if defined(__EMSCRIPTEN__)
    wasm_browser_pause_point();
    if (halted) {
        return;
    }
#endif
#if defined(__EMSCRIPTEN__)
    if (EM_ASM_INT({ return (typeof Module !== 'undefined' && Module['wasmStopRequested']) ? 1 : 0; })) {
        halted = 1;
        return;
    }
#endif
    skip_spaces(p);
    if (**p == '(') {
        (*p)++;
        v = eval_expr(p);
        skip_spaces(p);
        if (**p == ')') {
            (*p)++;
        } else {
            runtime_error_hint("Missing ')'", "Close SLEEP(n) with a right parenthesis.");
            return;
        }
    } else {
        v = eval_expr(p);
    }
    ensure_num(&v);
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    wasm_gfx_refresh_js();
#endif
    do_sleep_ticks(v.num);
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    wasm_gfx_refresh_js();
#endif
}

static void statement_cursor(char **p)
{
    skip_spaces(p);
    if (starts_with_kw(*p, "ON")) {
        *p += 2;
        BEFORE_CSTDIO();
        printf("\033[?25h");
        cursor_hidden = 0;
        OUTFLUSH();
        return;
    }
    if (starts_with_kw(*p, "OFF")) {
        *p += 3;
        BEFORE_CSTDIO();
        printf("\033[?25l");
        cursor_hidden = 1;
        OUTFLUSH();
        return;
    }
    runtime_error_hint("CURSOR expects ON or OFF", "Use CURSOR ON to show the cursor or CURSOR OFF to hide it.");
}

static void statement_color(char **p)
{
    /* COLOR n: set foreground colour using ANSI SGR based on C64-style palette index 0-15. */
    struct value v;
    int idx;

    v = eval_expr(p);
    ensure_num(&v);
    idx = (int)v.num;
    if (idx < 0 || idx > 15) {
        runtime_error_hint("COLOR index must be 0-15", "Foreground colours use indices 0-15 (C64-style palette).");
        return;
    }

#ifdef GFX_VIDEO
    if (gfx_vs) {
        gfx_fg = (uint8_t)idx;
        gfx_vs->bitmap_fg = (uint8_t)idx;
        return;
    }
#endif

    /* Map C64 color index to ANSI foreground SGR. */
    BEFORE_CSTDIO();
    switch (idx) {
    case 0:  printf("\033[30m"); break;       /* black */
    case 1:  printf("\033[37m"); break;       /* white */
    case 2:  printf("\033[31m"); break;       /* red */
    case 3:  printf("\033[36m"); break;       /* cyan */
    case 4:  printf("\033[35m"); break;       /* purple */
    case 5:  printf("\033[32m"); break;       /* green */
    case 6:  printf("\033[34m"); break;       /* blue */
    case 7:  printf("\033[33m"); break;       /* yellow */
    case 8:  printf("\033[38;5;208m"); break; /* orange */
    case 9:  printf("\033[33m"); break;       /* brown (approx) */
    case 10: printf("\033[91m"); break;       /* light red */
    case 11: printf("\033[90m"); break;       /* dark gray */
    case 12: printf("\033[37m"); break;       /* medium gray */
    case 13: printf("\033[92m"); break;       /* light green */
    case 14: printf("\033[94m"); break;       /* light blue */
    case 15: printf("\033[97m"); break;       /* light gray */
    default:
        break;
    }
    OUTFLUSH();
}

static void statement_background(char **p)
{
    /* BACKGROUND n: set background colour using ANSI SGR based on C64-style palette index 0-15. */
    struct value v;
    int idx;

    v = eval_expr(p);
    ensure_num(&v);
    idx = (int)v.num;
    if (idx < 0 || idx > 15) {
        runtime_error_hint("BACKGROUND index must be 0-15", "Pen/paper colours use indices 0-15 like COLOR.");
        return;
    }

#ifdef GFX_VIDEO
    if (gfx_vs) {
        gfx_bg = (uint8_t)idx;
        gfx_vs->bg_color = (uint8_t)idx;
        return;
    }
#endif

    /* Map C64 color index to ANSI background SGR. */
    BEFORE_CSTDIO();
    switch (idx) {
    case 0:  printf("\033[40m"); break;        /* black */
    case 1:  printf("\033[47m"); break;        /* white */
    case 2:  printf("\033[41m"); break;        /* red */
    case 3:  printf("\033[46m"); break;        /* cyan */
    case 4:  printf("\033[45m"); break;        /* purple */
    case 5:  printf("\033[42m"); break;        /* green */
    case 6:  printf("\033[44m"); break;        /* blue */
    case 7:  printf("\033[43m"); break;        /* yellow */
    case 8:  printf("\033[48;5;208m"); break;  /* orange */
    case 9:  printf("\033[43m"); break;        /* brown (approx) */
    case 10: printf("\033[101m"); break;       /* light red */
    case 11: printf("\033[100m"); break;       /* dark gray */
    case 12: printf("\033[47m"); break;        /* medium gray */
    case 13: printf("\033[102m"); break;       /* light green */
    case 14: printf("\033[104m"); break;       /* light blue */
    case 15: printf("\033[107m"); break;       /* light gray */
    default:
        break;
    }
    OUTFLUSH();
}

static void statement_pset(char **p, int preset)
{
#ifndef GFX_VIDEO
    (void)p;
    (void)preset;
    runtime_error_hint("PSET/PRESET is only available in basic-gfx",
                         "Bitmap pixels need basic-gfx or canvas WASM with SCREEN 1.");
#else
    struct value vx, vy;
    int xi, yi;

    skip_spaces(p);
    vx = eval_expr(p);
    ensure_num(&vx);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("PSET/PRESET expects x,y", "Use PSET x, y or PRESET x, y (comma between coordinates).");
        return;
    }
    (*p)++;
    skip_spaces(p);
    vy = eval_expr(p);
    ensure_num(&vy);
    if (!gfx_vs) {
        runtime_error_hint("PSET/PRESET is only available in basic-gfx",
                             "Start a graphics session (basic-gfx or canvas) before drawing pixels.");
        return;
    }
    xi = (int)vx.num;
    yi = (int)vy.num;
    gfx_bitmap_set_pixel(gfx_vs, xi, yi, preset ? 0 : 1);
#endif
}

static void statement_line(char **p)
{
#ifndef GFX_VIDEO
    (void)p;
    runtime_error_hint("LINE is only available in basic-gfx",
                         "LINE draws in bitmap mode (basic-gfx or canvas WASM).");
#else
    struct value vx0, vy0, vx1, vy1;
    int x0, y0, x1, y1;

    skip_spaces(p);
    vx0 = eval_expr(p);
    ensure_num(&vx0);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("LINE expects x1,y1 TO x2,y2", "First endpoint needs x1, y1 with a comma.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    vy0 = eval_expr(p);
    ensure_num(&vy0);
    skip_spaces(p);
    if (!starts_with_kw(*p, "TO")) {
        runtime_error_hint("LINE expects TO between endpoints", "Use LINE x0,y0 TO x1,y1");
        return;
    }
    *p += 2;
    skip_spaces(p);
    vx1 = eval_expr(p);
    ensure_num(&vx1);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("LINE expects x1,y1 TO x2,y2", "Second endpoint needs x2, y2 after TO.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    vy1 = eval_expr(p);
    ensure_num(&vy1);
    if (!gfx_vs) {
        runtime_error_hint("LINE is only available in basic-gfx",
                             "Bitmap LINE needs basic-gfx or canvas WASM.");
        return;
    }
    x0 = (int)vx0.num;
    y0 = (int)vy0.num;
    x1 = (int)vx1.num;
    y1 = (int)vy1.num;
    gfx_bitmap_line(gfx_vs, x0, y0, x1, y1, 1);
#endif
}

/* SCROLL x, y — viewport offset in pixels (text/bitmap layer + sprites; basic-gfx / canvas WASM). */
static void statement_scroll(char **p)
{
#ifndef GFX_VIDEO
    (void)p;
    runtime_error_hint("SCROLL is only available in basic-gfx or canvas WASM",
                         "SCROLL dx, dy shifts the visible framebuffer (camera-style).");
#else
    struct value vx, vy;
    int dx, dy;
    skip_spaces(p);
    vx = eval_expr(p);
    ensure_num(&vx);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("SCROLL expects dx, dy",
                             "Example: SCROLL 8, 0  (pan one character width right).");
        return;
    }
    (*p)++;
    skip_spaces(p);
    vy = eval_expr(p);
    ensure_num(&vy);
    if (!gfx_vs) {
        runtime_error_hint("SCROLL requires basic-gfx or canvas WASM", NULL);
        return;
    }
    dx = (int)vx.num;
    dy = (int)vy.num;
    if (dx < -32768) {
        dx = -32768;
    }
    if (dx > 32767) {
        dx = 32767;
    }
    if (dy < -32768) {
        dy = -32768;
    }
    if (dy > 32767) {
        dy = 32767;
    }
    gfx_vs->scroll_x = (int16_t)dx;
    gfx_vs->scroll_y = (int16_t)dy;
#endif
}

static void statement_screen(char **p)
{
#ifndef GFX_VIDEO
    (void)p;
    runtime_error_hint("SCREEN is only available in basic-gfx",
                         "SCREEN 0/1 switches text vs bitmap in basic-gfx/canvas.");
#else
    /* SCREEN 0: 40/80-column text. SCREEN 1: 320×200 monochrome bitmap. */
    struct value v;
    int mode;

    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    mode = (int)v.num;
    if (!gfx_vs) {
        runtime_error_hint("SCREEN is only available in basic-gfx",
                             "Graphics builds only; terminal basic has no SCREEN.");
        return;
    }
    if (mode == 0) {
        gfx_vs->screen_mode = GFX_SCREEN_TEXT;
        return;
    }
    if (mode == 1) {
        gfx_vs->screen_mode = GFX_SCREEN_BITMAP;
        return;
    }
    runtime_error_hint("SCREEN expects 0 (text) or 1 (bitmap)",
                         "Use SCREEN 0 for PETSCII text or SCREEN 1 for 320×200 bitmap.");
#endif
}

static void statement_screencodes(char **p)
{
    /* SCREENCODES ON|OFF: in gfx build, control whether PRINT outputs bytes
     * as raw screen codes (0–255) or maps ASCII to screen codes. */
    skip_spaces(p);
    if (starts_with_kw(*p, "ON")) {
        *p += 2;
        #ifdef GFX_VIDEO
        if (gfx_vs) gfx_raw_screen_codes = 1;
        #endif
        return;
    }
    if (starts_with_kw(*p, "OFF")) {
        *p += 3;
        #ifdef GFX_VIDEO
        if (gfx_vs) gfx_raw_screen_codes = 0;
        #endif
        return;
    }
    runtime_error_hint("SCREENCODES expects ON or OFF",
                         "SCREENCODES ON prints raw screen codes in gfx mode.");
}

#ifdef GFX_VIDEO
static int path_ends_with_png(const char *path)
{
    size_t len;
    if (!path) return 0;
    len = strlen(path);
    if (len < 4) return 0;
    return (path[len - 4] == '.' &&
            (path[len - 3] == 'p' || path[len - 3] == 'P') &&
            (path[len - 2] == 'n' || path[len - 2] == 'N') &&
            (path[len - 1] == 'g' || path[len - 1] == 'G'));
}

/* LOADSPRITE slot, "file.png" [, tile_w, tile_h] — optional tile sheet cell size. */
static void statement_loadsprite(char **p)
{
    struct value vslot, vpath, vw, vh;
    int slot, tw = 0, th = 0;
    skip_spaces(p);
    vslot = eval_expr(p);
    ensure_num(&vslot);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("LOADSPRITE expects slot, \"path.png\"",
                             "Comma after slot: LOADSPRITE 0, \"sprite.png\"");
        return;
    }
    (*p)++;
    skip_spaces(p);
    vpath = eval_expr(p);
    ensure_str(&vpath);
    if (!path_ends_with_png(vpath.str)) {
        runtime_error_hint("LOADSPRITE: use LOAD for non-PNG; PNG path must end in .png",
                             "Sprite paths must end in .png; use LOAD for other files.");
        return;
    }
    skip_spaces(p);
    if (**p == ',') {
        (*p)++;
        skip_spaces(p);
        vw = eval_expr(p);
        ensure_num(&vw);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("LOADSPRITE tilemap needs tile width and height",
                                 "Use LOADSPRITE slot, \"tiles.png\", 16, 16 for 16×16 cells.");
            return;
        }
        (*p)++;
        skip_spaces(p);
        vh = eval_expr(p);
        ensure_num(&vh);
        tw = (int)vw.num;
        th = (int)vh.num;
        if (tw < 1 || th < 1) {
            runtime_error_hint("LOADSPRITE tile size invalid",
                                 "Tile width and height must be positive integers.");
            return;
        }
    }
    if (!gfx_vs) {
        runtime_error_hint("LOADSPRITE requires basic-gfx",
                             "Sprites need basic-gfx or canvas WASM (not terminal basic).");
        return;
    }
    slot = (int)vslot.num;
    if (tw > 0 && th > 0) {
        gfx_sprite_enqueue_load_ex(slot, vpath.str, tw, th);
    } else {
        gfx_sprite_enqueue_load(slot, vpath.str);
    }
}

/* DRAWSPRITETILE slot, x, y, tile_index [, z] — tile_index is 1-based into tilemap sheet. */
static void statement_drawspritetile(char **p)
{
    struct value v;
    int slot, z = 0, ti, sx, sy, sw, sh;
    float x, y;
    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    slot = (int)v.num;
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("DRAWSPRITETILE expects slot, x, y, tile_index [, z]",
                             "Example: DRAWSPRITETILE 0, 10, 20, 3");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    x = (float)v.num;
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("DRAWSPRITETILE expects slot, x, y, tile_index [, z]", NULL);
        return;
    }
    (*p)++;
    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    y = (float)v.num;
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("DRAWSPRITETILE expects slot, x, y, tile_index [, z]", NULL);
        return;
    }
    (*p)++;
    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    ti = (int)v.num;
    skip_spaces(p);
    if (**p == ',') {
        (*p)++;
        skip_spaces(p);
        v = eval_expr(p);
        ensure_num(&v);
        z = (int)v.num;
    }
    if (!gfx_vs) {
        runtime_error_hint("DRAWSPRITETILE requires basic-gfx",
                             "Use basic-gfx or canvas WASM.");
        return;
    }
    if (gfx_sprite_tile_source_rect(slot, ti, &sx, &sy, &sw, &sh) != 0) {
        runtime_error_hint("DRAWSPRITETILE: invalid slot or tile index",
                             "LOADSPRITE with two tile dimensions first; index 1..SPRITETILES(slot).");
        return;
    }
    gfx_sprite_enqueue_draw(slot, x, y, z, sx, sy, sw, sh);
}

/* DRAWSPRITE slot, x, y [, z [, sx, sy [, sw, sh ]]] — z higher = on top; alpha from PNG. */
static void statement_drawsprite(char **p)
{
    struct value v;
    int slot, z = 0, sx = 0, sy = 0, sw = 0, sh = 0;
    float x, y;
    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    slot = (int)v.num;
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("DRAWSPRITE expects slot, x, y [, z [, sx, sy [, sw, sh ]]]",
                             "Comma after slot: DRAWSPRITE 0, x, y then optional z and crop.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    x = (float)v.num;
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("DRAWSPRITE expects slot, x, y [, z ...]",
                             "Need x and y pixel positions after the slot.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    y = (float)v.num;
    skip_spaces(p);
    if (**p == ',') {
        (*p)++;
        skip_spaces(p);
        v = eval_expr(p);
        ensure_num(&v);
        z = (int)v.num;
        skip_spaces(p);
        if (**p == ',') {
            (*p)++;
            skip_spaces(p);
            v = eval_expr(p);
            ensure_num(&v);
            sx = (int)v.num;
            skip_spaces(p);
            if (**p != ',') {
                runtime_error_hint("DRAWSPRITE: sx,sy need both",
                                     "Source crop needs both sx and sy (comma between them).");
                return;
            }
            (*p)++;
            skip_spaces(p);
            v = eval_expr(p);
            ensure_num(&v);
            sy = (int)v.num;
            skip_spaces(p);
            if (**p == ',') {
                (*p)++;
                skip_spaces(p);
                v = eval_expr(p);
                ensure_num(&v);
                sw = (int)v.num;
                skip_spaces(p);
                if (**p != ',') {
                    runtime_error_hint("DRAWSPRITE: sw,sh need both",
                                         "If you give sw you must also give sh (destination width and height).");
                    return;
                }
                (*p)++;
                skip_spaces(p);
                v = eval_expr(p);
                ensure_num(&v);
                sh = (int)v.num;
            }
        }
    }
    if (!gfx_vs) {
        runtime_error_hint("DRAWSPRITE requires basic-gfx",
                             "Run with basic-gfx or canvas WASM; terminal has no sprite layer.");
        return;
    }
    if ((sw <= 0 || sh <= 0) && gfx_sprite_slot_tile_count(slot) > 0) {
        if (gfx_sprite_effective_source_rect(slot, &sx, &sy, &sw, &sh) != 0) {
            runtime_error_hint("DRAWSPRITE: could not resolve tile crop",
                                 "Use LOADSPRITE with tile width/height for tile sheets.");
            return;
        }
    }
    gfx_sprite_enqueue_draw(slot, x, y, z, sx, sy, sw, sh);
}

/* SPRITEFRAME slot, frame — 1-based tile index for next DRAWSPRITE without crop (tile sheets only). */
static void statement_spriteframe(char **p)
{
    struct value va, vb;
    int slot, fr;
    skip_spaces(p);
    va = eval_expr(p);
    ensure_num(&va);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("SPRITEFRAME expects slot, frame",
                             "Example: SPRITEFRAME 0, 2  (second tile in sheet)");
        return;
    }
    (*p)++;
    skip_spaces(p);
    vb = eval_expr(p);
    ensure_num(&vb);
    slot = (int)va.num;
    fr = (int)vb.num;
    if (!gfx_vs) {
        runtime_error_hint("SPRITEFRAME requires basic-gfx or canvas WASM", NULL);
        return;
    }
    gfx_sprite_set_draw_frame(slot, fr);
}

/* SPRITEVISIBLE slot, on — 1 show, 0 hide (texture kept). */
static void statement_spritevisible(char **p)
{
    struct value va, vb;
    int slot, on;
    skip_spaces(p);
    va = eval_expr(p);
    ensure_num(&va);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("SPRITEVISIBLE expects slot, 0|1",
                             "Use SPRITEVISIBLE n, 1 to show or n, 0 to hide.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    vb = eval_expr(p);
    ensure_num(&vb);
    slot = (int)va.num;
    on = ((int)vb.num != 0) ? 1 : 0;
    if (!gfx_vs) {
        runtime_error_hint("SPRITEVISIBLE requires basic-gfx",
                             "Sprite visibility is only in basic-gfx / canvas WASM.");
        return;
    }
    gfx_sprite_enqueue_visible(slot, on);
}

/* SPRITEMODULATE slot, alpha [, r, g, b [, scale_x [, scale_y]]] — alpha/r/g/b 0..255; scales default 1. */
static void statement_spritemodulate(char **p)
{
    struct value v;
    int slot;
    int alpha;
    int r = 255, g = 255, b = 255;
    double sx = 1.0, sy = 1.0;
    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    slot = (int)v.num;
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("SPRITEMODULATE expects slot, alpha [, r, g, b [, scale_x [, scale_y]]]",
                             "Example: SPRITEMODULATE 1, 128  or  SPRITEMODULATE 1, 255, 200, 200, 255, 1.2, 0.6");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v = eval_expr(p);
    ensure_num(&v);
    alpha = (int)v.num;
    skip_spaces(p);
    if (**p == ',') {
        (*p)++;
        skip_spaces(p);
        v = eval_expr(p);
        ensure_num(&v);
        r = (int)v.num;
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("SPRITEMODULATE: r, g, b need three values",
                                 "After alpha: give all three tint channels 0..255.");
            return;
        }
        (*p)++;
        skip_spaces(p);
        v = eval_expr(p);
        ensure_num(&v);
        g = (int)v.num;
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("SPRITEMODULATE: need b after r, g",
                                 NULL);
            return;
        }
        (*p)++;
        skip_spaces(p);
        v = eval_expr(p);
        ensure_num(&v);
        b = (int)v.num;
        skip_spaces(p);
        if (**p == ',') {
            (*p)++;
            skip_spaces(p);
            v = eval_expr(p);
            ensure_num(&v);
            sx = v.num;
            skip_spaces(p);
            if (**p == ',') {
                (*p)++;
                skip_spaces(p);
                v = eval_expr(p);
                ensure_num(&v);
                sy = v.num;
            } else {
                sy = sx;
            }
        }
    }
    if (!gfx_vs) {
        runtime_error_hint("SPRITEMODULATE requires basic-gfx or canvas WASM", NULL);
        return;
    }
    gfx_sprite_set_modulate(slot, alpha, r, g, b, (float)sx, (float)sy);
}
#endif /* GFX_VIDEO */

/* UNLOADSPRITE slot — free texture and clear draw state (basic-gfx only). */
static void statement_unloadsprite(char **p)
{
    struct value vslot;
    skip_spaces(p);
    vslot = eval_expr(p);
    ensure_num(&vslot);
#ifdef GFX_VIDEO
    if (gfx_vs) {
        gfx_sprite_enqueue_unload((int)vslot.num);
        return;
    }
#endif
    runtime_error_hint("UNLOADSPRITE requires basic-gfx",
                         "Sprite slots exist only in basic-gfx or canvas WASM.");
}

/* GET statement: GET A$ reads a single character into a string variable.
 * This is a blocking read from standard input. Newlines are returned as
 * an empty string so programs can poll if they wish.
 *
 * We stay in raw mode (no echo) across successive GET calls until Enter is
 * read. Otherwise the terminal would echo each key in cooked mode between
 * GETs, causing duplicate/trailing characters (e.g. trek.bas "sls" showing
 * extra "s" on next line).
 */
#if !defined(_WIN32) && !defined(__EMSCRIPTEN__)
static struct termios get_saved_termios;
static int get_raw_mode_active = 0;

/* Set raw mode before we wait for input. Called at start of GET so
 * interactive TTY is in raw mode before user types; otherwise stdin
 * stays cooked and we only see input after Enter. */
static void ensure_get_raw_mode(void)
{
    struct termios oldt, newt;
    if (!isatty(STDIN_FILENO))
        return;
    if (get_raw_mode_active)
        return;
    if (tcgetattr(STDIN_FILENO, &oldt) != 0)
        return;
    get_saved_termios = oldt;
    newt = oldt;
    newt.c_lflag &= ~(ICANON | ECHO);
    newt.c_cc[VMIN] = 1;
    newt.c_cc[VTIME] = 0;
    if (tcsetattr(STDIN_FILENO, TCSANOW, &newt) == 0)
        get_raw_mode_active = 1;
}
#endif

static int read_single_char(void)
{
#if defined(__EMSCRIPTEN__)
    return wasm_read_key_blocking();
#elif defined(_WIN32)
    /* _getch() reads a single keypress without waiting for Enter and
     * without echoing it to the console.
     */
    int ch = _getch();
    if (ch == 0 || ch == 224) {
        /* Swallow extended key prefix and read the actual code. */
        ch = _getch();
    }
    return ch;
#else
    struct termios oldt, newt;
    int ch = EOF;

    if (tcgetattr(STDIN_FILENO, &oldt) != 0) {
        return getchar();
    }
    /* If we're not yet in raw mode, set it. Keep it across GET calls. */
    if (!get_raw_mode_active) {
        get_saved_termios = oldt;
        newt = oldt;
        newt.c_lflag &= ~(ICANON | ECHO);
        newt.c_cc[VMIN] = 1;
        newt.c_cc[VTIME] = 0;
        if (tcsetattr(STDIN_FILENO, TCSANOW, &newt) != 0) {
            return getchar();
        }
        get_raw_mode_active = 1;
    }
    ch = getchar();
    /* On Enter: restore cooked mode and consume CR/LF pair. */
    if (ch == '\r' || ch == '\n') {
        if (get_raw_mode_active) {
            get_raw_mode_active = 0;
            tcsetattr(STDIN_FILENO, TCSANOW, &get_saved_termios);
        }
        /* Consume trailing LF after CR (or CR after LF) so it does not leak. */
        {
            int pair = (ch == '\r') ? '\n' : '\r';
            fd_set rfds;
            struct timeval tv = { 0, 0 };
            FD_ZERO(&rfds);
            FD_SET(STDIN_FILENO, &rfds);
            if (select(STDIN_FILENO + 1, &rfds, (fd_set *)0, (fd_set *)0, &tv) > 0) {
                int c2 = getchar();
                if (c2 != pair && c2 != EOF) {
                    ungetc(c2, stdin);
                }
            }
        }
    }
    return ch;
#endif
}

/* Non-blocking key read.
 * Returns EOF if no key is available right now. */
static int read_single_char_nonblock(void)
{
#if defined(__EMSCRIPTEN__)
    {
        unsigned char b;
        if (wasm_key_pop_byte(&b)) {
            return (int)b;
        }
        return EOF;
    }
#elif defined(_WIN32)
    if (!_kbhit()) {
        return EOF;
    }
    return read_single_char();
#else
    int fd;
    fd_set rfds;
    struct timeval tv;

    fd = fileno(stdin);
    if (fd < 0) {
        return EOF;
    }
    FD_ZERO(&rfds);
    FD_SET(fd, &rfds);
    tv.tv_sec = 0;
    tv.tv_usec = 0;
    if (select(fd + 1, &rfds, (fd_set *)0, (fd_set *)0, &tv) <= 0) {
        return EOF;
    }
    return read_single_char();
#endif
}

static void statement_get(char **p)
{
    struct value *vp;
    int is_array;
    int is_string;
    int ch;

    skip_spaces(p);
    vp = get_var_reference(p, &is_array, &is_string, NULL);
    if (!vp) {
        return;
    }
    if (!is_string) {
        runtime_error_hint("GET requires string variable", "Use GET A$ (one character into a string).");
        return;
    }

    OUTFLUSH();
#ifdef GFX_VIDEO
    if (gfx_vs) {
        uint8_t b = 0;
        if (gfx_keyq_pop(&b)) {
            ch = (int)b;
        } else {
#if defined(__EMSCRIPTEN__)
            /* C64-style GET is non-blocking (empty string if no key). A plain nonblock
             * read returns EOF immediately on wasm, so trek.bas-style "IF Y$=\"\" GOTO"
             * loops would freeze the tab without yielding. Yield once per empty GET. */
            wasm_browser_pause_point();
            if (halted) {
                ch = EOF;
            } else {
#if defined(GFX_VIDEO)
                wasm_gfx_refresh_js();
#endif
                emscripten_sleep(0);
                ch = read_single_char_nonblock();
            }
#else
            /* Native basic-gfx: allow pipe/redirect (non-interactive GET returns ""). */
            ch = read_single_char_nonblock();
#endif
        }
    } else
#endif
    {
#if !defined(_WIN32) && !defined(__EMSCRIPTEN__)
        ensure_get_raw_mode();
#endif
#if defined(__EMSCRIPTEN__)
        /* Terminal WASM (no GFX_VIDEO): same as canvas — empty GET must yield or
         * IF K$="" GOTO tight loops freeze the browser with no Asyncify unwind. */
        wasm_browser_pause_point();
        if (halted) {
            ch = EOF;
        } else {
            emscripten_sleep(0);
            ch = read_single_char_nonblock();
        }
#else
        ch = read_single_char_nonblock();
#endif
    }
    if (ch == EOF) {
        *vp = make_str("");
    } else if (ch == '\n' || ch == '\r') {
        /* Map Enter/Return to PETSCII-style CHR$(13) so ASC(Y$)=13 works. */
        char buf[2];
        buf[0] = 13;
        buf[1] = '\0';
        *vp = make_str(buf);
    } else {
        char buf[2];
        buf[0] = (char)ch;
        buf[1] = '\0';
        *vp = make_str(buf);
    }
}

/* JSON path extraction: JSON$(json$, path$) returns value at path as string.
 * Path format: "key", "key[0]", "key.sub", "key[0].sub" etc. */
static int json_skip_ws(const char **p)
{
    while (**p == ' ' || **p == '\t' || **p == '\n' || **p == '\r') (*p)++;
    return 1;
}
static void json_skip_value(const char **pp);
static const char *json_parse_value(const char **pp, char *out, size_t out_size);
static const char *json_parse_string(const char **pp, char *out, size_t out_size)
{
    const char *p = *pp;
    size_t i = 0;
    if (*p != '\"') return NULL;
    p++;
    while (*p && *p != '\"' && i < out_size - 1) {
        if (*p == '\\') {
            p++;
            if (*p == 'n') { out[i++] = '\n'; p++; }
            else if (*p == 't') { out[i++] = '\t'; p++; }
            else if (*p == 'r') { out[i++] = '\r'; p++; }
            else if (*p == '\"' || *p == '\\' || *p == '/') { out[i++] = *p++; }
            else if (*p == 'u' && p[1] && p[2] && p[3] && p[4]) {
                /* \uXXXX - skip for now, put placeholder */
                out[i++] = '?';
                p += 5;
            } else { out[i++] = *p++; }
        } else {
            out[i++] = *p++;
        }
    }
    out[i] = '\0';
    if (*p == '\"') p++;
    *pp = p;
    return out;
}
static const char *json_parse_value(const char **pp, char *out, size_t out_size)
{
    const char *p = *pp;
    json_skip_ws(&p);
    if (!*p) return NULL;
    if (*p == '\"') {
        json_parse_string(&p, out, out_size);
        *pp = p;
        return out;
    }
    if (*p == 'n' && p[1]=='u' && p[2]=='l' && p[3]=='l') {
        if (out_size > 0) { out[0] = '\0'; }
        *pp = p + 4;
        return out;
    }
    if (*p == 't' && p[1]=='r' && p[2]=='u' && p[3]=='e') {
        if (out_size > 5) strcpy(out, "true"); else if (out_size > 0) out[0] = '\0';
        *pp = p + 4;
        return out;
    }
    if (*p == 'f' && p[1]=='a' && p[2]=='l' && p[3]=='s' && p[4]=='e') {
        if (out_size > 6) strcpy(out, "false"); else if (out_size > 0) out[0] = '\0';
        *pp = p + 5;
        return out;
    }
    if (*p == '-' || (*p >= '0' && *p <= '9')) {
        size_t i = 0;
        while (*p && i < out_size - 1 && (*p == '-' || *p == '+' || *p == 'e' || *p == 'E' || *p == '.' || (*p >= '0' && *p <= '9'))) {
            out[i++] = *p++;
        }
        out[i] = '\0';
        *pp = p;
        return out;
    }
    if (*p == '{' || *p == '[') {
        json_skip_value(&p);
        *pp = p;
        return NULL;  /* caller should use out for primitive; for struct we return NULL */
    }
    return NULL;
}
static void json_skip_value(const char **pp)
{
    const char *p = *pp;
    json_skip_ws(&p);
    if (*p == '\"') {
        p++;
        while (*p && *p != '\"') { if (*p == '\\') p++; p++; }
        if (*p) p++;
    } else if (*p == '{') {
        p++;
        for (;;) {
            json_skip_ws(&p);
            if (*p == '}') { p++; break; }
            if (*p == '\"') {
                p++;
                while (*p && *p != '\"') { if (*p == '\\') p++; p++; }
                if (*p) p++;
            }
            json_skip_ws(&p);
            if (*p == ':') { p++; json_skip_value(&p); }
            json_skip_ws(&p);
            if (*p == ',') { p++; continue; }
            break;
        }
    } else if (*p == '[') {
        p++;
        for (;;) {
            json_skip_ws(&p);
            if (*p == ']') { p++; break; }
            json_skip_value(&p);
            json_skip_ws(&p);
            if (*p == ',') { p++; continue; }
            break;
        }
    } else if ((*p >= '0' && *p <= '9') || *p == '-' || *p == '+') {
        while (*p && (*p == '-' || *p == '+' || *p == 'e' || *p == 'E' || *p == '.' || (*p >= '0' && *p <= '9'))) p++;
    } else if ((p[0]=='n'&&p[1]=='u'&&p[2]=='l'&&p[3]=='l') || (p[0]=='t'&&p[1]=='r'&&p[2]=='u'&&p[3]=='e') || (p[0]=='f'&&p[1]=='a'&&p[2]=='l'&&p[3]=='s'&&p[4]=='e')) {
        if (p[0]=='n') p+=4; else if (p[0]=='t') p+=4; else p+=5;
    }
    *pp = p;
}
static int json_find_key(const char **pp, const char *key)
{
    const char *p = *pp;
    json_skip_ws(&p);
    if (*p != '{') return 0;
    p++;
    for (;;) {
        json_skip_ws(&p);
        if (*p == '}') { *pp = p; return 0; }
        if (*p == '\"') {
            char kbuf[128];
            size_t i = 0;
            p++;
            while (*p && *p != '\"' && i < sizeof(kbuf)-1) {
                if (*p == '\\') p++;
                kbuf[i++] = *p++;
            }
            kbuf[i] = '\0';
            if (*p == '\"') p++;
            json_skip_ws(&p);
            if (*p == ':') {
                p++;
                if (strcmp(kbuf, key) == 0) {
                    *pp = p;
                    return 1;
                }
            }
            /* skip value */
            json_skip_value(&p);
            json_skip_ws(&p);
            if (*p == ',') { p++; continue; }
        }
        break;
    }
    *pp = p;
    return 0;
}
static int json_array_index(const char **pp, int idx)
{
    const char *p = *pp;
    json_skip_ws(&p);
    if (*p != '[') return 0;
    p++;
    for (int i = 0; i <= idx; i++) {
        json_skip_ws(&p);
        if (*p == ']') { *pp = p; return 0; }
        if (i == idx) {
            *pp = p;
            return 1;
        }
        /* skip value */
        json_skip_value(&p);
        json_skip_ws(&p);
        if (*p == ',') p++;
    }
    *pp = p;
    return 0;
}
static int json_extract_path(const char *json, const char *path, char *out, size_t out_size)
{
    const char *p = json;
    json_skip_ws(&p);
    if (!*p || !path || !*path) return 0;
    for (;;) {
        const char *seg = path;
        char keybuf[128];
        size_t ki = 0;
        while (*seg && *seg != '.' && *seg != '[' && ki < sizeof(keybuf)-1) {
            keybuf[ki++] = *seg++;
        }
        keybuf[ki] = '\0';
        if (ki > 0) {
            if (*p == '{') {
                if (!json_find_key(&p, keybuf)) return 0;
            } else {
                return 0;
            }
        }
        if (*seg == '[') {
            seg++;
            int idx = 0;
            while (*seg >= '0' && *seg <= '9') { idx = idx * 10 + (*seg++ - '0'); }
            if (*seg == ']') seg++;
            if (!json_array_index(&p, idx)) return 0;
        }
        json_skip_ws(&p);
        if (!*seg) {
            return json_parse_value(&p, out, out_size) != NULL;
        }
        if (*seg == '.') seg++;
        path = seg;
    }
}

/* Case-insensitive string match helper for function names. */
/* Evaluate BASIC intrinsic functions (math/string/tab). */
static struct value eval_function(const char *name, char **p)
{
    (void)name;
    char tmp[32];
    struct value arg;
    char outbuf[MAX_STR_LEN];
    int code;
    int len;

    /* Advance past function name */
    read_identifier(p, tmp, sizeof(tmp));
    for (len = 0; tmp[len]; len++) {
        tmp[len] = toupper((unsigned char)tmp[len]);
    }
    code = function_lookup(tmp, len);
    skip_spaces(p);
    if (**p != '(') {
        runtime_error_hint("Function requires '('", "Intrinsic functions need parentheses: SIN(X), MID$(A$,1,1).");
        return make_num(0.0);
    }
    (*p)++;
    skip_spaces(p);
    if (code == FN_ARGC) {
        if (**p != ')') {
            runtime_error_hint("ARGC takes no arguments", "Use ARGC() with empty parentheses.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        return make_num((double)script_argc);
    }
    if (code == FN_INKEY) {
        if (**p != ')') {
            runtime_error_hint("INKEY$ takes no arguments", "Use INKEY$() with empty parentheses.");
            return make_str("");
        }
        (*p)++;
        skip_spaces(p);
#ifdef GFX_VIDEO
        if (gfx_vs) {
            uint8_t b;
            if (gfx_keyq_pop(&b)) {
                outbuf[0] = (char)b;
                outbuf[1] = '\0';
                return make_str(outbuf);
            }
            /* Fallback to stdin (allows pipe/redirect). */
            {
                int c = read_single_char_nonblock();
                if (c != EOF && c != '\n' && c != '\r') {
                    outbuf[0] = (char)c;
                    outbuf[1] = '\0';
                    return make_str(outbuf);
                }
            }
            return make_str("");
        }
#endif
#if defined(__EMSCRIPTEN__)
        {
            int c = read_single_char_nonblock();
            if (c != EOF && c != '\n' && c != '\r') {
                outbuf[0] = (char)c;
                outbuf[1] = '\0';
                return make_str(outbuf);
            }
            return make_str("");
        }
#else
        /* Terminal build: no non-blocking key queue. */
        return make_str("");
#endif
    }
    if (code == FN_HTTPSTATUS) {
        if (**p != ')') {
            runtime_error_hint("HTTPSTATUS() takes no arguments", "Use HTTPSTATUS() after HTTP$ to read the last status code.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        return make_num((double)http_last_status);
    }
    if (code == FN_HTTP) {
        struct value v_url, v_method, v_body;
        const char *meth = NULL;
        const char *bod = NULL;
        int blen = 0;
        int st = 0;

        v_url = eval_expr(p);
        ensure_str(&v_url);
        skip_spaces(p);
        if (**p == ',') {
            (*p)++;
            skip_spaces(p);
            v_method = eval_expr(p);
            ensure_str(&v_method);
            meth = v_method.str;
            skip_spaces(p);
            if (**p == ',') {
                (*p)++;
                skip_spaces(p);
                v_body = eval_expr(p);
                ensure_str(&v_body);
                bod = v_body.str;
                blen = (int)strlen(bod);
            }
        }
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("HTTP$ expects url$ [, method$ [, body$]]",
                "Example: R$ = HTTP$(\"https://example.com/api\") or HTTP$(U$, \"POST\", J$).");
            return make_str("");
        }
        (*p)++;
        skip_spaces(p);
#if defined(__EMSCRIPTEN__)
        wasm_http_fetch_emscripten(v_url.str, meth, bod, blen, outbuf, sizeof(outbuf), &st);
        http_last_status = st;
        return make_str(outbuf);
#else
        (void)meth;
        (void)bod;
        (void)blen;
        http_last_status = 0;
        return make_str("");
#endif
    }
#if !defined(GFX_VIDEO)
    if (code == FN_SPRITECOLLIDE) {
        struct value va, vb;
        skip_spaces(p);
        va = eval_expr(p);
        (void)va;
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("SPRITECOLLIDE expects slot_a, slot_b",
                                 "Use SPRITECOLLIDE(a, b) with two sprite slot numbers.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        vb = eval_expr(p);
        (void)vb;
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "Close SPRITECOLLIDE(slot_a, slot_b) with ')'.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        runtime_error_hint("SPRITECOLLIDE requires basic-gfx or canvas WASM",
                             "Sprite collision needs a graphics build with LOADSPRITE/DRAWSPRITE.");
        return make_num(0.0);
    }
    if (code == FN_SPRITETILES || code == FN_SPRITEFRAME) {
        struct value v1;
        skip_spaces(p);
        v1 = eval_expr(p);
        (void)v1;
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "SPRITETILES(slot) / SPRITEFRAME(slot) take one argument.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        runtime_error_hint("SPRITETILES/SPRITEFRAME require basic-gfx or canvas WASM", NULL);
        return make_num(0.0);
    }
    if (code == FN_JOY || code == FN_JOYAXIS) {
        struct value v1, v2;
        skip_spaces(p);
        v1 = eval_expr(p);
        (void)v1;
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("Missing ','", "JOY(port, button) or JOYAXIS(port, axis).");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        v2 = eval_expr(p);
        (void)v2;
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("Missing ')'", NULL);
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        runtime_error_hint("JOY/JOYAXIS require basic-gfx (native)", "Terminal basic has no gamepad.");
        return make_num(0.0);
    }
    if (code == FN_SCROLLX || code == FN_SCROLLY) {
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "SCROLLX() and SCROLLY() take no arguments.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        runtime_error_hint("SCROLLX/SCROLLY require basic-gfx or canvas WASM",
                             "Viewport scroll applies to the PETSCII/bitmap layer in graphics builds.");
        return make_num(0.0);
    }
#endif
#ifdef GFX_VIDEO
    if (code == FN_SPRITEW || code == FN_SPRITEH) {
        struct value vs;
        int slot, dim;
        skip_spaces(p);
        vs = eval_expr(p);
        ensure_num(&vs);
        slot = (int)vs.num;
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "SPRITEW/SPRITEH take one slot: SPRITEW(n).");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        if (gfx_vs) {
            dim = (code == FN_SPRITEW) ? gfx_sprite_slot_width(slot) : gfx_sprite_slot_height(slot);
            return make_num((double)dim);
        }
        return make_num(0.0);
    }
    if (code == FN_SPRITECOLLIDE) {
        struct value va, vb;
        int sa, sb, hit;
        skip_spaces(p);
        va = eval_expr(p);
        ensure_num(&va);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("SPRITECOLLIDE expects slot_a, slot_b",
                                 "Use SPRITECOLLIDE(a, b) with two sprite slot numbers.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        vb = eval_expr(p);
        ensure_num(&vb);
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "Close SPRITECOLLIDE(slot_a, slot_b) with ')'.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        sa = (int)va.num;
        sb = (int)vb.num;
        if (gfx_vs) {
            hit = gfx_sprite_slots_overlap_aabb(sa, sb);
            return make_num((double)hit);
        }
        return make_num(0.0);
    }
    if (code == FN_SPRITETILES) {
        struct value vs;
        int slot, n;
        skip_spaces(p);
        vs = eval_expr(p);
        ensure_num(&vs);
        slot = (int)vs.num;
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "SPRITETILES(slot) — one slot number.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        if (gfx_vs) {
            n = gfx_sprite_slot_tile_count(slot);
            return make_num((double)n);
        }
        return make_num(0.0);
    }
    if (code == FN_SPRITEFRAME) {
        struct value vs;
        int slot, fr;
        skip_spaces(p);
        vs = eval_expr(p);
        ensure_num(&vs);
        slot = (int)vs.num;
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "SPRITEFRAME(slot) — current animation frame (1-based).");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        if (gfx_vs) {
            fr = gfx_sprite_get_draw_frame(slot);
            return make_num((double)fr);
        }
        return make_num(0.0);
    }
    if (code == FN_SCROLLX || code == FN_SCROLLY) {
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "SCROLLX() and SCROLLY() take no arguments.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        if (gfx_vs) {
            return make_num((double)(code == FN_SCROLLX ? gfx_vs->scroll_x : gfx_vs->scroll_y));
        }
        return make_num(0.0);
    }
    if (code == FN_JOY || code == FN_JOYAXIS) {
        struct value vp, vb;
        int port, btn, ax;
        skip_spaces(p);
        vp = eval_expr(p);
        ensure_num(&vp);
        port = (int)vp.num;
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint(code == FN_JOY ? "JOY expects port, button" : "JOYAXIS expects port, axis",
                                 "Raylib codes: buttons 1–15 (DPAD/face), axes 0–5 (sticks/triggers).");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        vb = eval_expr(p);
        ensure_num(&vb);
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "Close JOY(port, btn) or JOYAXIS(port, axis) with ')'.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
#if defined(__EMSCRIPTEN__) && !defined(GFX_VIDEO)
        /* Terminal WASM build: no gamepad layer. */
        (void)port;
        (void)btn;
        (void)ax;
        return make_num(0.0);
#else
        if (code == FN_JOY) {
            btn = (int)vb.num;
            return make_num((double)gfx_gamepad_button_down(port, btn));
        }
        ax = (int)vb.num;
        return make_num((double)gfx_gamepad_axis_scaled(port, ax));
#endif
    }
#endif
    if (code == FN_PLATFORM) {
        if (**p != ')') {
            runtime_error_hint("PLATFORM$ takes no arguments", "Use PLATFORM$() with empty parentheses.");
            return make_str("");
        }
        (*p)++;
        skip_spaces(p);
        {
            const char *plat;
#if defined(__EMSCRIPTEN__)
            plat = "browser";
#elif defined(_WIN32)
            plat = "windows-terminal";
#elif defined(__APPLE__)
            plat = "mac-terminal";
#else
            plat = "linux-terminal";
#endif
#ifdef GFX_VIDEO
            if (gfx_vs) {
#if defined(_WIN32)
                plat = "windows-gfx";
#elif defined(__APPLE__)
                plat = "mac-gfx";
#else
                plat = "linux-gfx";
#endif
            }
#endif
            return make_str(plat);
        }
    }
    if (code == FN_INDEXOF || code == FN_LASTINDEXOF) {
        /* INDEXOF(arr, value) / LASTINDEXOF(arr, value) - 1-based index, 0 if not found. */
        char namebuf[VAR_NAME_MAX];
        int is_string = 0;
        struct var *arr_var = NULL;
        struct value v_search;
        int i;

        if (!isalpha((unsigned char)**p)) {
            runtime_error_hint("INDEXOF/LASTINDEXOF requires array name",
                                 "First argument is the array: INDEXOF(A, value) or INDEXOF(A$, item$).");
            return make_num(0.0);
        }
        read_identifier(p, namebuf, sizeof(namebuf));
        uppercase_name(namebuf, namebuf, sizeof(namebuf), &is_string);
        for (i = 0; i < var_count; i++) {
            if (strcmp(vars[i].name, namebuf) == 0 && vars[i].is_string == is_string) {
                arr_var = &vars[i];
                break;
            }
        }
        if (!arr_var || !arr_var->is_array || !arr_var->array || arr_var->size <= 0) {
            runtime_error_hint("INDEXOF/LASTINDEXOF requires 1-D array",
                                 "DIM a one-dimensional array first, then search it.");
            return make_num(0.0);
        }
        if (arr_var->dims != 1) {
            runtime_error_hint("INDEXOF/LASTINDEXOF requires 1-D array",
                                 "Multi-dimensional arrays are not supported here; use a 1-D list.");
            return make_num(0.0);
        }
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("INDEXOF/LASTINDEXOF requires 2 arguments",
                                 "Use INDEXOF(arr, value) — comma between array name and search value.");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        v_search = eval_expr(p);
        skip_spaces(p);
        if (**p == ')') (*p)++;
        skip_spaces(p);

        if (arr_var->is_string) {
            ensure_str(&v_search);
            if (code == FN_INDEXOF) {
                for (i = 0; i < arr_var->size; i++) {
                    if (strcmp(arr_var->array[i].str, v_search.str) == 0) {
                        return make_num((double)(i + 1));
                    }
                }
            } else {
                for (i = arr_var->size - 1; i >= 0; i--) {
                    if (strcmp(arr_var->array[i].str, v_search.str) == 0) {
                        return make_num((double)(i + 1));
                    }
                }
            }
        } else {
            ensure_num(&v_search);
            if (code == FN_INDEXOF) {
                for (i = 0; i < arr_var->size; i++) {
                    if (arr_var->array[i].num == v_search.num) {
                        return make_num((double)(i + 1));
                    }
                }
            } else {
                for (i = arr_var->size - 1; i >= 0; i--) {
                    if (arr_var->array[i].num == v_search.num) {
                        return make_num((double)(i + 1));
                    }
                }
            }
        }
        return make_num(0.0);
    }
    arg = eval_expr(p);
    skip_spaces(p);

    /* Functions that accept multiple arguments (MID$, LEFT$, RIGHT$) parse
     * their full argument list themselves and are responsible for consuming
     * the closing ')'. For all other intrinsics we expect exactly one
     * argument and consume ')' here so the caller resumes after it.
     */
    if (code != FN_MID && code != FN_LEFT && code != FN_RIGHT && code != FN_INSTR && code != FN_STRINGFN &&
        code != FN_REPLACE && code != FN_TRIM && code != FN_LTRIM && code != FN_RTRIM &&
        code != FN_FIELD && code != FN_PLATFORM && code != FN_JSON) {
        if (**p == ')') {
            (*p)++;
        } else {
            runtime_error_hint("Missing ')'", "Close the function call with ')'.");
            return make_num(0.0);
        }
        skip_spaces(p);
    }

    switch (code) {
    case FN_SIN:
        ensure_num(&arg);
        return make_num(sin(arg.num));
    case FN_COS:
        ensure_num(&arg);
        return make_num(cos(arg.num));
    case FN_TAN:
        ensure_num(&arg);
        return make_num(tan(arg.num));
    case FN_ABS:
        ensure_num(&arg);
        return make_num(fabs(arg.num));
    case FN_INT:
        ensure_num(&arg);
        return make_num(floor(arg.num));
    case FN_SQR:
        ensure_num(&arg);
        return make_num(sqrt(arg.num));
    case FN_SGN:
        ensure_num(&arg);
        if (arg.num > 0) {
            return make_num(1.0);
        } else if (arg.num < 0) {
            return make_num(-1.0);
        } else {
            return make_num(0.0);
        }
    case FN_EXP:
        ensure_num(&arg);
        return make_num(exp(arg.num));
    case FN_LOG:
        ensure_num(&arg);
        return make_num(log(arg.num));
    case FN_RND:
        ensure_num(&arg);
        if (arg.num < 0) {
            /* Reseed: C64-style RND(negative) starts a new sequence. We use time so each run gets a different sequence (like RND(-TI) on C64). */
            srand((unsigned int)time(NULL));
        }
        return make_num((double)rand() / (double)RAND_MAX);
    case FN_LEN:
        ensure_str(&arg);
        return make_num((double)strlen(arg.str));
    case FN_VAL:
        ensure_str(&arg);
        return make_num(atof(arg.str));
    case FN_STR:
        ensure_num(&arg);
        sprintf(outbuf, "%g", arg.num);
        return make_str(outbuf);
    case FN_CHR:
        ensure_num(&arg);
        {
            int code = (int)arg.num & 0xff;
#ifdef GFX_VIDEO
            /* In gfx mode we want raw bytes so screen/control codes can be
             * interpreted by the gfx output backend (including {TOKENS}). */
            if (gfx_vs) {
                outbuf[0] = (char)code;
                outbuf[1] = '\0';
                return make_str(outbuf);
            }
#endif
            if (petscii_mode) {
                /* -petscii-plain: no ANSI; control/color output nothing (invisible, like C64 - no visible space). */
                if (petscii_plain) {
                    if (code == 13) return make_str("\n");
                    if (code == 27) return make_str("\033");  /* ESC for {RESET}/{DEFAULT} */
                    if (code <= 31 && code != 10) return make_str("");
                    if (code >= 128 && code <= 159) return make_str("");
                    if (code == 127) return make_str("");
                    return make_str(petscii_code_to_utf8((unsigned char)code));
                }
                /* Optional 8-bit palette approximating C64 colors. */
                if (palette_mode == PALETTE_C64_8BIT) {
                    int idx = -1;
                    switch (code) {
                    /* Base C64 colors */
                    case 144: /* black */
                        idx = 16;  /* dark black-ish */
                        break;
                    case 28:  /* red */
                        idx = 196;
                        break;
                    case 30:  /* green */
                        idx = 46;
                        break;
                    case 31:  /* blue */
                        idx = 21;
                        break;
                    case 159: /* cyan */
                        idx = 51;
                        break;
                    case 156: /* purple */
                        idx = 93;
                        break;
                    case 158: /* yellow */
                        idx = 226;
                        break;
                    case 5:   /* white */
                        idx = 231;
                        break;
                    /* Extended C64 colors */
                    case 129: /* orange */
                        idx = 208;
                        break;
                    case 149: /* brown */
                        idx = 130;
                        break;
                    case 150: /* light red */
                        idx = 203;
                        break;
                    case 151: /* dark gray */
                        idx = 238;
                        break;
                    case 152: /* medium gray */
                        idx = 244;
                        break;
                    case 153: /* light green */
                        idx = 120;
                        break;
                    case 154: /* light blue */
                        idx = 81;
                        break;
                    case 155: /* light gray */
                        idx = 252;
                        break;
                    default:
                        break;
                    }
                    if (idx >= 0) {
                        sprintf(outbuf, "\033[38;5;%dm", idx);
                        return make_str(outbuf);
                    }
                }

                /* Default ANSI palette mapping for PETSCII control codes. */
                switch (code) {
                case 14:  /* switch to lowercase/uppercase charset */
                    petscii_set_lowercase(1);
                    return make_str("");
                case 142: /* switch to uppercase/graphics charset */
                    petscii_set_lowercase(0);
                    return make_str("");
                case 19:  /* HOME: home cursor */
                    return make_str("\033[H");
                case 147: /* CLR: clear screen, home cursor */
                    return make_str("\033[2J\033[H");
                case 17:  /* cursor down */
                    return make_str("\033[B");
                case 145: /* cursor up */
                    return make_str("\033[A");
                case 29:  /* cursor right */
                    return make_str("\033[C");
                case 20:  /* DEL: backspace — cursor left and erase character (like ^H) */
                    return make_str("\033[D\033[P");
                case 157: /* cursor left (no erase) */
                    return make_str("\033[D");
                case 18:  /* reverse on */
                    return make_str("\033[7m");
                case 146: /* reverse off */
                    return make_str("\033[27m");
                case 27:  /* ESC — needed for ANSI sequences like {RESET}/{DEFAULT} -> ESC[0m */
                    return make_str("\033");
                case 13:  /* carriage return -> newline */
                    return make_str("\n");
                /* Base colors */
                case 144: /* black */
                    return make_str("\033[30m");
                case 5:   /* white */
                    return make_str("\033[37m");
                case 28:  /* red */
                    return make_str("\033[31m");
                case 30:  /* green */
                    return make_str("\033[32m");
                case 31:  /* blue */
                    return make_str("\033[34m");
                case 159: /* cyan */
                    return make_str("\033[96m");
                case 156: /* purple */
                    return make_str("\033[35m");
                case 158: /* yellow */
                    return make_str("\033[33m");
                /* Extended colors (approximate mappings) */
                case 129: /* orange */
                    return make_str("\033[38;5;208m");
                case 149: /* brown */
                    return make_str("\033[33m");
                case 150: /* light red */
                    return make_str("\033[91m");
                case 151: /* dark gray */
                    return make_str("\033[90m");
                case 152: /* medium gray */
                    return make_str("\033[37m");
                case 153: /* light green */
                    return make_str("\033[92m");
                case 154: /* light blue */
                    return make_str("\033[94m");
                case 155: /* light gray */
                    return make_str("\033[97m");
                default:
                    break;
                }
                /* Control/color not in switch: output nothing (invisible, like C64). Table would give " " and break layout. */
                if (code <= 31 && code != 10 && code != 13) return make_str("");
                if (code == 127) return make_str("");
                if (code >= 128 && code <= 159) return make_str("");
                /* Printable PETSCII: map to UTF-8 for terminal (block graphics, etc.) */
                return make_str(petscii_code_to_utf8((unsigned char)code));
            }
            outbuf[0] = (char)code;
            outbuf[1] = '\0';
            return make_str(outbuf);
        }
    case FN_ASC:
        ensure_str(&arg);
        if (arg.str[0] == '\0') {
            return make_num(0.0);
        }
        return make_num((unsigned char)arg.str[0]);
    case FN_TAB: {
        int target;
        int cur;
        int width;
        ensure_num(&arg);
        target = (int)arg.num;
        width = print_width;
        if (width <= 0) {
            width = 80;
        }
        target = target % width;
        if (target < 0) {
            target += width;
        }
        cur = print_col;
#ifdef GFX_VIDEO
        /* Canvas/GFX: must move the framebuffer cursor (gfx_x), not only stdout. */
        if (gfx_vs) {
            if (target < cur) {
                gfx_newline();
                cur = 0;
            }
            print_spaces(target - cur);
            return make_str("");
        }
#endif
        if (target < cur) {
            OUTC('\n');
            cur = 0;
        }
        while (cur < target) {
            OUTC(' ');
            cur++;
        }
        print_col = cur;
        return make_str("");
    }
    case FN_SPC: {
        int count;
        ensure_num(&arg);
        count = (int)arg.num;
        if (count < 0) {
            count = 0;
        }
        print_spaces(count);
        return make_str("");
    }
    case FN_MID: {
        struct value src = arg;
        struct value v_start;
        struct value v_len;
        int start_pos;
        int sub_len;
        int s_len;

        ensure_str(&src);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("MID requires at least 2 arguments",
                                 "Use MID$(s$, start [, length]) — at least source and start position.");
            return make_str("");
        }
        (*p)++;
        v_start = eval_expr(p);
        ensure_num(&v_start);
        skip_spaces(p);
        sub_len = -1;
        if (**p == ',') {
            (*p)++;
            v_len = eval_expr(p);
            ensure_num(&v_len);
            sub_len = (int)v_len.num;
        }
        skip_spaces(p);
        if (**p == ')') {
            (*p)++;
        } else {
            runtime_error_hint("Missing ')'", "Close MID$(...) with ')'.");
        }

        /* BASIC is 1-based for MID$, and negative/zero starts are treated as 1. */
        start_pos = (int)v_start.num;
        if (start_pos < 1) {
            start_pos = 1;
        }
        /* Convert to 0-based index. */
        start_pos -= 1;
        s_len = (int)strlen(src.str);
        if (start_pos >= s_len) {
            return make_str("");
        }
        if (sub_len < 0 || start_pos + sub_len > s_len) {
            sub_len = s_len - start_pos;
        }
        if (sub_len <= 0) {
            return make_str("");
        }
        if (sub_len >= MAX_STR_LEN) {
            sub_len = MAX_STR_LEN - 1;
        }
        {
            char out[MAX_STR_LEN];
            memcpy(out, src.str + start_pos, (size_t)sub_len);
            out[sub_len] = '\0';
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
            wasm_str_builtin_budget++;
            if ((wasm_str_builtin_budget & 63u) == 0u) {
                wasm_browser_pause_point();
                if (!halted) {
                    wasm_gfx_refresh_js();
                    emscripten_sleep(0);
                }
            }
#endif
            return make_str(out);
        }
    }
    case FN_LEFT: {
        struct value src = arg;
        struct value v_len;
        int sub_len;
        int s_len;

        ensure_str(&src);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("LEFT requires 2 arguments", "Use LEFT$(s$, n) — string and character count.");
            return make_str("");
        }
        (*p)++;
        v_len = eval_expr(p);
        ensure_num(&v_len);
        skip_spaces(p);
        if (**p == ')') {
            (*p)++;
        } else {
            runtime_error_hint("Missing ')'", "Close LEFT$(...) with ')'.");
        }

        sub_len = (int)v_len.num;
        if (sub_len <= 0) {
            return make_str("");
        }
        s_len = (int)strlen(src.str);
        if (sub_len > s_len) {
            sub_len = s_len;
        }
        if (sub_len >= MAX_STR_LEN) {
            sub_len = MAX_STR_LEN - 1;
        }
        {
            char out[MAX_STR_LEN];
            memcpy(out, src.str, (size_t)sub_len);
            out[sub_len] = '\0';
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
            wasm_str_builtin_budget++;
            if ((wasm_str_builtin_budget & 63u) == 0u) {
                wasm_browser_pause_point();
                if (!halted) {
                    wasm_gfx_refresh_js();
                    emscripten_sleep(0);
                }
            }
#endif
            return make_str(out);
        }
    }
    case FN_RIGHT: {
        struct value src = arg;
        struct value v_len;
        int sub_len;
        int s_len;
        int start_pos;

        ensure_str(&src);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("RIGHT requires 2 arguments", "Use RIGHT$(s$, n) — string and character count.");
            return make_str("");
        }
        (*p)++;
        v_len = eval_expr(p);
        ensure_num(&v_len);
        skip_spaces(p);
        if (**p == ')') {
            (*p)++;
        } else {
            runtime_error_hint("Missing ')'", "Close RIGHT$(...) with ')'.");
        }

        sub_len = (int)v_len.num;
        if (sub_len <= 0) {
            return make_str("");
        }
        s_len = (int)strlen(src.str);
        if (sub_len > s_len) {
            sub_len = s_len;
        }
        if (sub_len >= MAX_STR_LEN) {
            sub_len = MAX_STR_LEN - 1;
        }
        start_pos = s_len - sub_len;
        if (start_pos < 0) {
            start_pos = 0;
        }
        {
            char out[MAX_STR_LEN];
            memcpy(out, src.str + start_pos, (size_t)sub_len);
            out[sub_len] = '\0';
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
            wasm_str_builtin_budget++;
            if ((wasm_str_builtin_budget & 63u) == 0u) {
                wasm_browser_pause_point();
                if (!halted) {
                    wasm_gfx_refresh_js();
                    emscripten_sleep(0);
                }
            }
#endif
            return make_str(out);
        }
    }
    case FN_INSTR: {
        /* INSTR(source$, search$ [, start]) -> 1-based index or 0 if not found. */
        struct value v_source = arg;
        struct value v_search;
        int s_len;
        int sub_len;
        int start_pos = 0;  /* 0-based; default 0 = search from beginning */
        int i;

        ensure_str(&v_source);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("INSTR requires at least 2 arguments",
                                 "Use INSTR(haystack$, needle$) or INSTR(haystack$, needle$, start).");
            return make_num(0.0);
        }
        (*p)++;
        skip_spaces(p);
        v_search = eval_expr(p);
        ensure_str(&v_search);
        skip_spaces(p);
        if (**p == ',') {
            struct value v_start;
            (*p)++;
            skip_spaces(p);
            v_start = eval_expr(p);
            ensure_num(&v_start);
            start_pos = (int)v_start.num - 1;  /* convert 1-based to 0-based */
            if (start_pos < 0) start_pos = 0;
            skip_spaces(p);
        }
        if (**p == ')') {
            (*p)++;
        } else {
            runtime_error_hint("Missing ')'", "Close INSTR(...) with ')'.");
            return make_num(0.0);
        }

        s_len = (int)strlen(v_source.str);
        sub_len = (int)strlen(v_search.str);
        if (sub_len == 0 || s_len == 0 || start_pos >= s_len) {
            return make_num(0.0);
        }
        if (start_pos + sub_len > s_len) {
            return make_num(0.0);
        }
        for (i = start_pos; i <= s_len - sub_len; i++) {
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
            if (((i - start_pos) & 127) == 0 && i > start_pos) {
                wasm_browser_pause_point();
                if (!halted) {
                    wasm_gfx_refresh_js();
                    emscripten_sleep(0);
                }
            }
#endif
            if (strncmp(v_source.str + i, v_search.str, (size_t)sub_len) == 0) {
                return make_num((double)(i + 1));
            }
        }
        return make_num(0.0);
    }
    case FN_REPLACE: {
        /* REPLACE(str$, find$, repl$) - replace all occurrences. */
        struct value v_str = arg;
        struct value v_find;
        struct value v_repl;
        char out[MAX_STR_LEN];
        int pos, len, flen, rlen;
        size_t out_len;

        ensure_str(&v_str);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("REPLACE requires 3 arguments",
                                 "Use REPLACE(s$, find$, repl$) with commas between all three strings.");
            return make_str("");
        }
        (*p)++;
        skip_spaces(p);
        v_find = eval_expr(p);
        ensure_str(&v_find);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("REPLACE requires 3 arguments",
                                 "Use REPLACE(s$, find$, repl$) with commas between all three strings.");
            return make_str("");
        }
        (*p)++;
        skip_spaces(p);
        v_repl = eval_expr(p);
        ensure_str(&v_repl);
        skip_spaces(p);
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "Close REPLACE(...) with ')'.");
            return make_str("");
        }
        (*p)++;

        len = (int)strlen(v_str.str);
        flen = (int)strlen(v_find.str);
        rlen = (int)strlen(v_repl.str);
        if (flen == 0) return make_str(v_str.str);
        out_len = 0;
        pos = 0;
        while (pos <= len - flen && out_len < (size_t)(max_str_limit - 1)) {
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
            if ((pos & 255) == 0 && pos > 0) {
                wasm_browser_pause_point();
                if (!halted) {
                    wasm_gfx_refresh_js();
                    emscripten_sleep(0);
                }
            }
#endif
            if (strncmp(v_str.str + pos, v_find.str, (size_t)flen) == 0) {
                for (int j = 0; j < rlen && out_len < (size_t)(max_str_limit - 1); j++)
                    out[out_len++] = v_repl.str[j];
                pos += flen;
            } else {
                out[out_len++] = v_str.str[pos++];
            }
        }
        while (pos < len && out_len < (size_t)(max_str_limit - 1))
            out[out_len++] = v_str.str[pos++];
        out[out_len] = '\0';
        return make_str(out);
    }
    case FN_TRIM:
    case FN_LTRIM:
    case FN_RTRIM: {
        /* TRIM$(s$), LTRIM$(s$), RTRIM$(s$) - remove leading/trailing whitespace. */
        const char *s;
        const char *start, *end;
        size_t n;

        ensure_str(&arg);
        s = arg.str;
        start = s;
        end = s + strlen(s);
        if (code != FN_RTRIM) {
            while (start < end && isspace((unsigned char)*start)) start++;
        }
        if (code != FN_LTRIM) {
            while (end > start && isspace((unsigned char)end[-1])) end--;
        }
        n = (size_t)(end - start);
        if (n > (size_t)(max_str_limit - 1)) n = (size_t)(max_str_limit - 1);
        memcpy(outbuf, start, n);
        outbuf[n] = '\0';
        skip_spaces(p);
        if (**p == ')') (*p)++;
        skip_spaces(p);
        return make_str(outbuf);
    }
    case FN_DEC: {
        /* DEC(s$): parse hexadecimal string into numeric value. */
        char *endptr;
        long v;
        ensure_str(&arg);
        if (arg.str[0] == '\0') {
            return make_num(0.0);
        }
        v = strtol(arg.str, &endptr, 16);
        if (endptr == arg.str) {
            return make_num(0.0);
        }
        return make_num((double)v);
    }
    case FN_HEX: {
        /* HEX$(n): format integer as uppercase hexadecimal string without prefix. */
        long v;
        ensure_num(&arg);
        v = (long)arg.num;
        sprintf(outbuf, "%lX", v);
        return make_str(outbuf);
    }
    case FN_STRINGFN: {
        /* STRING$(n, char$) or STRING$(n, code) */
        struct value v_count = arg;
        struct value v_ch;
        int count;
        char ch;

        ensure_num(&v_count);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("STRING$ requires 2 arguments",
                                 "Use STRING$(n, \"x\") or STRING$(n, code) — count and character.");
            return make_str("");
        }
        (*p)++;
        v_ch = eval_expr(p);
        skip_spaces(p);
        if (**p == ')') {
            (*p)++;
        } else {
            runtime_error_hint("Missing ')'", "Close STRING$(...) with ')'.");
            return make_str("");
        }

        count = (int)v_count.num;
        if (count <= 0) {
            return make_str("");
        }
        if (count > max_str_limit) count = max_str_limit;
        if (count >= MAX_STR_LEN) count = MAX_STR_LEN - 1;

        if (v_ch.type == VAL_STR) {
            if (v_ch.str[0] == '\0') {
                ch = ' ';
            } else {
                ch = v_ch.str[0];
            }
        } else {
            /* Treat numeric second arg as character code. */
            ch = (char)((int)v_ch.num & 0xff);
        }

        {
            char out[MAX_STR_LEN];
            int i;
            for (i = 0; i < count; i++) {
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
                if ((i & 1023) == 0 && i > 0) {
                    wasm_browser_pause_point();
                    if (!halted) {
                        wasm_gfx_refresh_js();
                        emscripten_sleep(0);
                    }
                }
#endif
                out[i] = ch;
            }
            out[count] = '\0';
            return make_str(out);
        }
    }
    case FN_PEEK: {
        ensure_num(&arg);
#ifdef GFX_VIDEO
        if (gfx_vs) {
            return make_num((double)gfx_peek(gfx_vs,
                            (uint16_t)((int)arg.num & 0xFFFF)));
        }
#endif
        return make_num(0.0);
    }
    case FN_UCASE: {
        char out[MAX_STR_LEN];
        size_t i, n;
        ensure_str(&arg);
        n = strlen(arg.str);
        if (n >= MAX_STR_LEN) n = MAX_STR_LEN - 1;
        for (i = 0; i < n; i++)
            out[i] = (char)toupper((unsigned char)arg.str[i]);
        out[n] = '\0';
        return make_str(out);
    }
    case FN_LCASE: {
        char out[MAX_STR_LEN];
        size_t i, n;
        ensure_str(&arg);
        n = strlen(arg.str);
        if (n >= MAX_STR_LEN) n = MAX_STR_LEN - 1;
        for (i = 0; i < n; i++)
            out[i] = (char)tolower((unsigned char)arg.str[i]);
        out[n] = '\0';
        return make_str(out);
    }
    case FN_ARG: {
        int idx;
        ensure_num(&arg);
        idx = (int)arg.num;
        if (idx == 0)
            return make_str(script_path ? script_path : "");
        if (idx < 1 || idx > script_argc || !script_argv)
            return make_str("");
        return make_str(script_argv[idx - 1]);
    }
    case FN_SYSTEM: {
        ensure_str(&arg);
        return make_num((double)do_system(arg.str));
    }
    case FN_EXEC: {
        ensure_str(&arg);
        do_exec(arg.str, outbuf, sizeof(outbuf));
        return make_str(outbuf);
    }
    case FN_ENV: {
        const char *val;
        ensure_str(&arg);
        val = getenv(arg.str);
        return make_str(val ? val : "");
    }
    case FN_EVAL: {
        char *ep;
        struct value result;
        ensure_str(&arg);
        if (strlen(arg.str) >= MAX_STR_LEN - 1) {
            runtime_error_hint("EVAL: expression too long",
                                 "Shorten the string passed to EVAL(...); it must fit in one line buffer.");
            return make_num(0.0);
        }
        {
            char buf[MAX_STR_LEN];
            char *q;
            strncpy(buf, arg.str, sizeof(buf) - 1);
            buf[sizeof(buf) - 1] = '\0';
            q = buf;
            skip_spaces(&q);
            /* LET-style assignment: "a=a+10" is not a comparison inside eval_expr; treat as assign. */
            if (isalpha((unsigned char)*q)) {
                char namebuf[VAR_NAME_MAX];
                char norm[VAR_NAME_MAX];
                char *scan = q;
                int is_slhs = 0;
                struct var *v;
                read_identifier(&scan, namebuf, sizeof(namebuf));
                uppercase_name(namebuf, norm, sizeof(norm), &is_slhs);
                if (norm[0] != '\0' && !is_reserved_word(norm)) {
                    skip_spaces(&scan);
                    if (*scan == '=') {
                        scan++;
                        skip_spaces(&scan);
                        v = find_or_create_var(norm, is_slhs, 0, 0, NULL, 0);
                        if (v) {
                            struct value rhs = eval_expr(&scan);
                            if (is_slhs) {
                                ensure_str(&rhs);
                                rhs.type = VAL_STR;
                            } else {
                                ensure_num(&rhs);
                                rhs.type = VAL_NUM;
                            }
                            v->scalar = rhs;
                            return rhs;
                        }
                    }
                }
            }
            ep = buf;
            result = eval_expr(&ep);
        }
        return result;
    }
    case FN_JSON: {
        struct value v_json = arg;
        struct value v_path;
        ensure_str(&v_json);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("JSON$ requires 2 arguments",
                                 "Use JSON$(json$, \"/path/to/key\") — JSON text and a path string.");
            return make_str("");
        }
        (*p)++;
        skip_spaces(p);
        v_path = eval_expr(p);
        ensure_str(&v_path);
        skip_spaces(p);
        if (**p == ')') (*p)++;
        skip_spaces(p);
        if (json_extract_path(v_json.str, v_path.str, outbuf, sizeof(outbuf))) {
            return make_str(outbuf);
        }
        return make_str("");
    }
    case FN_FIELD: {
        /* FIELD$(str$, delim$, n) - get Nth field (1-based), awk-like. */
        struct value v_str = arg;
        struct value v_delim;
        struct value v_n;
        const char *s;
        const char *delim;
        size_t dlen;
        int n, idx;
        const char *start, *end;

        ensure_str(&v_str);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("FIELD$ requires 3 arguments",
                                 "Use FIELD$(line$, delim$, n) — string, delimiter, and 1-based field index.");
            return make_str("");
        }
        (*p)++;
        skip_spaces(p);
        v_delim = eval_expr(p);
        ensure_str(&v_delim);
        skip_spaces(p);
        if (**p != ',') {
            runtime_error_hint("FIELD$ requires 3 arguments",
                                 "Use FIELD$(line$, delim$, n) — string, delimiter, and 1-based field index.");
            return make_str("");
        }
        (*p)++;
        skip_spaces(p);
        v_n = eval_expr(p);
        ensure_num(&v_n);
        skip_spaces(p);
        if (**p == ')') (*p)++;
        skip_spaces(p);

        n = (int)v_n.num;
        if (n < 1) return make_str("");
        s = v_str.str;
        delim = v_delim.str;
        dlen = strlen(delim);
        if (dlen == 0) return make_str("");
        idx = 0;
        start = s;
        for (;;) {
            if (idx + 1 == n) {
                end = strstr(start, delim);
                if (end == NULL) end = s + strlen(s);
                {
                    size_t len = (size_t)(end - start);
                    if (len >= MAX_STR_LEN) len = MAX_STR_LEN - 1;
                    if (len > (size_t)(max_str_limit - 1)) len = (size_t)(max_str_limit - 1);
                    memcpy(outbuf, start, len);
                    outbuf[len] = '\0';
                    return make_str(outbuf);
                }
            }
            end = strstr(start, delim);
            if (end == NULL) return make_str("");
            idx++;
            start = end + dlen;
        }
    }
    default: {
        char ubuf[96];
        snprintf(ubuf, sizeof(ubuf), "Unknown function: %s", tmp);
        runtime_error_hint(ubuf, "Check spelling; intrinsic names have no spaces.");
        return make_num(0.0);
    }
    }
}

/* Normalize variable name to uppercase in dest, strip trailing $ and set is_string. */
static void uppercase_name(const char *src, char *dest, int dest_size, int *is_string)
{
    int i, len;
    len = (int)strlen(src);
    *is_string = 0;
    if (len > 0 && src[len - 1] == '$') {
        *is_string = 1;
        len--;
    }
    if (len >= dest_size) len = dest_size - 1;
    for (i = 0; i < len; i++) {
        dest[i] = (char)toupper((unsigned char)src[i]);
    }
    dest[i] = '\0';
}

static struct var *find_or_create_var(const char *name, int is_string, int want_array, int dims, const int *dim_sizes, int total_size)
{
    int i, idx;
    struct var *v;
    for (i = 0; i < var_count; i++) {
        if (strcmp(vars[i].name, name) == 0 && vars[i].is_string == is_string) {
            v = &vars[i];
            if (want_array && !v->is_array) {
                v->is_array = 1;
                v->dims = dims;
                if (dims > 0 && dim_sizes) {
                    int d;
                    for (d = 0; d < dims && d < MAX_DIMS; d++) {
                        v->dim_sizes[d] = dim_sizes[d];
                    }
                }
                v->size = total_size;
                v->array = (struct value *)calloc(total_size, sizeof(struct value));
                if (!v->array) {
                    runtime_error_hint("Out of memory",
                                         "Could not allocate array storage; reduce DIM sizes or free variables.");
                    return v;
                }
            }
            return v;
        }
    }
    if (var_count >= MAX_VARS) {
        runtime_error_hint("Variable table full",
                             "Too many distinct variables; reuse names or split into smaller programs.");
        return NULL;
    }
    idx = var_count++;
    v = &vars[idx];
    strncpy(v->name, name, VAR_NAME_MAX - 1);
    v->name[VAR_NAME_MAX - 1] = '\0';
    v->is_string = is_string;
    v->is_array = want_array;
    v->dims = want_array ? dims : 0;
    if (want_array && dims > 0 && dim_sizes) {
        int d;
        for (d = 0; d < dims && d < MAX_DIMS; d++) {
            v->dim_sizes[d] = dim_sizes[d];
        }
    } else {
        int d;
        for (d = 0; d < MAX_DIMS; d++) {
            v->dim_sizes[d] = 0;
        }
    }
    v->size = want_array ? total_size : 0;
    v->array = NULL;
    v->scalar = make_num(0.0);
    if (is_string) {
        v->scalar = make_str("");
    }
    if (want_array) {
        v->array = (struct value *)calloc(total_size, sizeof(struct value));
        if (!v->array) {
            runtime_error_hint("Out of memory",
                                 "Could not allocate array storage; reduce DIM sizes or free variables.");
        }
    }
    return v;
}

/* Read an identifier (letters/digits/$/_) into buf, advancing the pointer. */
static int read_identifier(char **p, char *buf, int buf_size)
{
    int i;
    i = 0;
    while (isalpha((unsigned char)(**p)) || isdigit((unsigned char)(**p)) || **p == '$' || **p == '_') {
        if (i < buf_size - 1) {
            buf[i++] = **p;
        }
        (*p)++;
    }
    buf[i] = '\0';
    return i;
}

/* Resolve a variable (and optional array index) creating it if needed.
 * If name_out is non-NULL, store the normalized variable name there (for FOR stack, etc.). */
static struct value *get_var_reference(char **p, int *is_array_out, int *is_string_out, char *name_out)
{
    char namebuf[VAR_NAME_MAX];
    int is_string;
    struct var *v;
    struct value *valp;
    int is_array;
    int dims;
    int indices[MAX_DIMS];
    int flat_index = 0;
    int stride = 1;
    struct value idx_val;

    skip_spaces(p);
    if (!isalpha((unsigned char)**p)) {
        runtime_error_hint("Expected variable", "Assignment and LET need a variable name (e.g. X or A$).");
        return NULL;
    }
    read_identifier(p, namebuf, sizeof(namebuf));
    uppercase_name(namebuf, namebuf, sizeof(namebuf), &is_string);
    if (name_out) {
        strncpy(name_out, namebuf, VAR_NAME_MAX - 1);
        name_out[VAR_NAME_MAX - 1] = '\0';
    }
    if (is_reserved_word(namebuf)) {
        runtime_error_hint("Reserved word cannot be used as variable",
                           "Pick a different name; keywords like IF, FOR, PRINT are not variables.");
        return NULL;
    }
    if (is_string_out) {
        *is_string_out = is_string;
    }
    skip_spaces(p);
    is_array = 0;
    dims = 0;
    if (**p == '(') {
        is_array = 1;
        (*p)++;
        for (;;) {
            if (dims >= MAX_DIMS) {
                runtime_error_hint("Too many subscripts",
                                   "At most 3 indices per access (e.g. A(1,2,3)).");
                return NULL;
            }
            idx_val = eval_expr(p);
            ensure_num(&idx_val);
            indices[dims] = (int)(idx_val.num + 0.00001);
            if (indices[dims] < 0) {
                runtime_error_hint("Negative array index", "Indices must be 0 or positive.");
                return NULL;
            }
            dims++;
            skip_spaces(p);
            if (**p == ',') {
                (*p)++;
                continue;
            }
            break;
        }
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "Close array subscripts: A(1) or M(1,2).");
            return NULL;
        }
        (*p)++;
    }
    if (is_array_out) {
        *is_array_out = is_array;
    }
    v = find_or_create_var(namebuf, is_string, is_array, 0, NULL, 0);
    if (!v) {
        return NULL;
    }
    if (!is_array) {
        valp = &v->scalar;
    } else {
        int d;
        if (v->dims == 0) {
            /* First array use: assume 1-D and adopt current index as size hint. */
            v->dims = 1;
            v->dim_sizes[0] = (indices[0] + 1 > DEFAULT_ARRAY_SIZE) ? (indices[0] + 1) : DEFAULT_ARRAY_SIZE;
            v->size = v->dim_sizes[0];
            v->array = (struct value *)calloc(v->size, sizeof(struct value));
            if (!v->array) {
                runtime_error_hint("Out of memory",
                                     "Could not allocate implicit array storage; use DIM with explicit size.");
                return NULL;
            }
        }
        if (dims == 0) {
            runtime_error_hint("Array subscript required", "Use A(0) or A(I), not the bare array name.");
            return NULL;
        }
        if (dims > v->dims) {
            runtime_error_hint("Too many subscripts",
                               "Fewer indices than dimensions in DIM (e.g. DIM A(9) needs one index).");
            return NULL;
        }
        /* For now we assume dimensions were fixed by DIM; no auto-resize for multi-dim. */
        flat_index = 0;
        stride = 1;
        for (d = v->dims - 1; d >= 0; d--) {
            int idx = (d < dims) ? indices[d] : 0;
            if (idx < 0 || idx >= v->dim_sizes[d]) {
                runtime_error_hint("Subscript out of range",
                                     "Index must be within DIM bounds (0 .. upper bound).");
                return NULL;
            }
            flat_index += idx * stride;
            stride *= v->dim_sizes[d];
        }
        if (flat_index >= v->size) {
            runtime_error_hint("Subscript out of range",
                                 "Index must be within DIM bounds (0 .. upper bound).");
            return NULL;
        }
        valp = &v->array[flat_index];
    }
    if (is_string && valp->type != VAL_STR) {
        *valp = make_str("");
    } else if (!is_string && valp->type != VAL_NUM) {
        *valp = make_num(0.0);
    }
    return valp;
}

/* Run statements until RETURN or END FUNCTION sets udf_returned. */
static void run_until_udf_return(void)
{
    char *p;
    udf_returned = 0;
    while (!udf_returned && !halted && current_line >= 0 && current_line < line_count) {
        if (statement_pos == NULL) {
            statement_pos = program_lines[current_line]->text;
        }
        p = statement_pos;
        skip_spaces(&p);
        if (*p == '\0') {
            current_line++;
            statement_pos = NULL;
            continue;
        }
        statement_pos = p;
        execute_statement(&statement_pos);
        if (udf_returned || halted) break;
        if (statement_pos == NULL) continue;
        skip_spaces(&statement_pos);
        if (*statement_pos == ':') {
            statement_pos++;
            continue;
        }
        skip_spaces(&statement_pos);
        if (*statement_pos == '\0') {
            current_line++;
            statement_pos = NULL;
        }
    }
}

/* Invoke UDF and return its value. Caller has already parsed name and '('; args evaluated. */
static struct value invoke_udf(int func_index, struct value *args, int nargs)
{
    struct udf_func *uf = &udf_funcs[func_index];
    struct var *param_var;
    int i;

    if (udf_call_depth >= MAX_UDF_DEPTH) {
        runtime_error_hint("FUNCTION nesting too deep",
                             "Too many nested FUNCTION calls; simplify recursion or split into smaller routines.");
        return make_num(0.0);
    }
    udf_call_stack[udf_call_depth].func_index = func_index;
    udf_call_stack[udf_call_depth].saved_line = current_line;
    udf_call_stack[udf_call_depth].saved_pos = statement_pos;
    for (i = 0; i < uf->param_count; i++) {
        param_var = find_or_create_var(uf->param_names[i], uf->param_is_string[i], 0, 0, NULL, 0);
        if (param_var && i < nargs) {
            udf_call_stack[udf_call_depth].saved_params[i] = param_var->scalar;
            if (uf->param_is_string[i]) {
                ensure_str(&args[i]);
                param_var->scalar = args[i];
                param_var->scalar.type = VAL_STR;
            } else {
                ensure_num(&args[i]);
                param_var->scalar = args[i];
                param_var->scalar.type = VAL_NUM;
            }
        }
    }
    udf_call_depth++;
    current_line = uf->body_line;
    statement_pos = uf->body_pos;
    run_until_udf_return();
    /* statement_return/statement_end_function already pops; restore params from saved frame */
    for (i = 0; i < uf->param_count; i++) {
        param_var = find_or_create_var(uf->param_names[i], uf->param_is_string[i], 0, 0, NULL, 0);
        if (param_var) param_var->scalar = udf_call_stack[udf_call_depth].saved_params[i];
    }
    return udf_return_value;
}

/* Parse a factor: number, string, variable, function call, or parenthesized expr. */
static struct value eval_factor(char **p)
{
    struct value v;
    char buf[MAX_LINE_LEN];
    double num;
    skip_spaces(p);
    if (**p == '(') {
        (*p)++;
        v = eval_expr(p);
        skip_spaces(p);
        if (**p == ')') {
            (*p)++;
        } else {
            runtime_error_hint("Missing ')'", "Close the parenthesized expression with ')'.");
        }
        return v;
    }
    if (**p == '\"') {
        int i;
        (*p)++;
        i = 0;
        while (**p && **p != '\"' && i < MAX_LINE_LEN - 1) {
            buf[i++] = **p;
            (*p)++;
        }
        buf[i] = '\0';
        if (**p == '\"') {
            (*p)++;
        } else {
            runtime_error_hint("Unterminated string", "Add a closing double quote to end the string literal.");
        }
        return make_str(buf);
    }
    if (isalpha((unsigned char)**p)) {
        /* System jiffy clock (C64-style): TI and TI$.
         * CBM BASIC resolves TIME, TICKS, etc. to TI due to 2-char name matching;
         * we do the same by keying off the first two characters. */
        {
            char namebuf[8];
            char *q = *p;
            int i, len;
            read_identifier(&q, namebuf, sizeof(namebuf));
            for (i = 0; namebuf[i]; i++) {
                namebuf[i] = (char)toupper((unsigned char)namebuf[i]);
            }
            len = i;
            if (len >= 2 && namebuf[0] == 'T' && namebuf[1] == 'I') {
                int is_str = (len > 0 && namebuf[len - 1] == '$');
#ifdef GFX_VIDEO
                if (gfx_vs) {
                    uint32_t t;
#if defined(__EMSCRIPTEN__)
                    /* Canvas WASM: no per-frame tick increment; use monotonic ms → 60 Hz jiffies. */
                    {
                        double now = emscripten_get_now();
                        double elapsed_ms = now - wasm_gfx_ti_epoch_ms;
                        if (elapsed_ms < 0.0) {
                            elapsed_ms = 0.0;
                        }
                        t = (uint32_t)((elapsed_ms * 60.0 / 1000.0) + 0.5);
                        t %= GFX_TICKS60_WRAP;
                    }
#else
                    t = gfx_vs->ticks60;
#endif
                    *p = q;
                    if (!is_str) {
                        return make_num((double)t);
                    } else {
                        unsigned long sec = (unsigned long)(t / 60u);
                        unsigned long h = (sec / 3600u) % 24u;
                        unsigned long m = (sec / 60u) % 60u;
                        unsigned long s = sec % 60u;
                        sprintf(buf, "%02lu%02lu%02lu", h, m, s);
                        return make_str(buf);
                    }
                } else
#endif
                {
                    /* Terminal fallback: use wall-clock time (e.g. for RND(-TI)). */
                    time_t tt = time(NULL);
                    *p = q;
                    if (is_str) {
                        struct tm *tm = localtime(&tt);
                        sprintf(buf, "%02d%02d%02d",
                                tm->tm_hour, tm->tm_min, tm->tm_sec);
                        return make_str(buf);
                    } else {
                        return make_num((double)(unsigned long)tt);
                    }
                }
            }
        }
    /* Function call? */
    if (starts_with_kw(*p, "SIN") || starts_with_kw(*p, "COS") || starts_with_kw(*p, "TAN") ||
            starts_with_kw(*p, "ABS") || starts_with_kw(*p, "INT") || starts_with_kw(*p, "SQR") ||
            starts_with_kw(*p, "SGN") || starts_with_kw(*p, "EXP") || starts_with_kw(*p, "LOG") ||
            starts_with_kw(*p, "RND") || starts_with_kw(*p, "LEN") || starts_with_kw(*p, "VAL") ||
            starts_with_kw(*p, "STR") || starts_with_kw(*p, "CHR") || starts_with_kw(*p, "ASC") ||
            starts_with_kw(*p, "TAB") || starts_with_kw(*p, "SPC") || starts_with_kw(*p, "MID") ||
            starts_with_kw(*p, "LEFT") || starts_with_kw(*p, "RIGHT") || starts_with_kw(*p, "STRING") ||
            starts_with_kw(*p, "UCASE") || starts_with_kw(*p, "LCASE") ||
            starts_with_kw(*p, "INSTR") || starts_with_kw(*p, "DEC") || starts_with_kw(*p, "HEX") ||
            starts_with_kw(*p, "REPLACE") || starts_with_kw(*p, "TRIM") || starts_with_kw(*p, "LTRIM") || starts_with_kw(*p, "RTRIM") ||
            starts_with_kw(*p, "FIELD") || starts_with_kw(*p, "INDEXOF") || starts_with_kw(*p, "LASTINDEXOF") ||
            starts_with_kw(*p, "ENV") || starts_with_kw(*p, "EVAL") || starts_with_kw(*p, "PLATFORM") || starts_with_kw(*p, "JSON") ||
            starts_with_kw(*p, "HTTPSTATUS") || starts_with_kw(*p, "HTTP$") ||
            starts_with_kw(*p, "ARGC") || starts_with_kw(*p, "ARG") ||
            starts_with_kw(*p, "SYSTEM") || starts_with_kw(*p, "EXEC") ||
            starts_with_kw(*p, "PEEK") || starts_with_kw(*p, "INKEY") ||
            starts_with_kw(*p, "SPRITEW") || starts_with_kw(*p, "SPRITEH") ||
            starts_with_kw(*p, "SPRITECOLLIDE") || starts_with_kw(*p, "SPRITETILES") || starts_with_kw(*p, "SPRITEFRAME") ||
            starts_with_kw(*p, "SCROLLX") || starts_with_kw(*p, "SCROLLY") ||
            starts_with_kw(*p, "JOY") || starts_with_kw(*p, "JOYSTICK") || starts_with_kw(*p, "JOYAXIS")) {
            char namebuf[32];
            char *q;
            q = *p;
            read_identifier(&q, namebuf, sizeof(namebuf));
            return eval_function(namebuf, p);
        } else {
            /* HTTP(...) without $ — same intrinsic as HTTP$(...); "HTTP" alone must not match UDF HTTP. */
            if (toupper((unsigned char)(*p)[0]) == 'H' && toupper((unsigned char)(*p)[1]) == 'T' &&
                toupper((unsigned char)(*p)[2]) == 'T' && toupper((unsigned char)(*p)[3]) == 'P' &&
                (*p)[4] == '(') {
                return eval_function("HTTP$", p);
            }
            /* Check for user-defined FUNCTION or DEF FN, else variable */
            char namebuf[VAR_NAME_MAX];
            char *q;
            int i, arg_count, udf_idx, uf_index;
            q = *p;
            read_identifier(&q, namebuf, sizeof(namebuf));
            for (i = 0; namebuf[i]; i++) {
                namebuf[i] = (char)toupper((unsigned char)namebuf[i]);
            }
            skip_spaces(&q);
            if (*q == '(') {
                struct value *args = (struct value *)calloc(MAX_UDF_PARAMS, sizeof(struct value));
                if (!args) {
                    runtime_error_hint("Out of memory",
                                         "Could not allocate argument list for the call.");
                    return make_num(0.0);
                }
                char *saved_p = *p;
                *p = q + 1;
                skip_spaces(p);
                arg_count = 0;
                if (**p != ')') {
                    for (;;) {
                        if (arg_count >= MAX_UDF_PARAMS) {
                            free(args);
                            runtime_error_hint("Too many arguments",
                                                 "Reduce the number of arguments; split the call or use fewer parameters.");
                            return make_num(0.0);
                        }
                        args[arg_count] = eval_expr(p);
                        arg_count++;
                        skip_spaces(p);
                        if (**p == ')') break;
                        if (**p != ',') {
                            free(args);
                            runtime_error_hint("Expected ',' or ')'",
                                                 "Separate arguments with commas: FOO(1, 2, 3).");
                            return make_num(0.0);
                        }
                        (*p)++;
                        skip_spaces(p);
                    }
                }
                if (**p == ')') (*p)++;
                udf_idx = udf_lookup(namebuf, arg_count);
                if (udf_idx >= 0) {
                    struct value ret = invoke_udf(udf_idx, args, arg_count);
                    free(args);
                    return ret;
                }
                if (arg_count == 1) {
                    uf_index = user_func_lookup(namebuf);
                    if (uf_index >= 0) {
                        struct user_func *uf = &user_funcs[uf_index];
                        struct value result;
                        struct var *param_var;
                        struct value saved_scalar;
                        char pname_buf[VAR_NAME_MAX];

                        strncpy(pname_buf, uf->param_name, sizeof(pname_buf) - 1);
                        pname_buf[sizeof(pname_buf) - 1] = '\0';
                        param_var = find_or_create_var(pname_buf, uf->param_is_string, 0, 0, NULL, 0);
                        if (!param_var) { free(args); return make_num(0.0); }
                        saved_scalar = param_var->scalar;
                        if (uf->param_is_string) {
                            ensure_str(&args[0]);
                            param_var->scalar = args[0];
                            param_var->scalar.type = VAL_STR;
                        } else {
                            ensure_num(&args[0]);
                            param_var->scalar = args[0];
                            param_var->scalar.type = VAL_NUM;
                        }
                        { char *body_p = uf->body; result = eval_expr(&body_p); }
                        param_var->scalar = saved_scalar;
                        free(args);
                        return result;
                    }
                }
                /* No UDF or DEF FN matched; treat as array/variable */
                free(args);
                *p = saved_p;
            }
            {
                struct value *vp;
                vp = get_var_reference(p, NULL, NULL, NULL);
                if (!vp) return make_num(0.0);
                return *vp;
            }
        }
    }
    if (**p == '+' || **p == '-') {
        char sign;
        struct value inner;
        sign = **p;
        (*p)++;
        inner = eval_factor(p);
        ensure_num(&inner);
        if (sign == '-') {
            inner.num = -inner.num;
        }
        return inner;
    }
    if (parse_number_literal(p, &num)) {
        return make_num(num);
    }
    runtime_error_hint("Syntax error in expression",
                         "Expected a number, string, variable, or function call; check operators and parentheses.");
    return make_num(0.0);
}

/* Parse exponentiation (right-associative ^). */
static struct value eval_power(char **p)
{
    struct value left, right;
    skip_spaces(p);
    left = eval_factor(p);
    skip_spaces(p);
    if (**p == '^') {
        (*p)++;
        right = eval_power(p);
        ensure_num(&left);
        ensure_num(&right);
        left.num = pow(left.num, right.num);
    }
    return left;
}

/* Parse <<, >> shift operators. */
static struct value eval_shift(char **p)
{
    struct value left, right;
    skip_spaces(p);
    left = eval_power(p);
    for (;;) {
        skip_spaces(p);
        if (**p == '<' && *(*p + 1) == '<') {
            *p += 2;
            right = eval_power(p);
            ensure_num(&left);
            ensure_num(&right);
            {
                int a = (int)left.num;
                unsigned int b = (unsigned int)((int)right.num & 0x1F); /* 0-31 */
                left.num = (double)(a << b);
            }
        } else if (**p == '>' && *(*p + 1) == '>') {
            *p += 2;
            right = eval_power(p);
            ensure_num(&left);
            ensure_num(&right);
            {
                int a = (int)left.num;
                unsigned int b = (unsigned int)((int)right.num & 0x1F);
                left.num = (double)(a >> b);
            }
        } else {
            break;
        }
    }
    return left;
}

/* Parse *, /, MOD terms. */
static struct value eval_term(char **p)
{
    struct value left, right;
    skip_spaces(p);
    left = eval_shift(p);
    for (;;) {
        skip_spaces(p);
        if (**p == '*' || **p == '/') {
            char op;
            op = **p;
            (*p)++;
            right = eval_shift(p);
            ensure_num(&left);
            ensure_num(&right);
            if (op == '*') {
                left.num *= right.num;
            } else {
                left.num /= right.num;
            }
        } else if (starts_with_kw(*p, "MOD")) {
            *p += 3;
            right = eval_shift(p);
            ensure_num(&left);
            ensure_num(&right);
            {
                double a = left.num, b = right.num;
                left.num = (b != 0) ? (a - floor(a / b) * b) : 0.0;
            }
        } else {
            break;
        }
    }
    return left;
}

/* Parse + and - (with string concatenation on +). */
static struct value eval_addsub(char **p)
{
    struct value left, right;
    skip_spaces(p);
    left = eval_term(p);
    for (;;) {
        skip_spaces(p);
        if (**p == '+' || **p == '-') {
            char op;
            op = **p;
            (*p)++;
            right = eval_term(p);
            if (op == '+') {
                if (left.type == VAL_STR || right.type == VAL_STR) {
                    size_t cur, avail;
                    ensure_str(&left);
                    ensure_str(&right);
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
                    /* trek.bas GOSUB 5440: Q$=LEFT$+A$+RIGHT$ — no MID$; must yield here. */
                    wasm_str_concat_budget++;
                    if ((wasm_str_concat_budget & 255u) == 0u) {
                        wasm_browser_pause_point();
                        if (!halted) {
                            wasm_gfx_refresh_js();
                            emscripten_sleep(0);
                        }
                    }
#endif
                    cur = strlen(left.str);
                    avail = (size_t)max_str_limit - cur;
                    if (avail > MAX_STR_LEN - 1 - cur) avail = MAX_STR_LEN - 1 - cur;
                    if (avail > 0) strncat(left.str, right.str, avail);
                    left.str[max_str_limit] = '\0';
                } else {
                    left.num += right.num;
                }
            } else {
                ensure_num(&left);
                ensure_num(&right);
                left.num -= right.num;
            }
        } else {
            break;
        }
    }
    return left;
}

/* Parse bitwise AND. */
static struct value eval_bit_and(char **p)
{
    struct value left, right;
    skip_spaces(p);
    left = eval_addsub(p);
    for (;;) {
        skip_spaces(p);
        if (starts_with_kw(*p, "AND")) {
            *p += 3;
            right = eval_addsub(p);
            ensure_num(&left);
            ensure_num(&right);
            left.num = (double)((int)left.num & (int)right.num);
        } else {
            break;
        }
    }
    return left;
}

/* Parse bitwise XOR. */
static struct value eval_bit_xor(char **p)
{
    struct value left, right;
    skip_spaces(p);
    left = eval_bit_and(p);
    for (;;) {
        skip_spaces(p);
        if (starts_with_kw(*p, "XOR")) {
            *p += 3;
            right = eval_bit_and(p);
            ensure_num(&left);
            ensure_num(&right);
            left.num = (double)((int)left.num ^ (int)right.num);
        } else {
            break;
        }
    }
    return left;
}

/* Parse bitwise OR. */
static struct value eval_bit_or(char **p)
{
    struct value left, right;
    skip_spaces(p);
    left = eval_bit_xor(p);
    for (;;) {
        skip_spaces(p);
        if (starts_with_kw(*p, "OR")) {
            *p += 2;
            right = eval_bit_xor(p);
            ensure_num(&left);
            ensure_num(&right);
            left.num = (double)((int)left.num | (int)right.num);
        } else {
            break;
        }
    }
    return left;
}

/* Top-level expression parser (bitwise OR has lowest precedence). */
static struct value eval_expr(char **p)
{
    return eval_bit_or(p);
}

static int eval_condition(char **p);

/* Evaluate IF conditions with BASIC relational operators. */
/* Evaluate a single relational comparison (no AND/OR). */
static int eval_simple_condition(char **p)
{
    struct value left, right;
    char op1, op2;

    skip_spaces(p);
    /* Leading '(': either "(expr) relop rhs" e.g. (1+1)=2, or boolean group "(J=F OR ...)" */
    if (**p == '(') {
        char *after_open;
        (*p)++;
        after_open = *p;
        left = eval_expr(p);
        skip_spaces(p);
        if (**p == ')') {
            (*p)++;
            skip_spaces(p);
            op1 = **p;
            op2 = *(*p + 1);
            if (op1 == '<' || op1 == '>' || op1 == '=' ||
                (op1 == '<' && op2 == '>') || (op1 == '<' && op2 == '=') || (op1 == '>' && op2 == '=')) {
                if (op1 == '<' && op2 == '>') {
                    *p += 2;
                    right = eval_addsub(p);
                    if (left.type == VAL_STR || right.type == VAL_STR) {
                        ensure_str(&left);
                        ensure_str(&right);
                        return strcmp(left.str, right.str) != 0;
                    }
                    return left.num != right.num;
                }
                if (op1 == '<' && op2 == '=') {
                    *p += 2;
                    right = eval_addsub(p);
                    ensure_num(&left);
                    ensure_num(&right);
                    return left.num <= right.num;
                }
                if (op1 == '>' && op2 == '=') {
                    *p += 2;
                    right = eval_addsub(p);
                    ensure_num(&left);
                    ensure_num(&right);
                    return left.num >= right.num;
                }
                if (op1 == '<' || op1 == '>' || op1 == '=') {
                    (*p)++;
                    right = eval_addsub(p);
                    if (left.type == VAL_STR || right.type == VAL_STR) {
                        ensure_str(&left);
                        ensure_str(&right);
                        if (op1 == '<') {
                            return strcmp(left.str, right.str) < 0;
                        }
                        if (op1 == '>') {
                            return strcmp(left.str, right.str) > 0;
                        }
                        return strcmp(left.str, right.str) == 0;
                    }
                    if (op1 == '<') {
                        return left.num < right.num;
                    }
                    if (op1 == '>') {
                        return left.num > right.num;
                    }
                    return left.num == right.num;
                }
            }
            if (left.type == VAL_STR) {
                ensure_str(&left);
                return strlen(left.str) > 0;
            }
            return left.num != 0.0;
        }
        /* No closing ')' yet after one expr — boolean group "(J=F OR ...)" */
        *p = after_open;
        {
            int inner = eval_condition(p);
            skip_spaces(p);
            if (**p != ')') {
                runtime_error_hint("Missing ')'", "Close a parenthesized IF condition with ')'.");
                return 0;
            }
            (*p)++;
            return inner;
        }
    }
    left = eval_expr(p);
    skip_spaces(p);
    /* Workaround: TRIM$, REPLACE etc. may leave ')' unconsumed; consume before relational op */
    if (**p == ')') {
        (*p)++;
        skip_spaces(p);
    }
    op1 = **p;
    op2 = *(*p + 1);

    if (op1 == '<' && op2 == '>') {
        *p += 2;
        right = eval_addsub(p);  /* stop before AND/OR so condition "X<>Y AND Z" parses correctly */
        if (left.type == VAL_STR || right.type == VAL_STR) {
            ensure_str(&left);
            ensure_str(&right);
            return strcmp(left.str, right.str) != 0;
        } else {
            return left.num != right.num;
        }
    }
    if (op1 == '<' && op2 == '=') {
        *p += 2;
        right = eval_addsub(p);
        ensure_num(&left);
        ensure_num(&right);
        return left.num <= right.num;
    }
    if (op1 == '>' && op2 == '=') {
        *p += 2;
        right = eval_addsub(p);
        ensure_num(&left);
        ensure_num(&right);
        return left.num >= right.num;
    }
    if (op1 == '<' || op1 == '>' || op1 == '=') {
        (*p)++;
        right = eval_addsub(p);  /* stop before AND/OR so "X=13 AND Y=0 THEN" parses correctly */
        if (left.type == VAL_STR || right.type == VAL_STR) {
            ensure_str(&left);
            ensure_str(&right);
            if (op1 == '<') {
                return strcmp(left.str, right.str) < 0;
            } else if (op1 == '>') {
                return strcmp(left.str, right.str) > 0;
            } else {
                return strcmp(left.str, right.str) == 0;
            }
        } else {
            if (op1 == '<') {
                return left.num < right.num;
            } else if (op1 == '>') {
                return left.num > right.num;
            } else {
                return left.num == right.num;
            }
        }
    }
    /* No explicit relational operator: treat expression truthiness. */
    if (left.type == VAL_STR) {
        ensure_str(&left);
        return strlen(left.str) > 0;
    }
    return left.num != 0.0;
}

/* Evaluate IF conditions with BASIC relational operators and AND/OR. */
static int eval_condition(char **p)
{
    int result;

    result = eval_simple_condition(p);
    for (;;) {
        skip_spaces(p);
        if (starts_with_kw(*p, "AND")) {
            *p += 3;
            {
                int rhs = eval_simple_condition(p);
                result = result && rhs;
            }
            continue;
        }
        if (starts_with_kw(*p, "OR")) {
            *p += 2;
            {
                int rhs = eval_simple_condition(p);
                result = result || rhs;
            }
            continue;
        }
        break;
    }
    return result;
}

/* Skip rest of line (REM or ' comment). */
static void statement_rem(char **p)
{
    *p += strlen(*p);
}

/* PRINT / ? statement.
 * Semantics are CBM-like:
 * - Expressions separated by ';' print back-to-back with no extra spacing.
 * - Expressions separated by ',' advance to the next print "zone".
 * - If the last separator in the statement is ';' or ',', no newline is emitted.
 * - A bare PRINT (no expressions) always emits a newline.
 */
static void statement_print(char **p)
{
    int any_output;
    int ended_with_sep;
    struct value v;

    any_output = 0;
    ended_with_sep = 0;

    for (;;) {
        skip_spaces(p);
        if (**p == '\0' || **p == ':') {
            break;
        }

        /* Leading separators (e.g., PRINT , , "X") */
        if (**p == ';') {
            ended_with_sep = 1;
            (*p)++;
            continue;
        } else if (**p == ',') {
            int zone;
            int nextcol;
            ended_with_sep = 1;
            zone = (print_width >= 80) ? 20 : 10;  /* 80 cols: 20-char zones; 40 cols: 10-char */
            nextcol = ((print_col / zone) + 1) * zone;
            if (nextcol < print_col) {
                nextcol = print_col;
            }
            print_spaces(nextcol - print_col);
            (*p)++;
            continue;
        }

        v = eval_expr(p);
        print_value(&v);
        any_output = 1;
        ended_with_sep = 0;

        skip_spaces(p);
        if (**p == ';') {
            ended_with_sep = 1;
            (*p)++;
        } else if (**p == ',') {
            int zone;
            int nextcol;
            ended_with_sep = 1;
            zone = (print_width >= 80) ? 20 : 10;  /* 80 cols: 20-char zones; 40 cols: 10-char */
            nextcol = ((print_col / zone) + 1) * zone;
            if (nextcol < print_col) {
                nextcol = print_col;
            }
            print_spaces(nextcol - print_col);
            (*p)++;
        } else {
            break;
        }
    }

    /* Bare PRINT: always newline. */
    if (!any_output) {
#ifdef GFX_VIDEO
        if (gfx_vs) {
            gfx_newline();
            return;
        }
#endif
        OUTC('\n');
        print_col = 0;
        OUTFLUSH();
        return;
    }

    /* Trailing ';' or ',' suppresses newline. */
    if (!ended_with_sep) {
#ifdef GFX_VIDEO
        if (gfx_vs) {
            gfx_newline();
            return;
        }
#endif
        OUTC('\n');
        print_col = 0;
    }
    OUTFLUSH();
}


static void statement_textat(char **p)
{
    struct value vx, vy, vtext;
    int x, y;

    /* TEXTAT x, y, text */
    vx = eval_expr(p);
    ensure_num(&vx);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("TEXTAT: expected ',' after X", "Use TEXTAT x, y, \"text\" (commas between x, y, and string).");
        return;
    }
    (*p)++;

    vy = eval_expr(p);
    ensure_num(&vy);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("TEXTAT: expected ',' after Y", "Use TEXTAT x, y, \"text\" — comma before the string.");
        return;
    }
    (*p)++;

    vtext = eval_expr(p);
    ensure_str(&vtext);

    x = (int)vx.num;
    if (x < 0) x = 0;
    y = (int)vy.num;
    if (y < 0) y = 0;

#ifdef GFX_VIDEO
    if (gfx_vs) {
        gfx_x = x;
        gfx_y = y;
        print_col = gfx_x;
        {
            char *s = vtext.str;
            while (*s) {
                gfx_put_byte((unsigned char)*s++);
            }
        }
        return;
    }
#endif

    /* Move cursor with ANSI: rows/cols are 1-based */
    BEFORE_CSTDIO();
    printf("\033[%d;%dH", y + 1, x + 1);
    OUTS(vtext.str);
    OUTFLUSH();
}


static void statement_locate(char **p)
{
    // Passed as LOCATE x, y
    struct value vx, vy;
    int x, y;

    // Validation
    vx = eval_expr(p);  ensure_num(&vx);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("LOCATE: expected ',' after X", "Use LOCATE x, y (column then row, 0-based in gfx).");
        return;
    }
    (*p)++;
    vy = eval_expr(p);  ensure_num(&vy);
    skip_spaces(p);

    x = (int)vx.num; if (x < 0) x = 0;
    y = (int)vy.num; if (y < 0) y = 0;

#ifdef GFX_VIDEO
    if (gfx_vs) {
        gfx_x = x;
        gfx_y = y;
        print_col = gfx_x;
        return;
    }
#endif

    // Move cursor with ANSI: rows/cols are 1-based
    BEFORE_CSTDIO();
    printf("\033[%d;%dH", y + 1, x + 1);
    OUTFLUSH();
}

#ifdef GFX_VIDEO
#if defined(__EMSCRIPTEN__)
/* Shadow framebuffer + version: C updates while waiting for INPUT; JS rAF copies from
 * linear memory only (no EM_ASM / no wasm ccall while Asyncify is suspended). */
/* Max 80×25×8×8 RGBA (same as gfx_canvas); 40-col uses left portion only. */
#define WASM_GFX_SHADOW_RGBA_BYTES (640u * 200u * 4u)
typedef struct {
    volatile uint32_t version;
    uint8_t rgba[WASM_GFX_SHADOW_RGBA_BYTES];
} WasmGfxShadow;
static WasmGfxShadow wasm_gfx_shadow;

EMSCRIPTEN_KEEPALIVE int wasm_gfx_shadow_base(void)
{
    return (int)(uintptr_t)(void *)&wasm_gfx_shadow;
}
#endif
/* Read a line from gfx key queue; echo to screen; handle backspace (20).
 * Do not debounce repeated printable bytes: OS key-repeat and fast typing
 * (e.g. "LOOK", "book") must deliver every character. */
static int gfx_read_line(char *buf, int size)
{
    int len = 0;
    uint8_t b;
    buf[0] = '\0';
    if (size <= 0) return 0;
    while (len < size - 1) {
        if (gfx_keyq_pop(&b)) {
#if defined(__EMSCRIPTEN__)
            emscripten_sleep(0);
#endif
            if (b == 13 || b == 10) {
                buf[len] = '\0';
                gfx_put_byte('\n');
                return 1;
            }
            if (b == 20) { /* DEL / backspace */
                if (len > 0) {
                    len--;
                    buf[len] = '\0';
                    gfx_put_byte((unsigned char)b);
                }
                continue;
            }
            if (b >= 32 && b <= 126) {
                buf[len++] = (char)b;
                buf[len] = '\0';
                gfx_put_byte((unsigned char)b);
            }
        } else {
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
            wasm_browser_pause_point();
            if (halted) {
                buf[0] = '\0';
                return 0;
            }
            wasm_gfx_refresh_js();
#endif
            do_sleep_ticks(1.0 / 60.0);
        }
    }
    buf[len] = '\0';
    return 1;
}
#endif

static void statement_input(char **p)
{
    char prompt[MAX_STR_LEN];
    char linebuf[MAX_LINE_LEN];
    int first_prompt;
    struct value *vp;
    int is_array;
    int is_string;

    prompt[0] = '\0';
    skip_spaces(p);
    first_prompt = 1;
    if (**p == '\"') {
        struct value s;
        s = eval_factor(p);
        ensure_str(&s);
        strncpy(prompt, s.str, sizeof(prompt) - 1);
        prompt[sizeof(prompt) - 1] = '\0';
        skip_spaces(p);
        if (**p == ';' || **p == ',') {
            (*p)++;
        }
    }
    for (;;) {
        skip_spaces(p);
        if (**p == '\0' || **p == ':') {
            break;
        }
        if (!isalpha((unsigned char)**p)) {
            runtime_error_hint("Expected variable in INPUT",
                                 "List variables after an optional prompt: INPUT A or INPUT \"Name\"; A$");
            return;
        }
        vp = get_var_reference(p, &is_array, &is_string, NULL);
        if (!vp) {
            return;
        }
#ifdef GFX_VIDEO
        if (gfx_vs) {
            const char *s;
            if (prompt[0] != '\0' && first_prompt) {
                for (s = prompt; *s; s++) gfx_put_byte((unsigned char)*s);
            }
            for (s = "? "; *s; s++) gfx_put_byte((unsigned char)*s);
            if (!gfx_read_line(linebuf, (int)sizeof(linebuf))) {
                /* Watchdog / Stop sets wasmStopRequested → halted; not stdin EOF. */
                if (halted) {
                    runtime_error_hint("Stopped", "Execution was halted (Stop or host interrupt).");
                } else {
                    runtime_error_hint("Unexpected end of input",
                                         "No line received; use the INPUT field in the browser, or Run again.");
                }
                return;
            }
        } else
#endif
#if defined(__EMSCRIPTEN__)
        {
            const char *s;
            if (prompt[0] != '\0' && first_prompt) {
                for (s = prompt; *s; s++) {
                    OUTC((unsigned char)*s);
                }
            }
            for (s = "? "; *s; s++) {
                OUTC((unsigned char)*s);
            }
            OUTFLUSH();
            wasm_read_input_line_blocking(linebuf, sizeof(linebuf));
            trim_newline(linebuf);
        }
#else
        {
            if (prompt[0] != '\0' && first_prompt) {
                printf("%s", prompt);
            }
            printf("? ");
            fflush(stdout);
            if (!fgets(linebuf, sizeof(linebuf), stdin)) {
                runtime_error_hint("Unexpected end of input",
                                   "stdin ended (EOF); pipe a file or type a line at the prompt.");
                return;
            }
            trim_newline(linebuf);
        }
#endif
        if (is_string) {
            *vp = make_str(linebuf);
        } else {
            *vp = make_num(atof(linebuf));
        }
        skip_spaces(p);
        if (**p == ',') {
            (*p)++;
            first_prompt = 0;
            continue;
        }
        break;
    }
}

/* ON expr GOTO line1, line2, ... / ON expr GOSUB line1, line2, ... */
static void statement_on(char **p)
{
    struct value idxv;
    int idx;
    int is_gosub = 0;

    /* Evaluate the selector expression (1-based index). */
    idxv = eval_expr(p);
    ensure_num(&idxv);
    idx = (int)idxv.num;

    skip_spaces(p);
    if (starts_with_kw(*p, "GOTO")) {
        is_gosub = 0;
        *p += 4;
    } else if (starts_with_kw(*p, "GOSUB")) {
        is_gosub = 1;
        *p += 5;
    } else {
        runtime_error_hint("ON must be followed by GOTO or GOSUB",
                             "Use ON X GOTO 100,200,300 or ON X GOSUB 100,200,300");
        return;
    }

    /* Walk the comma-separated list of line numbers. */
    {
        int current = 1;
        while (1) {
            int target;

            skip_spaces(p);
            if (!isdigit((unsigned char)**p)) {
                runtime_error_hint("Expected line number in ON",
                                     "After GOTO/GOSUB list comma-separated line numbers only.");
                return;
            }
            target = atoi(*p);
            while (**p && isdigit((unsigned char)**p)) {
                (*p)++;
            }

            if (idx == current) {
                int line_index = find_line_index(target);
                if (line_index < 0) {
                    {
                        char h[96];
                        snprintf(h, sizeof(h), "No line %d in program. Check ON … GOTO/GOSUB list.", target);
                        runtime_error_hint("Target line not found", h);
                    }
                    return;
                }
                if (is_gosub) {
                    if (gosub_top >= MAX_GOSUB) {
                        runtime_error_hint("GOSUB stack overflow",
                                             "Too many nested GOSUBs; RETURN before deeper GOSUB.");
                        return;
                    }
                    gosub_stack[gosub_top].line_index = current_line;
                    gosub_stack[gosub_top].position = *p;
                    gosub_top++;
                }
                current_line = line_index;
                statement_pos = NULL;
                return;
            }

            /* Not the selected entry; skip to next, if any. */
            skip_spaces(p);
            if (**p == ',') {
                (*p)++;
                current++;
                continue;
            }
            break;
        }
    }
    /* If index is out of range, ON expression simply falls through. */
}

/* LOAD "path" INTO addr [, length] or LOAD @label INTO addr [, length].
 * GFX-only: loads raw bytes into virtual memory via gfx_poke. */
static void statement_load(char **p)
{
    char pathbuf[MAX_INCLUDE_PATH];
    int from_label = 0;
    char labelbuf[32];
    int addr, len_limit = -1;
    int i, count = 0;
    skip_spaces(p);
    if (**p == '@') {
        from_label = 1;
        (*p)++;
        skip_spaces(p);
        if (!isalpha((unsigned char)**p)) {
            runtime_error_hint("LOAD @label: expected label name",
                                 "Use LOAD @MYLABEL INTO addr where MYLABEL: marks DATA.");
            return;
        }
        {
            char *q = *p;
            int j = 0;
            while ((isalpha((unsigned char)*q) || isdigit((unsigned char)*q) || *q == '$' || *q == '_') && j < (int)sizeof(labelbuf) - 1)
                labelbuf[j++] = (char)*q++;
            labelbuf[j] = '\0';
            *p = q;
            for (j = 0; labelbuf[j]; j++)
                labelbuf[j] = (char)toupper((unsigned char)labelbuf[j]);
        }
    } else if (**p == '"' || **p == '\'') {
        char quote = **p;
        (*p)++;
        i = 0;
        while (**p && **p != quote && i < (int)sizeof(pathbuf) - 1)
            pathbuf[i++] = (char)*(*p)++;
        pathbuf[i] = '\0';
        if (**p == quote) (*p)++;
    } else {
        runtime_error_hint("LOAD: expected \"path\" or @label",
                             "Use LOAD \"file.bin\" INTO address or LOAD @label INTO address.");
        return;
    }
    skip_spaces(p);
    if (!starts_with_kw(*p, "INTO")) {
        runtime_error_hint("LOAD: expected INTO", "Syntax: LOAD \"path\" INTO addr [, maxbytes].");
        return;
    }
    *p += 4;
    skip_spaces(p);
    {
        struct value v = eval_expr(p);
        ensure_num(&v);
        addr = (int)v.num & 0xFFFF;
    }
    skip_spaces(p);
    if (**p == ',') {
        (*p)++;
        skip_spaces(p);
        {
            struct value v = eval_expr(p);
            ensure_num(&v);
            len_limit = (int)v.num;
            if (len_limit < 0) len_limit = 0;
        }
    }
#ifdef GFX_VIDEO
    if (!gfx_vs) {
        runtime_error_hint("LOAD INTO: no graphics context",
                             "LOAD INTO needs basic-gfx or canvas WASM (virtual video memory).");
        return;
    }
    if (from_label) {
        int label_line_idx, label_line_no, next_label_line_no, di_start, di_end;
        label_line_idx = find_label_line(labelbuf);
        if (label_line_idx < 0) {
            runtime_error_hint("LOAD @label: label not found",
                                 "Define a line like MYLABEL: before LOAD @MYLABEL INTO …");
            return;
        }
        label_line_no = program_lines[label_line_idx] ? program_lines[label_line_idx]->number : 0;
        next_label_line_no = 999999;
        for (i = 0; i < label_count; i++) {
            if (label_table[i].line_index == label_line_idx) continue;
            {
                int ln = program_lines[label_table[i].line_index] ? program_lines[label_table[i].line_index]->number : 0;
                if (ln > label_line_no && ln < next_label_line_no)
                    next_label_line_no = ln;
            }
        }
        di_start = data_count;
        di_end = data_count;
        for (i = 0; i < data_line_count; i++) {
            if (data_line_numbers[i] >= label_line_no && data_line_numbers[i] < next_label_line_no) {
                if (di_start == data_count) di_start = data_line_start_index[i];
                di_end = (i + 1 < data_line_count) ? data_line_start_index[i + 1] : data_count;
            }
        }
        count = di_end - di_start;
        if (len_limit >= 0 && count > len_limit) count = len_limit;
        for (i = 0; i < count; i++) {
            struct value *v = &data_items[di_start + i];
            uint8_t b;
            if (v->type == VAL_NUM)
                b = (uint8_t)((int)v->num & 0xFF);
            else
                b = (uint8_t)(v->str[0] ? (unsigned char)v->str[0] : 0);
            gfx_poke(gfx_vs, (uint16_t)(addr + i), b);
        }
    } else {
        FILE *f;
        int c;
        count = 0;
        f = fopen(pathbuf, "rb");
        if (!f) {
            {
                char h[160];
                snprintf(h, sizeof(h), "Check path (tried \"%s\").", pathbuf);
                runtime_error_hint("LOAD: cannot open file", h);
            }
            return;
        }
        while ((c = fgetc(f)) != EOF && (len_limit < 0 || count < len_limit)) {
            gfx_poke(gfx_vs, (uint16_t)(addr + count), (uint8_t)(c & 0xFF));
            count++;
        }
        fclose(f);
    }
#else
    (void)addr;
    (void)len_limit;
    (void)from_label;
    (void)count;
    runtime_error_hint("LOAD INTO requires basic-gfx (graphics build)",
                         "Build basic-gfx or use canvas WASM; terminal basic has no LOAD INTO.");
#endif
}

/* MEMSET addr, len, val — fill len bytes at addr with val (GFX-only). */
static void statement_memset(char **p)
{
    struct value v_addr, v_len, v_val;
    skip_spaces(p);
    v_addr = eval_expr(p);
    ensure_num(&v_addr);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("MEMSET requires 3 arguments", "Use MEMSET addr, length, byte_value.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v_len = eval_expr(p);
    ensure_num(&v_len);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("MEMSET requires 3 arguments", "Use MEMSET addr, length, byte_value.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v_val = eval_expr(p);
    ensure_num(&v_val);
#ifdef GFX_VIDEO
    {
        int addr, len, i;
        unsigned char b;
        if (!gfx_vs) {
            runtime_error_hint("MEMSET requires basic-gfx (graphics build)",
                                 "Needs video memory; use basic-gfx or canvas WASM.");
            return;
        }
        addr = (int)v_addr.num & 0xFFFF;
        len = (int)v_len.num;
        if (len < 0) len = 0;
        b = (unsigned char)((int)v_val.num & 0xFF);
        for (i = 0; i < len; i++) {
            gfx_poke(gfx_vs, (uint16_t)(addr + i), (uint8_t)b);
        }
    }
#else
    (void)v_addr;
    (void)v_len;
    (void)v_val;
    runtime_error_hint("MEMSET requires basic-gfx (graphics build)",
                         "Terminal build has no MEMSET; use basic-gfx or canvas WASM.");
#endif
}

/* MEMCPY dest, src, len — copy len bytes from src to dest; overlap-safe (GFX-only). */
static void statement_memcpy(char **p)
{
    struct value v_dest, v_src, v_len;
    skip_spaces(p);
    v_dest = eval_expr(p);
    ensure_num(&v_dest);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("MEMCPY requires 3 arguments", "Use MEMCPY dest_addr, src_addr, length.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v_src = eval_expr(p);
    ensure_num(&v_src);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("MEMCPY requires 3 arguments", "Use MEMCPY dest_addr, src_addr, length.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v_len = eval_expr(p);
    ensure_num(&v_len);
#ifdef GFX_VIDEO
    {
        int dest, src, len, i;
        unsigned char buf[256];
        if (!gfx_vs) {
            runtime_error_hint("MEMCPY requires basic-gfx (graphics build)",
                                 "Needs video memory; use basic-gfx or canvas WASM.");
            return;
        }
        dest = (int)v_dest.num & 0xFFFF;
        src = (int)v_src.num & 0xFFFF;
        len = (int)v_len.num;
        if (len < 0) len = 0;
        /* Overlap-safe: read into buffer then write. For large len, do in chunks. */
        for (i = 0; i < len; ) {
            int chunk = len - i;
            if (chunk > (int)sizeof(buf)) chunk = (int)sizeof(buf);
            {
                int j;
                for (j = 0; j < chunk; j++)
                    buf[j] = (unsigned char)gfx_peek(gfx_vs, (uint16_t)(src + i + j));
                for (j = 0; j < chunk; j++)
                    gfx_poke(gfx_vs, (uint16_t)(dest + i + j), (uint8_t)buf[j]);
            }
            i += chunk;
        }
    }
#else
    (void)v_dest;
    (void)v_src;
    (void)v_len;
    runtime_error_hint("MEMCPY requires basic-gfx (graphics build)",
                         "Terminal build has no MEMCPY; use basic-gfx or canvas WASM.");
#endif
}

/* RESTORE [line]: reset DATA pointer. No arg = first DATA; line number = first DATA at or after that line (C64-style). */
static void statement_restore(char **p)
{
    skip_spaces(p);
    if (**p == '\0' || **p == ':') {
        data_index = 0;
        return;
    }
    {
        struct value v;
        int target_line, i;
        v = eval_expr(p);
        ensure_num(&v);
        target_line = (int)v.num;
        data_index = 0;
        for (i = 0; i < data_line_count; i++) {
            if (data_line_numbers[i] >= target_line) {
                data_index = data_line_start_index[i];
                return;
            }
        }
        if (data_line_count == 0) {
            runtime_error_hint("RESTORE: no DATA in program",
                                 "Add DATA lines, or use RESTORE with no line to reset to start.");
        } else {
            char h[120];
            snprintf(h, sizeof(h), "No DATA at or after line %d; add DATA or use a lower line.", target_line);
            runtime_error_hint("RESTORE: no DATA at or after line", h);
        }
    }
}

/* CLR: reset all variables to 0/empty, clear GOSUB/FOR stacks, reset DATA pointer.
 * DEF FN definitions are left intact (CBM-style). */
static void basic_clr_memory(void)
{
    int i, j;

    for (i = 0; i < var_count; i++) {
        struct var *v = &vars[i];
        v->scalar = v->is_string ? make_str("") : make_num(0.0);
        if (v->array && v->size > 0) {
            for (j = 0; j < v->size; j++) {
                v->array[j] = v->is_string ? make_str("") : make_num(0.0);
            }
        }
    }
    gosub_top = 0;
    for_top = 0;
    while_top = 0;
    do_top = 0;
    if_depth = 0;
    data_index = 0;
}

static void statement_clr(char **p)
{
    (void)p;
    basic_clr_memory();
}

/* SORT arr [, mode]: in-place sort. mode: 1 or "asc" (default), -1 or "desc". */
static int sort_desc = 0;

static int sort_cmp_num(const void *a, const void *b)
{
    double x = ((const struct value *)a)->num;
    double y = ((const struct value *)b)->num;
    int r = (x < y) ? -1 : (x > y) ? 1 : 0;
    return sort_desc ? -r : r;
}

static int sort_cmp_str(const void *a, const void *b)
{
    int r = strcmp(((const struct value *)a)->str, ((const struct value *)b)->str);
    return sort_desc ? -r : r;
}

static void statement_sort(char **p)
{
    char namebuf[VAR_NAME_MAX];
    int is_string = 0;
    struct var *v = NULL;
    int i, mode = 1;

    skip_spaces(p);
    if (!isalpha((unsigned char)**p)) {
        runtime_error_hint("SORT requires array variable", "Use SORT A or SORT T$ with a DIMmed 1-D array name.");
        return;
    }
    read_identifier(p, namebuf, sizeof(namebuf));
    uppercase_name(namebuf, namebuf, sizeof(namebuf), &is_string);
    for (i = 0; i < var_count; i++) {
        if (strcmp(vars[i].name, namebuf) == 0 && vars[i].is_string == is_string) {
            v = &vars[i];
            break;
        }
    }
    if (!v || !v->is_array || !v->array || v->size <= 0) {
        runtime_error_hint("SORT requires 1-D array", "DIM the array first: DIM A(10) then SORT A.");
        return;
    }
    if (v->dims != 1) {
        runtime_error_hint("SORT requires 1-D array", "Multi-dimensional arrays cannot be SORTed; use 1-D only.");
        return;
    }
    skip_spaces(p);
    if (**p == ',') {
        (*p)++;
        skip_spaces(p);
        {
            struct value vm = eval_expr(p);
            if (vm.type == VAL_NUM) {
                mode = (int)vm.num;
            } else {
                ensure_str(&vm);
                if (str_eq_ci(vm.str, "asc") || str_eq_ci(vm.str, "ascending")) mode = 1;
                else if (str_eq_ci(vm.str, "desc") || str_eq_ci(vm.str, "descending")) mode = -1;
                else mode = 1;
            }
        }
    }
    sort_desc = (mode < 0) ? 1 : 0;
    if (v->is_string)
        qsort(v->array, (size_t)v->size, sizeof(struct value), sort_cmp_str);
    else
        qsort(v->array, (size_t)v->size, sizeof(struct value), sort_cmp_num);
}

/* SPLIT str$, delim$ INTO arr$: split string by delimiter, fill pre-dimmed 1-D string array. */
static int split_count = 0;  /* set by SPLIT, used by JOIN when count omitted */

static void statement_split(char **p)
{
    struct value v_str, v_delim;
    struct var *arr_var = NULL;
    const char *s, *delim;
    size_t dlen;
    int i, count, arr_size;
    char *start, *end;

    v_str = eval_expr(p);
    ensure_str(&v_str);
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("SPLIT: expected ,", "Use SPLIT s$, \",\" INTO arr$ — comma after the string and delimiter.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v_delim = eval_expr(p);
    ensure_str(&v_delim);
    skip_spaces(p);
    if (!starts_with_kw(*p, "INTO")) {
        runtime_error_hint("SPLIT: expected INTO", "Syntax: SPLIT text$, delim$ INTO string_array.");
        return;
    }
    *p += 4;
    skip_spaces(p);
    if (!isalpha((unsigned char)**p)) {
        runtime_error_hint("SPLIT: expected array variable", "After INTO, give the string array name (e.g. P$).");
        return;
    }
    {
        char namebuf[VAR_NAME_MAX];
        int is_string = 0;
        read_identifier(p, namebuf, sizeof(namebuf));
        uppercase_name(namebuf, namebuf, sizeof(namebuf), &is_string);
        if (!is_string) {
            runtime_error_hint("SPLIT: expected string array", "SPLIT fills a string array (name ends with $).");
            return;
        }
        for (i = 0; i < var_count; i++) {
            if (strcmp(vars[i].name, namebuf) == 0 && vars[i].is_string) {
                arr_var = &vars[i];
                break;
            }
        }
    }
    if (!arr_var || !arr_var->is_array || !arr_var->array || arr_var->dims != 1) {
        runtime_error_hint("SPLIT: requires 1-D string array (DIM first)",
                             "DIM P$(20) before SPLIT … INTO P$.");
        return;
    }
    s = v_str.str;
    delim = v_delim.str;
    dlen = strlen(delim);
    if (dlen == 0) {
        runtime_error_hint("SPLIT: empty delimiter", "Delimiter must be non-empty (e.g. \",\" or \"|\").");
        return;
    }
    arr_size = arr_var->size;
    count = 0;
    start = (char *)s;
    while (count < arr_size) {
        end = strstr(start, delim);
        if (end == NULL) end = (char *)(s + strlen(s));
        {
            size_t len = (size_t)(end - start);
            if (len >= MAX_STR_LEN) len = MAX_STR_LEN - 1;
            if (len > (size_t)(max_str_limit - 1)) len = (size_t)(max_str_limit - 1);
            memcpy(arr_var->array[count].str, start, len);
            arr_var->array[count].str[len] = '\0';
            arr_var->array[count].type = VAL_STR;
            arr_var->array[count].num = 0.0;
        }
        count++;
        if (*end == '\0') break;
        start = end + dlen;
    }
    for (; count < arr_size; count++) {
        arr_var->array[count].type = VAL_STR;
        arr_var->array[count].str[0] = '\0';
        arr_var->array[count].num = 0.0;
    }
    split_count = count;
}

/* JOIN arr$, delim$ INTO result$ [, count]: join array elements. Optional count limits elements. */
static void statement_join(char **p)
{
    struct var *arr_var = NULL;
    struct value v_delim;
    char namebuf[VAR_NAME_MAX];
    int i, is_string, n_elems;

    skip_spaces(p);
    if (!isalpha((unsigned char)**p)) {
        runtime_error_hint("JOIN: expected array variable", "Start with the string array: JOIN P$, …");
        return;
    }
    read_identifier(p, namebuf, sizeof(namebuf));
    uppercase_name(namebuf, namebuf, sizeof(namebuf), &is_string);
    if (!is_string) {
        runtime_error_hint("JOIN: expected string array", "JOIN combines a string array (name ends with $).");
        return;
    }
    for (i = 0; i < var_count; i++) {
        if (strcmp(vars[i].name, namebuf) == 0 && vars[i].is_string) {
            arr_var = &vars[i];
            break;
        }
    }
    if (!arr_var || !arr_var->is_array || !arr_var->array || arr_var->dims != 1) {
        runtime_error_hint("JOIN: requires 1-D string array", "DIM a string array first, same as for SPLIT.");
        return;
    }
    skip_spaces(p);
    if (**p != ',') {
        runtime_error_hint("JOIN: expected ,", "Use JOIN arr$, \",\" INTO result$ — comma after array name.");
        return;
    }
    (*p)++;
    skip_spaces(p);
    v_delim = eval_expr(p);
    ensure_str(&v_delim);
    skip_spaces(p);
    if (!starts_with_kw(*p, "INTO")) {
        runtime_error_hint("JOIN: expected INTO", "Syntax: JOIN arr$, delim$ INTO out$ [, count].");
        return;
    }
    *p += 4;
    skip_spaces(p);
    {
        struct value *out = get_var_reference(p, &i, &is_string, NULL);
        if (!out || !is_string) {
            runtime_error_hint("JOIN: expected string variable for result",
                                 "After INTO, use a scalar string variable (e.g. Q$) for the joined text.");
            return;
        }
        skip_spaces(p);
        if (**p == ',') {
            (*p)++;
            skip_spaces(p);
            {
                struct value vc = eval_expr(p);
                ensure_num(&vc);
                n_elems = (int)vc.num;
                if (n_elems < 0) n_elems = 0;
                if (n_elems > arr_var->size) n_elems = arr_var->size;
            }
        } else {
            n_elems = (split_count > 0 && split_count <= arr_var->size) ? split_count : arr_var->size;
        }
        {
            size_t total = 0;
            out->type = VAL_STR;
            out->str[0] = '\0';
            for (i = 0; i < n_elems && total < (size_t)(max_str_limit - 1); i++) {
                if (i > 0) {
                    size_t dlen = strlen(v_delim.str);
                    if (total + dlen < (size_t)(max_str_limit - 1)) {
                        strncat(out->str, v_delim.str, max_str_limit - 1 - (int)total);
                        total += dlen;
                    }
                }
                size_t elen = strlen(arr_var->array[i].str);
                if (total + elen < (size_t)(max_str_limit - 1)) {
                    strncat(out->str, arr_var->array[i].str, max_str_limit - 1 - (int)total);
                    total += elen;
                }
            }
            out->num = 0.0;
        }
    }
}

/* Set ST (I/O status) variable for file operations: 0=ok, 64=EOF, 1=error. */
static void set_io_status(int st)
{
    struct var *v = find_or_create_var("ST", 0, 0, 0, NULL, 0);
    if (v) {
        v->scalar.type = VAL_NUM;
        v->scalar.num = (double)st;
        v->scalar.str[0] = '\0';
    }
}

/* OPEN lfn [, device [, secondary [, "filename" ]]] */
static void statement_open(char **p)
{
    int lfn, device, secondary;
    char fname[MAX_STR_LEN];
    const char *mode;
    FILE *fp;

    skip_spaces(p);
    if (!isdigit((unsigned char)**p)) {
        runtime_error_hint("OPEN: expected logical file number",
                             "Use OPEN 1,8,0,\"file.txt\" — first number is the channel (1-255).");
        return;
    }
    lfn = atoi(*p);
    while (isdigit((unsigned char)**p)) (*p)++;
    if (lfn < 1 || lfn > 255) {
        runtime_error_hint("OPEN: file number must be 1-255", "Choose a channel 1-255 for OPEN/CLOSE/PRINT#.");
        return;
    }
    skip_spaces(p);
    device = 1;
    secondary = 0;
    if (**p == ',') {
        (*p)++;
        skip_spaces(p);
        if (isdigit((unsigned char)**p)) {
            device = atoi(*p);
            while (isdigit((unsigned char)**p)) (*p)++;
        }
        skip_spaces(p);
        if (**p == ',') {
            (*p)++;
            skip_spaces(p);
            if (isdigit((unsigned char)**p)) {
                secondary = atoi(*p);
                while (isdigit((unsigned char)**p)) (*p)++;
            }
            skip_spaces(p);
        }
    }
    fname[0] = '\0';
    if (**p == ',') {
        (*p)++;
        skip_spaces(p);
        if (**p == '"') {
            (*p)++;
            size_t i = 0;
            while (**p && **p != '"' && i < sizeof(fname) - 1)
                fname[i++] = *(*p)++;
            fname[i] = '\0';
            if (**p == '"') (*p)++;
        }
    }
    if (open_files[lfn]) {
        fclose(open_files[lfn]);
        open_files[lfn] = NULL;
    }
    if (fname[0] == '\0') {
        runtime_error_hint("OPEN: filename required",
                             "Pass a path in quotes: OPEN 1,8,0,\"data.txt\" (device 8 = disk).");
        return;
    }
    if (device == 1 || device == 0) {
        if (secondary == 0) mode = "r";
        else if (secondary == 1) mode = "w";
        else mode = "a";
        fp = fopen(fname, mode);
        if (!fp) {
            set_io_status(1);
            {
                char h[160];
                snprintf(h, sizeof(h), "Check path and permissions (tried \"%s\").", fname);
                runtime_error_hint("OPEN: cannot open file", h);
            }
            return;
        }
        open_files[lfn] = fp;
        set_io_status(0);
    } else {
        set_io_status(1);
        runtime_error_hint("OPEN: unsupported device",
                             "Use device 0 or 1 for host files; other devices are not implemented.");
    }
}

/* CLOSE [lfn [, lfn ...]] or CLOSE (close all) */
static void statement_close(char **p)
{
    int lfn;
    skip_spaces(p);
    if (**p == '\0' || **p == ':') {
        for (lfn = 1; lfn < 256; lfn++) {
            if (open_files[lfn]) {
                fclose(open_files[lfn]);
                open_files[lfn] = NULL;
            }
        }
        return;
    }
    for (;;) {
        if (!isdigit((unsigned char)**p)) break;
        lfn = atoi(*p);
        while (isdigit((unsigned char)**p)) (*p)++;
        if (lfn >= 1 && lfn <= 255 && open_files[lfn]) {
            fclose(open_files[lfn]);
            open_files[lfn] = NULL;
        }
        skip_spaces(p);
        if (**p != ',') break;
        (*p)++;
        skip_spaces(p);
    }
}

/* PRINT# lfn, expr [,|; expr ...] — like PRINT but to file. */
static void statement_print_hash(char **p)
{
    int lfn;
    struct value v;
    int any_output = 0;
    int ended_with_sep = 0;

    skip_spaces(p);
    if (!isdigit((unsigned char)**p)) {
        runtime_error_hint("PRINT#: expected file number", "Use PRINT# 1, A after OPEN 1, …");
        return;
    }
    lfn = atoi(*p);
    while (isdigit((unsigned char)**p)) (*p)++;
    if (lfn < 1 || lfn > 255 || !open_files[lfn]) {
        runtime_error_hint("PRINT#: file not open", "OPEN the channel first, then PRINT# to it.");
        return;
    }
    skip_spaces(p);
    if (**p == ',') (*p)++;
    skip_spaces(p);

    for (;;) {
        if (**p == '\0' || **p == ':') break;
        if (**p == ';') { (*p)++; continue; }
        if (**p == ',') { fprintf(open_files[lfn], "\t"); (*p)++; continue; }
        v = eval_expr(p);
        any_output = 1;
        ended_with_sep = 0;
        if (v.type == VAL_STR) {
            fputs(v.str, open_files[lfn]);
        } else {
            fprintf(open_files[lfn], "%g", v.num);
        }
        skip_spaces(p);
        if (**p == ';') { ended_with_sep = 1; (*p)++; }
        else if (**p == ',') { fprintf(open_files[lfn], "\t"); ended_with_sep = 1; (*p)++; }
        else break;
        skip_spaces(p);
    }
    if (!ended_with_sep && any_output) fprintf(open_files[lfn], "\n");
    fflush(open_files[lfn]);
}

/* Read one token from file (skip spaces/newlines, read until comma or newline or EOF). */
static int read_file_token(FILE *fp, char *buf, int buf_size)
{
    int i = 0;
    int c;
    while ((c = fgetc(fp)) != EOF && (c == ' ' || c == '\t' || c == '\n' || c == '\r')) ;
    if (c == EOF) { buf[0] = '\0'; return 0; }
    if (c == ',') { buf[0] = '\0'; return 1; }
    if (c == '\n' || c == '\r') { buf[0] = '\0'; ungetc(c, fp); return 1; }
    while (i < buf_size - 1) {
        if (c == EOF || c == ',' || c == '\n' || c == '\r') break;
        buf[i++] = (char)(unsigned char)c;
        c = fgetc(fp);
    }
    buf[i] = '\0';
    if (c == ',' || c == '\n' || c == '\r') ungetc(c, fp);
    return 1;
}

/* INPUT# lfn, var [, var ...] — one token per variable (comma/newline separated). */
static void statement_input_hash(char **p)
{
    int lfn;
    char tokbuf[MAX_STR_LEN];
    struct value *vp;
    int is_array, is_string;

    skip_spaces(p);
    if (!isdigit((unsigned char)**p)) {
        runtime_error_hint("INPUT#: expected file number", "Use INPUT# 1, A$ after OPEN 1, …");
        return;
    }
    lfn = atoi(*p);
    while (isdigit((unsigned char)**p)) (*p)++;
    if (lfn < 1 || lfn > 255 || !open_files[lfn]) {
        set_io_status(1);
        runtime_error_hint("INPUT#: file not open", "OPEN the file first with the same channel number.");
        return;
    }
    skip_spaces(p);
    if (**p == ',') (*p)++;
    skip_spaces(p);

    for (;;) {
        if (**p == '\0' || **p == ':') break;
        if (!isalpha((unsigned char)**p)) break;
        vp = get_var_reference(p, &is_array, &is_string, NULL);
        if (!vp) return;
        if (is_array) {
            runtime_error_hint("INPUT#: array not allowed",
                                 "Read into scalars only; use INPUT# 1, A, B$ not array elements.");
            return;
        }
        if (!read_file_token(open_files[lfn], tokbuf, sizeof(tokbuf))) {
            set_io_status(64);
            *vp = is_string ? make_str("") : make_num(0.0);
        } else {
            set_io_status(0);
            if (is_string) {
                *vp = make_str(tokbuf);
            } else {
                *vp = make_num(atof(tokbuf));
            }
        }
        skip_spaces(p);
        if (**p == ',') (*p)++;
        else break;
    }
}

/* GET# lfn, stringvar — read one character. */
static void statement_get_hash(char **p)
{
    int lfn;
    int c;
    struct value *vp;
    int is_array, is_string;

    skip_spaces(p);
    if (!isdigit((unsigned char)**p)) {
        runtime_error_hint("GET#: expected file number", "Use GET# 1, A$ after OPEN 1, …");
        return;
    }
    lfn = atoi(*p);
    while (isdigit((unsigned char)**p)) (*p)++;
    if (lfn < 1 || lfn > 255 || !open_files[lfn]) {
        set_io_status(1);
        runtime_error_hint("GET#: file not open", "OPEN the file first with the same channel number.");
        return;
    }
    skip_spaces(p);
    if (**p == ',') (*p)++;
    skip_spaces(p);
    if (!isalpha((unsigned char)**p)) {
        runtime_error_hint("GET#: expected string variable", "GET# reads one byte into a string variable.");
        return;
    }
    vp = get_var_reference(p, &is_array, &is_string, NULL);
    if (!vp || !is_string || is_array) {
        runtime_error_hint("GET#: requires string variable", "Use a plain string variable like A$, not a number.");
        return;
    }
    c = fgetc(open_files[lfn]);
    if (c == EOF) {
        set_io_status(64);
        *vp = make_str("");
    } else {
        set_io_status(0);
        {
            char buf[2];
            buf[0] = (char)(unsigned char)c;
            buf[1] = '\0';
            *vp = make_str(buf);
        }
    }
}

static void statement_let(char **p)
{
    struct value *vp;
    struct value rhs;
    int is_array;
    int is_string;

    vp = get_var_reference(p, &is_array, &is_string, NULL);
    if (!vp) {
        return;
    }
    skip_spaces(p);
    if (**p != '=') {
        runtime_error_hint("Expected '='", "Assignment needs = : LET X = 1 or X = 1 (LET is optional).");
        return;
    }
    (*p)++;
    rhs = eval_expr(p);
    if (is_string) {
        ensure_str(&rhs);
        rhs.type = VAL_STR;
    } else {
        ensure_num(&rhs);
        rhs.type = VAL_NUM;
    }
    *vp = rhs;
}

static void statement_goto(char **p)
{
    skip_spaces(p);
    if (isdigit((unsigned char)**p)) {
        int line_number;
        line_number = atoi(*p);
        while (**p && isdigit((unsigned char)**p)) {
            (*p)++;
        }
        current_line = find_line_index(line_number);
        if (current_line < 0) {
            {
                char h[96];
                snprintf(h, sizeof(h), "No line %d in program. Check the line number exists.", line_number);
                runtime_error_hint("Target line not found", h);
            }
            return;
        }
        statement_pos = NULL;
    } else if (isalpha((unsigned char)**p)) {
        char namebuf[32];
        int len = 0;
        while ((isalpha((unsigned char)**p) || isdigit((unsigned char)**p) || **p == '_') &&
               len < (int)sizeof(namebuf) - 1) {
            namebuf[len++] = **p;
            (*p)++;
        }
        namebuf[len] = '\0';
        current_line = find_label_line(namebuf);
        if (current_line < 0) {
            {
                char h[96];
                snprintf(h, sizeof(h), "Define a line like `%s:` before GOTO.", namebuf);
                runtime_error_hint("Target label not found", h);
            }
            return;
        }
        statement_pos = NULL;
    } else {
        runtime_error_hint("Expected line number or label in GOTO",
                           "Use GOTO 100 or GOTO mylabel (label lines look like `mylabel:`).");
    }
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    wasm_maybe_yield_loop();
#endif
}

static void statement_gosub(char **p)
{
    int target_index = -1;
    int target_line_num = -1;
    char namebuf[32];
    char *return_pos;
    int len;

    if (gosub_top >= MAX_GOSUB) {
        runtime_error_hint("GOSUB stack overflow",
                             "Too many nested GOSUBs without RETURN; reduce nesting.");
        return;
    }
    skip_spaces(p);
    namebuf[0] = '\0';
    if (isdigit((unsigned char)**p)) {
        target_line_num = atoi(*p);
        while (**p && isdigit((unsigned char)**p)) {
            (*p)++;
        }
        target_index = find_line_index(target_line_num);
    } else if (isalpha((unsigned char)**p)) {
        len = 0;
        while ((isalpha((unsigned char)**p) || isdigit((unsigned char)**p) || **p == '_') &&
               len < (int)sizeof(namebuf) - 1) {
            namebuf[len++] = **p;
            (*p)++;
        }
        namebuf[len] = '\0';
        target_index = find_label_line(namebuf);
    } else {
        runtime_error_hint("Expected line number or label in GOSUB",
                           "Use GOSUB 100 or GOSUB mylabel (label lines look like `mylabel:`).");
        return;
    }

    if (target_index < 0) {
        if (target_line_num >= 0) {
            char h[96];
            snprintf(h, sizeof(h), "No line %d in program. GOSUB needs an existing line.", target_line_num);
            runtime_error_hint("Target line not found", h);
        } else {
            char h[96];
            snprintf(h, sizeof(h), "Define a line like `%s:` before GOSUB.", namebuf);
            runtime_error_hint("Target line/label not found", h);
        }
        return;
    }

    return_pos = *p;
    gosub_stack[gosub_top].line_index = current_line;
    gosub_stack[gosub_top].position = return_pos;
    gosub_top++;
    current_line = target_index;
    statement_pos = NULL;
}

static void statement_return(char **p)
{
    if (udf_call_depth > 0) {
        skip_spaces(p);
        if (*p && **p && **p != ':' && (isalnum((unsigned char)**p) || **p == '(' || **p == '-' || **p == '+' || **p == '\"')) {
            udf_return_value = eval_expr(p);
        } else {
            udf_return_value = make_num(0.0);
        }
        udf_returned = 1;
        udf_call_depth--;
        current_line = udf_call_stack[udf_call_depth].saved_line;
        statement_pos = udf_call_stack[udf_call_depth].saved_pos;
        return;
    }
    if (gosub_top <= 0) {
        runtime_error_hint("RETURN without GOSUB", "RETURN only works after GOSUB; remove stray RETURN or add GOSUB.");
        return;
    }
    gosub_top--;
    for_unwind_after_return(gosub_top);
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    if (wasm_canvas_debug_trace_for) {
        char tb[160];
        snprintf(tb, sizeof(tb),
            "[rgc-basic canvas] trace RETURN gosub_top=%d for_top=%d",
            gosub_top, for_top);
        wasm_canvas_debug_log_cstr(tb);
    }
#endif
    current_line = gosub_stack[gosub_top].line_index;
    statement_pos = gosub_stack[gosub_top].position;
}

/* Skip forward from current position to ELSE (if want_else) or END IF.
 * Updates current_line, statement_pos, and *p. Handles nested IF blocks. */
static void skip_if_block_to_target(char **p, int want_else)
{
    int line = current_line;
    char *pos = *p;
    int nesting = 1;

    while (line >= 0 && line < line_count && program_lines[line]) {
        if (!pos) pos = program_lines[line]->text;
        while (pos && *pos) {
            char *q = pos;
            skip_spaces(&q);
            if (!*q) break;
            /* Nested block IF only: inline IF ... THEN PRINT ... has no END IF and must
             * not increment nesting (otherwise we never reach nesting==0 at the real END IF). */
            if (starts_with_kw(q, "IF")) {
                char *r = q + 2;
                while (*r) {
                    skip_spaces(&r);
                    if (!*r) break;
                    if (starts_with_kw(r, "THEN")) {
                        r += 4;
                        skip_spaces(&r);
                        if (!*r || (*r == ':' && !r[1])) {
                            nesting++;
                        }
                        break;
                    }
                    if (*r == '\"') { r++; while (*r && *r != '\"') r++; if (*r) r++; continue; }
                    if (*r == '(') { int pn = 1; r++; while (pn && *r) { if (*r == '(') pn++; else if (*r == ')') pn--; r++; } continue; }
                    r++;
                }
                pos = r;
                continue;
            }
            if (starts_with_kw(q, "END")) {
                char *r = q + 3;
                skip_spaces(&r);
                if (starts_with_kw(r, "IF")) {
                    r += 2;
                    skip_spaces(&r);
                    nesting--;
                    if (nesting == 0) {
                        current_line = line;
                        statement_pos = r;
                        *p = r;
                        if_depth--;
                        return;
                    }
                    pos = r;
                    continue;
                }
            }
            if (nesting == 1 && starts_with_kw(q, "ELSE")) {
                if (want_else) {
                    q += 4;
                    skip_spaces(&q);
                    current_line = line;
                    statement_pos = q;
                    *p = q;
                    return;
                }
                q += 4;
                skip_spaces(&q);
                pos = q;
                continue;
            }
            pos = strchr(pos, ':');
            pos = pos ? pos + 1 : NULL;
        }
        line++;
        pos = NULL;
    }
    runtime_error_hint("END IF expected",
                         "Block IF must end with END IF; check IF/ELSE/END IF pairing and nesting.");
}

/* Skip forward from current position to matching WEND. Handles nested WHILE/WEND. */
static void skip_while_to_wend(char **p)
{
    int line = current_line;
    char *pos = *p;
    int nesting = 1;

    while (line >= 0 && line < line_count && program_lines[line]) {
        if (!pos) pos = program_lines[line]->text;
        while (pos && *pos) {
            char *q = pos;
            skip_spaces(&q);
            if (!*q) break;
            if (starts_with_kw(q, "WHILE")) {
                q += 5;
                skip_spaces(&q);
                if (*q && *q != ':') {
                    nesting++;
                    while (*q && *q != ':') q++;
                    pos = (*q == ':') ? q + 1 : q;
                    continue;
                }
            }
            if (starts_with_kw(q, "WEND")) {
                char *r = q + 4;
                skip_spaces(&r);
                nesting--;
                if (nesting == 0) {
                    if (!*r && line + 1 < line_count) {
                        current_line = line + 1;
                        statement_pos = program_lines[line + 1]->text;
                        *p = statement_pos;
                    } else {
                        current_line = line;
                        statement_pos = r;
                        *p = r;
                    }
                    return;
                }
                pos = r;
                continue;
            }
            pos = strchr(pos, ':');
            pos = pos ? pos + 1 : NULL;
        }
        line++;
        pos = NULL;
    }
    runtime_error_hint("WEND expected", "WHILE … WEND blocks must close with WEND; check nesting.");
}

static void statement_if(char **p)
{
    int cond_true;
    char *after_then;

    cond_true = eval_condition(p);
    skip_spaces(p);
    if (!starts_with_kw(*p, "THEN")) {
        runtime_error_hint("Missing THEN", "Write IF condition THEN statement (THEN is required).");
        return;
    }
    *p += 4;
    skip_spaces(p);
    after_then = *p;
    /* Block mode: THEN at EOL or followed only by ':' then EOL */
    if (!*after_then || (*after_then == ':' && !after_then[1])) {
        if (if_depth >= MAX_IF_DEPTH) {
            runtime_error_hint("IF nesting too deep", "Too many nested block IFs; simplify or split lines.");
            return;
        }
        if_stack[if_depth].took_then = cond_true ? 1 : 0;
        if_depth++;
        if (!cond_true) {
            skip_if_block_to_target(p, 1);
        }
        return;
    }
    if (!cond_true) {
        *p += strlen(*p);
        return;
    }
    if (isdigit((unsigned char)**p)) {
        int target;
        target = atoi(*p);
        while (**p && isdigit((unsigned char)**p)) {
            (*p)++;
        }
        current_line = find_line_index(target);
        if (current_line < 0) {
            {
                char h[96];
                snprintf(h, sizeof(h), "No line %d in program. IF … THEN line must exist.", target);
                runtime_error_hint("Target line not found", h);
            }
            return;
        }
        statement_pos = NULL;
    } else {
        skip_spaces(p);
        statement_pos = *p;
    }
}

static void statement_else(char **p)
{
    if (if_depth <= 0) {
        runtime_error_hint("ELSE without IF", "ELSE belongs inside a block IF … THEN … ELSE … END IF.");
        return;
    }
    skip_spaces(p);
    if (if_stack[if_depth - 1].took_then) {
        skip_if_block_to_target(p, 0);
    }
}

static void statement_end_if(char **p)
{
    if (if_depth <= 0) {
        runtime_error_hint("END IF without matching IF", "Each END IF closes a block IF above it.");
        return;
    }
    skip_spaces(p);
    if_depth--;
}

/* Skip from FUNCTION to after matching END FUNCTION (top-level only). */
static void skip_function_block(char **p)
{
    int line = current_line;
    char *pos;
    int nesting = 1;

    *p += 8; /* past "FUNCTION" */
    while (**p && **p != ':') (*p)++;
    if (**p == ':') { (*p)++; skip_spaces(p); pos = *p; } else { line++; pos = NULL; }
    while (line >= 0 && line < line_count && program_lines[line]) {
        if (!pos) pos = program_lines[line]->text;
        while (pos && *pos) {
            char *q = pos;
            skip_spaces(&q);
            if (!*q) break;
            if ((toupper((unsigned char)q[0])=='F' && toupper((unsigned char)q[1])=='U' &&
                 toupper((unsigned char)q[2])=='N' && toupper((unsigned char)q[3])=='C' &&
                 toupper((unsigned char)q[4])=='T' && toupper((unsigned char)q[5])=='I' &&
                 toupper((unsigned char)q[6])=='O' && toupper((unsigned char)q[7])=='N') &&
                (q[8]=='\0' || q[8]==' ' || q[8]=='\t')) {
                nesting++;
                q += 8;
                while (*q && *q != ':') q++;
                pos = (*q == ':') ? q + 1 : q;
                continue;
            }
            if (toupper((unsigned char)q[0])=='E' && toupper((unsigned char)q[1])=='N' &&
                toupper((unsigned char)q[2])=='D' && (q[3]=='\0' || q[3]==' ' || q[3]=='\t')) {
                char *ef = q + 3;
                while (*ef == ' ' || *ef == '\t') ef++;
                if (toupper((unsigned char)ef[0])=='F' && toupper((unsigned char)ef[1])=='U' &&
                    toupper((unsigned char)ef[2])=='N' && toupper((unsigned char)ef[3])=='C' &&
                    toupper((unsigned char)ef[4])=='T' && toupper((unsigned char)ef[5])=='I' &&
                    toupper((unsigned char)ef[6])=='O' && toupper((unsigned char)ef[7])=='N' &&
                    (ef[8]=='\0' || ef[8]==' ' || ef[8]=='\t' || ef[8]==':')) {
                    nesting--;
                    if (nesting == 0) {
                        ef += 8;
                        skip_spaces(&ef);
                        current_line = line;
                        statement_pos = ef;
                        *p = ef;
                        return;
                    }
                    pos = ef + 8;
                    while (*pos && *pos != ':') pos++;
                    pos = (*pos == ':') ? pos + 1 : pos;
                    continue;
                }
            }
            pos = strchr(pos, ':');
            pos = pos ? pos + 1 : NULL;
        }
        line++;
        pos = NULL;
    }
    runtime_error_hint("END FUNCTION expected",
                         "Every FUNCTION … must end with END FUNCTION; check nesting and spelling.");
}

static void statement_end_function(char **p)
{
    if (udf_call_depth <= 0) {
        runtime_error_hint("END FUNCTION without FUNCTION",
                             "END FUNCTION only closes a FUNCTION block; remove stray END FUNCTION.");
        return;
    }
    skip_spaces(p);
    udf_return_value = make_num(0.0);
    udf_returned = 1;
    udf_call_depth--;
    current_line = udf_call_stack[udf_call_depth].saved_line;
    statement_pos = udf_call_stack[udf_call_depth].saved_pos;
}

static void statement_while(char **p, char *while_pos)
{
    int cond_true;

    cond_true = eval_condition(p);
    if (!cond_true) {
        skip_while_to_wend(p);
        return;
    }
    if (while_top >= MAX_WHILE_DEPTH) {
        runtime_error_hint("WHILE nesting too deep", "Reduce nested WHILE/WEND blocks.");
        return;
    }
    while_stack[while_top].line_index = current_line;
    while_stack[while_top].position = while_pos;
    while_top++;
}

static void statement_wend(char **p)
{
    if (while_top <= 0) {
        runtime_error_hint("WEND without WHILE", "Every WEND needs a matching WHILE above it.");
        return;
    }
    *p += 4;
    skip_spaces(p);
    {
        int idx = while_top - 1;
        current_line = while_stack[idx].line_index;
        statement_pos = while_stack[idx].position;
        while_top--;
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
        wasm_maybe_yield_loop();
#endif
    }
}

/* Skip forward from current position to after the matching LOOP. Handles nested DO/LOOP. */
static void skip_do_to_after_loop(char **p)
{
    int line = current_line;
    char *pos = *p;
    int nesting = 1;

    while (line >= 0 && line < line_count && program_lines[line]) {
        if (!pos) pos = program_lines[line]->text;
        while (pos && *pos) {
            char *q = pos;
            skip_spaces(&q);
            if (!*q) break;
            if (starts_with_kw(q, "DO")) {
                nesting++;
                q += 2;
                skip_spaces(&q);
                pos = q;
                continue;
            }
            if (starts_with_kw(q, "LOOP")) {
                char *r = q + 4;
                skip_spaces(&r);
                nesting--;
                if (nesting == 0) {
                    /* Skip past LOOP [UNTIL expr] */
                    if (starts_with_kw(r, "UNTIL")) {
                        r += 5;
                        skip_spaces(&r);
                        if (*r && *r != ':') {
                            struct value dummy = eval_expr(&r);
                            (void)dummy;
                        }
                    }
                    skip_spaces(&r);
                    if (!*r && line + 1 < line_count) {
                        current_line = line + 1;
                        statement_pos = program_lines[line + 1]->text;
                        *p = statement_pos;
                    } else {
                        current_line = line;
                        statement_pos = r;
                        *p = r;
                    }
                    return;
                }
                pos = r;
                continue;
            }
            pos = strchr(pos, ':');
            pos = pos ? pos + 1 : NULL;
        }
        line++;
        pos = NULL;
    }
    runtime_error_hint("LOOP expected", "DO … LOOP needs a matching LOOP (check nested DO/LOOP pairs).");
}

static void statement_do(char **p)
{
    skip_spaces(p);
    if (do_top >= MAX_DO_DEPTH) {
        runtime_error_hint("DO nesting too deep", "Reduce nested DO/LOOP blocks.");
        return;
    }
    do_stack[do_top].line_index = current_line;
    do_stack[do_top].position = *p;
    do_top++;
}

static void statement_loop(char **p)
{
    int cond_true = 0;
    int has_until = 0;

    if (do_top <= 0) {
        runtime_error_hint("LOOP without DO", "LOOP must follow DO on an outer block.");
        return;
    }
    skip_spaces(p);
    if (starts_with_kw(*p, "UNTIL")) {
        has_until = 1;
        *p += 5;
        skip_spaces(p);
        cond_true = eval_condition(p);
    }
    if (has_until && cond_true) {
        /* Exit loop: pop and continue after LOOP UNTIL expr */
        do_top--;
        skip_spaces(p);
        if (!**p && current_line + 1 < line_count) {
            current_line++;
            statement_pos = program_lines[current_line]->text;
            *p = statement_pos;
        }
        return;
    }
    /* Loop back to DO (do not pop - we will hit this LOOP again) */
    {
        int idx = do_top - 1;
        current_line = do_stack[idx].line_index;
        statement_pos = do_stack[idx].position;
        *p = statement_pos;
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
        wasm_maybe_yield_loop();
#endif
    }
}

static void statement_exit_do(char **p)
{
    if (do_top <= 0) {
        runtime_error_hint("EXIT without DO", "EXIT only exits the innermost DO … LOOP.");
        return;
    }
    do_top--;
    skip_do_to_after_loop(p);
}

static void statement_for(char **p)
{
    struct value *vp;
    struct value startv, endv, stepv;
    int is_array;
    int is_string;
    int i;
    char loop_name[VAR_NAME_MAX];
    vp = get_var_reference(p, &is_array, &is_string, loop_name);
    if (!vp) {
        return;
    }
    if (is_array) {
        runtime_error_hint("FOR variable must be scalar",
                             "Use a simple variable (e.g. I), not an array element.");
        return;
    }
    if (is_string) {
        runtime_error_hint("FOR variable must be numeric",
                             "FOR only works with numeric variables (not names ending in $).");
        return;
    }
    skip_spaces(p);
    if (**p != '=') {
        runtime_error_hint("Expected '=' in FOR", "Use FOR I = 1 TO 10 ( = after the variable).");
        return;
    }
    (*p)++;
    startv = eval_expr(p);
    ensure_num(&startv);
    skip_spaces(p);
    if (!starts_with_kw(*p, "TO")) {
        runtime_error_hint("Expected TO in FOR", "Use FOR var = start TO end [STEP n].");
        return;
    }
    *p += 2;
    endv = eval_expr(p);
    ensure_num(&endv);
    skip_spaces(p);
    if (starts_with_kw(*p, "STEP")) {
        *p += 4;
        stepv = eval_expr(p);
        ensure_num(&stepv);
    } else {
        stepv = make_num(1.0);
    }
    *vp = startv;

    /* FOR stack needs the normalized loop variable name for NEXT and duplicate-FOR cleanup. */
    strncpy(for_stack[for_top].name, loop_name, VAR_NAME_MAX - 1);
    for_stack[for_top].name[VAR_NAME_MAX - 1] = '\0';

    /* Abandon any outstanding FOR for the same control variable.
     * This models classic BASIC behaviour where jumping out of a loop
     * effectively discards it, so reusing the same variable does not
     * grow the FOR stack without bound.
     * Empty names must not match (nested FOR could otherwise collapse the stack).
     */
    if (for_stack[for_top].name[0] != '\0') {
        for (i = for_top - 1; i >= 0; i--) {
            if (for_stack[i].name[0] != '\0' &&
                strcmp(for_stack[i].name, for_stack[for_top].name) == 0) {
                for_top = i;
                break;
            }
        }
    }

    if (for_top >= MAX_FOR) {
        runtime_error_hint("FOR stack overflow", "Too many nested FOR loops; reduce nesting.");
        return;
    }
    for_stack[for_top].end_value = endv.num;
    for_stack[for_top].step = stepv.num;
    for_stack[for_top].line_index = current_line;
    for_stack[for_top].resume_pos = *p;
    for_stack[for_top].var = vp;
    for_stack[for_top].is_string = is_string;
    for_stack[for_top].gosub_depth_at_entry = gosub_top;
    for_top++;
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    if (wasm_canvas_debug_trace_for) {
        char tb[200];
        int bl = (current_line >= 0 && current_line < line_count && program_lines[current_line])
            ? program_lines[current_line]->number : -1;
        snprintf(tb, sizeof(tb),
            "[rgc-basic canvas] trace FOR push name=%s gosub_top=%d for_top=%d BASIC_line=%d var=%p",
            loop_name, gosub_top, for_top, bl, (void *)vp);
        wasm_canvas_debug_log_cstr(tb);
    }
#endif
}

/* Recover variable name from FOR stack var pointer (when frame name was empty). */
static int for_stack_var_name(const struct value *vp, char *out, size_t outsz)
{
    int j;
    if (!vp || !out || outsz < 2) {
        return 0;
    }
    for (j = 0; j < var_count; j++) {
        if (&vars[j].scalar == vp) {
            strncpy(out, vars[j].name, outsz - 1);
            out[outsz - 1] = '\0';
            return 1;
        }
        if (vars[j].is_array && vars[j].array &&
            vp >= vars[j].array && vp < vars[j].array + vars[j].size) {
            strncpy(out, vars[j].name, outsz - 1);
            out[outsz - 1] = '\0';
            return 1;
        }
    }
    return 0;
}

static void statement_next(char **p)
{
    char namebuf[VAR_NAME_MAX];
    char recovered[VAR_NAME_MAX];
    int i;
    struct value *vp;
    int is_string;
    skip_spaces(p);
    if (isalpha((unsigned char)**p)) {
        read_identifier(p, namebuf, sizeof(namebuf));
        uppercase_name(namebuf, namebuf, sizeof(namebuf), &is_string);
    } else {
        namebuf[0] = '\0';
    }
    for (i = for_top - 1; i >= 0; i--) {
        if (namebuf[0] == '\0') {
            break;
        }
        if (for_stack[i].name[0] != '\0') {
            if (strcmp(for_stack[i].name, namebuf) == 0) {
                break;
            }
            continue;
        }
        /* Older builds / edge cases: frame name empty but var pointer is valid. */
        if (for_stack_var_name(for_stack[i].var, recovered, sizeof(recovered)) &&
            strcmp(recovered, namebuf) == 0) {
            break;
        }
    }
    if (i < 0) {
        runtime_error_hint("NEXT without FOR",
                             "Every NEXT needs a matching FOR above; NEXT I pairs with FOR I = …");
        return;
    }
    for_top = i + 1;
    vp = for_stack[for_top - 1].var;
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    if (wasm_canvas_debug_trace_for) {
        char tb[240];
        int bl = (current_line >= 0 && current_line < line_count && program_lines[current_line])
            ? program_lines[current_line]->number : -1;
        snprintf(tb, sizeof(tb),
            "[rgc-basic canvas] trace NEXT name=%s slot=%d for_top=%d BASIC_line=%d vp=%p",
            namebuf[0] ? namebuf : "(implicit)", i, for_top, bl, (void *)vp);
        wasm_canvas_debug_log_cstr(tb);
    }
#endif
    if (!vp) {
        runtime_error_hint("Loop variable missing",
                           "FOR stack inconsistency; avoid GOTO into NEXT without a matching FOR.");
        return;
    }
    vp->num += for_stack[for_top - 1].step;
    if ((for_stack[for_top - 1].step >= 0 && vp->num <= for_stack[for_top - 1].end_value) ||
        (for_stack[for_top - 1].step < 0 && vp->num >= for_stack[for_top - 1].end_value)) {
        current_line = for_stack[for_top - 1].line_index;
        statement_pos = for_stack[for_top - 1].resume_pos;
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
        wasm_maybe_yield_loop();
#endif
    } else {
        for_top--;
    }
}

static void statement_dim(char **p)
{
    for (;;) {
        char namebuf[VAR_NAME_MAX];
        int is_string;
        int dims = 0;
        int dim_sizes[MAX_DIMS];
        int total_size = 1;
        struct var *v;
        struct value sizev;
        skip_spaces(p);
        if (!isalpha((unsigned char)**p)) {
            runtime_error_hint("Expected array name", "DIM needs a variable name: DIM A(10) or DIM A$(5).");
            return;
        }
        read_identifier(p, namebuf, sizeof(namebuf));
        uppercase_name(namebuf, namebuf, sizeof(namebuf), &is_string);
        if (is_reserved_word(namebuf)) {
            runtime_error_hint("Reserved word cannot be used as variable",
                                 "Pick another name; keywords like PRINT or FOR cannot be variable names.");
            return;
        }
        skip_spaces(p);
        if (**p != '(') {
            runtime_error_hint("DIM requires size", "Use parentheses for bounds: DIM A(9) for indices 0..9.");
            return;
        }
        (*p)++;
        for (;;) {
            if (dims >= MAX_DIMS) {
                runtime_error_hint("Too many dimensions",
                                   "At most 3 dimensions (e.g. DIM A(9,9,9)).");
                return;
            }
            sizev = eval_expr(p);
            ensure_num(&sizev);
            dim_sizes[dims] = (int)sizev.num + 1;
            if (dim_sizes[dims] <= 0) {
                runtime_error_hint("Invalid array size",
                                   "Sizes are upper bounds (0-based); use a non-negative size in DIM.");
                return;
            }
            dims++;
            skip_spaces(p);
            if (**p == ',') {
                (*p)++;
                continue;
            }
            break;
        }
        if (**p != ')') {
            runtime_error_hint("Missing ')'", "Close DIM subscripts: DIM A(10) or DIM M(2,3).");
            return;
        }
        (*p)++;
        /* Compute total size as product of dimensions. */
        {
            int d;
            for (d = 0; d < dims; d++) {
                total_size *= dim_sizes[d];
            }
        }
        v = find_or_create_var(namebuf, is_string, 1, dims, dim_sizes, total_size);
        (void)v;
        skip_spaces(p);
        if (**p == ',') {
            (*p)++;
            continue;
        }
        break;
    }
}

static void execute_statement(char **p)
{
    char c;
    skip_spaces(p);
    if (**p == '\0') {
        return;
    }
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    wasm_gfx_stmt_exec_budget++;
    /* Rare: tight FOR/NEXT (pause/resume test) must advance POKE every few ms when unpaused. */
    if ((wasm_gfx_stmt_exec_budget & 127u) == 0u) {
        wasm_browser_pause_point();
        if (!halted) {
            wasm_gfx_refresh_js();
            emscripten_sleep(0);
        }
    }
#endif
    /* Explicit PRINT# / INPUT# / GET# (allow optional space before #). */
    if ((*p)[0] != '\0' && toupper((unsigned char)(*p)[0]) == 'P' && toupper((unsigned char)(*p)[1]) == 'R' &&
        toupper((unsigned char)(*p)[2]) == 'I' && toupper((unsigned char)(*p)[3]) == 'N' &&
        toupper((unsigned char)(*p)[4]) == 'T') {
        char *q = *p + 5;
        while (*q == ' ' || *q == '\t') q++;
        if (*q == '#') {
            *p = q + 1;
            statement_print_hash(p);
            return;
        }
    }
    if (toupper((unsigned char)(*p)[0]) == 'I' && toupper((unsigned char)(*p)[1]) == 'N' &&
        toupper((unsigned char)(*p)[2]) == 'P' && toupper((unsigned char)(*p)[3]) == 'U' &&
        toupper((unsigned char)(*p)[4]) == 'T') {
        char *q = *p + 5;
        while (*q == ' ' || *q == '\t') q++;
        if (*q == '#') {
            *p = q + 1;
            statement_input_hash(p);
            return;
        }
    }
    if (toupper((unsigned char)(*p)[0]) == 'G' && toupper((unsigned char)(*p)[1]) == 'E' &&
        toupper((unsigned char)(*p)[2]) == 'T') {
        char *q = *p + 3;
        while (*q == ' ' || *q == '\t') q++;
        if (*q == '#') {
            *p = q + 1;
            statement_get_hash(p);
            return;
        }
    }
    c = toupper((unsigned char)**p);
    if (c == '\0') {
        return;
    }
    if (c == '\'') {
        statement_rem(p);
        return;
    }
    if (c == '?') {
        (*p)++;
        statement_print(p);
        return;
    }
    if (c == 'R') {
        if (starts_with_kw(*p, "REM")) {
            *p += 3;
            statement_rem(p);
            return;
        }
        if (starts_with_kw(*p, "READ")) {
            *p += 4;
            statement_read(p);
            return;
        }
        if (starts_with_kw(*p, "RESTORE")) {
            *p += 7;
            statement_restore(p);
            return;
        }
        if (starts_with_kw(*p, "RETURN")) {
            *p += 6;
            statement_return(p);
            return;
        }
    }
    if (c == 'O') {
        if (starts_with_kw(*p, "OPEN")) {
            *p += 4;
            statement_open(p);
            return;
        }
    }
    if (c == 'C') {
        if (starts_with_kw(*p, "CLOSE")) {
            *p += 5;
            statement_close(p);
            return;
        }
    }
    if (c == 'P') {
        /* PRINT# must be recognized (starts_with_kw allows '#' as terminator for PRINT). */
        if (starts_with_kw(*p, "PRINT")) {
            *p += 5;
            skip_spaces(p);
            if (**p == '#') {
                (*p)++;
                statement_print_hash(p);
                return;
            }
            statement_print(p);
            return;
        }
        if (starts_with_kw(*p, "POKE")) {
            *p += 4;
#ifdef GFX_VIDEO
            {
                struct value v_addr, v_val;
                v_addr = eval_expr(p);
                ensure_num(&v_addr);
                skip_spaces(p);
                if (**p == ',') (*p)++;
                v_val = eval_expr(p);
                ensure_num(&v_val);
                if (gfx_vs) {
                    gfx_poke(gfx_vs,
                             (uint16_t)((int)v_addr.num & 0xFFFF),
                             (uint8_t)((int)v_val.num & 0xFF));
                }
            }
#else
            *p += strlen(*p);
#endif
            return;
        }
        if (starts_with_kw(*p, "PRESET")) {
            *p += 6;
            statement_pset(p, 1);
            return;
        }
        if (starts_with_kw(*p, "PSET")) {
            *p += 4;
            statement_pset(p, 0);
            return;
        }
    }
    if (c == 'I' && starts_with_kw(*p, "INPUT")) {
        *p += 5;
        skip_spaces(p);
        if (**p == '#') {
            (*p)++;
            statement_input_hash(p);
            return;
        }
        statement_input(p);
        return;
    }
    if (c == 'L') {
        if (starts_with_kw(*p, "LINE")) {
            *p += 4;
            statement_line(p);
            return;
        }
        if (starts_with_kw(*p, "LOOP")) {
            *p += 4;
            statement_loop(p);
            return;
        }
        if (starts_with_kw(*p, "LET")) {
            *p += 3;
            statement_let(p);
            return;
        }
#ifdef GFX_VIDEO
        if (starts_with_kw(*p, "LOADSPRITE")) {
            *p += 10;
            statement_loadsprite(p);
            return;
        }
#endif
        if (starts_with_kw(*p, "LOAD")) {
            *p += 4;
            statement_load(p);
            return;
        }
    }
    if (c == 'M') {
        if (starts_with_kw(*p, "MEMSET")) {
            *p += 6;
            statement_memset(p);
            return;
        }
        if (starts_with_kw(*p, "MEMCPY")) {
            *p += 6;
            statement_memcpy(p);
            return;
        }
    }
    if (c == 'L' && starts_with_kw(*p, "LOCATE")) {
        *p += 6;
        statement_locate(p);
        return;
    }
    if (c == 'T' && starts_with_kw(*p, "TEXTAT")) {
        *p += 6;
        statement_textat(p);
        return;
    }
    if (c == 'G' && starts_with_kw(*p, "GET")) {
        *p += 3;
        skip_spaces(p);
        if (**p == '#') {
            (*p)++;
            statement_get_hash(p);
            return;
        }
        statement_get(p);
        return;
    }
    if (c == 'G' && starts_with_kw(*p, "GOTO")) {
        *p += 4;
        statement_goto(p);
        return;
    }
    if (c == 'G' && starts_with_kw(*p, "GOSUB")) {
        *p += 5;
        statement_gosub(p);
        return;
    }
    if (c == 'O' && starts_with_kw(*p, "ON")) {
        *p += 2;
        statement_on(p);
        return;
    }
    if (c == 'R' && starts_with_kw(*p, "RETURN")) {
        *p += 6;
        statement_return(p);
        return;
    }
    if (c == 'I' && starts_with_kw(*p, "IF")) {
        *p += 2;
        statement_if(p);
        return;
    }
    if (c == 'F' && starts_with_kw(*p, "FOR")) {
        *p += 3;
        statement_for(p);
        return;
    }
    if (c == 'N' && starts_with_kw(*p, "NEXT")) {
        *p += 4;
        statement_next(p);
        return;
    }
    if (c == 'W') {
        if (starts_with_kw(*p, "WHILE")) {
            char *while_pos = *p;
            *p += 5;
            skip_spaces(p);
            statement_while(p, while_pos);
            return;
        }
        if (starts_with_kw(*p, "WEND")) {
            statement_wend(p);
            return;
        }
    }
    if (c == 'D') {
#ifdef GFX_VIDEO
        if (starts_with_kw(*p, "DRAWSPRITETILE")) {
            *p += 14;
            statement_drawspritetile(p);
            return;
        }
        if (starts_with_kw(*p, "DRAWSPRITE")) {
            *p += 10;
            statement_drawsprite(p);
            return;
        }
#endif
        if (starts_with_kw(*p, "DO")) {
            *p += 2;
            statement_do(p);
            return;
        }
        /* DATA lines are non-executable (values were collected at load time). */
        if (starts_with_kw(*p, "DATA")) {
            *p += strlen(*p);
            return;
        }
        /* DIM arrays */
        if (starts_with_kw(*p, "DIM")) {
            *p += 3;
            statement_dim(p);
            return;
        }
        /* DEF FN user-defined function */
        {
            char *q;
            q = *p;
            if ((q[0] == 'D' || q[0] == 'd') &&
                (q[1] == 'E' || q[1] == 'e') &&
                (q[2] == 'F' || q[2] == 'f') &&
                (q[3] == '\0' || q[3] == ' ' || q[3] == '\t' || q[3] == '(' || q[3] == ':')) {
                *p += 3;
                statement_def(p);
                return;
            }
        }
    }
    if (c == 'S') {
#ifdef GFX_VIDEO
        if (starts_with_kw(*p, "SPRITEVISIBLE")) {
            *p += 13;
            statement_spritevisible(p);
            return;
        }
        if (starts_with_kw(*p, "SPRITEMODULATE")) {
            *p += 15;
            statement_spritemodulate(p);
            return;
        }
        if (starts_with_kw(*p, "SPRITEFRAME")) {
            *p += 11;
            statement_spriteframe(p);
            return;
        }
#endif
        if (starts_with_kw(*p, "SLEEP")) {
            *p += 5;
            statement_sleep(p);
            return;
        }
        if (starts_with_kw(*p, "SORT")) {
            *p += 4;
            statement_sort(p);
            return;
        }
        if (starts_with_kw(*p, "SPLIT")) {
            *p += 5;
            statement_split(p);
            return;
        }
    }
    if (c == 'J' && starts_with_kw(*p, "JOIN")) {
        *p += 4;
        statement_join(p);
        return;
    }
    if (c == 'U' && starts_with_kw(*p, "UNLOADSPRITE")) {
        *p += 13;
        statement_unloadsprite(p);
        return;
    }
    if (c == 'E') {
        if (starts_with_kw(*p, "EXIT")) {
            *p += 4;  /* consume EXIT */
            statement_exit_do(p);
            return;
        }
        if (starts_with_kw(*p, "ELSE")) {
            *p += 4;
            statement_else(p);
            return;
        }
        if (starts_with_kw(*p, "END")) {
            char *q = *p + 3;
            skip_spaces(&q);
            if (starts_with_kw(q, "IF")) {
                *p = q + 2;
                statement_end_if(p);
                return;
            }
            if (starts_with_kw(q, "FUNCTION")) {
                *p = q + 8;
                statement_end_function(p);
                return;
            }
            halted = 1;
            *p += strlen(*p);
            return;
        }
    }
    if (c == 'F') {
        if (starts_with_kw(*p, "FUNCTION") && ((*p)[8]=='\0' || (*p)[8]==' ' || (*p)[8]=='\t')) {
            skip_function_block(p);
            return;
        }
    }
    if (c == 'S' && starts_with_kw(*p, "STOP")) {
        halted = 1;
        *p += strlen(*p);
        return;
    }
    if (c == 'C') {
        if (starts_with_kw(*p, "CLR")) {
            *p += 3;
            statement_clr(p);
            return;
        }
        if (starts_with_kw(*p, "CURSOR")) {
            *p += 6;
            statement_cursor(p);
            return;
        }
        if (starts_with_kw(*p, "COLOR") || starts_with_kw(*p, "COLOUR")) {
            /* Accept both COLOR and COLOUR spellings. */
            if (toupper((unsigned char)(*p)[3]) == 'O' && toupper((unsigned char)(*p)[4]) == 'U') {
                *p += 6; /* COLOUR */
            } else {
                *p += 5; /* COLOR */
            }
            statement_color(p);
            return;
        }
    }
    if (c == 'B' && starts_with_kw(*p, "BACKGROUND")) {
        *p += 10;
        statement_background(p);
        return;
    }
    if (c == 'S' && starts_with_kw(*p, "SCREEN")) {
        *p += 6;
        statement_screen(p);
        return;
    }
    if (c == 'S' && starts_with_kw(*p, "SCROLL")) {
        *p += 6;
        statement_scroll(p);
        return;
    }
    if (c == 'S' && starts_with_kw(*p, "SCREENCODES")) {
        *p += 11;
        statement_screencodes(p);
        return;
    }
    if (isalpha((unsigned char)c)) {
        /* Check for "name(...)" as UDF or DEF FN call (statement form, discard return). */
        {
            char namebuf[VAR_NAME_MAX];
            char *q = *p;
            int arg_count, udf_idx, uf_index, i;
            read_identifier(&q, namebuf, sizeof(namebuf));
            for (i = 0; namebuf[i]; i++) namebuf[i] = (char)toupper((unsigned char)namebuf[i]);
            skip_spaces(&q);
            /* HTTP(url) statement — intrinsic, not UDF "HTTP" */
            if (strcmp(namebuf, "HTTP") == 0 && *q == '(') {
                struct value discard;
                char *ep = *p;
                discard = eval_function("HTTP$", &ep);
                (void)discard;
                *p = ep;
                return;
            }
            if (*q == '(') {
                struct value *args = (struct value *)calloc(MAX_UDF_PARAMS, sizeof(struct value));
                if (!args) {
                    runtime_error_hint("Out of memory",
                                         "Could not allocate argument list for the call.");
                    return;
                }
                char *saved_p = *p;
                *p = q + 1;
                skip_spaces(p);
                arg_count = 0;
                if (**p != ')') {
                    for (;;) {
                        if (arg_count >= MAX_UDF_PARAMS) {
                            free(args);
                            runtime_error_hint("Too many arguments",
                                                 "Reduce the number of arguments; split the call or use fewer parameters.");
                            return;
                        }
                        args[arg_count] = eval_expr(p);
                        arg_count++;
                        skip_spaces(p);
                        if (**p == ')') break;
                        if (**p != ',') {
                            free(args);
                            runtime_error_hint("Expected ',' or ')'",
                                                 "Separate arguments with commas: FOO(1, 2, 3).");
                            return;
                        }
                        (*p)++;
                        skip_spaces(p);
                    }
                }
                if (**p == ')') (*p)++;
                udf_idx = udf_lookup(namebuf, arg_count);
                if (udf_idx >= 0) {
                    (void)invoke_udf(udf_idx, args, arg_count);
                    free(args);
                    return;
                }
                if (arg_count == 1) {
                    uf_index = user_func_lookup(namebuf);
                    if (uf_index >= 0) {
                        struct user_func *uf = &user_funcs[uf_index];
                        struct var *param_var;
                        struct value saved_scalar;
                        char pname_buf[VAR_NAME_MAX];
                        strncpy(pname_buf, uf->param_name, sizeof(pname_buf) - 1);
                        pname_buf[sizeof(pname_buf) - 1] = '\0';
                        param_var = find_or_create_var(pname_buf, uf->param_is_string, 0, 0, NULL, 0);
                        if (param_var) {
                            saved_scalar = param_var->scalar;
                            if (uf->param_is_string) {
                                ensure_str(&args[0]);
                                param_var->scalar = args[0];
                                param_var->scalar.type = VAL_STR;
                            } else {
                                ensure_num(&args[0]);
                                param_var->scalar = args[0];
                                param_var->scalar.type = VAL_NUM;
                            }
                            { char *body_p = uf->body; (void)eval_expr(&body_p); }
                            param_var->scalar = saved_scalar;
                        }
                        free(args);
                        return;
                    }
                }
                /* No match; restore and fall through to implicit LET */
                free(args);
                *p = saved_p;
            }
        }
        /* Fallback: treat as implicit LET (assignment). */
        statement_let(p);
        return;
    }
    /* As a last resort, treat unknown leading tokens as a no-op for this
     * statement, skipping to the end of the line. This avoids spurious
     * "Unknown statement" errors on otherwise valid programs that use
     * extended syntax we don't fully recognize yet.
     */
    *p += strlen(*p);
}

static void sort_program(void)
{
    int i, j;
    for (i = 0; i < line_count; i++) {
        for (j = i + 1; j < line_count; j++) {
            if (program_lines[j]->number < program_lines[i]->number) {
                struct line *tmp;
                tmp = program_lines[i];
                program_lines[i] = program_lines[j];
                program_lines[j] = tmp;
            }
        }
    }
}

static int find_line_index(int number)
{
    int i;
    for (i = 0; i < line_count; i++) {
        if (program_lines[i] && program_lines[i]->number == number) {
            return i;
        }
    }
    return -1;
}

static void add_or_replace_line(int number, const char *text)
{
    int i;
    for (i = 0; i < line_count; i++) {
        if (program_lines[i] && program_lines[i]->number == number) {
            if (program_lines[i]->text) {
                free(program_lines[i]->text);
            }
            program_lines[i]->text = dupstr_local(text);
            return;
        }
    }
    if (line_count >= MAX_LINES) {
        runtime_error_hint("Program too large",
                             "Too many program lines for the built-in limit; split into includes or shorten.");
        return;
    }
    program_lines[line_count] = (struct line *)malloc(sizeof(struct line));
    if (!program_lines[line_count]) {
        runtime_error_hint("Out of memory",
                             "Could not allocate program line storage; free memory or shorten the program.");
        return;
    }
    program_lines[line_count]->number = number;
    program_lines[line_count]->text = dupstr_local(text);
    line_count++;
}

/* Add line from included file; error if line number already exists. */
static void add_line_from_include(int number, const char *text)
{
    int i;
    for (i = 0; i < line_count; i++) {
        if (program_lines[i] && program_lines[i]->number == number) {
            fprintf(stderr, "Duplicate line number %d in include\n", number);
            fprintf(stderr, "  Hint: Renumber lines in the include or main file so each line number is unique.\n");
            exit(1);
        }
    }
    add_or_replace_line(number, text);
}

/* Get directory part of path. Returns "." if no directory. Writes to static buffer. */
static const char *get_base_dir(const char *path)
{
    static char dirbuf[MAX_INCLUDE_PATH];
    const char *last;
    last = strrchr(path, '/');
#if defined(_WIN32)
    {
        const char *b = strrchr(path, '\\');
        if (b && (!last || b > last)) last = b;
    }
#endif
    if (!last || last == path) {
        return ".";
    }
    if ((size_t)(last - path + 1) >= sizeof(dirbuf)) {
        return ".";
    }
    memcpy(dirbuf, path, (size_t)(last - path));
    dirbuf[last - path] = '\0';
    return dirbuf;
}

/* Resolve include path relative to base_dir. Writes to static buffer. */
static const char *resolve_include_path(const char *base_dir, const char *rel_path)
{
    static char buf[MAX_INCLUDE_PATH];
    if (!base_dir || !rel_path) return rel_path;
    if (strcmp(base_dir, ".") == 0) {
        if (strlen(rel_path) >= sizeof(buf)) return NULL;
        strncpy(buf, rel_path, sizeof(buf) - 1);
        buf[sizeof(buf) - 1] = '\0';
        return buf;
    }
    if (strlen(base_dir) + 1 + strlen(rel_path) >= sizeof(buf)) return NULL;
    snprintf(buf, sizeof(buf), "%s/%s", base_dir, rel_path);
    return buf;
}

static char loading_paths[MAX_INCLUDE_DEPTH][MAX_INCLUDE_PATH];
static int loading_count = 0;

/* Read one logical line (to \n, \r\n, or EOF). Returns 1 with *out_line malloc'd, or 0 at EOF. */
static int read_source_line(FILE *f, const char *path_for_err, char **out_line)
{
    StrBuf sb;
    int c;

    sb_init(&sb);
    for (;;) {
        c = fgetc(f);
        if (c == EOF) {
            if (sb.len == 0) {
                free(sb.buf);
                *out_line = NULL;
                return 0;
            }
            break;
        }
        if (c == '\n') {
            break;
        }
        if (c == '\r') {
            {
                int c2 = fgetc(f);
                if (c2 != '\n' && c2 != EOF) {
                    ungetc(c2, f);
                }
            }
            break;
        }
        if (sb.len >= (size_t)(MAX_LINE_LEN_LOAD - 1)) {
            free(sb.buf);
            fprintf(stderr, "Program line too long (max %d bytes) in %s\n",
                MAX_LINE_LEN_LOAD - 1, path_for_err ? path_for_err : "?");
            fprintf(stderr, "  Hint: Split the line or move data into shorter lines / includes.\n");
            exit(1);
        }
        sb_append_char(&sb, (char)c);
    }
    *out_line = sb.buf;
    return 1;
}

/* Load a file into the program, with directive processing. Recursive for #INCLUDE. */
static void load_file_into_program(const char *path, const char *base_dir, int include_depth,
    int *use_explicit_numbers, int *auto_line_no, int *first_line_seen)
{
    FILE *f;
    char *linebuf;
    char *p;
    int number;
    const char *resolved;
    int i;

    if (include_depth >= MAX_INCLUDE_DEPTH) {
        fprintf(stderr, "Include nesting too deep: %s\n", path);
        fprintf(stderr, "  Hint: Flatten includes or reduce #INCLUDE depth (max %d).\n", MAX_INCLUDE_DEPTH);
        exit(1);
    }
    /* Circular include: check if we're already loading this path. */
    for (i = 0; i < loading_count; i++) {
        if (strcmp(loading_paths[i], path) == 0) {
            fprintf(stderr, "Circular include: %s\n", path);
            fprintf(stderr, "  Hint: Remove a file that includes itself (directly or indirectly).\n");
            exit(1);
        }
    }
    if (loading_count >= MAX_INCLUDE_DEPTH || strlen(path) >= MAX_INCLUDE_PATH) {
        fprintf(stderr, "Include error: %s\n", path);
        fprintf(stderr, "  Hint: Shorten the path or reduce include stack depth.\n");
        exit(1);
    }
    strncpy(loading_paths[loading_count], path, MAX_INCLUDE_PATH - 1);
    loading_paths[loading_count][MAX_INCLUDE_PATH - 1] = '\0';
    loading_count++;

    f = fopen(path, "r");
    if (!f) {
        fprintf(stderr, "Cannot open %s\n", path);
        fprintf(stderr, "  Hint: Check the path, current directory, and read permissions.\n");
        exit(1);
    }

    while (read_source_line(f, path, &linebuf)) {
        p = linebuf;
        while (*p == ' ' || *p == '\t') p++;
        if ((unsigned char)p[0] == 0xef && (unsigned char)p[1] == 0xbb && (unsigned char)p[2] == 0xbf)
            p += 3;
        if (*p == '\0') {
            free(linebuf);
            continue;
        }

        /* "10 #OPTION ..." / "20 #INCLUDE ..." pasted in canvas (numberless program):
         * without this, load fails or #OPTION is skipped and charset stays wrong. */
        {
            char *scan = p;
            if (isdigit((unsigned char)*scan)) {
                while (isdigit((unsigned char)*scan)) {
                    scan++;
                }
                if (*scan == ' ' || *scan == '\t') {
                    while (*scan == ' ' || *scan == '\t') {
                        scan++;
                    }
                    if (*scan == '#') {
                        char *dir = scan + 1;
                        while (*dir == ' ' || *dir == '\t') {
                            dir++;
                        }
                        if ((toupper((unsigned char)dir[0]) == 'O' && toupper((unsigned char)dir[1]) == 'P' &&
                             toupper((unsigned char)dir[2]) == 'T' && toupper((unsigned char)dir[3]) == 'I' &&
                             toupper((unsigned char)dir[4]) == 'O' && toupper((unsigned char)dir[5]) == 'N') &&
                            (dir[6] == '\0' || dir[6] == ' ' || dir[6] == '\t')) {
                            p = scan;
                        } else if ((toupper((unsigned char)dir[0]) == 'I' && toupper((unsigned char)dir[1]) == 'N' &&
                                    toupper((unsigned char)dir[2]) == 'C' && toupper((unsigned char)dir[3]) == 'L' &&
                                    toupper((unsigned char)dir[4]) == 'U' && toupper((unsigned char)dir[5]) == 'D' &&
                                    toupper((unsigned char)dir[6]) == 'E') &&
                                   (dir[7] == '\0' || dir[7] == ' ' || dir[7] == '\t')) {
                            p = scan;
                        }
                    }
                }
            }
        }

        /* Shebang: first line of first file only */
        if (!*first_line_seen && p[0] == '#' && p[1] == '!') {
            *first_line_seen = 1;
            free(linebuf);
            continue;
        }

        /* Meta directives: #OPTION, #INCLUDE */
        if (p[0] == '#') {
            *first_line_seen = 1;
            p++;
            while (*p == ' ' || *p == '\t') p++;
            if ((toupper((unsigned char)p[0])=='O' && toupper((unsigned char)p[1])=='P' && toupper((unsigned char)p[2])=='T' && toupper((unsigned char)p[3])=='I' && toupper((unsigned char)p[4])=='O' && toupper((unsigned char)p[5])=='N') && (p[6]=='\0' || p[6]==' ' || p[6]=='\t')) {
                char opt_name[64], opt_val[64];
                char *q;
                p += 6;
                while (*p == ' ' || *p == '\t') p++;
                q = opt_name;
                while (*p && *p != ' ' && *p != '\t' && (size_t)(q - opt_name) < sizeof(opt_name) - 1)
                    *q++ = (char)*p++;
                *q = '\0';
                while (*p == ' ' || *p == '\t') p++;
                q = opt_val;
                while (*p && (size_t)(q - opt_val) < sizeof(opt_val) - 1) *q++ = (char)*p++;
                *q = '\0';
                while (q > opt_val && (q[-1] == ' ' || q[-1] == '\t')) *--q = '\0';
                if (apply_option_directive(opt_name, opt_val[0] ? opt_val : NULL) != 0) {
                    fprintf(stderr, "Unknown or invalid #OPTION: %s %s\n", opt_name, opt_val);
                    fprintf(stderr, "  Hint: See #OPTION names in docs (e.g. columns, charset) and values.\n");
                    free(linebuf);
                    exit(1);
                }
                free(linebuf);
                continue;
            }
            if ((toupper((unsigned char)p[0])=='I' && toupper((unsigned char)p[1])=='N' && toupper((unsigned char)p[2])=='C' && toupper((unsigned char)p[3])=='L' && toupper((unsigned char)p[4])=='U' && toupper((unsigned char)p[5])=='D' && toupper((unsigned char)p[6])=='E') && (p[7]=='\0' || p[7]==' ' || p[7]=='\t')) {
                char inc_file[MAX_INCLUDE_PATH];
                p += 7;
                while (*p == ' ' || *p == '\t') p++;
                if (*p != '"' && *p != '\'') {
                    fprintf(stderr, "Expected quoted path in #INCLUDE\n");
                    fprintf(stderr, "  Hint: Use #INCLUDE \"file.bas\" or #INCLUDE 'file.bas'.\n");
                    free(linebuf);
                    exit(1);
                }
                {
                    char quote = *p++;
                    char *q = inc_file;
                    while (*p && *p != quote && (size_t)(q - inc_file) < sizeof(inc_file) - 1)
                        *q++ = (char)*p++;
                    *q = '\0';
                    if (*p) p++;
                }
                resolved = resolve_include_path(base_dir, inc_file);
                if (!resolved) {
                    fprintf(stderr, "Include path too long\n");
                    fprintf(stderr, "  Hint: Shorten directory names or move files closer to the project root.\n");
                    exit(1);
                }
                if (strlen(resolved) >= MAX_INCLUDE_PATH) {
                    fprintf(stderr, "Include path too long\n");
                    fprintf(stderr, "  Hint: Shorten directory names or move files closer to the project root.\n");
                    exit(1);
                }
                /* Store resolved path so it survives the recursive call. */
                strncpy(include_path_store[MAX_INCLUDE_DEPTH - 1], resolved, MAX_INCLUDE_PATH - 1);
                include_path_store[MAX_INCLUDE_DEPTH - 1][MAX_INCLUDE_PATH - 1] = '\0';
                load_file_into_program(include_path_store[MAX_INCLUDE_DEPTH - 1], get_base_dir(include_path_store[MAX_INCLUDE_DEPTH - 1]), include_depth + 1,
                    use_explicit_numbers, auto_line_no, first_line_seen);
                free(linebuf);
                continue;
            }
            fprintf(stderr, "Unknown directive: #%.*s\n", 60, p);
            fprintf(stderr, "  Hint: Supported meta lines are #OPTION and #INCLUDE (see docs).\n");
            free(linebuf);
            exit(1);
        }

        *first_line_seen = 1;

        if (*use_explicit_numbers == -1) {
            *use_explicit_numbers = isdigit((unsigned char)*p) ? 1 : 0;
        }

        if (*use_explicit_numbers == 1) {
            char *transformed;
            if (!isdigit((unsigned char)*p)) {
                fprintf(stderr, "Line missing number: %s\n", linebuf);
                fprintf(stderr, "  Hint: Numbered programs need a line number at the start (e.g. 10 PRINT ...).\n");
                free(linebuf);
                exit(1);
            }
            number = atoi(p);
            while (*p && !isspace((unsigned char)*p)) p++;
            while (*p == ' ' || *p == '\t') p++;
            /* Numbered line may be just a directive, e.g. "2 #OPTION columns 80" */
            if (*p == '#') {
                char *dir = p + 1;
                while (*dir == ' ' || *dir == '\t') dir++;
                if ((toupper((unsigned char)dir[0])=='O' && toupper((unsigned char)dir[1])=='P' && toupper((unsigned char)dir[2])=='T' && toupper((unsigned char)dir[3])=='I' && toupper((unsigned char)dir[4])=='O' && toupper((unsigned char)dir[5])=='N') && (dir[6]=='\0' || dir[6]==' ' || dir[6]=='\t')) {
                    char opt_name[64], opt_val[64];
                    char *q;
                    dir += 6;
                    while (*dir == ' ' || *dir == '\t') dir++;
                    q = opt_name;
                    while (*dir && *dir != ' ' && *dir != '\t' && (size_t)(q - opt_name) < sizeof(opt_name) - 1)
                        *q++ = (char)*dir++;
                    *q = '\0';
                    while (*dir == ' ' || *dir == '\t') dir++;
                    q = opt_val;
                    while (*dir && (size_t)(q - opt_val) < sizeof(opt_val) - 1) *q++ = (char)*dir++;
                    *q = '\0';
                    while (q > opt_val && (q[-1] == ' ' || q[-1] == '\t')) *--q = '\0';
                    if (apply_option_directive(opt_name, opt_val[0] ? opt_val : NULL) != 0) {
                        fprintf(stderr, "Unknown or invalid #OPTION: %s %s\n", opt_name, opt_val);
                        fprintf(stderr, "  Hint: See #OPTION names in docs (e.g. columns, charset) and values.\n");
                        free(linebuf);
                        exit(1);
                    }
                    free(linebuf);
                    continue;
                }
                if ((toupper((unsigned char)dir[0])=='I' && toupper((unsigned char)dir[1])=='N' && toupper((unsigned char)dir[2])=='C' && toupper((unsigned char)dir[3])=='L' && toupper((unsigned char)dir[4])=='U' && toupper((unsigned char)dir[5])=='D' && toupper((unsigned char)dir[6])=='E') && (dir[7]=='\0' || dir[7]==' ' || dir[7]=='\t')) {
                    fprintf(stderr, "#INCLUDE on numbered line not supported\n");
                    fprintf(stderr, "  Hint: Put #INCLUDE on its own unnumbered line at the top, or use numberless mode.\n");
                    free(linebuf);
                    exit(1);
                }
            }
            transformed = transform_basic_line(p);
            {
                char *normalized = normalize_keywords_line(transformed);
                if (include_depth > 0) add_line_from_include(number, normalized);
                else add_or_replace_line(number, normalized);
                free(normalized);
            }
            free(transformed);
        } else {
            if (isdigit((unsigned char)*p)) {
                fprintf(stderr, "Mixed numbered and numberless lines are not supported: %s\n", linebuf);
                fprintf(stderr, "  Hint: Use all numbered lines or all numberless lines in one file.\n");
                free(linebuf);
                exit(1);
            }
            number = *auto_line_no;
            *auto_line_no += 10;
            {
                char *transformed = transform_basic_line(p);
                char *normalized = normalize_keywords_line(transformed);
                add_or_replace_line(number, normalized);
                free(normalized);
                free(transformed);
            }
        }
        free(linebuf);
    }
    fclose(f);
    loading_count--;
}

static void load_program(const char *path)
{
    int auto_line_no = 10;
    int use_explicit_numbers = -1;
    int first_line_seen = 0;
    const char *base_dir = get_base_dir(path);

#ifdef GFX_VIDEO
    /* Each load starts from CLI memory map; #OPTION in file overrides. */
    gfx_mem_bases_restore_from_init();
    gfx_mem_bases_apply_to_video();
#endif
    /* Restore charset from CLI baseline; #OPTION in file overrides during parse. */
    petscii_lowercase_opt = petscii_lowercase_cli;
    charrom_family_opt = charrom_family_cli;
    petscii_set_lowercase(petscii_lowercase_opt);
#ifdef GFX_VIDEO
    if (gfx_vs) {
        gfx_vs->charset_lowercase = (uint8_t)(petscii_lowercase_opt ? 1 : 0);
        gfx_vs->charrom_family = (uint8_t)(charrom_family_opt ? 1 : 0);
        gfx_load_default_charrom(gfx_vs);
    }
#if defined(__EMSCRIPTEN__)
    wasm_canvas_sync_charset_from_options();
#endif
#endif

    load_file_into_program(path, base_dir, 0,
        &use_explicit_numbers, &auto_line_no, &first_line_seen);

    sort_program();
    collect_data_from_program();
    build_label_table();
    build_udf_table();

#ifdef GFX_VIDEO
    /* #OPTION columns may run during load after basic_set_video(); keep gfx in sync. */
    if (gfx_vs) {
        gfx_vs->cols = (print_width >= 80) ? 80 : 40;
    }
    gfx_set_sprite_base_dir(base_dir);
#endif
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    /* Canvas JS resizes framebuffer from this after #OPTION columns in file. */
    EM_ASM({
        if (typeof Module !== 'undefined') {
            Module['wasmGfxFbW'] = $0;
            Module['wasmGfxFbH'] = 200;
            Module['wasmGfxBorderPx'] = $1;
            Module['wasmGfxBorderColorIdx'] = $2;
        }
    },
        (print_width >= 80) ? 640 : 320,
        basic_get_gfx_border(),
        basic_get_gfx_border_color());
#endif
}

static void run_program(const char *script_path_arg, int nargs, char **args)
{
#if defined(__EMSCRIPTEN__)
    int wasm_stmt_budget = 0;
#endif
    /* Fresh run: same effect as CLR so prior RUN does not leave variables (browser re-RUN, etc.). */
    basic_clr_memory();
#if defined(__EMSCRIPTEN__)
    EM_ASM({
        if (typeof Module !== 'undefined') {
            Module['wasmStopRequested'] = 0;
            Module['wasmPaused'] = 0;
        }
    });
#endif
    script_path = script_path_arg;
    script_argc = nargs;
    script_argv = args;
    halted = 0;
    current_line = 0;
    statement_pos = NULL;
    print_col = 0;
#if defined(__EMSCRIPTEN__) && defined(GFX_VIDEO)
    wasm_gfx_put_budget = 0;
    wasm_gfx_stmt_exec_budget = 0;
    wasm_str_builtin_budget = 0;
    wasm_str_concat_budget = 0;
#endif
#ifdef GFX_VIDEO
    if (gfx_vs) {
        gfx_x = 0;
        gfx_y = 0;
    }
#endif
    for_top = 0;
    while_top = 0;
    do_top = 0;
    if_depth = 0;
    while (!halted && current_line >= 0 && current_line < line_count) {
        char *p;
#if defined(__EMSCRIPTEN__)
        wasm_browser_pause_point();
        if (halted) {
            break;
        }
        if (EM_ASM_INT({ return (typeof Module !== 'undefined' && Module['wasmStopRequested']) ? 1 : 0; })) {
            halted = 1;
            break;
        }
#endif
        if (statement_pos == NULL) {
            statement_pos = program_lines[current_line]->text;
        }
        p = statement_pos;
        skip_spaces(&p);
        if (*p == '\0') {
            current_line++;
            statement_pos = NULL;
            continue;
        }
        statement_pos = p;
        execute_statement(&statement_pos);
#if defined(__EMSCRIPTEN__)
        wasm_stmt_budget++;
#if defined(GFX_VIDEO)
        /* Compound lines (trek.bas): yield without slowing full suite too much. */
        if ((wasm_stmt_budget & 31) == 0) {
            wasm_browser_pause_point();
            if (halted) {
                break;
            }
            wasm_gfx_refresh_js();
            emscripten_sleep(0);
        }
#else
        if ((wasm_stmt_budget & 2047) == 0) {
            wasm_browser_pause_point();
            if (halted) {
                break;
            }
            emscripten_sleep(0);
        }
#endif
#endif
        if (halted) {
            break;
        }
        if (statement_pos == NULL) {
            continue;
        }
        skip_spaces(&statement_pos);
        if (*statement_pos == ':') {
            statement_pos++;
            continue;
        }
        skip_spaces(&statement_pos);
        if (*statement_pos == '\0') {
            current_line++;
            statement_pos = NULL;
        }
    }
    /* Close any files left open when program ends. */
    {
        int lfn;
        for (lfn = 1; lfn < 256; lfn++) {
            if (open_files[lfn]) {
                fclose(open_files[lfn]);
                open_files[lfn] = NULL;
            }
        }
    }
}

/* ── Public API for gfx builds ──────────────────────────────────── */

/* Parse interpreter flags starting at argv[start] (use start=1 for normal argv).
 * If expect_program_path is non-zero, the first non-option argument is the .bas path
 * and its index is returned. If zero (browser), trailing non-options are an error;
 * return 0 on success, -1 on error. */
int basic_parse_arg_flags(int argc, char **argv, int start, int expect_program_path)
{
    int i;
    init_console_ansi();
    for (i = start; i < argc; i++) {
        if (strcmp(argv[i], "-petscii") == 0 || strcmp(argv[i], "--petscii") == 0) {
            petscii_mode = 1;
            petscii_plain = 0;
            petscii_no_wrap = 1;
        } else if (strcmp(argv[i], "-petscii-plain") == 0 || strcmp(argv[i], "--petscii-plain") == 0) {
            petscii_mode = 1;
            petscii_plain = 1;
            petscii_no_wrap = 1;
        } else if (strcmp(argv[i], "-charset") == 0) {
            const char *name;
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -charset\n");
                return -1;
            }
            name = argv[++i];
            if (strcmp(name, "upper") == 0 || strcmp(name, "uc") == 0 || strcmp(name, "upper-graphics") == 0
                || strcmp(name, "c64-upper") == 0 || strcmp(name, "c64-uppercase") == 0) {
                charrom_family_opt = 0;
                charrom_family_cli = 0;
                petscii_lowercase_opt = 0;
                petscii_lowercase_cli = 0;
                petscii_set_lowercase(0);
            } else if (strcmp(name, "lower") == 0 || strcmp(name, "lc") == 0 || strcmp(name, "lowercase") == 0
                || strcmp(name, "c64-lower") == 0 || strcmp(name, "c64-lowercase") == 0) {
                charrom_family_opt = 0;
                charrom_family_cli = 0;
                petscii_lowercase_opt = 1;
                petscii_lowercase_cli = 1;
                petscii_set_lowercase(1);
            } else if (strcmp(name, "pet-upper") == 0 || strcmp(name, "pet-uppercase") == 0
                || strcmp(name, "pet-graphics") == 0) {
                charrom_family_opt = 1;
                charrom_family_cli = 1;
                petscii_lowercase_opt = 0;
                petscii_lowercase_cli = 0;
                petscii_set_lowercase(0);
            } else if (strcmp(name, "pet-lower") == 0 || strcmp(name, "pet-lowercase") == 0
                || strcmp(name, "pet-text") == 0) {
                charrom_family_opt = 1;
                charrom_family_cli = 1;
                petscii_lowercase_opt = 1;
                petscii_lowercase_cli = 1;
                petscii_set_lowercase(1);
            } else {
                fprintf(stderr,
                    "Unknown charset '%s' (expected upper|lower, c64-upper|c64-lower, pet-upper|pet-lower, …)\n",
                    name);
                return -1;
            }
        } else if (strcmp(argv[i], "-palette") == 0) {
            const char *name;
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -palette\n");
                return -1;
            }
            name = argv[++i];
            if (strcmp(name, "ansi") == 0) {
                palette_mode = PALETTE_ANSI;
            } else if (strcmp(name, "c64") == 0 || strcmp(name, "c64-8bit") == 0) {
                palette_mode = PALETTE_C64_8BIT;
            } else {
                fprintf(stderr, "Unknown palette '%s' (expected ansi or c64)\n", name);
                return -1;
            }
        } else if (strcmp(argv[i], "-maxstr") == 0 || strcmp(argv[i], "--maxstr") == 0) {
            int n;
            char *end;
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -maxstr\n");
                return -1;
            }
            n = (int)strtol(argv[++i], &end, 10);
            if (end == argv[i] || *end != '\0' || n < 1 || n > MAX_STR_LEN) {
                fprintf(stderr, "Invalid -maxstr value (expected 1..%d)\n", MAX_STR_LEN);
                return -1;
            }
            max_str_limit = n;
        } else if (strcmp(argv[i], "-columns") == 0 || strcmp(argv[i], "--columns") == 0) {
            int n;
            char *end;
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -columns\n");
                return -1;
            }
            n = (int)strtol(argv[++i], &end, 10);
            if (end == argv[i] || *end != '\0' || n < 1 || n > 255) {
                fprintf(stderr, "Invalid -columns value (expected 1..255)\n");
                return -1;
            }
            print_width = n;
        } else if (strcmp(argv[i], "-nowrap") == 0 || strcmp(argv[i], "--nowrap") == 0) {
            terminal_no_wrap = 1;
#ifdef GFX_VIDEO
        } else if (strcmp(argv[i], "-gfx-title") == 0 || strcmp(argv[i], "--gfx-title") == 0) {
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -gfx-title\n");
                return -1;
            }
            basic_set_gfx_window_title(argv[++i]);
        } else if (strcmp(argv[i], "-gfx-border") == 0 || strcmp(argv[i], "--gfx-border") == 0) {
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -gfx-border\n");
                return -1;
            }
            {
                const char *val = argv[++i];
                if (apply_option_directive("border", val) != 0) {
                    fprintf(stderr, "Invalid -gfx-border value (e.g. 24 or 24 cyan)\n");
                    return -1;
                }
            }
        } else if (strcmp(argv[i], "-memory") == 0 || strcmp(argv[i], "--memory") == 0) {
            const char *preset;
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -memory\n");
                fprintf(stderr, "  Hint: Use c64, pet, or default.\n");
                return -1;
            }
            preset = argv[++i];
            if (gfx_mem_try_preset(preset) != 0) {
                fprintf(stderr, "Unknown -memory preset '%s' (expected c64, pet, or default)\n", preset);
                return -1;
            }
#endif
        } else if (argv[i][0] == '-') {
            fprintf(stderr, "Unknown option: %s\n", argv[i]);
            return -1;
        } else if (expect_program_path) {
#ifdef GFX_VIDEO
            gfx_mem_snapshot_init();
#endif
            return i;   /* index of the .bas path */
        } else {
            fprintf(stderr, "Unexpected argument: %s\n", argv[i]);
            return -1;
        }
    }
#ifdef GFX_VIDEO
    if (!expect_program_path) {
        gfx_mem_snapshot_init();
    }
#endif
    return expect_program_path ? -1 : 0;
}

int basic_parse_args(int argc, char **argv)
{
    return basic_parse_arg_flags(argc, argv, 1, 1);
}

void basic_load(const char *path) { load_program(path); }

void basic_run(const char *script_path_arg, int nargs, char **args)
{
    run_program(script_path_arg, nargs, args);
}

int basic_halted(void) { return halted; }

#ifdef GFX_VIDEO
void basic_set_video(GfxVideoState *vs) {
    gfx_vs = vs;
    if (vs) {
        vs->cols = (print_width >= 80) ? 80 : 40;
        vs->bitmap_fg = gfx_fg;
        vs->charrom_family = (uint8_t)(charrom_family_opt ? 1 : 0);
        (void)gfx_video_set_memory_bases(vs,
            gfx_mem_base_text, gfx_mem_base_color, gfx_mem_base_char,
            gfx_mem_base_key, gfx_mem_base_bitmap);
#if defined(__EMSCRIPTEN__)
        /* #OPTION charset runs during load before wasm_gfx_set_video(); sync ROM when
         * video attaches so PETSCII space (sc 32) matches the selected charset. */
        wasm_canvas_sync_charset_from_options();
#endif
    }
}

int basic_get_charrom_family(void)
{
    return charrom_family_opt ? 1 : 0;
}

static char gfx_window_title[128];

void basic_set_gfx_window_title(const char *title)
{
    if (!title || !title[0]) {
        gfx_window_title[0] = '\0';
        return;
    }
    strncpy(gfx_window_title, title, sizeof(gfx_window_title) - 1);
    gfx_window_title[sizeof(gfx_window_title) - 1] = '\0';
}

const char *basic_get_gfx_window_title(void)
{
    return gfx_window_title[0] ? gfx_window_title : NULL;
}

static int gfx_border_pixels = 0;
static int gfx_border_color = -1;  /* -1 = use background colour */

void basic_set_gfx_border(int pixels)
{
    if (pixels < 0) pixels = 0;
    if (pixels > 256) pixels = 256;
    gfx_border_pixels = pixels;
}

int basic_get_gfx_border(void)
{
    return gfx_border_pixels;
}

void basic_set_gfx_border_color(int idx)
{
    gfx_border_color = (idx >= 0 && idx <= 15) ? idx : -1;
}

int basic_get_gfx_border_color(void)
{
    return gfx_border_color;
}

#if defined(__EMSCRIPTEN__)
/* Browser canvas: shared video + RGBA framebuffer for JS rAF (Asyncify-safe). */
#define WASM_GFX_RGBA_BYTES (640u * 200u * 4u)
static GfxVideoState wasm_gfx_state;
static uint8_t wasm_gfx_rgba[WASM_GFX_RGBA_BYTES];
static volatile uint32_t wasm_gfx_rgba_version;

static void wasm_gfx_refresh_js(void)
{
    if (!gfx_vs) {
        return;
    }
    EM_ASM({
        if (typeof Module !== 'undefined' && typeof Module['wasmPollGamepads'] === 'function') {
            Module['wasmPollGamepads']();
        }
    });
    gfx_canvas_render_full_frame(gfx_vs, wasm_gfx_rgba, sizeof(wasm_gfx_rgba));
    wasm_gfx_rgba_version++;
    EM_ASM({
        if (typeof Module !== 'undefined') {
            Module['wasmGfxFbW'] = $0;
            Module['wasmGfxFbH'] = $1;
            Module['wasmGfxRgbaVersion'] = $2;
            Module['wasmGfxBorderPx'] = $3;
            Module['wasmGfxBorderColorIdx'] = $4;
            Module['wasmGfxContentBgIdx'] = $5;
        }
    },
        gfx_cols() * 8,
        GFX_ROWS * 8,
        wasm_gfx_rgba_version,
        basic_get_gfx_border(),
        basic_get_gfx_border_color(),
        gfx_vs ? (int)(gfx_vs->bg_color & 0x0Fu) : 0);
}

static void wasm_canvas_sync_charset_from_options(void)
{
    if (!gfx_vs) {
        return;
    }
    wasm_gfx_state.charset_lowercase = (uint8_t)(petscii_get_lowercase() ? 1 : 0);
    wasm_gfx_state.charrom_family = (uint8_t)(charrom_family_opt ? 1 : 0);
    gfx_vs->charset_lowercase = wasm_gfx_state.charset_lowercase;
    gfx_vs->charrom_family = wasm_gfx_state.charrom_family;
    gfx_canvas_load_default_charrom(gfx_vs);
    wasm_gfx_refresh_js();
}

EMSCRIPTEN_KEEPALIVE uint8_t *wasm_gfx_rgba_ptr(void)
{
    return wasm_gfx_rgba;
}

EMSCRIPTEN_KEEPALIVE uint32_t wasm_gfx_rgba_version_read(void)
{
    return wasm_gfx_rgba_version;
}

/* Test hook: screen RAM screencode at text column / row (for canvas WASM TAB, etc.). */
EMSCRIPTEN_KEEPALIVE int wasm_gfx_screen_screencode_at(int col, int row)
{
    int c;
    int idx;
    if (!gfx_vs) {
        return -1;
    }
    c = gfx_cols();
    if (col < 0 || row < 0 || col >= c || row >= GFX_ROWS) {
        return -1;
    }
    idx = row * c + col;
    if (idx < 0 || idx >= (int)GFX_TEXT_SIZE) {
        return -1;
    }
    return (int)gfx_vs->screen[idx];
}

/* Browser: mirror Raylib key_state[] so PEEK(GFX_KEY_BASE + code) works (e.g. gfx_jiffy_game_demo.bas). */
EMSCRIPTEN_KEEPALIVE void wasm_gfx_key_state_set(unsigned int offset, unsigned int down)
{
    if (!gfx_vs || offset >= GFX_KEY_SIZE) {
        return;
    }
    gfx_vs->key_state[offset] = down ? (uint8_t)1 : (uint8_t)0;
}

EMSCRIPTEN_KEEPALIVE void wasm_gfx_key_state_clear(void)
{
    if (!gfx_vs) {
        return;
    }
    gfx_video_clear_keys(gfx_vs);
}

/* JS may set key_state[] via HEAPU8 at this address (avoids ccall while Asyncify sleeps in SLEEP). */
EMSCRIPTEN_KEEPALIVE uint8_t *wasm_gfx_key_state_ptr(void)
{
    if (!gfx_vs) {
        return NULL;
    }
    return gfx_vs->key_state;
}

static void wasm_gfx_set_video(void)
{
    wasm_gfx_ti_epoch_ms = emscripten_get_now();
    gfx_sprite_shutdown();
    gfx_video_init(&wasm_gfx_state);
    wasm_gfx_state.charset_lowercase = (uint8_t)(petscii_get_lowercase() ? 1 : 0);
    wasm_gfx_state.charrom_family = (uint8_t)(charrom_family_opt ? 1 : 0);
    gfx_canvas_load_default_charrom(&wasm_gfx_state);
    memset(wasm_gfx_state.screen, 32, GFX_TEXT_SIZE);
    memset(wasm_gfx_state.color, 14, GFX_COLOR_SIZE);
    basic_set_video(&wasm_gfx_state);
    wasm_gfx_refresh_js();
}

EMSCRIPTEN_KEEPALIVE void basic_load_and_run_gfx(const char *path)
{
    EM_ASM({ if (typeof Module !== 'undefined') { Module['wasmGfxRunDone'] = 0; } });
    load_program(path);
    wasm_gfx_set_video();
    run_program(path, 0, NULL);
    wasm_gfx_refresh_js();
    EM_ASM({ if (typeof Module !== 'undefined') { Module['wasmGfxRunDone'] = 1; } });
}
#endif /* __EMSCRIPTEN__ */
#endif /* GFX_VIDEO */

/* ── Terminal-mode entry point (not used when GFX_VIDEO or __EMSCRIPTEN__) ── */

#if !defined(GFX_VIDEO) && !defined(__EMSCRIPTEN__)
int main(int argc, char **argv)
{
    const char *prog_path = NULL;
    int i;

    /* Initialize console so ANSI colors/control codes behave consistently. */
    init_console_ansi();

    if (argc < 2) {
        fprintf(stderr, "Usage: %s [-petscii] [-petscii-plain] [-charset upper|lower|c64-*|pet-*] [-palette ansi|c64] [-maxstr N] [-columns N] [-nowrap] <program.bas>\n", argv[0]);
        return 1;
    }

    for (i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-petscii") == 0 || strcmp(argv[i], "--petscii") == 0) {
            petscii_mode = 1;
            petscii_plain = 0;
            /* Disable our column-based wrap in PETSCII mode: many Unicode block/symbol
             * glyphs are "ambiguous" width (1 or 2 cols) so our count doesn't match
             * the terminal. Let the terminal wrap at its width to avoid misalignment. */
            petscii_no_wrap = 1;
        } else if (strcmp(argv[i], "-petscii-plain") == 0 || strcmp(argv[i], "--petscii-plain") == 0) {
            petscii_mode = 1;
            petscii_plain = 1;
            petscii_no_wrap = 1;
        } else if (strcmp(argv[i], "-charset") == 0) {
            const char *name;
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -charset\n");
                return 1;
            }
            name = argv[++i];
            if (strcmp(name, "upper") == 0 || strcmp(name, "uc") == 0 || strcmp(name, "upper-graphics") == 0
                || strcmp(name, "c64-upper") == 0 || strcmp(name, "c64-uppercase") == 0) {
                charrom_family_opt = 0;
                charrom_family_cli = 0;
                petscii_lowercase_opt = 0;
                petscii_lowercase_cli = 0;
                petscii_set_lowercase(0);
            } else if (strcmp(name, "lower") == 0 || strcmp(name, "lc") == 0 || strcmp(name, "lowercase") == 0
                || strcmp(name, "c64-lower") == 0 || strcmp(name, "c64-lowercase") == 0) {
                charrom_family_opt = 0;
                charrom_family_cli = 0;
                petscii_lowercase_opt = 1;
                petscii_lowercase_cli = 1;
                petscii_set_lowercase(1);
            } else if (strcmp(name, "pet-upper") == 0 || strcmp(name, "pet-uppercase") == 0
                || strcmp(name, "pet-graphics") == 0) {
                charrom_family_opt = 1;
                charrom_family_cli = 1;
                petscii_lowercase_opt = 0;
                petscii_lowercase_cli = 0;
                petscii_set_lowercase(0);
            } else if (strcmp(name, "pet-lower") == 0 || strcmp(name, "pet-lowercase") == 0
                || strcmp(name, "pet-text") == 0) {
                charrom_family_opt = 1;
                charrom_family_cli = 1;
                petscii_lowercase_opt = 1;
                petscii_lowercase_cli = 1;
                petscii_set_lowercase(1);
            } else {
                fprintf(stderr,
                    "Unknown charset '%s' (expected upper|lower, c64-upper|c64-lower, pet-upper|pet-lower, …)\n",
                    name);
                return 1;
            }
        } else if (strcmp(argv[i], "-palette") == 0) {
            const char *name;
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -palette\n");
                return 1;
            }
            name = argv[++i];
            if (strcmp(name, "ansi") == 0) {
                palette_mode = PALETTE_ANSI;
            } else if (strcmp(name, "c64") == 0 || strcmp(name, "c64-8bit") == 0) {
                palette_mode = PALETTE_C64_8BIT;
            } else {
                fprintf(stderr, "Unknown palette '%s' (expected ansi or c64)\n", name);
                return 1;
            }
        } else if (strcmp(argv[i], "-maxstr") == 0 || strcmp(argv[i], "--maxstr") == 0) {
            int n;
            char *end;
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -maxstr\n");
                return 1;
            }
            n = (int)strtol(argv[++i], &end, 10);
            if (end == argv[i] || *end != '\0' || n < 1 || n > MAX_STR_LEN) {
                fprintf(stderr, "Invalid -maxstr value (expected 1..%d)\n", MAX_STR_LEN);
                return 1;
            }
            max_str_limit = n;
        } else if (strcmp(argv[i], "-columns") == 0 || strcmp(argv[i], "--columns") == 0) {
            int n;
            char *end;
            if (i + 1 >= argc) {
                fprintf(stderr, "Missing value for -columns\n");
                return 1;
            }
            n = (int)strtol(argv[++i], &end, 10);
            if (end == argv[i] || *end != '\0' || n < 1 || n > 255) {
                fprintf(stderr, "Invalid -columns value (expected 1..255)\n");
                return 1;
            }
            print_width = n;
        } else if (strcmp(argv[i], "-nowrap") == 0 || strcmp(argv[i], "--nowrap") == 0) {
            terminal_no_wrap = 1;
        } else if (argv[i][0] == '-') {
            fprintf(stderr, "Unknown option: %s\n", argv[i]);
            fprintf(stderr, "Usage: %s [-petscii] [-petscii-plain] [-charset upper|lower|c64-*|pet-*] [-palette ansi|c64] [-maxstr N] [-columns N] [-nowrap] <program.bas>\n", argv[0]);
            return 1;
        } else {
            prog_path = argv[i];
            break;
        }
    }

    if (!prog_path) {
        fprintf(stderr, "Usage: %s [-petscii] [-petscii-plain] [-charset upper|lower|c64-*|pet-*] [-palette ansi|c64] [-maxstr N] [-columns N] [-nowrap] <program.bas>\n", argv[0]);
        return 1;
    }

    load_program(prog_path);
    run_program(prog_path, argc - (i + 1), (argc > (i + 1)) ? (argv + (i + 1)) : NULL);
    return 0;
}
#endif /* !GFX_VIDEO */

#ifdef __EMSCRIPTEN__

/* Apply space-separated interpreter flags from JS (e.g. "-petscii -palette c64").
 * Returns 0 on success, -1 on error (details on stderr / Module.printErr). */
EMSCRIPTEN_KEEPALIVE int basic_apply_arg_string(const char *argline)
{
    char buf[512];
    char *argv[40];
    int argc;
    char *p;
    size_t n;

    if (!argline) {
        argline = "";
    }
    n = strlen(argline);
    if (n >= sizeof(buf)) {
        fprintf(stderr, "Interpreter options string too long (max %zu chars)\n", sizeof(buf) - 1);
        return -1;
    }
    memcpy(buf, argline, n + 1);

    argv[0] = "basic";
    argc = 1;
    p = buf;
    while (*p && argc < (int)(sizeof(argv) / sizeof(argv[0]) - 1)) {
        while (*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n') {
            p++;
        }
        if (!*p) {
            break;
        }
        argv[argc++] = p;
        while (*p && *p != ' ' && *p != '\t' && *p != '\r' && *p != '\n') {
            p++;
        }
        if (*p) {
            *p++ = '\0';
        }
    }
    return basic_parse_arg_flags(argc, argv, 1, 0);
}

/* Browser entry: no main(); JS calls basic_load + basic_run. */
EMSCRIPTEN_KEEPALIVE void basic_load_and_run(const char *path)
{
    EM_ASM({ if (typeof Module !== 'undefined') { Module['wasmRunDone'] = 0; } });
    load_program(path);
    run_program(path, 0, NULL);
    EM_ASM({ if (typeof Module !== 'undefined') { Module['wasmRunDone'] = 1; } });
}
#endif