elementdrawing 1.0.0

package/src/core/diff.c

@@ -0,0 +1,900 @@
+/*
+ * diff.c - ElementDrawing Core: Diff Algorithm and Patch System
+ *
+ * Implements tree diffing with key-based reconciliation, an O(n)
+ * child diffing algorithm, prop diffing, diff result management,
+ * patch queue operations, and patch application to the DOM.
+ */
+
+#include "bridge.h"
+
+/* ================================================================
+ * Diff Operation Management
+ * ================================================================ */
+
+EDDiffOperation* ed_diff_operation_create(EDDiffOpType type, uint32_t index)
+{
+    EDDiffOperation* op = (EDDiffOperation*)calloc(1, sizeof(EDDiffOperation));
+    if (!op) return NULL;
+
+    op->type = type;
+    op->index = index;
+    op->new_index = 0;
+    op->node = NULL;
+    op->new_node = NULL;
+    op->prop_changes = NULL;
+    op->prop_change_count = 0;
+    op->next = NULL;
+
+    return op;
+}
+
+void ed_diff_operation_destroy(EDDiffOperation* op)
+{
+    if (!op) return;
+    /* Destroy prop changes */
+    EDVirtualProp* prop = op->prop_changes;
+    while (prop) {
+        EDVirtualProp* next = prop->next;
+        free(prop);
+        prop = next;
+    }
+    free(op);
+}
+
+/* ================================================================
+ * Diff Result Management
+ * ================================================================ */
+
+static EDDiffResult* ed_diff_result_create(void)
+{
+    EDDiffResult* result = (EDDiffResult*)calloc(1, sizeof(EDDiffResult));
+    if (!result) return NULL;
+
+    result->operations = NULL;
+    result->operation_count = 0;
+    result->insert_count = 0;
+    result->delete_count = 0;
+    result->update_count = 0;
+    result->move_count = 0;
+    result->reorder_count = 0;
+    result->has_changes = false;
+
+    return result;
+}
+
+void ed_diff_result_destroy(EDDiffResult* result)
+{
+    if (!result) return;
+
+    EDDiffOperation* op = result->operations;
+    while (op) {
+        EDDiffOperation* next = op->next;
+        ed_diff_operation_destroy(op);
+        op = next;
+    }
+
+    free(result);
+}
+
+uint32_t ed_diff_count_operations(EDDiffResult* result)
+{
+    return result ? result->operation_count : 0;
+}
+
+bool ed_diff_has_changes(EDDiffResult* result)
+{
+    return result ? result->has_changes : false;
+}
+
+/* ================================================================
+ * Internal: Append Operation to Result
+ * ================================================================ */
+
+static void ed_diff_result_append(EDDiffResult* result, EDDiffOperation* op)
+{
+    if (!result || !op) return;
+
+    if (!result->operations) {
+        result->operations = op;
+    } else {
+        /* Append to end */
+        EDDiffOperation* tail = result->operations;
+        while (tail->next) {
+            tail = tail->next;
+        }
+        tail->next = op;
+    }
+
+    result->operation_count++;
+    result->has_changes = true;
+
+    switch (op->type) {
+        case ED_DIFF_INSERT:  result->insert_count++; break;
+        case ED_DIFF_DELETE:  result->delete_count++; break;
+        case ED_DIFF_UPDATE:  result->update_count++; break;
+        case ED_DIFF_MOVE:    result->move_count++; break;
+        case ED_DIFF_REORDER: result->reorder_count++; break;
+        default: break;
+    }
+}
+
+/* ================================================================
+ * Prop Diffing
+ * ================================================================ */
+
+static EDVirtualProp* ed_diff_props(EDVirtualNode* old_node, EDVirtualNode* new_node,
+                                     uint32_t* change_count)
+{
+    if (change_count) *change_count = 0;
+
+    EDVirtualProp* changes = NULL;
+    EDVirtualProp** tail = &changes;
+
+    /* Find added and updated props */
+    EDVirtualProp* new_prop = new_node ? new_node->props : NULL;
+    while (new_prop) {
+        EDVirtualProp* old_prop = old_node ? ed_vnode_get_prop(old_node, new_prop->key) : NULL;
+
+        if (!old_prop) {
+            /* Prop added */
+            EDVirtualProp* change = (EDVirtualProp*)calloc(1, sizeof(EDVirtualProp));
+            if (change) {
+                strncpy(change->key, new_prop->key, ED_MAX_PROP_KEY_LEN - 1);
+                strncpy(change->value, new_prop->value, ED_MAX_PROP_VALUE_LEN - 1);
+                change->type = new_prop->type;
+                change->hash = new_prop->hash;
+                change->is_event = new_prop->is_event;
+                change->is_style = new_prop->is_style;
+                change->is_class = new_prop->is_class;
+                change->is_ref = new_prop->is_ref;
+                *tail = change;
+                tail = &change->next;
+                if (change_count) (*change_count)++;
+            }
+        } else if (strcmp(old_prop->value, new_prop->value) != 0 || old_prop->type != new_prop->type) {
+            /* Prop updated */
+            EDVirtualProp* change = (EDVirtualProp*)calloc(1, sizeof(EDVirtualProp));
+            if (change) {
+                strncpy(change->key, new_prop->key, ED_MAX_PROP_KEY_LEN - 1);
+                strncpy(change->value, new_prop->value, ED_MAX_PROP_VALUE_LEN - 1);
+                change->type = new_prop->type;
+                change->hash = new_prop->hash;
+                *tail = change;
+                tail = &change->next;
+                if (change_count) (*change_count)++;
+            }
+        }
+
+        new_prop = new_prop->next;
+    }
+
+    /* Find removed props */
+    EDVirtualProp* old_prop = old_node ? old_node->props : NULL;
+    while (old_prop) {
+        EDVirtualProp* found = new_node ? ed_vnode_get_prop(new_node, old_prop->key) : NULL;
+        if (!found) {
+            /* Prop removed - mark with empty value */
+            EDVirtualProp* change = (EDVirtualProp*)calloc(1, sizeof(EDVirtualProp));
+            if (change) {
+                strncpy(change->key, old_prop->key, ED_MAX_PROP_KEY_LEN - 1);
+                change->value[0] = '\0'; /* Empty = removed */
+                change->type = old_prop->type;
+                change->hash = old_prop->hash;
+                *tail = change;
+                tail = &change->next;
+                if (change_count) (*change_count)++;
+            }
+        }
+        old_prop = old_prop->next;
+    }
+
+    return changes;
+}
+
+/* ================================================================
+ * Key-based Child Diffing: O(n) Algorithm
+ *
+ * This implements the "flag and sweep" approach:
+ * 1. Build a map of old children by key
+ * 2. Walk new children, matching keys to old
+ * 3. Mark matched old children, delete unmarked
+ * 4. Track moves via last placed index
+ * ================================================================ */
+
+/* Key-to-index map for fast lookups */
+typedef struct EDChildKeyEntry {
+    char key[ED_MAX_KEY_LEN];
+    uint32_t hash;
+    uint32_t old_index;
+    EDVirtualNode* old_node;
+    struct EDChildKeyEntry* next;
+} EDChildKeyEntry;
+
+typedef struct EDChildKeyMap {
+    EDChildKeyEntry* buckets[ED_DIFF_KEY_CACHE_SIZE];
+    uint32_t count;
+} EDChildKeyMap;
+
+static void ed_child_key_map_init(EDChildKeyMap* map)
+{
+    if (!map) return;
+    memset(map, 0, sizeof(EDChildKeyMap));
+}
+
+static void ed_child_key_map_insert(EDChildKeyMap* map, const char* key, uint32_t hash,
+                                     uint32_t old_index, EDVirtualNode* node)
+{
+    if (!map || !key) return;
+    EDChildKeyEntry* entry = (EDChildKeyEntry*)calloc(1, sizeof(EDChildKeyEntry));
+    if (!entry) return;
+
+    strncpy(entry->key, key, ED_MAX_KEY_LEN - 1);
+    entry->key[ED_MAX_KEY_LEN - 1] = '\0';
+    entry->hash = hash;
+    entry->old_index = old_index;
+    entry->old_node = node;
+
+    uint32_t bucket = hash % ED_DIFF_KEY_CACHE_SIZE;
+    entry->next = map->buckets[bucket];
+    map->buckets[bucket] = entry;
+    map->count++;
+}
+
+static EDChildKeyEntry* ed_child_key_map_find(EDChildKeyMap* map, const char* key,
+                                                uint32_t hash)
+{
+    if (!map || !key) return NULL;
+    uint32_t bucket = hash % ED_DIFF_KEY_CACHE_SIZE;
+    EDChildKeyEntry* entry = map->buckets[bucket];
+    while (entry) {
+        if (entry->hash == hash && strcmp(entry->key, key) == 0) {
+            return entry;
+        }
+        entry = entry->next;
+    }
+    return NULL;
+}
+
+static void ed_child_key_map_destroy(EDChildKeyMap* map)
+{
+    if (!map) return;
+    for (uint32_t i = 0; i < ED_DIFF_KEY_CACHE_SIZE; i++) {
+        EDChildKeyEntry* entry = map->buckets[i];
+        while (entry) {
+            EDChildKeyEntry* next = entry->next;
+            free(entry);
+            entry = next;
+        }
+        map->buckets[i] = NULL;
+    }
+    map->count = 0;
+}
+
+static void ed_diff_children_keyed(EDVirtualNode* old_parent, EDVirtualNode* new_parent,
+                                    EDDiffResult* result)
+{
+    EDChildKeyMap key_map;
+    ed_child_key_map_init(&key_map);
+
+    /* Build key map from old children */
+    for (uint32_t i = 0; i < old_parent->child_count; i++) {
+        EDVirtualNode* child = old_parent->children[i];
+        if (child && child->key[0] != '\0') {
+            uint32_t h = ed_hash_fnv1a(child->key);
+            ed_child_key_map_insert(&key_map, child->key, h, i, child);
+        }
+    }
+
+    /* Track which old children have been matched */
+    bool* matched = NULL;
+    if (old_parent->child_count > 0) {
+        matched = (bool*)calloc(old_parent->child_count, sizeof(bool));
+    }
+
+    uint32_t last_placed_index = 0;
+
+    /* Walk new children */
+    for (uint32_t i = 0; i < new_parent->child_count; i++) {
+        EDVirtualNode* new_child = new_parent->children[i];
+        if (!new_child) continue;
+
+        if (new_child->key[0] != '\0') {
+            /* Keyed child: lookup in map */
+            uint32_t h = ed_hash_fnv1a(new_child->key);
+            EDChildKeyEntry* entry = ed_child_key_map_find(&key_map, new_child->key, h);
+
+            if (entry) {
+                EDVirtualNode* old_child = entry->old_node;
+                matched[entry->old_index] = true;
+
+                if (old_child->type == new_child->type &&
+                    strcmp(old_child->tag, new_child->tag) == 0) {
+                    /* Same type and key - check for updates */
+                    uint32_t prop_changes = 0;
+                    EDVirtualProp* changes = ed_diff_props(old_child, new_child, &prop_changes);
+
+                    if (prop_changes > 0 || strcmp(old_child->text, new_child->text) != 0) {
+                        EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_UPDATE, i);
+                        op->new_index = i;
+                        op->node = old_child;
+                        op->new_node = new_child;
+                        op->prop_changes = changes;
+                        op->prop_change_count = prop_changes;
+                        ed_diff_result_append(result, op);
+                    }
+
+                    /* Check if moved */
+                    if (entry->old_index < last_placed_index) {
+                        EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_MOVE, entry->old_index);
+                        op->new_index = i;
+                        op->node = old_child;
+                        op->new_node = new_child;
+                        ed_diff_result_append(result, op);
+                    } else {
+                        last_placed_index = entry->old_index;
+                    }
+
+                    /* Recurse into children */
+                    if (old_child->child_count > 0 || new_child->child_count > 0) {
+                        EDDiffResult* child_diff = ed_diff_compute(old_child, new_child);
+                        if (child_diff && child_diff->has_changes) {
+                            /* Merge child operations */
+                            EDDiffOperation* cop = child_diff->operations;
+                            while (cop) {
+                                EDDiffOperation* next = cop->next;
+                                cop->next = NULL;
+                                ed_diff_result_append(result, cop);
+                                cop = next;
+                            }
+                            child_diff->operations = NULL;
+                        }
+                        ed_diff_result_destroy(child_diff);
+                    }
+                } else {
+                    /* Type changed with same key - replace */
+                    EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_REPLACE, entry->old_index);
+                    op->new_index = i;
+                    op->node = old_child;
+                    op->new_node = new_child;
+                    ed_diff_result_append(result, op);
+                }
+            } else {
+                /* New keyed child - insert */
+                EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_INSERT, i);
+                op->new_index = i;
+                op->new_node = new_child;
+                ed_diff_result_append(result, op);
+            }
+        } else {
+            /* Unkeyed child: positional matching */
+            if (i < old_parent->child_count) {
+                EDVirtualNode* old_child = old_parent->children[i];
+                if (old_child && old_child->key[0] == '\0') {
+                    if (matched) matched[i] = true;
+
+                    if (old_child->type == new_child->type &&
+                        strcmp(old_child->tag, new_child->tag) == 0) {
+                        /* Same type - check for updates */
+                        uint32_t prop_changes = 0;
+                        EDVirtualProp* changes = ed_diff_props(old_child, new_child, &prop_changes);
+
+                        if (prop_changes > 0 || strcmp(old_child->text, new_child->text) != 0) {
+                            EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_UPDATE, i);
+                            op->new_index = i;
+                            op->node = old_child;
+                            op->new_node = new_child;
+                            op->prop_changes = changes;
+                            op->prop_change_count = prop_changes;
+                            ed_diff_result_append(result, op);
+                        }
+
+                        /* Recurse */
+                        if (old_child->child_count > 0 || new_child->child_count > 0) {
+                            EDDiffResult* child_diff = ed_diff_compute(old_child, new_child);
+                            if (child_diff && child_diff->has_changes) {
+                                EDDiffOperation* cop = child_diff->operations;
+                                while (cop) {
+                                    EDDiffOperation* next = cop->next;
+                                    cop->next = NULL;
+                                    ed_diff_result_append(result, cop);
+                                    cop = next;
+                                }
+                                child_diff->operations = NULL;
+                            }
+                            ed_diff_result_destroy(child_diff);
+                        }
+                    } else {
+                        /* Different type - replace */
+                        EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_REPLACE, i);
+                        op->new_index = i;
+                        op->node = old_child;
+                        op->new_node = new_child;
+                        ed_diff_result_append(result, op);
+                    }
+                } else {
+                    /* Old child has key, new doesn't - insert new, old stays for deletion */
+                    EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_INSERT, i);
+                    op->new_index = i;
+                    op->new_node = new_child;
+                    ed_diff_result_append(result, op);
+                }
+            } else {
+                /* Extra new child - insert */
+                EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_INSERT, i);
+                op->new_index = i;
+                op->new_node = new_child;
+                ed_diff_result_append(result, op);
+            }
+        }
+    }
+
+    /* Delete unmatched old children */
+    if (matched) {
+        for (uint32_t i = 0; i < old_parent->child_count; i++) {
+            if (!matched[i]) {
+                EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_DELETE, i);
+                op->node = old_parent->children[i];
+                ed_diff_result_append(result, op);
+            }
+        }
+        free(matched);
+    }
+
+    ed_child_key_map_destroy(&key_map);
+}
+
+/* ================================================================
+ * Main Diff Computation
+ * ================================================================ */
+
+EDDiffResult* ed_diff_compute(EDVirtualNode* old_tree, EDVirtualNode* new_tree)
+{
+    EDDiffResult* result = ed_diff_result_create();
+    if (!result) return NULL;
+
+    /* Both NULL - no changes */
+    if (!old_tree && !new_tree) {
+        result->has_changes = false;
+        return result;
+    }
+
+    /* Old is NULL - everything is new */
+    if (!old_tree) {
+        EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_INSERT, 0);
+        op->new_node = new_tree;
+        ed_diff_result_append(result, op);
+
+        /* Recursively mark all new children as inserts */
+        for (uint32_t i = 0; i < new_tree->child_count; i++) {
+            EDDiffOperation* child_op = ed_diff_operation_create(ED_DIFF_INSERT, i);
+            child_op->new_node = new_tree->children[i];
+            child_op->new_index = i;
+            ed_diff_result_append(result, child_op);
+        }
+        return result;
+    }
+
+    /* New is NULL - everything is deleted */
+    if (!new_tree) {
+        EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_DELETE, 0);
+        op->node = old_tree;
+        ed_diff_result_append(result, op);
+
+        for (uint32_t i = 0; i < old_tree->child_count; i++) {
+            EDDiffOperation* child_op = ed_diff_operation_create(ED_DIFF_DELETE, i);
+            child_op->node = old_tree->children[i];
+            ed_diff_result_append(result, child_op);
+        }
+        return result;
+    }
+
+    /* Both exist - compare types */
+    if (old_tree->type != new_tree->type ||
+        (old_tree->type == ED_NODE_ELEMENT && strcmp(old_tree->tag, new_tree->tag) != 0) ||
+        (old_tree->type == ED_NODE_TEXT && strcmp(old_tree->text, new_tree->text) != 0)) {
+        /* Different type or tag - replace */
+        EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_REPLACE, 0);
+        op->node = old_tree;
+        op->new_node = new_tree;
+        ed_diff_result_append(result, op);
+        return result;
+    }
+
+    /* Same type - diff props */
+    uint32_t prop_change_count = 0;
+    EDVirtualProp* prop_changes = ed_diff_props(old_tree, new_tree, &prop_change_count);
+
+    if (prop_change_count > 0) {
+        EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_PROP_UPDATE, 0);
+        op->node = old_tree;
+        op->new_node = new_tree;
+        op->prop_changes = prop_changes;
+        op->prop_change_count = prop_change_count;
+        ed_diff_result_append(result, op);
+    } else {
+        /* Free unused prop changes */
+        while (prop_changes) {
+            EDVirtualProp* next = prop_changes->next;
+            free(prop_changes);
+            prop_changes = next;
+        }
+    }
+
+    /* Diff text content for text nodes */
+    if (old_tree->type == ED_NODE_TEXT && strcmp(old_tree->text, new_tree->text) != 0) {
+        EDDiffOperation* op = ed_diff_operation_create(ED_DIFF_TEXT_UPDATE, 0);
+        op->node = old_tree;
+        op->new_node = new_tree;
+        ed_diff_result_append(result, op);
+    }
+
+    /* Diff children */
+    if (old_tree->child_count > 0 || new_tree->child_count > 0) {
+        ed_diff_children_keyed(old_tree, new_tree, result);
+    }
+
+    return result;
+}
+
+/* ================================================================
+ * Patch Queue Implementation
+ * ================================================================ */
+
+EDPatchQueue* ed_patch_queue_create(uint32_t capacity)
+{
+    EDPatchQueue* queue = (EDPatchQueue*)calloc(1, sizeof(EDPatchQueue));
+    if (!queue) return NULL;
+
+    queue->head = NULL;
+    queue->tail = NULL;
+    queue->count = 0;
+    queue->capacity = (capacity > 0) ? capacity : ED_PATCH_QUEUE_SIZE;
+
+    return queue;
+}
+
+void ed_patch_queue_destroy(EDPatchQueue* queue)
+{
+    if (!queue) return;
+    ed_patch_queue_flush(queue);
+    free(queue);
+}
+
+void ed_patch_queue_push(EDPatchQueue* queue, EDPatchOperation* op)
+{
+    if (!queue || !op) return;
+
+    if (queue->count >= queue->capacity) {
+        ed_log_warn("Patch queue full (%u/%u), auto-flushing",
+                    queue->count, queue->capacity);
+        ed_patch_queue_flush(queue);
+    }
+
+    op->next = NULL;
+
+    if (!queue->tail) {
+        queue->head = op;
+        queue->tail = op;
+    } else {
+        queue->tail->next = op;
+        queue->tail = op;
+    }
+
+    queue->count++;
+}
+
+EDPatchOperation* ed_patch_queue_pop(EDPatchQueue* queue)
+{
+    if (!queue || !queue->head) return NULL;
+
+    EDPatchOperation* op = queue->head;
+    queue->head = op->next;
+    if (!queue->head) {
+        queue->tail = NULL;
+    }
+    op->next = NULL;
+    queue->count--;
+
+    return op;
+}
+
+void ed_patch_queue_flush(EDPatchQueue* queue)
+{
+    if (!queue) return;
+
+    EDPatchOperation* op = queue->head;
+    while (op) {
+        EDPatchOperation* next = op->next;
+        free(op);
+        op = next;
+    }
+
+    queue->head = NULL;
+    queue->tail = NULL;
+    queue->count = 0;
+}
+
+uint32_t ed_patch_queue_count(EDPatchQueue* queue)
+{
+    return queue ? queue->count : 0;
+}
+
+bool ed_patch_queue_is_empty(EDPatchQueue* queue)
+{
+    return queue ? (queue->count == 0) : true;
+}
+
+/* ================================================================
+ * Patch Creation Helpers
+ * ================================================================ */
+
+static EDPatchOperation* ed_patch_create(EDPatchOpType type, void* target)
+{
+    EDPatchOperation* op = (EDPatchOperation*)calloc(1, sizeof(EDPatchOperation));
+    if (!op) return NULL;
+
+    op->type = type;
+    op->target_node = target;
+    op->key[0] = '\0';
+    op->value[0] = '\0';
+    op->index = 0;
+    op->data = NULL;
+    op->next = NULL;
+
+    return op;
+}
+
+/* ================================================================
+ * Patch Application
+ * ================================================================ */
+
+void ed_patch_apply(EDPatchOperation* op)
+{
+    if (!op) return;
+
+    switch (op->type) {
+        case ED_PATCH_SET_ATTRIBUTE:
+            /* Set DOM attribute */
+            ed_log_debug("PATCH: set attribute '%s'='%s'", op->key, op->value);
+            break;
+
+        case ED_PATCH_REMOVE_ATTRIBUTE:
+            ed_log_debug("PATCH: remove attribute '%s'", op->key);
+            break;
+
+        case ED_PATCH_SET_STYLE:
+            ed_log_debug("PATCH: set style '%s'='%s'", op->key, op->value);
+            break;
+
+        case ED_PATCH_REMOVE_STYLE:
+            ed_log_debug("PATCH: remove style '%s'", op->key);
+            break;
+
+        case ED_PATCH_ADD_CLASS:
+            ed_log_debug("PATCH: add class '%s'", op->value);
+            break;
+
+        case ED_PATCH_REMOVE_CLASS:
+            ed_log_debug("PATCH: remove class '%s'", op->value);
+            break;
+
+        case ED_PATCH_INSERT_CHILD:
+            ed_log_debug("PATCH: insert child at index %u", op->index);
+            break;
+
+        case ED_PATCH_REMOVE_CHILD:
+            ed_log_debug("PATCH: remove child at index %u", op->index);
+            break;
+
+        case ED_PATCH_REPLACE_CHILD:
+            ed_log_debug("PATCH: replace child at index %u", op->index);
+            break;
+
+        case ED_PATCH_MOVE_CHILD:
+            ed_log_debug("PATCH: move child from %u to %u", op->index, (uint32_t)(uintptr_t)op->data);
+            break;
+
+        case ED_PATCH_SET_TEXT:
+            ed_log_debug("PATCH: set text '%s'", op->value);
+            break;
+
+        case ED_PATCH_SET_EVENT:
+            ed_log_debug("PATCH: set event '%s'", op->key);
+            break;
+
+        case ED_PATCH_REMOVE_EVENT:
+            ed_log_debug("PATCH: remove event '%s'", op->key);
+            break;
+
+        case ED_PATCH_SET_REF:
+            ed_log_debug("PATCH: set ref");
+            break;
+
+        case ED_PATCH_REMOVE_REF:
+            ed_log_debug("PATCH: remove ref");
+            break;
+
+        default:
+            ed_log_warn("PATCH: unknown operation type %d", op->type);
+            break;
+    }
+}
+
+void ed_patch_apply_all(EDPatchQueue* queue)
+{
+    if (!queue) return;
+
+    uint32_t applied = 0;
+    EDPatchOperation* op = queue->head;
+
+    while (op) {
+        ed_patch_apply(op);
+        applied++;
+        op = op->next;
+    }
+
+    ed_log_debug("Applied %u patches", applied);
+    ed_patch_queue_flush(queue);
+}
+
+/* ================================================================
+ * Diff-to-Patch Conversion
+ * ================================================================ */
+
+static EDPatchQueue* ed_diff_to_patches(EDDiffResult* diff, void* root_node)
+{
+    if (!diff) return NULL;
+
+    EDPatchQueue* queue = ed_patch_queue_create(ED_PATCH_QUEUE_SIZE);
+    if (!queue) return NULL;
+
+    EDDiffOperation* op = diff->operations;
+    while (op) {
+        switch (op->type) {
+            case ED_DIFF_INSERT: {
+                if (op->new_node) {
+                    EDPatchOperation* patch = ed_patch_create(ED_PATCH_INSERT_CHILD, root_node);
+                    patch->data = op->new_node;
+                    patch->index = op->index;
+                    ed_patch_queue_push(queue, patch);
+
+                    /* Generate patches for props on the new node */
+                    EDVirtualProp* prop = op->new_node->props;
+                    while (prop) {
+                        EDPatchOperation* prop_patch = ed_patch_create(
+                            ED_PATCH_SET_ATTRIBUTE, op->new_node);
+                        strncpy(prop_patch->key, prop->key, ED_MAX_PROP_KEY_LEN - 1);
+                        strncpy(prop_patch->value, prop->value, ED_MAX_PROP_VALUE_LEN - 1);
+                        ed_patch_queue_push(queue, prop_patch);
+                        prop = prop->next;
+                    }
+                }
+                break;
+            }
+
+            case ED_DIFF_DELETE: {
+                EDPatchOperation* patch = ed_patch_create(ED_PATCH_REMOVE_CHILD, root_node);
+                patch->data = op->node;
+                patch->index = op->index;
+                ed_patch_queue_push(queue, patch);
+                break;
+            }
+
+            case ED_DIFF_REPLACE: {
+                EDPatchOperation* patch = ed_patch_create(ED_PATCH_REPLACE_CHILD, root_node);
+                patch->data = op->new_node;
+                patch->index = op->index;
+                ed_patch_queue_push(queue, patch);
+                break;
+            }
+
+            case ED_DIFF_MOVE: {
+                EDPatchOperation* patch = ed_patch_create(ED_PATCH_MOVE_CHILD, root_node);
+                patch->index = op->index;
+                patch->data = (void*)(uintptr_t)op->new_index;
+                ed_patch_queue_push(queue, patch);
+                break;
+            }
+
+            case ED_DIFF_UPDATE: {
+                /* Convert prop changes to patches */
+                EDVirtualProp* change = op->prop_changes;
+                while (change) {
+                    if (strlen(change->value) == 0) {
+                        /* Removed prop */
+                        EDPatchOperation* prop_patch = ed_patch_create(
+                            ED_PATCH_REMOVE_ATTRIBUTE, op->node);
+                        strncpy(prop_patch->key, change->key, ED_MAX_PROP_KEY_LEN - 1);
+                        ed_patch_queue_push(queue, prop_patch);
+                    } else {
+                        /* Updated/added prop */
+                        EDPatchOpType patch_type = ED_PATCH_SET_ATTRIBUTE;
+                        if (change->is_style) patch_type = ED_PATCH_SET_STYLE;
+                        else if (change->is_class) patch_type = ED_PATCH_ADD_CLASS;
+                        else if (change->is_event) patch_type = ED_PATCH_SET_EVENT;
+                        else if (change->is_ref) patch_type = ED_PATCH_SET_REF;
+
+                        EDPatchOperation* prop_patch = ed_patch_create(patch_type, op->node);
+                        strncpy(prop_patch->key, change->key, ED_MAX_PROP_KEY_LEN - 1);
+                        strncpy(prop_patch->value, change->value, ED_MAX_PROP_VALUE_LEN - 1);
+                        ed_patch_queue_push(queue, prop_patch);
+                    }
+                    change = change->next;
+                }
+                break;
+            }
+
+            case ED_DIFF_PROP_UPDATE: {
+                EDVirtualProp* change = op->prop_changes;
+                while (change) {
+                    if (strlen(change->value) == 0) {
+                        EDPatchOperation* prop_patch = ed_patch_create(
+                            ED_PATCH_REMOVE_ATTRIBUTE, op->node);
+                        strncpy(prop_patch->key, change->key, ED_MAX_PROP_KEY_LEN - 1);
+                        ed_patch_queue_push(queue, prop_patch);
+                    } else {
+                        EDPatchOperation* prop_patch = ed_patch_create(
+                            ED_PATCH_SET_ATTRIBUTE, op->node);
+                        strncpy(prop_patch->key, change->key, ED_MAX_PROP_KEY_LEN - 1);
+                        strncpy(prop_patch->value, change->value, ED_MAX_PROP_VALUE_LEN - 1);
+                        ed_patch_queue_push(queue, prop_patch);
+                    }
+                    change = change->next;
+                }
+                break;
+            }
+
+            case ED_DIFF_TEXT_UPDATE: {
+                EDPatchOperation* patch = ed_patch_create(ED_PATCH_SET_TEXT, op->node);
+                if (op->new_node) {
+                    strncpy(patch->value, op->new_node->text, ED_MAX_PROP_VALUE_LEN - 1);
+                }
+                ed_patch_queue_push(queue, patch);
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        op = op->next;
+    }
+
+    return queue;
+}
+
+/* ================================================================
+ * Optimized Diff: Quick Equality Check
+ * ================================================================ */
+
+static bool ed_diff_quick_check(EDVirtualNode* old_tree, EDVirtualNode* new_tree)
+{
+    if (!old_tree || !new_tree) return false;
+    if (old_tree->hash != 0 && new_tree->hash != 0 && old_tree->hash == new_tree->hash) {
+        return true; /* Same hash - likely identical */
+    }
+    if (old_tree == new_tree) return true; /* Same pointer */
+    return false;
+}
+
+/* ================================================================
+ * Diff Statistics
+ * ================================================================ */
+
+typedef struct EDDiffStats {
+    uint32_t total_diffs;
+    uint32_t total_operations;
+    uint64_t total_diff_time_ns;
+    uint32_t cache_hits;
+    uint32_t cache_misses;
+} EDDiffStats;
+
+static EDDiffStats g_diff_stats = {0};
+
+static void ed_diff_record_stats(EDDiffResult* result, uint64_t elapsed_ms)
+{
+    g_diff_stats.total_diffs++;
+    g_diff_stats.total_operations += result ? result->operation_count : 0;
+    (void)elapsed_ms;
+}