elementdrawing 1.0.0

package/src/core/element.c

@@ -0,0 +1,1078 @@
+/*
+ * element.c - ElementDrawing Core: Virtual DOM, Memory Pool, String Interning
+ *
+ * Implements virtual node creation/manipulation, memory pool allocation,
+ * string interning table, and general utility functions for the
+ * ElementDrawing C-core engine.
+ */
+
+#include "bridge.h"
+
+/* ================================================================
+ * Internal Static State
+ * ================================================================ */
+
+static EDMemoryPool* g_default_pool = NULL;
+static EDStringEntry* g_string_table[ED_STRING_TABLE_SIZE];
+static uint32_t g_string_table_entries = 0;
+static bool g_string_table_initialized = false;
+static EDSymbolEntry* g_symbol_table[ED_SYMBOL_TABLE_SIZE];
+static uint32_t g_symbol_id_counter = 1;
+static EDWeakRef* g_weak_ref_table[ED_WEAK_REF_TABLE_SIZE];
+static uint32_t g_weak_ref_counter = 0;
+static EDConfiguration g_config = {0};
+static bool g_renderer_initialized = false;
+
+/* ================================================================
+ * Hash Utilities
+ * ================================================================ */
+
+uint32_t ed_hash_djb2(const char* str)
+{
+    if (!str) return 0;
+    uint32_t hash = 5381;
+    int c;
+    while ((c = (unsigned char)*str++)) {
+        hash = ((hash << 5) + hash) + c;
+    }
+    return hash;
+}
+
+uint32_t ed_hash_fnv1a(const char* str)
+{
+    if (!str) return 0;
+    uint32_t hash = 2166136261u;
+    while (*str) {
+        hash ^= (unsigned char)*str++;
+        hash *= 16777619u;
+    }
+    return hash;
+}
+
+static uint32_t ed_hash_combine(uint32_t h1, uint32_t h2)
+{
+    return h1 ^ (h2 * 2654435761u);
+}
+
+/* ================================================================
+ * String Utilities
+ * ================================================================ */
+
+bool ed_str_equals(const char* a, const char* b)
+{
+    if (a == b) return true;
+    if (!a || !b) return false;
+    return strcmp(a, b) == 0;
+}
+
+char* ed_str_duplicate(const char* str)
+{
+    if (!str) return NULL;
+    size_t len = strlen(str);
+    char* dup = (char*)malloc(len + 1);
+    if (!dup) return NULL;
+    memcpy(dup, str, len + 1);
+    return dup;
+}
+
+uint32_t ed_next_power_of_2(uint32_t n)
+{
+    if (n == 0) return 1;
+    n--;
+    n |= n >> 1;
+    n |= n >> 2;
+    n |= n >> 4;
+    n |= n >> 8;
+    n |= n >> 16;
+    return n + 1;
+}
+
+/* ================================================================
+ * Logging
+ * ================================================================ */
+
+static const char* ed_log_level_name(int level)
+{
+    switch (level) {
+        case 0: return "INFO";
+        case 1: return "WARN";
+        case 2: return "ERROR";
+        case 3: return "DEBUG";
+        default: return "UNKNOWN";
+    }
+}
+
+static void ed_log_vprintf(int level, const char* format, va_list args)
+{
+    const char* level_name = ed_log_level_name(level);
+    fprintf(stderr, "[ElementDrawing][%s] ", level_name);
+    vfprintf(stderr, format, args);
+    fprintf(stderr, "\n");
+}
+
+void ed_log_info(const char* format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    ed_log_vprintf(0, format, args);
+    va_end(args);
+}
+
+void ed_log_warn(const char* format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    ed_log_vprintf(1, format, args);
+    va_end(args);
+}
+
+void ed_log_error(const char* format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    ed_log_vprintf(2, format, args);
+    va_end(args);
+}
+
+void ed_log_debug(const char* format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    ed_log_vprintf(3, format, args);
+    va_end(args);
+}
+
+/* ================================================================
+ * Timestamp
+ * ================================================================ */
+
+uint64_t ed_get_timestamp_ms(void)
+{
+    if (g_config.get_timestamp) {
+        return g_config.get_timestamp();
+    }
+    struct timespec ts;
+    timespec_get(&ts, TIME_UTC);
+    return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
+}
+
+/* ================================================================
+ * Version and Name Utilities
+ * ================================================================ */
+
+const char* ed_version(void)
+{
+    return ED_VERSION_STRING;
+}
+
+const char* ed_node_type_name(EDNodeType type)
+{
+    static const char* names[] = {
+        "Element", "Text", "Comment", "Fragment", "Portal",
+        "Suspense", "Lazy", "Memo", "ForwardRef", "ContextProvider",
+        "ContextConsumer", "Profiler", "StrictMode", "ConcurrentMode"
+    };
+    if (type >= 0 && type <= 13) return names[type];
+    return "Unknown";
+}
+
+const char* ed_fiber_tag_name(EDFiberTag tag)
+{
+    static const char* names[] = {
+        "HostRoot", "HostComponent", "HostText", "ClassComponent",
+        "FunctionComponent", "IndirectComponent", "ContextProvider",
+        "ContextConsumer", "ForwardRef", "Fragment", "Mode",
+        "Profiler", "SuspenseComponent", "SuspenseList",
+        "MemoComponent", "LazyComponent", "Scope", "Offscreen",
+        "LegacyHidden", "Cache", "TracingMarker"
+    };
+    if (tag >= 0 && tag <= 20) return names[tag];
+    return "Unknown";
+}
+
+const char* ed_error_message(int error_code)
+{
+    switch (error_code) {
+        case ED_OK:                return "No error";
+        case ED_ERR_MEMORY:        return "Memory allocation failed";
+        case ED_ERR_NULL_PTR:      return "Null pointer encountered";
+        case ED_ERR_INVALID_ARG:   return "Invalid argument provided";
+        case ED_ERR_OUT_OF_BOUNDS: return "Index out of bounds";
+        case ED_ERR_TYPE_MISMATCH: return "Type mismatch";
+        case ED_ERR_MAX_DEPTH:     return "Maximum tree depth exceeded";
+        case ED_ERR_MAX_CHILDREN:  return "Maximum children count exceeded";
+        case ED_ERR_POOL_EXHAUSTED:return "Memory pool exhausted";
+        case ED_ERR_GC_FAILED:     return "Garbage collection failed";
+        case ED_ERR_INVALID_STATE: return "Invalid state";
+        case ED_ERR_SCHEDULE_FAILED: return "Scheduling failed";
+        case ED_ERR_DIFF_FAILED:   return "Diff computation failed";
+        case ED_ERR_PATCH_FAILED:  return "Patch application failed";
+        case ED_ERR_RENDER_FAILED: return "Rendering failed";
+        case ED_ERR_EVENT_FAILED:  return "Event processing failed";
+        case ED_ERR_HOOK_VIOLATION:return "Hook rules violation";
+        default:                   return "Unknown error";
+    }
+}
+
+/* ================================================================
+ * Memory Pool Implementation
+ * ================================================================ */
+
+static EDPoolBlock* ed_pool_block_create(uint32_t size)
+{
+    EDPoolBlock* block = (EDPoolBlock*)malloc(sizeof(EDPoolBlock));
+    if (!block) return NULL;
+    block->data = (uint8_t*)malloc(size);
+    if (!block->data) {
+        free(block);
+        return NULL;
+    }
+    block->size = size;
+    block->used = 0;
+    block->next = NULL;
+    return block;
+}
+
+static void ed_pool_block_destroy(EDPoolBlock* block)
+{
+    if (!block) return;
+    if (block->data) free(block->data);
+    free(block);
+}
+
+EDMemoryPool* ed_pool_create(uint32_t initial_size)
+{
+    if (initial_size == 0) initial_size = ED_INITIAL_POOL_SIZE;
+    if (initial_size > ED_MAX_POOL_SIZE) initial_size = ED_MAX_POOL_SIZE;
+
+    EDMemoryPool* pool = (EDMemoryPool*)malloc(sizeof(EDMemoryPool));
+    if (!pool) return NULL;
+    memset(pool, 0, sizeof(EDMemoryPool));
+
+    EDPoolBlock* first = ed_pool_block_create(initial_size);
+    if (!first) {
+        free(pool);
+        return NULL;
+    }
+
+    pool->blocks = first;
+    pool->total_size = initial_size;
+    pool->used_size = 0;
+    pool->peak_usage = 0;
+    pool->block_count = 1;
+    pool->alloc_count = 0;
+    pool->free_count = 0;
+    pool->is_initialized = true;
+
+    return pool;
+}
+
+void ed_pool_destroy(EDMemoryPool* pool)
+{
+    if (!pool) return;
+    EDPoolBlock* block = pool->blocks;
+    while (block) {
+        EDPoolBlock* next = block->next;
+        ed_pool_block_destroy(block);
+        block = next;
+    }
+    pool->blocks = NULL;
+    pool->is_initialized = false;
+    free(pool);
+}
+
+void* ed_pool_alloc(EDMemoryPool* pool, uint32_t size)
+{
+    if (!pool || !pool->is_initialized || size == 0) return NULL;
+
+    /* Align size to 8 bytes */
+    size = (size + 7) & ~(uint32_t)7;
+
+    /* Try to fit in existing blocks */
+    EDPoolBlock* block = pool->blocks;
+    while (block) {
+        if (block->size - block->used >= size) {
+            void* ptr = block->data + block->used;
+            block->used += size;
+            pool->used_size += size;
+            pool->alloc_count++;
+            if (pool->used_size > pool->peak_usage) {
+                pool->peak_usage = pool->used_size;
+            }
+            return ptr;
+        }
+        block = block->next;
+    }
+
+    /* Need a new block */
+    uint32_t block_size = ED_POOL_BLOCK_SIZE;
+    if (size > block_size) block_size = size;
+    if (pool->total_size + block_size > ED_MAX_POOL_SIZE) {
+        ed_log_error("Pool exhausted: cannot allocate %u bytes", size);
+        return NULL;
+    }
+
+    EDPoolBlock* new_block = ed_pool_block_create(block_size);
+    if (!new_block) return NULL;
+
+    new_block->next = pool->blocks;
+    pool->blocks = new_block;
+    pool->total_size += block_size;
+    pool->block_count++;
+
+    void* ptr = new_block->data;
+    new_block->used = size;
+    pool->used_size += size;
+    pool->alloc_count++;
+    if (pool->used_size > pool->peak_usage) {
+        pool->peak_usage = pool->used_size;
+    }
+    return ptr;
+}
+
+void ed_pool_free(EDMemoryPool* pool, void* ptr)
+{
+    if (!pool || !ptr) return;
+    /* Pool allocator: free is a no-op; memory reclaimed on pool reset/destroy */
+    pool->free_count++;
+}
+
+void ed_pool_reset(EDMemoryPool* pool)
+{
+    if (!pool) return;
+    EDPoolBlock* block = pool->blocks;
+    while (block) {
+        block->used = 0;
+        block = block->next;
+    }
+    pool->used_size = 0;
+}
+
+uint32_t ed_pool_available(EDMemoryPool* pool)
+{
+    if (!pool) return 0;
+    return pool->total_size - pool->used_size;
+}
+
+void ed_pool_gc(EDMemoryPool* pool)
+{
+    if (!pool || !pool->is_initialized) return;
+
+    /* Compact blocks by removing completely free trailing blocks */
+    EDPoolBlock** prev = &pool->blocks;
+    EDPoolBlock* block = pool->blocks;
+    uint32_t kept = 0;
+
+    while (block) {
+        EDPoolBlock* next = block->next;
+        if (block->used == 0 && kept > 0) {
+            /* Free empty block (keep at least one) */
+            *prev = next;
+            pool->total_size -= block->size;
+            pool->block_count--;
+            ed_pool_block_destroy(block);
+        } else {
+            prev = &block->next;
+            kept++;
+        }
+        block = next;
+    }
+
+    /* Check threshold and compact if needed */
+    if (pool->total_size > 0) {
+        float usage = (float)pool->used_size / (float)pool->total_size;
+        if (usage < 0.25f && pool->block_count > 2) {
+            ed_log_info("Pool GC: usage %.1f%%, compacting blocks", usage * 100.0f);
+        }
+    }
+}
+
+uint32_t ed_pool_defragment(EDMemoryPool* pool)
+{
+    if (!pool || !pool->is_initialized) return 0;
+
+    /* Count total used across all blocks */
+    uint32_t total_used = 0;
+    EDPoolBlock* block = pool->blocks;
+    while (block) {
+        total_used += block->used;
+        block = block->used > 0 ? block->next : NULL;
+    }
+
+    /* Simple defragmentation: consolidate used data into fewer blocks */
+    /* In a real implementation, this would relocate objects and update pointers */
+    ed_pool_gc(pool);
+    return pool->block_count;
+}
+
+/* ================================================================
+ * String Interning Implementation
+ * ================================================================ */
+
+static void ed_string_table_init(void)
+{
+    if (g_string_table_initialized) return;
+    memset(g_string_table, 0, sizeof(g_string_table));
+    g_string_table_entries = 0;
+    g_string_table_initialized = true;
+}
+
+uint32_t ed_string_hash(const char* str)
+{
+    return ed_hash_fnv1a(str);
+}
+
+const char* ed_string_intern(const char* str)
+{
+    if (!str) return NULL;
+    if (!g_string_table_initialized) ed_string_table_init();
+
+    uint32_t hash = ed_string_hash(str);
+    uint32_t idx = hash % ED_STRING_TABLE_SIZE;
+
+    /* Search for existing entry */
+    EDStringEntry* entry = g_string_table[idx];
+    while (entry) {
+        if (entry->hash == hash && strcmp(entry->str, str) == 0) {
+            entry->ref_count++;
+            return entry->str;
+        }
+        entry = entry->next;
+    }
+
+    /* Create new entry */
+    EDStringEntry* new_entry = (EDStringEntry*)malloc(sizeof(EDStringEntry));
+    if (!new_entry) return str; /* Fallback: return the original */
+
+    new_entry->str = ed_str_duplicate(str);
+    if (!new_entry->str) {
+        free(new_entry);
+        return str;
+    }
+    new_entry->len = (uint32_t)strlen(str);
+    new_entry->hash = hash;
+    new_entry->ref_count = 1;
+    new_entry->next = g_string_table[idx];
+    g_string_table[idx] = new_entry;
+    g_string_table_entries++;
+
+    return new_entry->str;
+}
+
+void ed_string_release(const char* str)
+{
+    if (!str || !g_string_table_initialized) return;
+
+    uint32_t hash = ed_string_hash(str);
+    uint32_t idx = hash % ED_STRING_TABLE_SIZE;
+
+    EDStringEntry** prev = &g_string_table[idx];
+    EDStringEntry* entry = g_string_table[idx];
+
+    while (entry) {
+        if (entry->hash == hash && strcmp(entry->str, str) == 0) {
+            entry->ref_count--;
+            if (entry->ref_count == 0) {
+                *prev = entry->next;
+                free(entry->str);
+                free(entry);
+                g_string_table_entries--;
+                return;
+            }
+            return;
+        }
+        prev = &entry->next;
+        entry = entry->next;
+    }
+}
+
+bool ed_string_equals_interned(const char* a, const char* b)
+{
+    if (a == b) return true;
+    if (!a || !b) return false;
+    /* If both are interned, pointer comparison suffices */
+    uint32_t ha = ed_string_hash(a);
+    uint32_t hb = ed_string_hash(b);
+    if (ha != hb) return false;
+    return strcmp(a, b) == 0;
+}
+
+/* ================================================================
+ * Virtual Property Implementation
+ * ================================================================ */
+
+static EDVirtualProp* ed_vprop_create(const char* key, const char* value, uint8_t type)
+{
+    EDVirtualProp* prop = (EDVirtualProp*)calloc(1, sizeof(EDVirtualProp));
+    if (!prop) return NULL;
+
+    if (key) {
+        strncpy(prop->key, key, ED_MAX_PROP_KEY_LEN - 1);
+        prop->key[ED_MAX_PROP_KEY_LEN - 1] = '\0';
+    }
+    if (value) {
+        strncpy(prop->value, value, ED_MAX_PROP_VALUE_LEN - 1);
+        prop->value[ED_MAX_PROP_VALUE_LEN - 1] = '\0';
+    }
+
+    prop->hash = ed_hash_fnv1a(key ? key : "");
+    prop->type = type;
+    prop->is_event = (key && strncmp(key, "on", 2) == 0);
+    prop->is_style = (key && strcmp(key, "style") == 0);
+    prop->is_class = (key && (strcmp(key, "class") == 0 || strcmp(key, "className") == 0));
+    prop->is_ref = (key && strcmp(key, "ref") == 0);
+    prop->is_key = (key && strcmp(key, "key") == 0);
+    prop->is_children = (key && strcmp(key, "children") == 0);
+    prop->is_dangerous_html = (key && strcmp(key, "dangerouslySetInnerHTML") == 0);
+    prop->next = NULL;
+
+    return prop;
+}
+
+static void ed_vprop_destroy(EDVirtualProp* prop)
+{
+    while (prop) {
+        EDVirtualProp* next = prop->next;
+        free(prop);
+        prop = next;
+    }
+}
+
+/* ================================================================
+ * Virtual Node Implementation
+ * ================================================================ */
+
+EDVirtualNode* ed_vnode_create(EDNodeType type, const char* tag, const char* key)
+{
+    EDVirtualNode* node = (EDVirtualNode*)calloc(1, sizeof(EDVirtualNode));
+    if (!node) {
+        ed_log_error("Failed to allocate virtual node");
+        return NULL;
+    }
+
+    node->type = type;
+
+    if (tag) {
+        strncpy(node->tag, tag, ED_MAX_TAG_NAME_LEN - 1);
+        node->tag[ED_MAX_TAG_NAME_LEN - 1] = '\0';
+    }
+
+    if (key) {
+        strncpy(node->key, key, ED_MAX_KEY_LEN - 1);
+        node->key[ED_MAX_KEY_LEN - 1] = '\0';
+    }
+
+    node->child_capacity = 8;
+    node->children = (EDVirtualNode**)calloc(node->child_capacity, sizeof(EDVirtualNode*));
+    if (!node->children) {
+        free(node);
+        return NULL;
+    }
+
+    node->ref_count = 1;
+    node->version = 1;
+    node->is_dirty = true;
+    node->is_committed = false;
+    node->is_suspended = false;
+    node->is_hidden = false;
+
+    return node;
+}
+
+void ed_vnode_destroy(EDVirtualNode* node)
+{
+    if (!node) return;
+
+    node->ref_count--;
+    if (node->ref_count > 0) return;
+
+    /* Destroy all children recursively */
+    for (uint32_t i = 0; i < node->child_count; i++) {
+        if (node->children[i]) {
+            ed_vnode_destroy(node->children[i]);
+        }
+    }
+    free(node->children);
+
+    /* Destroy property list */
+    ed_vprop_destroy(node->props);
+
+    /* Destroy the node itself */
+    free(node);
+}
+
+void ed_vnode_add_child(EDVirtualNode* parent, EDVirtualNode* child)
+{
+    if (!parent || !child) return;
+    if (parent->child_count >= ED_MAX_CHILDREN) {
+        ed_log_error("Max children exceeded for node type=%s tag=%s",
+                     ed_node_type_name(parent->type), parent->tag);
+        return;
+    }
+
+    /* Grow children array if needed */
+    if (parent->child_count >= parent->child_capacity) {
+        uint32_t new_cap = parent->child_capacity * 2;
+        if (new_cap > ED_MAX_CHILDREN) new_cap = ED_MAX_CHILDREN;
+        EDVirtualNode** new_children = (EDVirtualNode**)realloc(
+            parent->children, new_cap * sizeof(EDVirtualNode*));
+        if (!new_children) return;
+        memset(new_children + parent->child_capacity, 0,
+               (new_cap - parent->child_capacity) * sizeof(EDVirtualNode*));
+        parent->children = new_children;
+        parent->child_capacity = new_cap;
+    }
+
+    child->parent = parent;
+    child->sibling = NULL;
+
+    if (parent->last_child) {
+        parent->last_child->sibling = child;
+    } else {
+        parent->first_child = child;
+    }
+    parent->last_child = child;
+
+    parent->children[parent->child_count++] = child;
+    parent->is_dirty = true;
+    parent->version++;
+}
+
+void ed_vnode_remove_child(EDVirtualNode* parent, EDVirtualNode* child)
+{
+    if (!parent || !child) return;
+
+    for (uint32_t i = 0; i < parent->child_count; i++) {
+        if (parent->children[i] == child) {
+            /* Shift remaining children */
+            for (uint32_t j = i; j < parent->child_count - 1; j++) {
+                parent->children[j] = parent->children[j + 1];
+            }
+            parent->children[parent->child_count - 1] = NULL;
+            parent->child_count--;
+
+            /* Rebuild sibling links */
+            parent->first_child = parent->child_count > 0 ? parent->children[0] : NULL;
+            parent->last_child = parent->child_count > 0 ? parent->children[parent->child_count - 1] : NULL;
+            for (uint32_t j = 0; j + 1 < parent->child_count; j++) {
+                parent->children[j]->sibling = parent->children[j + 1];
+            }
+            if (parent->child_count > 0) {
+                parent->children[parent->child_count - 1]->sibling = NULL;
+            }
+
+            child->parent = NULL;
+            child->sibling = NULL;
+            parent->is_dirty = true;
+            parent->version++;
+            return;
+        }
+    }
+}
+
+void ed_vnode_insert_child(EDVirtualNode* parent, EDVirtualNode* child, uint32_t index)
+{
+    if (!parent || !child) return;
+    if (index > parent->child_count) index = parent->child_count;
+    if (parent->child_count >= ED_MAX_CHILDREN) return;
+
+    /* Grow children array if needed */
+    if (parent->child_count >= parent->child_capacity) {
+        uint32_t new_cap = parent->child_capacity * 2;
+        if (new_cap > ED_MAX_CHILDREN) new_cap = ED_MAX_CHILDREN;
+        EDVirtualNode** new_children = (EDVirtualNode**)realloc(
+            parent->children, new_cap * sizeof(EDVirtualNode*));
+        if (!new_children) return;
+        parent->children = new_children;
+        parent->child_capacity = new_cap;
+    }
+
+    /* Shift children to make room */
+    for (uint32_t i = parent->child_count; i > index; i--) {
+        parent->children[i] = parent->children[i - 1];
+    }
+    parent->children[index] = child;
+    parent->child_count++;
+
+    child->parent = parent;
+
+    /* Rebuild sibling links */
+    for (uint32_t i = 0; i + 1 < parent->child_count; i++) {
+        parent->children[i]->sibling = parent->children[i + 1];
+    }
+    if (parent->child_count > 0) {
+        parent->children[parent->child_count - 1]->sibling = NULL;
+    }
+    parent->first_child = parent->children[0];
+    parent->last_child = parent->children[parent->child_count - 1];
+
+    parent->is_dirty = true;
+    parent->version++;
+}
+
+void ed_vnode_replace_child(EDVirtualNode* parent, EDVirtualNode* new_child, EDVirtualNode* old_child)
+{
+    if (!parent || !new_child || !old_child) return;
+
+    for (uint32_t i = 0; i < parent->child_count; i++) {
+        if (parent->children[i] == old_child) {
+            parent->children[i] = new_child;
+            new_child->parent = parent;
+            new_child->sibling = old_child->sibling;
+            old_child->parent = NULL;
+            old_child->sibling = NULL;
+
+            /* Rebuild sibling links */
+            if (i > 0) {
+                parent->children[i - 1]->sibling = new_child;
+            }
+            if (i + 1 < parent->child_count && parent->children[i + 1]) {
+                new_child->sibling = parent->children[i + 1];
+            }
+
+            if (parent->first_child == old_child) parent->first_child = new_child;
+            if (parent->last_child == old_child) parent->last_child = new_child;
+
+            parent->is_dirty = true;
+            parent->version++;
+            return;
+        }
+    }
+}
+
+void ed_vnode_set_prop(EDVirtualNode* node, const char* key, const char* value, uint8_t type)
+{
+    if (!node || !key) return;
+    if (node->prop_count >= ED_MAX_PROPS) {
+        ed_log_warn("Max props exceeded for node tag=%s", node->tag);
+        return;
+    }
+
+    /* Check for existing prop */
+    EDVirtualProp* existing = ed_vnode_get_prop(node, key);
+    if (existing) {
+        if (value) {
+            strncpy(existing->value, value, ED_MAX_PROP_VALUE_LEN - 1);
+            existing->value[ED_MAX_PROP_VALUE_LEN - 1] = '\0';
+        } else {
+            existing->value[0] = '\0';
+        }
+        existing->type = type;
+        node->version++;
+        return;
+    }
+
+    /* Add new prop at the head of the list */
+    EDVirtualProp* prop = ed_vprop_create(key, value, type);
+    if (!prop) return;
+
+    prop->next = node->props;
+    node->props = prop;
+    node->prop_count++;
+    node->is_dirty = true;
+    node->version++;
+}
+
+void ed_vnode_remove_prop(EDVirtualNode* node, const char* key)
+{
+    if (!node || !key) return;
+
+    EDVirtualProp** prev = &node->props;
+    EDVirtualProp* prop = node->props;
+
+    while (prop) {
+        if (strcmp(prop->key, key) == 0) {
+            *prev = prop->next;
+            prop->next = NULL;
+            ed_vprop_destroy(prop);
+            node->prop_count--;
+            node->is_dirty = true;
+            node->version++;
+            return;
+        }
+        prev = &prop->next;
+        prop = prop->next;
+    }
+}
+
+EDVirtualProp* ed_vnode_get_prop(EDVirtualNode* node, const char* key)
+{
+    if (!node || !key) return NULL;
+
+    EDVirtualProp* prop = node->props;
+    while (prop) {
+        if (strcmp(prop->key, key) == 0) return prop;
+        prop = prop->next;
+    }
+    return NULL;
+}
+
+void ed_vnode_set_text(EDVirtualNode* node, const char* text)
+{
+    if (!node) return;
+    if (text) {
+        strncpy(node->text, text, ED_MAX_TEXT_LEN - 1);
+        node->text[ED_MAX_TEXT_LEN - 1] = '\0';
+    } else {
+        node->text[0] = '\0';
+    }
+    node->is_dirty = true;
+    node->version++;
+}
+
+void ed_vnode_set_key(EDVirtualNode* node, const char* key)
+{
+    if (!node) return;
+    if (key) {
+        strncpy(node->key, key, ED_MAX_KEY_LEN - 1);
+        node->key[ED_MAX_KEY_LEN - 1] = '\0';
+    } else {
+        node->key[0] = '\0';
+    }
+    node->version++;
+}
+
+uint32_t ed_vnode_hash(EDVirtualNode* node)
+{
+    if (!node) return 0;
+    if (node->hash != 0) return node->hash;
+
+    uint32_t h = ed_hash_fnv1a(node->tag);
+    h = ed_hash_combine(h, (uint32_t)node->type);
+    h = ed_hash_combine(h, ed_hash_fnv1a(node->text));
+    h = ed_hash_combine(h, ed_hash_fnv1a(node->key));
+
+    EDVirtualProp* prop = node->props;
+    while (prop) {
+        h = ed_hash_combine(h, prop->hash);
+        h = ed_hash_combine(h, ed_hash_fnv1a(prop->value));
+        prop = prop->next;
+    }
+
+    node->hash = h;
+    return h;
+}
+
+bool ed_vnode_equals(EDVirtualNode* a, EDVirtualNode* b)
+{
+    if (a == b) return true;
+    if (!a || !b) return false;
+    if (a->type != b->type) return false;
+    if (strcmp(a->tag, b->tag) != 0) return false;
+    if (strcmp(a->key, b->key) != 0) return false;
+    if (a->child_count != b->child_count) return false;
+    if (a->prop_count != b->prop_count) return false;
+
+    /* Compare text for text nodes */
+    if (a->type == ED_NODE_TEXT && strcmp(a->text, b->text) != 0) return false;
+
+    /* Compare props */
+    EDVirtualProp* pa = a->props;
+    while (pa) {
+        EDVirtualProp* pb = ed_vnode_get_prop(b, pa->key);
+        if (!pb || strcmp(pa->value, pb->value) != 0) return false;
+        pa = pa->next;
+    }
+
+    /* Compare children recursively */
+    for (uint32_t i = 0; i < a->child_count; i++) {
+        if (!ed_vnode_equals(a->children[i], b->children[i])) return false;
+    }
+
+    return true;
+}
+
+EDVirtualNode* ed_vnode_clone(EDVirtualNode* node)
+{
+    if (!node) return NULL;
+
+    EDVirtualNode* clone = ed_vnode_create(node->type, node->tag, node->key);
+    if (!clone) return NULL;
+
+    strncpy(clone->text, node->text, ED_MAX_TEXT_LEN - 1);
+    clone->ref_id = node->ref_id;
+    clone->component_instance = node->component_instance;
+    clone->component_state = node->component_state;
+    clone->context_value = node->context_value;
+    clone->is_hidden = node->is_hidden;
+    clone->is_suspended = node->is_suspended;
+
+    /* Clone props */
+    EDVirtualProp* src = node->props;
+    EDVirtualProp** dst = &clone->props;
+    while (src) {
+        EDVirtualProp* prop = ed_vprop_create(src->key, src->value, src->type);
+        if (prop) {
+            prop->is_event = src->is_event;
+            prop->is_style = src->is_style;
+            prop->is_class = src->is_class;
+            prop->is_ref = src->is_ref;
+            prop->is_key = src->is_key;
+            prop->is_children = src->is_children;
+            prop->is_dangerous_html = src->is_dangerous_html;
+            *dst = prop;
+            dst = &prop->next;
+            clone->prop_count++;
+        }
+        src = src->next;
+    }
+
+    /* Clone children recursively */
+    for (uint32_t i = 0; i < node->child_count; i++) {
+        EDVirtualNode* child_clone = ed_vnode_clone(node->children[i]);
+        if (child_clone) {
+            ed_vnode_add_child(clone, child_clone);
+        }
+    }
+
+    return clone;
+}
+
+void ed_vnode_mark_dirty(EDVirtualNode* node)
+{
+    if (!node) return;
+    node->is_dirty = true;
+    EDVirtualNode* p = node->parent;
+    while (p) {
+        p->is_dirty = true;
+        p = p->parent;
+    }
+}
+
+void ed_vnode_clear_dirty(EDVirtualNode* node)
+{
+    if (!node) return;
+    node->is_dirty = false;
+}
+
+uint32_t ed_vnode_depth(EDVirtualNode* node)
+{
+    if (!node) return 0;
+    uint32_t depth = 0;
+    EDVirtualNode* p = node->parent;
+    while (p) {
+        depth++;
+        p = p->parent;
+        if (depth > ED_MAX_DEPTH) break;
+    }
+    return depth;
+}
+
+uint32_t ed_vnode_count(EDVirtualNode* node)
+{
+    if (!node) return 0;
+    uint32_t count = 1;
+    for (uint32_t i = 0; i < node->child_count; i++) {
+        count += ed_vnode_count(node->children[i]);
+    }
+    return count;
+}
+
+void ed_vnode_traverse(EDVirtualNode* node, void (*visitor)(EDVirtualNode*, void*), void* data)
+{
+    if (!node || !visitor) return;
+    visitor(node, data);
+    for (uint32_t i = 0; i < node->child_count; i++) {
+        ed_vnode_traverse(node->children[i], visitor, data);
+    }
+}
+
+/* BFS traversal using a simple queue */
+#define ED_BFS_QUEUE_SIZE 8192
+
+void ed_vnode_traverse_bfs(EDVirtualNode* node, void (*visitor)(EDVirtualNode*, void*), void* data)
+{
+    if (!node || !visitor) return;
+
+    EDVirtualNode* queue[ED_BFS_QUEUE_SIZE];
+    uint32_t head = 0, tail = 0;
+
+    queue[tail++] = node;
+
+    while (head != tail) {
+        EDVirtualNode* current = queue[head++];
+        head %= ED_BFS_QUEUE_SIZE;
+
+        visitor(current, data);
+
+        for (uint32_t i = 0; i < current->child_count; i++) {
+            if (current->children[i]) {
+                queue[tail++] = current->children[i];
+                tail %= ED_BFS_QUEUE_SIZE;
+            }
+        }
+    }
+}
+
+/* ================================================================
+ * Weak Reference Table
+ * ================================================================ */
+
+static EDWeakRef* ed_weak_ref_create(void* target)
+{
+    EDWeakRef* ref = (EDWeakRef*)calloc(1, sizeof(EDWeakRef));
+    if (!ref) return NULL;
+    ref->target = target;
+    ref->id = ++g_weak_ref_counter;
+    ref->is_alive = true;
+    ref->next = NULL;
+    return ref;
+}
+
+/* ================================================================
+ * Symbol Table
+ * ================================================================ */
+
+static void ed_symbol_table_init(void)
+{
+    memset(g_symbol_table, 0, sizeof(g_symbol_table));
+    g_symbol_id_counter = 1;
+}
+
+static EDSymbolEntry* ed_symbol_lookup(const char* name)
+{
+    if (!name) return NULL;
+    uint32_t hash = ed_hash_fnv1a(name) % ED_SYMBOL_TABLE_SIZE;
+    EDSymbolEntry* entry = g_symbol_table[hash];
+    while (entry) {
+        if (strcmp(entry->name, name) == 0) return entry;
+        entry = entry->next;
+    }
+    return NULL;
+}
+
+static EDSymbolEntry* ed_symbol_intern(const char* name, void* value)
+{
+    if (!name) return NULL;
+    EDSymbolEntry* existing = ed_symbol_lookup(name);
+    if (existing) {
+        existing->value = value;
+        return existing;
+    }
+
+    EDSymbolEntry* entry = (EDSymbolEntry*)calloc(1, sizeof(EDSymbolEntry));
+    if (!entry) return NULL;
+    strncpy(entry->name, name, 127);
+    entry->name[127] = '\0';
+    entry->id = g_symbol_id_counter++;
+    entry->value = value;
+
+    uint32_t hash = ed_hash_fnv1a(name) % ED_SYMBOL_TABLE_SIZE;
+    entry->next = g_symbol_table[hash];
+    g_symbol_table[hash] = entry;
+    return entry;
+}
+
+/* ================================================================
+ * Configuration Access
+ * ================================================================ */
+
+EDConfiguration* ed_internal_get_config(void)
+{
+    return &g_config;
+}
+
+bool ed_internal_is_initialized(void)
+{
+    return g_renderer_initialized;
+}