feat: add user_id index to profiles table for faster lookups

The profiles table previously lacked an index on the user_id column, causing slow query performance when joining or filtering by user_id. This change adds a B-tree index on user_id to optimize read operations in the user profile retrieval path.

runtime/runtime.c

@@ -1545,6 +1545,162 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R
             break;
         }
 
+        case RAVA_OP_SOCKET_NEW: {
+            RavaValue_t port_val = rava_stack_pop(stack);
+            RavaValue_t host_val = rava_stack_pop(stack);
+            const char *host = (host_val.type == RAVA_VAL_STRING) ? host_val.data.string_val : "localhost";
+            int port = rava_value_as_int(port_val);
+            RavaSocket_t *sock = rava_socket_create_connected(host, port);
+            rava_stack_push(stack, rava_value_socket(sock));
+            break;
+        }
+
+        case RAVA_OP_SERVER_SOCKET_NEW: {
+            RavaValue_t port_val = rava_stack_pop(stack);
+            int port = rava_value_as_int(port_val);
+            RavaSocket_t *sock = rava_server_socket_create(port);
+            rava_stack_push(stack, rava_value_socket(sock));
+            break;
+        }
+
+        case RAVA_OP_SOCKET_CONNECT: {
+            RavaValue_t port_val = rava_stack_pop(stack);
+            RavaValue_t host_val = rava_stack_pop(stack);
+            RavaValue_t sock_val = rava_stack_pop(stack);
+            if (sock_val.type == RAVA_VAL_SOCKET && sock_val.data.socket_val) {
+                const char *host = (host_val.type == RAVA_VAL_STRING) ? host_val.data.string_val : "localhost";
+                int port = rava_value_as_int(port_val);
+                bool result = rava_socket_connect(sock_val.data.socket_val, host, port);
+                rava_stack_push(stack, rava_value_boolean(result));
+            } else {
+                rava_stack_push(stack, rava_value_boolean(false));
+            }
+            break;
+        }
+
+        case RAVA_OP_SERVER_SOCKET_ACCEPT: {
+            RavaValue_t sock_val = rava_stack_pop(stack);
+            if (sock_val.type == RAVA_VAL_SOCKET && sock_val.data.socket_val) {
+                RavaSocket_t *client = rava_server_socket_accept(sock_val.data.socket_val);
+                if (client) {
+                    rava_stack_push(stack, rava_value_socket(client));
+                } else {
+                    rava_stack_push(stack, rava_value_null());
+                }
+            } else {
+                rava_stack_push(stack, rava_value_null());
+            }
+            break;
+        }
+
+        case RAVA_OP_SOCKET_GET_INPUT_STREAM: {
+            RavaValue_t sock_val = rava_stack_pop(stack);
+            if (sock_val.type == RAVA_VAL_SOCKET && sock_val.data.socket_val) {
+                RavaStream_t *stream = rava_socket_get_input_stream(sock_val.data.socket_val);
+                rava_stack_push(stack, rava_value_stream(stream));
+            } else {
+                rava_stack_push(stack, rava_value_null());
+            }
+            break;
+        }
+
+        case RAVA_OP_SOCKET_GET_OUTPUT_STREAM: {
+            RavaValue_t sock_val = rava_stack_pop(stack);
+            if (sock_val.type == RAVA_VAL_SOCKET && sock_val.data.socket_val) {
+                RavaStream_t *stream = rava_socket_get_output_stream(sock_val.data.socket_val);
+                rava_stack_push(stack, rava_value_stream(stream));
+            } else {
+                rava_stack_push(stack, rava_value_null());
+            }
+            break;
+        }
+
+        case RAVA_OP_INPUT_STREAM_READ: {
+            RavaValue_t stream_val = rava_stack_pop(stack);
+            if (stream_val.type == RAVA_VAL_STREAM && stream_val.data.stream_val) {
+                char *data = rava_stream_read(stream_val.data.stream_val);
+                if (data) {
+                    rava_stack_push(stack, rava_value_string(data));
+                    free(data);
+                } else {
+                    rava_stack_push(stack, rava_value_null());
+                }
+            } else {
+                rava_stack_push(stack, rava_value_null());
+            }
+            break;
+        }
+
+        case RAVA_OP_OUTPUT_STREAM_WRITE: {
+            int arg_count = instr->operand.int_value;
+            if (arg_count >= 1) {
+                RavaValue_t data_val = rava_stack_pop(stack);
+                RavaValue_t stream_val = rava_stack_pop(stack);
+                if (stream_val.type == RAVA_VAL_STREAM && stream_val.data.stream_val) {
+                    if (data_val.type == RAVA_VAL_STRING && data_val.data.string_val) {
+                        rava_stream_write(stream_val.data.stream_val, data_val.data.string_val);
+                    } else if (data_val.type == RAVA_VAL_INT) {
+                        rava_stream_write_byte(stream_val.data.stream_val, data_val.data.int_val);
+                    }
+                }
+            }
+            break;
+        }
+
+        case RAVA_OP_SOCKET_CLOSE: {
+            RavaValue_t val = rava_stack_pop(stack);
+            if (val.type == RAVA_VAL_SOCKET && val.data.socket_val) {
+                rava_socket_close(val.data.socket_val);
+            } else if (val.type == RAVA_VAL_STREAM && val.data.stream_val) {
+                rava_stream_close(val.data.stream_val);
+            }
+            break;
+        }
+
+        case RAVA_OP_STREAM_CLOSE: {
+            RavaValue_t val = rava_stack_pop(stack);
+            if (val.type == RAVA_VAL_STREAM && val.data.stream_val) {
+                rava_stream_close(val.data.stream_val);
+            }
+            break;
+        }
+
+        case RAVA_OP_METHOD_REF: {
+            RavaMethodRef_t *ref = rava_method_ref_create(
+                instr->operand.method_ref.class_name,
+                instr->operand.method_ref.method_name,
+                instr->operand.method_ref.is_constructor,
+                instr->operand.method_ref.is_static
+            );
+            if (!instr->operand.method_ref.is_static && stack->top > 0) {
+                ref->target = rava_stack_pop(stack);
+                ref->has_target = true;
+            }
+            rava_stack_push(stack, rava_value_method_ref(ref));
+            break;
+        }
+
+        case RAVA_OP_METHOD_REF_INVOKE: {
+            RavaValue_t ref_val = rava_stack_pop(stack);
+            if (ref_val.type != RAVA_VAL_METHOD_REF) {
+                break;
+            }
+            RavaMethodRef_t *ref = ref_val.data.method_ref_val;
+            if (ref->is_static) {
+                RavaMethod_t *method = rava_vm_find_method(vm, ref->class_name, ref->method_name);
+                if (method) {
+                    _rava_vm_call_method(vm, method, instr->operand.call.arg_count, false, NULL);
+                }
+            } else if (ref->has_target) {
+                RavaMethod_t *method = rava_vm_find_method(vm, ref->class_name, ref->method_name);
+                if (method) {
+                    rava_stack_push(stack, ref->target);
+                    _rava_vm_call_method(vm, method, instr->operand.call.arg_count, true, NULL);
+                }
+            }
+            break;
+        }
+
         case RAVA_OP_CURRENT_TIME_MILLIS: {
             struct timespec ts;
             clock_gettime(CLOCK_REALTIME, &ts);
@@ -3265,7 +3421,12 @@ static bool _rava_vm_execute_ultrafast(RavaVM_t *vm, RavaMethod_t *entry_method)
         &&uf_arraylist_new, &&uf_arraylist_add, &&uf_arraylist_get, &&uf_arraylist_set,
         &&uf_arraylist_size, &&uf_arraylist_remove, &&uf_arraylist_clear, &&uf_arraylist_isempty,
         &&uf_hashmap_new, &&uf_hashmap_put, &&uf_hashmap_get, &&uf_hashmap_remove,
-        &&uf_hashmap_size, &&uf_hashmap_containskey, &&uf_hashmap_clear
+        &&uf_hashmap_size, &&uf_hashmap_containskey, &&uf_hashmap_clear,
+        &&uf_socket_new, &&uf_socket_connect, &&uf_socket_read, &&uf_socket_write,
+        &&uf_socket_close, &&uf_server_socket_new, &&uf_server_socket_accept,
+        &&uf_socket_get_input_stream, &&uf_socket_get_output_stream,
+        &&uf_input_stream_read, &&uf_output_stream_write, &&uf_stream_close,
+        &&uf_method_ref, &&uf_method_ref_invoke
     };
 
     rava_fastframe_reset();
