elementdrawing 1.0.0

package/src/core/fiber.c

@@ -0,0 +1,1027 @@
+/*
+ * fiber.c - ElementDrawing Core: Fiber Architecture
+ *
+ * Implements fiber node creation/destruction, fiber pool management,
+ * fiber tree manipulation (add child/sibling), property and state
+ * management, effect tracking, flag operations, and the complete
+ * reconciliation algorithm for the ElementDrawing engine.
+ */
+
+#include "bridge.h"
+
+/* ================================================================
+ * Fiber Node Creation and Destruction
+ * ================================================================ */
+
+EDFiberNode* ed_fiber_create(EDFiberTag tag, EDFiberFlags flags)
+{
+    EDFiberNode* fiber = (EDFiberNode*)calloc(1, sizeof(EDFiberNode));
+    if (!fiber) {
+        ed_log_error("Failed to allocate fiber node (tag=%d)", tag);
+        return NULL;
+    }
+
+    fiber->tag = tag;
+    fiber->flags = flags;
+    fiber->priority = ED_PRIORITY_NORMAL;
+
+    /* Tree structure initialized to NULL by calloc */
+    fiber->parent = NULL;
+    fiber->child = NULL;
+    fiber->sibling = NULL;
+    fiber->alternate = NULL;
+
+    /* Work */
+    fiber->pending_props = NULL;
+    fiber->memoized_props = NULL;
+    fiber->memoized_state = NULL;
+    fiber->memoized_hooks = NULL;
+
+    /* DOM reference */
+    fiber->state_node = NULL;
+    fiber->ref_value = NULL;
+
+    /* Key */
+    fiber->key[0] = '\0';
+    fiber->key_hash = 0;
+
+    /* Effect lists */
+    fiber->first_effect = NULL;
+    fiber->last_effect = NULL;
+    fiber->next_effect = NULL;
+
+    /* Dependency tracking */
+    fiber->dependencies = NULL;
+    fiber->lanes = 0;
+    fiber->child_lanes = 0;
+
+    /* Update queue */
+    fiber->update_queue = NULL;
+    fiber->update_count = 0;
+
+    /* Return node */
+    fiber->return_node = NULL;
+
+    /* Index */
+    fiber->index = 0;
+
+    /* Scheduling */
+    fiber->expiration_time = 0;
+    fiber->start_time = 0;
+    fiber->finish_time = 0;
+
+    /* Error boundary */
+    fiber->error_boundary = NULL;
+    fiber->error_boundary_info = NULL;
+
+    /* Offscreen */
+    fiber->is_hidden = false;
+    fiber->is_offscreen = false;
+
+    /* Pool */
+    fiber->is_active = true;
+    fiber->next_free = NULL;
+
+    return fiber;
+}
+
+void ed_fiber_destroy(EDFiberNode* fiber)
+{
+    if (!fiber) return;
+
+    /* Destroy memoized hooks chain */
+    EDHookNode* hook = fiber->memoized_hooks;
+    while (hook) {
+        EDHookNode* next = hook->next;
+        ed_hook_destroy(hook);
+        hook = next;
+    }
+
+    /* Don't recursively destroy children - that's the pool's job
+     * or the tree traversal that initiates destruction */
+
+    /* Clear references (don't free what we don't own) */
+    fiber->pending_props = NULL;
+    fiber->memoized_props = NULL;
+    fiber->memoized_state = NULL;
+    fiber->state_node = NULL;
+    fiber->ref_value = NULL;
+    fiber->update_queue = NULL;
+    fiber->error_boundary_info = NULL;
+    fiber->dependencies = NULL;
+
+    /* Clear effect list references */
+    fiber->first_effect = NULL;
+    fiber->last_effect = NULL;
+    fiber->next_effect = NULL;
+
+    /* Mark as inactive for pool recycling */
+    fiber->is_active = false;
+
+    free(fiber);
+}
+
+/* ================================================================
+ * Fiber Pool
+ * ================================================================ */
+
+EDFiberPool* ed_fiber_pool_create(uint32_t capacity)
+{
+    if (capacity == 0) capacity = ED_FIBER_POOL_SIZE;
+
+    EDFiberPool* pool = (EDFiberPool*)calloc(1, sizeof(EDFiberPool));
+    if (!pool) return NULL;
+
+    pool->nodes = (EDFiberNode*)calloc(capacity, sizeof(EDFiberNode));
+    if (!pool->nodes) {
+        free(pool);
+        return NULL;
+    }
+
+    pool->capacity = capacity;
+    pool->used_count = 0;
+    pool->peak_usage = 0;
+    pool->alloc_count = 0;
+    pool->free_count = 0;
+    pool->reuse_count = 0;
+
+    /* Initialize all nodes as inactive and build free list */
+    pool->free_list = NULL;
+    for (uint32_t i = capacity; i > 0; i--) {
+        EDFiberNode* node = &pool->nodes[i - 1];
+        node->is_active = false;
+        node->next_free = pool->free_list;
+        pool->free_list = node;
+    }
+
+    ed_log_debug("Fiber pool created: capacity=%u", capacity);
+    return pool;
+}
+
+void ed_fiber_pool_destroy(EDFiberPool* pool)
+{
+    if (!pool) return;
+
+    /* Destroy any active fiber hooks */
+    for (uint32_t i = 0; i < pool->capacity; i++) {
+        EDFiberNode* node = &pool->nodes[i];
+        if (node->is_active && node->memoized_hooks) {
+            EDHookNode* hook = node->memoized_hooks;
+            while (hook) {
+                EDHookNode* next = hook->next;
+                ed_hook_destroy(hook);
+                hook = next;
+            }
+        }
+    }
+
+    free(pool->nodes);
+    pool->nodes = NULL;
+    pool->free_list = NULL;
+    free(pool);
+}
+
+EDFiberNode* ed_fiber_pool_alloc(EDFiberPool* pool)
+{
+    if (!pool) return ed_fiber_create(ED_FIBER_HOST_COMPONENT, ED_FIBER_FLAG_NONE);
+
+    /* Try to get from free list */
+    if (pool->free_list) {
+        EDFiberNode* fiber = pool->free_list;
+        pool->free_list = fiber->next_free;
+        fiber->next_free = NULL;
+
+        /* Reset the fiber to a clean state */
+        memset(fiber, 0, sizeof(EDFiberNode));
+        fiber->is_active = true;
+        fiber->tag = ED_FIBER_HOST_COMPONENT;
+        fiber->priority = ED_PRIORITY_NORMAL;
+
+        pool->used_count++;
+        pool->alloc_count++;
+        pool->reuse_count++;
+
+        if (pool->used_count > pool->peak_usage) {
+            pool->peak_usage = pool->used_count;
+        }
+
+        return fiber;
+    }
+
+    /* Pool exhausted - allocate a new standalone fiber */
+    ed_log_warn("Fiber pool exhausted (capacity=%u), allocating standalone", pool->capacity);
+    EDFiberNode* fiber = ed_fiber_create(ED_FIBER_HOST_COMPONENT, ED_FIBER_FLAG_NONE);
+    pool->alloc_count++;
+    return fiber;
+}
+
+void ed_fiber_pool_free(EDFiberPool* pool, EDFiberNode* fiber)
+{
+    if (!pool || !fiber) return;
+
+    /* Check if fiber belongs to pool */
+    if (fiber >= pool->nodes && fiber < pool->nodes + pool->capacity) {
+        /* Reset the fiber */
+        EDHookNode* hook = fiber->memoized_hooks;
+        while (hook) {
+            EDHookNode* next = hook->next;
+            ed_hook_destroy(hook);
+            hook = next;
+        }
+
+        memset(fiber, 0, sizeof(EDFiberNode));
+        fiber->is_active = false;
+        fiber->next_free = pool->free_list;
+        pool->free_list = fiber;
+
+        pool->used_count--;
+        pool->free_count++;
+    } else {
+        /* Standalone fiber - just destroy it */
+        ed_fiber_destroy(fiber);
+        pool->free_count++;
+    }
+}
+
+/* ================================================================
+ * Fiber Clone
+ * ================================================================ */
+
+EDFiberNode* ed_fiber_clone(EDFiberNode* fiber)
+{
+    if (!fiber) return NULL;
+
+    EDFiberNode* clone = ed_fiber_create(fiber->tag, fiber->flags);
+    if (!clone) return NULL;
+
+    /* Copy scalar fields */
+    clone->priority = fiber->priority;
+    clone->lanes = fiber->lanes;
+    clone->child_lanes = fiber->child_lanes;
+    clone->index = fiber->index;
+    clone->is_hidden = fiber->is_hidden;
+    clone->is_offscreen = fiber->is_offscreen;
+
+    /* Copy key */
+    if (fiber->key[0] != '\0') {
+        strncpy(clone->key, fiber->key, ED_MAX_KEY_LEN - 1);
+        clone->key[ED_MAX_KEY_LEN - 1] = '\0';
+    }
+    clone->key_hash = fiber->key_hash;
+
+    /* Set up alternate relationship */
+    clone->alternate = fiber;
+    fiber->alternate = clone;
+
+    /* Copy props/state references (shared, not deep-copied) */
+    clone->pending_props = fiber->pending_props;
+    clone->memoized_props = fiber->memoized_props;
+    clone->memoized_state = fiber->memoized_state;
+    clone->memoized_hooks = fiber->memoized_hooks;
+
+    /* Copy DOM reference */
+    clone->state_node = fiber->state_node;
+    clone->ref_value = fiber->ref_value;
+
+    /* Copy return pointer */
+    clone->return_node = fiber->return_node;
+
+    /* Copy scheduling info */
+    clone->expiration_time = fiber->expiration_time;
+
+    /* Copy error boundary */
+    clone->error_boundary = fiber->error_boundary;
+
+    /* Set WIP flag */
+    ed_fiber_set_flag(clone, ED_FIBER_FLAG_WORK_IN_PROGRESS);
+    ed_fiber_set_flag(clone, ED_FIBER_FLAG_CLONED);
+
+    return clone;
+}
+
+/* ================================================================
+ * Fiber Tree Manipulation
+ * ================================================================ */
+
+void ed_fiber_add_child(EDFiberNode* parent, EDFiberNode* child)
+{
+    if (!parent || !child) return;
+
+    child->return_node = parent;
+
+    if (!parent->child) {
+        parent->child = child;
+    } else {
+        /* Add as last sibling */
+        EDFiberNode* sibling = parent->child;
+        while (sibling->sibling) {
+            sibling = sibling->sibling;
+        }
+        sibling->sibling = child;
+    }
+
+    /* Update child lanes on parent */
+    parent->child_lanes |= child->lanes;
+}
+
+void ed_fiber_add_sibling(EDFiberNode* a, EDFiberNode* b)
+{
+    if (!a || !b) return;
+
+    EDFiberNode* sibling = a;
+    while (sibling->sibling) {
+        sibling = sibling->sibling;
+    }
+    sibling->sibling = b;
+    b->return_node = a->return_node;
+}
+
+void ed_fiber_set_props(EDFiberNode* fiber, EDVirtualNode* props)
+{
+    if (!fiber) return;
+    fiber->pending_props = props;
+    ed_fiber_set_flag(fiber, ED_FIBER_FLAG_NEEDS_UPDATE);
+}
+
+void ed_fiber_set_state(EDFiberNode* fiber, EDVirtualNode* state)
+{
+    if (!fiber) return;
+    fiber->memoized_state = state;
+    ed_fiber_set_flag(fiber, ED_FIBER_FLAG_UPDATE);
+}
+
+void ed_fiber_add_effect(EDFiberNode* fiber, EDFiberNode* effect)
+{
+    if (!fiber || !effect) return;
+
+    if (!fiber->last_effect) {
+        fiber->first_effect = effect;
+        fiber->last_effect = effect;
+    } else {
+        fiber->last_effect->next_effect = effect;
+        fiber->last_effect = effect;
+    }
+
+    ed_fiber_set_flag(fiber, ED_FIBER_FLAG_HAS_EFFECT);
+}
+
+void ed_fiber_add_dependency(EDFiberNode* fiber, EDFiberNode* dep)
+{
+    if (!fiber || !dep) return;
+
+    /* Simple linked list for dependencies */
+    dep->dependencies = fiber->dependencies;
+    fiber->dependencies = dep;
+}
+
+void ed_fiber_set_priority(EDFiberNode* fiber, EDSchedulerPriority priority)
+{
+    if (!fiber) return;
+    fiber->priority = priority;
+
+    /* Update expiration time based on priority */
+    uint64_t now = ed_get_timestamp_ms();
+    switch (priority) {
+        case ED_PRIORITY_IMMEDIATE:
+            fiber->expiration_time = now;
+            break;
+        case ED_PRIORITY_USER_BLOCKING:
+            fiber->expiration_time = now + 100;
+            break;
+        case ED_PRIORITY_NORMAL:
+            fiber->expiration_time = now + ED_FIBER_WORK_EXPIRATION;
+            break;
+        case ED_PRIORITY_LOW:
+            fiber->expiration_time = now + 10000;
+            break;
+        case ED_PRIORITY_IDLE:
+            fiber->expiration_time = UINT64_MAX;
+            break;
+    }
+}
+
+/* ================================================================
+ * Fiber Traversal and Counting
+ * ================================================================ */
+
+uint32_t ed_fiber_count_descendants(EDFiberNode* fiber)
+{
+    if (!fiber) return 0;
+
+    uint32_t count = 0;
+    EDFiberNode* child = fiber->child;
+    while (child) {
+        count += 1 + ed_fiber_count_descendants(child);
+        child = child->sibling;
+    }
+    return count;
+}
+
+uint32_t ed_fiber_count_effects(EDFiberNode* fiber)
+{
+    if (!fiber) return 0;
+
+    uint32_t count = 0;
+    EDFiberNode* effect = fiber->first_effect;
+    while (effect) {
+        count++;
+        effect = effect->next_effect;
+    }
+    return count;
+}
+
+/* ================================================================
+ * Fiber Flag Operations
+ * ================================================================ */
+
+bool ed_fiber_has_effect(EDFiberNode* fiber, EDFiberFlags flag)
+{
+    if (!fiber) return false;
+    return (fiber->flags & flag) != 0;
+}
+
+void ed_fiber_set_flag(EDFiberNode* fiber, EDFiberFlags flag)
+{
+    if (!fiber) return;
+    fiber->flags |= flag;
+}
+
+void ed_fiber_clear_flag(EDFiberNode* fiber, EDFiberFlags flag)
+{
+    if (!fiber) return;
+    fiber->flags &= ~flag;
+}
+
+/* ================================================================
+ * Reconciliation: Single Element
+ * ================================================================ */
+
+static bool ed_fiber_tags_match(EDFiberNode* current, EDVirtualNode* element)
+{
+    if (!current || !element) return false;
+
+    switch (element->type) {
+        case ED_NODE_ELEMENT:
+            return current->tag == ED_FIBER_HOST_COMPONENT &&
+                   strcmp(current->memoized_props ? current->memoized_props->tag : "",
+                          element->tag) == 0;
+        case ED_NODE_TEXT:
+            return current->tag == ED_FIBER_HOST_TEXT;
+        case ED_NODE_FRAGMENT:
+            return current->tag == ED_FIBER_FRAGMENT;
+        case ED_NODE_CONTEXT_PROVIDER:
+            return current->tag == ED_FIBER_CONTEXT_PROVIDER;
+        case ED_NODE_CONTEXT_CONSUMER:
+            return current->tag == ED_FIBER_CONTEXT_CONSUMER;
+        default:
+            return false;
+    }
+}
+
+EDFiberNode* ed_reconcile_single_element(EDFiberNode* current,
+                                          EDFiberNode* work_in_progress,
+                                          EDVirtualNode* element)
+{
+    if (!element) return NULL;
+
+    const char* key = element->key[0] != '\0' ? element->key : NULL;
+
+    if (current !== NULL) {
+        /* Check if we can reuse the existing fiber */
+        if (ed_fiber_tags_match(current, element)) {
+            /* Check keys match */
+            if ((key == NULL && current->key[0] == '\0') ||
+                (key != NULL && strcmp(current->key, key) == 0)) {
+                /* Reuse the current fiber */
+                EDFiberNode* existing = ed_use_fiber(current, element);
+                ed_fiber_clear_flag(existing, ED_FIBER_FLAG_DELETION);
+                ed_fiber_set_flag(existing, ED_FIBER_FLAG_UPDATE);
+                return existing;
+            }
+        }
+
+        /* Cannot reuse - delete the current fiber */
+        ed_fiber_set_flag(current, ED_FIBER_FLAG_DELETION);
+    }
+
+    /* Create a new fiber */
+    EDFiberNode* fiber = ed_create_child(element, 0);
+    if (key && key[0] != '\0') {
+        strncpy(fiber->key, key, ED_MAX_KEY_LEN - 1);
+        fiber->key[ED_MAX_KEY_LEN - 1] = '\0';
+        fiber->key_hash = ed_hash_fnv1a(key);
+    }
+
+    ed_fiber_set_flag(fiber, ED_FIBER_FLAG_PLACEMENT);
+    return fiber;
+}
+
+EDFiberNode* ed_reconcile_single_text(EDFiberNode* current,
+                                       EDFiberNode* work_in_progress,
+                                       EDVirtualNode* text)
+{
+    if (!text) return NULL;
+
+    if (current !== NULL && current->tag == ED_FIBER_HOST_TEXT) {
+        /* Reuse existing text fiber */
+        EDFiberNode* existing = ed_use_fiber(current, text);
+        ed_fiber_clear_flag(existing, ED_FIBER_FLAG_DELETION);
+
+        /* Check if text content changed */
+        if (current->memoized_props &&
+            strcmp(current->memoized_props->text, text->text) != 0) {
+            ed_fiber_set_flag(existing, ED_FIBER_FLAG_UPDATE);
+        }
+        return existing;
+    }
+
+    /* Create new text fiber */
+    EDFiberNode* fiber = ed_fiber_create(ED_FIBER_HOST_TEXT, ED_FIBER_FLAG_NONE);
+    if (!fiber) return NULL;
+
+    fiber->pending_props = text;
+    ed_fiber_set_flag(fiber, ED_FIBER_FLAG_PLACEMENT);
+    return fiber;
+}
+
+/* ================================================================
+ * Reconciliation: Children Array (O(n) algorithm with keys)
+ * ================================================================ */
+
+/* Key-to-fiber mapping for efficient lookups */
+typedef struct EDKeyMapEntry {
+    char key[ED_MAX_KEY_LEN];
+    uint32_t key_hash;
+    EDFiberNode* fiber;
+    uint32_t index;
+    struct EDKeyMapEntry* next;
+} EDKeyMapEntry;
+
+typedef struct EDKeyMap {
+    EDKeyMapEntry* buckets[ED_DIFF_KEY_CACHE_SIZE];
+    uint32_t count;
+} EDKeyMap;
+
+static void ed_key_map_init(EDKeyMap* map)
+{
+    if (!map) return;
+    memset(map, 0, sizeof(EDKeyMap));
+}
+
+static void ed_key_map_insert(EDKeyMap* map, const char* key, uint32_t key_hash,
+                               EDFiberNode* fiber, uint32_t index)
+{
+    if (!map || !key) return;
+
+    EDKeyMapEntry* entry = (EDKeyMapEntry*)calloc(1, sizeof(EDKeyMapEntry));
+    if (!entry) return;
+
+    strncpy(entry->key, key, ED_MAX_KEY_LEN - 1);
+    entry->key[ED_MAX_KEY_LEN - 1] = '\0';
+    entry->key_hash = key_hash;
+    entry->fiber = fiber;
+    entry->index = index;
+
+    uint32_t bucket = key_hash % ED_DIFF_KEY_CACHE_SIZE;
+    entry->next = map->buckets[bucket];
+    map->buckets[bucket] = entry;
+    map->count++;
+}
+
+static EDFiberNode* ed_key_map_lookup(EDKeyMap* map, const char* key, uint32_t key_hash,
+                                       uint32_t* out_index)
+{
+    if (!map || !key) return NULL;
+
+    uint32_t bucket = key_hash % ED_DIFF_KEY_CACHE_SIZE;
+    EDKeyMapEntry* entry = map->buckets[bucket];
+
+    while (entry) {
+        if (entry->key_hash == key_hash && strcmp(entry->key, key) == 0) {
+            if (out_index) *out_index = entry->index;
+            return entry->fiber;
+        }
+        entry = entry->next;
+    }
+    return NULL;
+}
+
+static void ed_key_map_destroy(EDKeyMap* map)
+{
+    if (!map) return;
+    for (uint32_t i = 0; i < ED_DIFF_KEY_CACHE_SIZE; i++) {
+        EDKeyMapEntry* entry = map->buckets[i];
+        while (entry) {
+            EDKeyMapEntry* next = entry->next;
+            free(entry);
+            entry = next;
+        }
+        map->buckets[i] = NULL;
+    }
+    map->count = 0;
+}
+
+EDFiberNode* ed_reconcile_children_array(EDFiberNode* current,
+                                          EDFiberNode* work_in_progress,
+                                          EDVirtualNode** next_children,
+                                          uint32_t count)
+{
+    if (!work_in_progress || !next_children || count == 0) return NULL;
+
+    /* Build key map from current children */
+    EDKeyMap existing_map;
+    ed_key_map_init(&existing_map);
+
+    EDFiberNode* existing_child = current ? current->child : NULL;
+    uint32_t existing_idx = 0;
+    while (existing_child) {
+        if (existing_child->key[0] != '\0') {
+            ed_key_map_insert(&existing_map, existing_child->key,
+                              existing_child->key_hash, existing_child, existing_idx);
+        }
+        existing_child = existing_child->sibling;
+        existing_idx++;
+    }
+
+    /* Reconcile each new child */
+    EDFiberNode* first_new_child = NULL;
+    EDFiberNode* prev_new_child = NULL;
+    uint32_t last_placed_index = 0;
+
+    for (uint32_t i = 0; i < count; i++) {
+        EDVirtualNode* element = next_children[i];
+        if (!element) continue;
+
+        EDFiberNode* new_fiber = NULL;
+        const char* key = element->key[0] != '\0' ? element->key : NULL;
+        uint32_t key_hash = key ? ed_hash_fnv1a(key) : 0;
+
+        if (key) {
+            /* Key-based matching */
+            uint32_t matched_index = 0;
+            EDFiberNode* matched = ed_key_map_lookup(&existing_map, key, key_hash,
+                                                      &matched_index);
+            if (matched) {
+                /* Found a match - reuse the fiber */
+                if (ed_fiber_tags_match(matched, element)) {
+                    new_fiber = ed_use_fiber(matched, element);
+                    ed_fiber_clear_flag(new_fiber, ED_FIBER_FLAG_DELETION);
+                    ed_fiber_set_flag(new_fiber, ED_FIBER_FLAG_UPDATE);
+
+                    /* Check if moved (out of order) */
+                    if (matched_index < last_placed_index) {
+                        ed_fiber_set_flag(new_fiber, ED_FIBER_FLAG_PLACEMENT);
+                    }
+                    last_placed_index = (matched_index > last_placed_index) ?
+                                         matched_index : last_placed_index;
+                } else {
+                    /* Type changed - delete old, create new */
+                    ed_fiber_set_flag(matched, ED_FIBER_FLAG_DELETION);
+                    new_fiber = ed_create_child(element, i);
+                    ed_fiber_set_flag(new_fiber, ED_FIBER_FLAG_PLACEMENT);
+                }
+            } else {
+                /* No match - create new */
+                new_fiber = ed_create_child(element, i);
+                ed_fiber_set_flag(new_fiber, ED_FIBER_FLAG_PLACEMENT);
+            }
+        } else {
+            /* No key - positional matching */
+            if (current) {
+                EDFiberNode* old_child = current->child;
+                uint32_t j = 0;
+                while (old_child && j < i) {
+                    old_child = old_child->sibling;
+                    j++;
+                }
+                if (old_child && ed_fiber_tags_match(old_child, element) &&
+                    old_child->key[0] == '\0') {
+                    new_fiber = ed_use_fiber(old_child, element);
+                    ed_fiber_clear_flag(new_fiber, ED_FIBER_FLAG_DELETION);
+                    ed_fiber_set_flag(new_fiber, ED_FIBER_FLAG_UPDATE);
+                } else {
+                    new_fiber = ed_create_child(element, i);
+                    ed_fiber_set_flag(new_fiber, ED_FIBER_FLAG_PLACEMENT);
+                }
+            } else {
+                new_fiber = ed_create_child(element, i);
+                ed_fiber_set_flag(new_fiber, ED_FIBER_FLAG_PLACEMENT);
+            }
+        }
+
+        if (new_fiber) {
+            new_fiber->index = i;
+            new_fiber->return_node = work_in_progress;
+
+            if (!first_new_child) {
+                first_new_child = new_fiber;
+            } else if (prev_new_child) {
+                prev_new_child->sibling = new_fiber;
+            }
+            prev_new_child = new_fiber;
+        }
+    }
+
+    ed_key_map_destroy(&existing_map);
+
+    /* Mark remaining old children for deletion */
+    if (current) {
+        EDFiberNode* old_child = current->child;
+        while (old_child) {
+            if (!ed_fiber_has_effect(old_child, ED_FIBER_FLAG_UPDATE) &&
+                !ed_fiber_has_effect(old_child, ED_FIBER_FLAG_PLACEMENT)) {
+                ed_fiber_set_flag(old_child, ED_FIBER_FLAG_DELETION);
+            }
+            old_child = old_child->sibling;
+        }
+    }
+
+    return first_new_child;
+}
+
+/* ================================================================
+ * Reconciliation: Top-Level Children
+ * ================================================================ */
+
+EDFiberNode* ed_reconcile_children(EDFiberNode* current, EDFiberNode* work_in_progress)
+{
+    if (!work_in_progress) return NULL;
+
+    EDVirtualNode* next_children = work_in_progress->pending_props;
+
+    if (current == NULL) {
+        /* Mount: no current tree, just create new fibers */
+        if (next_children) {
+            EDFiberNode* child = NULL;
+            if (next_children->type == ED_NODE_TEXT) {
+                child = ed_reconcile_single_text(NULL, work_in_progress, next_children);
+            } else {
+                child = ed_reconcile_single_element(NULL, work_in_progress, next_children);
+            }
+            work_in_progress->child = child;
+            return child;
+        }
+        return NULL;
+    }
+
+    /* Update: reconcile current with new */
+    if (next_children) {
+        if (next_children->child_count > 0) {
+            EDFiberNode* first_child = ed_reconcile_children_array(
+                current, work_in_progress,
+                next_children->children,
+                next_children->child_count);
+            work_in_progress->child = first_child;
+            return first_child;
+        } else if (next_children->type == ED_NODE_TEXT) {
+            EDFiberNode* child = ed_reconcile_single_text(
+                current->child, work_in_progress, next_children);
+            work_in_progress->child = child;
+            return child;
+        } else {
+            EDFiberNode* child = ed_reconcile_single_element(
+                current->child, work_in_progress, next_children);
+            work_in_progress->child = child;
+            return child;
+        }
+    }
+
+    /* No children - delete existing */
+    ed_delete_remaining_children(current);
+    work_in_progress->child = NULL;
+    return NULL;
+}
+
+void ed_reconcile_child_fibers(EDFiberNode* current, EDFiberNode* work_in_progress,
+                                EDVirtualNode* next_children)
+{
+    if (!work_in_progress) return;
+
+    if (next_children) {
+        work_in_progress->pending_props = next_children;
+    }
+
+    ed_reconcile_children(current, work_in_progress);
+}
+
+/* ================================================================
+ * Reconciliation Helpers
+ * ================================================================ */
+
+void ed_place_child(EDFiberNode* new_fiber, EDFiberFlags flags, uint32_t index)
+{
+    if (!new_fiber) return;
+
+    ed_fiber_set_flag(new_fiber, flags);
+    if (flags & ED_FIBER_FLAG_PLACEMENT) {
+        ed_fiber_set_flag(new_fiber, ED_FIBER_FLAG_PLACEMENT);
+    }
+    new_fiber->index = index;
+}
+
+EDFiberNode* ed_update_slot(EDFiberNode* current, uint32_t index, EDVirtualNode* element)
+{
+    if (!element) return NULL;
+
+    /* Return existing fiber at slot if compatible, otherwise create new */
+    if (current) {
+        EDFiberNode* child = current->child;
+        uint32_t i = 0;
+        while (child && i < index) {
+            child = child->sibling;
+            i++;
+        }
+        if (child && ed_fiber_tags_match(child, element)) {
+            return ed_use_fiber(child, element);
+        }
+    }
+
+    return ed_create_child(element, index);
+}
+
+EDFiberNode* ed_create_child(EDVirtualNode* element, uint32_t index)
+{
+    if (!element) return NULL;
+
+    EDFiberTag tag;
+    switch (element->type) {
+        case ED_NODE_TEXT:
+            tag = ED_FIBER_HOST_TEXT;
+            break;
+        case ED_NODE_FRAGMENT:
+            tag = ED_FIBER_FRAGMENT;
+            break;
+        case ED_NODE_ELEMENT:
+            tag = ED_FIBER_HOST_COMPONENT;
+            break;
+        case ED_NODE_CONTEXT_PROVIDER:
+            tag = ED_FIBER_CONTEXT_PROVIDER;
+            break;
+        case ED_NODE_CONTEXT_CONSUMER:
+            tag = ED_FIBER_CONTEXT_CONSUMER;
+            break;
+        default:
+            tag = ED_FIBER_HOST_COMPONENT;
+            break;
+    }
+
+    EDFiberNode* fiber = ed_fiber_create(tag, ED_FIBER_FLAG_NONE);
+    if (!fiber) return NULL;
+
+    fiber->pending_props = element;
+    fiber->index = index;
+
+    if (element->key[0] != '\0') {
+        strncpy(fiber->key, element->key, ED_MAX_KEY_LEN - 1);
+        fiber->key[ED_MAX_KEY_LEN - 1] = '\0';
+        fiber->key_hash = ed_hash_fnv1a(element->key);
+    }
+
+    ed_fiber_set_flag(fiber, ED_FIBER_FLAG_PLACEMENT);
+    return fiber;
+}
+
+EDFiberNode* ed_use_fiber(EDFiberNode* current, EDVirtualNode* pending_props)
+{
+    if (!current) return ed_create_child(pending_props, 0);
+
+    EDFiberNode* clone = ed_fiber_clone(current);
+    if (!clone) return current; /* Fallback */
+
+    clone->pending_props = pending_props;
+    clone->index = current->index;
+    return clone;
+}
+
+uint32_t ed_delete_remaining_children(EDFiberNode* current)
+{
+    if (!current) return 0;
+
+    uint32_t deleted = 0;
+    EDFiberNode* child = current->child;
+
+    while (child) {
+        ed_fiber_set_flag(child, ED_FIBER_FLAG_DELETION);
+        deleted++;
+        deleted += ed_delete_remaining_children(child);
+        child = child->sibling;
+    }
+
+    return deleted;
+}
+
+/* ================================================================
+ * Fiber Effect Bubble-Up
+ * ================================================================ */
+
+static void ed_fiber_bubble_effects(EDFiberNode* completed_work)
+{
+    if (!completed_work) return;
+
+    EDFiberFlags flags = completed_work->flags;
+
+    if (flags & (ED_FIBER_FLAG_PLACEMENT | ED_FIBER_FLAG_UPDATE |
+                 ED_FIBER_FLAG_DELETION | ED_FIBER_FLAG_REF)) {
+        /* This fiber has work to do, add to parent's effect list */
+        /* In the full implementation, this would traverse up to root
+         * building the effect list */
+    }
+}
+
+/* ================================================================
+ * Fiber Tree Utilities
+ * ================================================================ */
+
+static EDFiberNode* ed_fiber_find_deepest_child(EDFiberNode* fiber)
+{
+    if (!fiber) return NULL;
+    while (fiber->child) {
+        fiber = fiber->child;
+    }
+    return fiber;
+}
+
+static EDFiberNode* ed_fiber_next_work(EDFiberNode* fiber)
+{
+    if (!fiber) return NULL;
+
+    /* Child first */
+    if (fiber->child) {
+        return fiber->child;
+    }
+
+    /* Then sibling */
+    if (fiber->sibling) {
+        return fiber->sibling;
+    }
+
+    /* Then parent's sibling */
+    EDFiberNode* parent = fiber->return_node;
+    while (parent) {
+        if (parent->sibling) {
+            return parent->sibling;
+        }
+        parent = parent->return_node;
+    }
+
+    return NULL;
+}
+
+static void ed_fiber_collect_deletions(EDFiberNode* fiber, EDFiberNode** deletion_list,
+                                        uint32_t* count, uint32_t max)
+{
+    if (!fiber || !deletion_list || !count) return;
+
+    if (ed_fiber_has_effect(fiber, ED_FIBER_FLAG_DELETION)) {
+        if (*count < max) {
+            deletion_list[*count] = fiber;
+            (*count)++;
+        }
+    }
+
+    EDFiberNode* child = fiber->child;
+    while (child) {
+        ed_fiber_collect_deletions(child, deletion_list, count, max);
+        child = child->sibling;
+    }
+}
+
+/* ================================================================
+ * Fiber Work Loop (simplified)
+ * ================================================================ */
+
+typedef enum {
+    ED_WORK_PHASE_RENDER = 0,
+    ED_WORK_PHASE_COMMIT = 1,
+    ED_WORK_PHASE_COMPLETE = 2
+} EDWorkPhase;
+
+static EDWorkPhase ed_fiber_perform_work(EDFiberNode* fiber)
+{
+    if (!fiber) return ED_WORK_PHASE_COMPLETE;
+
+    ed_fiber_set_flag(fiber, ED_FIBER_FLAG_PERFORMED_WORK);
+    fiber->start_time = ed_get_timestamp_ms();
+
+    /* Perform work based on fiber tag */
+    switch (fiber->tag) {
+        case ED_FIBER_HOST_ROOT:
+            /* Process root */
+            break;
+        case ED_FIBER_HOST_COMPONENT:
+        case ED_FIBER_HOST_TEXT:
+            /* Host components: reconcile children */
+            ed_reconcile_children(fiber->alternate, fiber);
+            break;
+        case ED_FIBER_FUNCTION_COMPONENT:
+        case ED_FIBER_CLASS_COMPONENT:
+            /* Render component and reconcile */
+            ed_reconcile_children(fiber->alternate, fiber);
+            break;
+        default:
+            break;
+    }
+
+    fiber->finish_time = ed_get_timestamp_ms();
+    return ED_WORK_PHASE_RENDER;
+}