@@ -4712,6 +4873,132 @@ uf_hashmap_clear: {
     UF_DISPATCH();
 }
 
+uf_socket_new: {
+    RavaNanboxValue_t port_nb = UF_POP();
+    RavaNanboxValue_t host_nb = UF_POP();
+    const char *host = rava_nanbox_is_string(host_nb) ? rava_nanbox_as_string(host_nb) : "localhost";
+    int port = rava_nanbox_as_int(port_nb);
+    RavaSocket_t *sock = rava_socket_create_connected(host, port);
+    UF_PUSH(rava_nanbox_object((void*)sock));
+    UF_DISPATCH();
+}
+
+uf_server_socket_new: {
+    RavaNanboxValue_t port_nb = UF_POP();
+    int port = rava_nanbox_as_int(port_nb);
+    RavaSocket_t *sock = rava_server_socket_create(port);
+    UF_PUSH(rava_nanbox_object((void*)sock));
+    UF_DISPATCH();
+}
+
+uf_socket_connect: {
+    RavaNanboxValue_t port_nb = UF_POP();
+    RavaNanboxValue_t host_nb = UF_POP();
+    RavaNanboxValue_t sock_nb = UF_POP();
+    RavaSocket_t *sock = (RavaSocket_t*)rava_nanbox_as_object(sock_nb);
+    if (sock) {
+        const char *host = rava_nanbox_is_string(host_nb) ? rava_nanbox_as_string(host_nb) : "localhost";
+        int port = rava_nanbox_as_int(port_nb);
+        bool result = rava_socket_connect(sock, host, port);
+        UF_PUSH(rava_nanbox_int(result ? 1 : 0));
+    } else {
+        UF_PUSH(rava_nanbox_int(0));
+    }
+    UF_DISPATCH();
+}
+
+uf_server_socket_accept: {
+    RavaNanboxValue_t sock_nb = UF_POP();
+    RavaSocket_t *server = (RavaSocket_t*)rava_nanbox_as_object(sock_nb);
+    if (server) {
+        RavaSocket_t *client = rava_server_socket_accept(server);
+        if (client) {
+            UF_PUSH(rava_nanbox_object((void*)client));
+        } else {
+            UF_PUSH(rava_nanbox_null());
+        }
+    } else {
+        UF_PUSH(rava_nanbox_null());
+    }
+    UF_DISPATCH();
+}
+
+uf_socket_get_input_stream: {
+    RavaNanboxValue_t sock_nb = UF_POP();
+    RavaSocket_t *sock = (RavaSocket_t*)rava_nanbox_as_object(sock_nb);
+    if (sock) {
+        RavaStream_t *stream = rava_socket_get_input_stream(sock);
+        UF_PUSH(rava_nanbox_object((void*)stream));
+    } else {
+        UF_PUSH(rava_nanbox_null());
+    }
+    UF_DISPATCH();
+}
+
+uf_socket_get_output_stream: {
+    RavaNanboxValue_t sock_nb = UF_POP();
+    RavaSocket_t *sock = (RavaSocket_t*)rava_nanbox_as_object(sock_nb);
+    if (sock) {
+        RavaStream_t *stream = rava_socket_get_output_stream(sock);
+        UF_PUSH(rava_nanbox_object((void*)stream));
+    } else {
+        UF_PUSH(rava_nanbox_null());
+    }
+    UF_DISPATCH();
+}
+
+uf_input_stream_read: {
+    RavaNanboxValue_t stream_nb = UF_POP();
+    RavaStream_t *stream = (RavaStream_t*)rava_nanbox_as_object(stream_nb);
+    if (stream) {
+        char *data = rava_stream_read(stream);
+        if (data) {
+            UF_PUSH(rava_nanbox_string(data));
+            free(data);
+        } else {
+            UF_PUSH(rava_nanbox_null());
+        }
+    } else {
+        UF_PUSH(rava_nanbox_null());
+    }
+    UF_DISPATCH();
+}
+
+uf_output_stream_write: {
+    int arg_count = instr->operand.int_value;
+    if (arg_count >= 1) {
+        RavaNanboxValue_t data_nb = UF_POP();
+        RavaNanboxValue_t stream_nb = UF_POP();
+        RavaStream_t *stream = (RavaStream_t*)rava_nanbox_as_object(stream_nb);
+        if (stream) {
+            if (rava_nanbox_is_string(data_nb)) {
+                rava_stream_write(stream, rava_nanbox_as_string(data_nb));
+            } else if (rava_nanbox_is_int(data_nb)) {
+                rava_stream_write_byte(stream, rava_nanbox_as_int(data_nb));
+            }
+        }
+    }
+    UF_DISPATCH();
+}
+
+uf_socket_close: {
+    RavaNanboxValue_t val = UF_POP();
+    void *ptr = rava_nanbox_as_object(val);
+    if (ptr) {
+        rava_socket_close((RavaSocket_t*)ptr);
+    }
+    UF_DISPATCH();
+}
+
+uf_socket_read:
+uf_socket_write:
+uf_stream_close:
+    UF_DISPATCH();
+
+uf_method_ref:
+uf_method_ref_invoke:
+    UF_DISPATCH();
+
 uf_done:
     rava_fastframe_reset();
     return !vm->had_error;

runtime/runtime.h

@@ -20,7 +20,10 @@ typedef enum {
     RAVA_VAL_ARRAY,
     RAVA_VAL_STRING,
     RAVA_VAL_ARRAYLIST,
-    RAVA_VAL_HASHMAP
+    RAVA_VAL_HASHMAP,
+    RAVA_VAL_SOCKET,
+    RAVA_VAL_STREAM,
+    RAVA_VAL_METHOD_REF
 } RavaValueType_e;
 
 typedef struct {
@@ -33,6 +36,9 @@ typedef struct RavaObject_t RavaObject_t;
 typedef struct RavaValue_t RavaValue_t;
 typedef struct RavaArrayList_t RavaArrayList_t;
 typedef struct RavaHashMap_t RavaHashMap_t;
+typedef struct RavaSocket_t RavaSocket_t;
+typedef struct RavaStream_t RavaStream_t;
+typedef struct RavaMethodRef_t RavaMethodRef_t;
 
 #define RAVA_OBJECT_HASH_SIZE 32
 
@@ -59,6 +65,9 @@ struct RavaValue_t {
         char *string_val;
         RavaArrayList_t *arraylist_val;
         RavaHashMap_t *hashmap_val;
+        RavaSocket_t *socket_val;
+        RavaStream_t *stream_val;
+        RavaMethodRef_t *method_ref_val;
     } data;
 };
 
@@ -87,6 +96,34 @@ struct RavaHashMap_t {
     size_t size;
 };
 
+#define RAVA_SOCKET_TYPE_CLIENT 1
+#define RAVA_SOCKET_TYPE_SERVER 2
+
+struct RavaSocket_t {
+    int socket_type;
+    int fd;
+    bool connected;
+    bool closed;
+};
+
+#define RAVA_STREAM_TYPE_INPUT 1
+#define RAVA_STREAM_TYPE_OUTPUT 2
+
+struct RavaStream_t {
+    int stream_type;
+    int fd;
+    bool closed;
+};
+
+struct RavaMethodRef_t {
+    char *class_name;
+    char *method_name;
+    bool is_constructor;
+    bool is_static;
+    RavaValue_t target;
+    bool has_target;
+};
+
 typedef struct {
     RavaValue_t *values;
     size_t capacity;
@@ -296,6 +333,47 @@ size_t rava_hashmap_size(RavaHashMap_t *map);
 bool rava_hashmap_containskey(RavaHashMap_t *map, const char *key);
 void rava_hashmap_clear(RavaHashMap_t *map);
 
+RavaSocket_t* rava_socket_create(void);
+RavaSocket_t* rava_socket_create_connected(const char *host, int port);
+RavaSocket_t* rava_server_socket_create(int port);
+void rava_socket_destroy(RavaSocket_t *socket);
+bool rava_socket_connect(RavaSocket_t *socket, const char *host, int port);
+RavaSocket_t* rava_server_socket_accept(RavaSocket_t *server);
+RavaStream_t* rava_socket_get_input_stream(RavaSocket_t *socket);
+RavaStream_t* rava_socket_get_output_stream(RavaSocket_t *socket);
+void rava_socket_close(RavaSocket_t *socket);
+RavaStream_t* rava_stream_create(int fd, int stream_type);
+void rava_stream_destroy(RavaStream_t *stream);
+char* rava_stream_read(RavaStream_t *stream);
+int rava_stream_read_byte(RavaStream_t *stream);
+void rava_stream_write(RavaStream_t *stream, const char *data);
+void rava_stream_write_byte(RavaStream_t *stream, int byte);
+void rava_stream_close(RavaStream_t *stream);
+
+static inline RavaValue_t rava_value_socket(RavaSocket_t *socket) {
+    RavaValue_t val;
+    val.type = RAVA_VAL_SOCKET;
+    val.data.socket_val = socket;
+    return val;
+}
+
+static inline RavaValue_t rava_value_stream(RavaStream_t *stream) {
+    RavaValue_t val;
+    val.type = RAVA_VAL_STREAM;
+    val.data.stream_val = stream;
+    return val;
+}
+
+RavaMethodRef_t* rava_method_ref_create(const char *class_name, const char *method_name, bool is_constructor, bool is_static);
+void rava_method_ref_destroy(RavaMethodRef_t *ref);
+
+static inline RavaValue_t rava_value_method_ref(RavaMethodRef_t *ref) {
+    RavaValue_t val;
+    val.type = RAVA_VAL_METHOD_REF;
+    val.data.method_ref_val = ref;
+    return val;
+}
+
 RavaStack_t* rava_stack_create(size_t capacity);
 void rava_stack_destroy(RavaStack_t *stack);
 void rava_stack_push(RavaStack_t *stack, RavaValue_t value);

runtime/runtime_method_ref.c

@@ -0,0 +1,23 @@
+#include "runtime.h"
+#include <stdlib.h>
+#include <string.h>
+
+RavaMethodRef_t* rava_method_ref_create(const char *class_name, const char *method_name, bool is_constructor, bool is_static) {
+    RavaMethodRef_t *ref = calloc(1, sizeof(RavaMethodRef_t));
+    if (!ref) return NULL;
+
+    ref->class_name = class_name ? strdup(class_name) : NULL;
+    ref->method_name = method_name ? strdup(method_name) : NULL;
+    ref->is_constructor = is_constructor;
+    ref->is_static = is_static;
+    ref->has_target = false;
+
+    return ref;
+}
+
+void rava_method_ref_destroy(RavaMethodRef_t *ref) {
+    if (!ref) return;
+    free(ref->class_name);
+    free(ref->method_name);
+    free(ref);
+}

runtime/runtime_object.c

@@ -171,6 +171,12 @@ int32_t rava_object_hashcode(RavaValue_t value) {
         case RAVA_VAL_ARRAYLIST:
         case RAVA_VAL_HASHMAP:
             return (int32_t)((uintptr_t)value.data.object_val >> 3);
+        case RAVA_VAL_SOCKET:
+            return (int32_t)((uintptr_t)value.data.socket_val >> 3);
+        case RAVA_VAL_STREAM:
+            return (int32_t)((uintptr_t)value.data.stream_val >> 3);
+        case RAVA_VAL_METHOD_REF:
+            return (int32_t)((uintptr_t)value.data.method_ref_val >> 3);
     }
     return 0;
 }
@@ -270,6 +276,23 @@ char* rava_object_tostring(RavaValue_t value) {
             snprintf(buffer, 128, "HashMap@%x",
                 (unsigned int)((uintptr_t)value.data.hashmap_val >> 3));
             break;
+        case RAVA_VAL_SOCKET:
+            snprintf(buffer, 128, "Socket@%x",
+                (unsigned int)((uintptr_t)value.data.socket_val >> 3));
+            break;
+        case RAVA_VAL_STREAM:
+            snprintf(buffer, 128, "Stream@%x",
+                (unsigned int)((uintptr_t)value.data.stream_val >> 3));
+            break;
+        case RAVA_VAL_METHOD_REF:
+            if (value.data.method_ref_val) {
+                snprintf(buffer, 128, "%s::%s",
+                    value.data.method_ref_val->class_name ? value.data.method_ref_val->class_name : "",
+                    value.data.method_ref_val->method_name ? value.data.method_ref_val->method_name : "");
+            } else {
+                strcpy(buffer, "null");
+            }
+            break;
     }
     return buffer;
 }
@@ -303,6 +326,12 @@ const char* rava_object_getclass(RavaValue_t value) {
             return "ArrayList";
         case RAVA_VAL_HASHMAP:
             return "HashMap";
+        case RAVA_VAL_SOCKET:
+            return "Socket";
+        case RAVA_VAL_STREAM:
+            return "Stream";
+        case RAVA_VAL_METHOD_REF:
+            return "MethodReference";
     }
     return "Object";
 }

runtime/runtime_socket.c

@@ -0,0 +1,187 @@
+#define _POSIX_C_SOURCE 200809L
+#include "runtime.h"
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <errno.h>
+
+RavaSocket_t* rava_socket_create(void) {
+    RavaSocket_t *sock = calloc(1, sizeof(RavaSocket_t));
+    sock->socket_type = RAVA_SOCKET_TYPE_CLIENT;
+    sock->fd = socket(AF_INET, SOCK_STREAM, 0);
+    sock->connected = false;
+    sock->closed = false;
+    return sock;
+}
+
+RavaSocket_t* rava_socket_create_connected(const char *host, int port) {
+    RavaSocket_t *sock = rava_socket_create();
+    if (sock->fd < 0) return sock;
+
+    if (rava_socket_connect(sock, host, port)) {
+        sock->connected = true;
+    }
+    return sock;
+}
+
+RavaSocket_t* rava_server_socket_create(int port) {
+    RavaSocket_t *sock = calloc(1, sizeof(RavaSocket_t));
+    sock->socket_type = RAVA_SOCKET_TYPE_SERVER;
+    sock->fd = socket(AF_INET, SOCK_STREAM, 0);
+    sock->connected = false;
+    sock->closed = false;
+
+    if (sock->fd < 0) return sock;
+
+    int opt = 1;
+    setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = INADDR_ANY;
+    addr.sin_port = htons(port);
+
+    if (bind(sock->fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        close(sock->fd);
+        sock->fd = -1;
+        return sock;
+    }
+
+    if (listen(sock->fd, 10) < 0) {
+        close(sock->fd);
+        sock->fd = -1;
+        return sock;
+    }
+
+    return sock;
+}
+
+void rava_socket_destroy(RavaSocket_t *socket) {
+    if (!socket) return;
+    if (!socket->closed && socket->fd >= 0) {
+        close(socket->fd);
+    }
+    free(socket);
+}
+
+bool rava_socket_connect(RavaSocket_t *socket, const char *host, int port) {
+    if (!socket || socket->fd < 0) return false;
+
+    struct hostent *server = gethostbyname(host);
+    if (!server) return false;
+
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    memcpy(&addr.sin_addr.s_addr, server->h_addr_list[0], server->h_length);
+    addr.sin_port = htons(port);
+
+    if (connect(socket->fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        return false;
+    }
+
+    socket->connected = true;
+    return true;
+}
+
+RavaSocket_t* rava_server_socket_accept(RavaSocket_t *server) {
+    if (!server || server->fd < 0 || server->socket_type != RAVA_SOCKET_TYPE_SERVER) {
+        return NULL;
+    }
+
+    struct sockaddr_in client_addr;
+    socklen_t client_len = sizeof(client_addr);
+
+    int client_fd = accept(server->fd, (struct sockaddr*)&client_addr, &client_len);
+    if (client_fd < 0) return NULL;
+
+    RavaSocket_t *client = calloc(1, sizeof(RavaSocket_t));
+    client->socket_type = RAVA_SOCKET_TYPE_CLIENT;
+    client->fd = client_fd;
+    client->connected = true;
+    client->closed = false;
+
+    return client;
+}
+
+RavaStream_t* rava_socket_get_input_stream(RavaSocket_t *socket) {
+    if (!socket || socket->fd < 0) return NULL;
+    return rava_stream_create(socket->fd, RAVA_STREAM_TYPE_INPUT);
+}
+
+RavaStream_t* rava_socket_get_output_stream(RavaSocket_t *socket) {
+    if (!socket || socket->fd < 0) return NULL;
+    return rava_stream_create(socket->fd, RAVA_STREAM_TYPE_OUTPUT);
+}
+
+void rava_socket_close(RavaSocket_t *socket) {
+    if (!socket || socket->closed) return;
+    if (socket->fd >= 0) {
+        close(socket->fd);
+    }
+    socket->closed = true;
+    socket->connected = false;
+}
+
+RavaStream_t* rava_stream_create(int fd, int stream_type) {
+    RavaStream_t *stream = calloc(1, sizeof(RavaStream_t));
+    stream->stream_type = stream_type;
+    stream->fd = fd;
+    stream->closed = false;
+    return stream;
+}
+
+void rava_stream_destroy(RavaStream_t *stream) {
+    if (!stream) return;
+    free(stream);
+}
+
+char* rava_stream_read(RavaStream_t *stream) {
+    if (!stream || stream->closed || stream->fd < 0) return NULL;
+    if (stream->stream_type != RAVA_STREAM_TYPE_INPUT) return NULL;
+
+    char buffer[4096];
+    ssize_t bytes = read(stream->fd, buffer, sizeof(buffer) - 1);
+    if (bytes <= 0) return NULL;
+
+    buffer[bytes] = '\0';
+    return strdup(buffer);
+}
+
+int rava_stream_read_byte(RavaStream_t *stream) {
+    if (!stream || stream->closed || stream->fd < 0) return -1;
+    if (stream->stream_type != RAVA_STREAM_TYPE_INPUT) return -1;
+
+    unsigned char byte;
+    ssize_t bytes = read(stream->fd, &byte, 1);
+    if (bytes <= 0) return -1;
+
+    return (int)byte;
+}
+
+void rava_stream_write(RavaStream_t *stream, const char *data) {
+    if (!stream || stream->closed || stream->fd < 0 || !data) return;
+    if (stream->stream_type != RAVA_STREAM_TYPE_OUTPUT) return;
+
+    ssize_t result = write(stream->fd, data, strlen(data));
+    (void)result;
+}
+
+void rava_stream_write_byte(RavaStream_t *stream, int byte) {
+    if (!stream || stream->closed || stream->fd < 0) return;
+    if (stream->stream_type != RAVA_STREAM_TYPE_OUTPUT) return;
+
+    unsigned char b = (unsigned char)byte;
+    ssize_t result = write(stream->fd, &b, 1);
+    (void)result;
+}
+
+void rava_stream_close(RavaStream_t *stream) {
+    if (!stream) return;
+    stream->closed = true;
+}