elementdrawing 1.0.0

package/src/core/renderer.c

@@ -0,0 +1,963 @@
+/*
+ * renderer.c - ElementDrawing Core: Renderer Engine
+ *
+ * Implements the renderer lifecycle, batch creation/commit,
+ * update scheduling, paint requests, and effect flushing.
+ * Also includes DOM manipulation helpers, style computation,
+ * class merging, and attribute setting.
+ */
+
+#include "bridge.h"
+
+/* ================================================================
+ * Renderer Internal State
+ * ================================================================ */
+
+typedef struct EDRendererState {
+    EDConfiguration config;
+    EDMemoryPool* pool;
+    EDScheduler* scheduler;
+    EDEventSystem* event_system;
+    EDStateManager* state_manager;
+
+    /* Current fiber tree */
+    EDFiberNode* current_root;
+    EDFiberNode* work_in_progress_root;
+
+    /* Batch queue */
+    EDRenderBatch* batch_head;
+    EDRenderBatch* batch_tail;
+
+    /* Effect lists */
+    EDFiberNode* pending_passive_effects;
+    EDFiberNode* pending_layout_effects;
+    EDFiberNode* pending_insertion_effects;
+
+    /* Update tracking */
+    uint32_t pending_update_count;
+    bool has_pending_work;
+    bool is_rendering;
+    bool is_committing;
+
+    /* Performance metrics */
+    uint64_t total_render_time;
+    uint64_t total_commit_time;
+    uint32_t total_renders;
+    uint32_t total_commits;
+    uint32_t total_dom_writes;
+    uint32_t total_dom_reads;
+
+    /* Render callback */
+    EDRenderCallback on_render;
+    EDCommitCallback on_commit;
+
+    /* Paint state */
+    bool paint_requested;
+    uint64_t last_paint_time;
+    uint64_t next_paint_deadline;
+} EDRendererState;
+
+static EDRendererState g_renderer = {0};
+
+/* ================================================================
+ * Style Computation Helpers
+ * ================================================================ */
+
+typedef struct EDStyleEntry {
+    char property[ED_MAX_PROP_KEY_LEN];
+    char value[ED_MAX_PROP_VALUE_LEN];
+    uint32_t priority;    /* For !important */
+    bool is_important;
+} EDStyleEntry;
+
+typedef struct EDComputedStyles {
+    EDStyleEntry entries[ED_RENDER_MAX_STYLES];
+    uint32_t count;
+} EDComputedStyles;
+
+static void ed_style_entry_init(EDStyleEntry* entry, const char* prop, const char* val)
+{
+    if (!entry) return;
+    if (prop) {
+        strncpy(entry->property, prop, ED_MAX_PROP_KEY_LEN - 1);
+        entry->property[ED_MAX_PROP_KEY_LEN - 1] = '\0';
+    }
+    if (val) {
+        strncpy(entry->value, val, ED_MAX_PROP_VALUE_LEN - 1);
+        entry->value[ED_MAX_PROP_VALUE_LEN - 1] = '\0';
+    }
+    entry->priority = 0;
+    entry->is_important = false;
+}
+
+static EDComputedStyles* ed_computed_styles_create(void)
+{
+    EDComputedStyles* styles = (EDComputedStyles*)calloc(1, sizeof(EDComputedStyles));
+    return styles;
+}
+
+static void ed_computed_styles_destroy(EDComputedStyles* styles)
+{
+    free(styles);
+}
+
+static void ed_computed_styles_set(EDComputedStyles* styles, const char* prop, const char* val)
+{
+    if (!styles || !prop) return;
+
+    /* Check for existing property */
+    for (uint32_t i = 0; i < styles->count; i++) {
+        if (strcmp(styles->entries[i].property, prop) == 0) {
+            strncpy(styles->entries[i].value, val ? val : "", ED_MAX_PROP_VALUE_LEN - 1);
+            styles->entries[i].value[ED_MAX_PROP_VALUE_LEN - 1] = '\0';
+            return;
+        }
+    }
+
+    /* Add new property */
+    if (styles->count >= ED_RENDER_MAX_STYLES) return;
+    ed_style_entry_init(&styles->entries[styles->count], prop, val ? val : "");
+    styles->count++;
+}
+
+static const char* ed_computed_styles_get(EDComputedStyles* styles, const char* prop)
+{
+    if (!styles || !prop) return NULL;
+    for (uint32_t i = 0; i < styles->count; i++) {
+        if (strcmp(styles->entries[i].property, prop) == 0) {
+            return styles->entries[i].value;
+        }
+    }
+    return NULL;
+}
+
+static void ed_computed_styles_remove(EDComputedStyles* styles, const char* prop)
+{
+    if (!styles || !prop) return;
+    for (uint32_t i = 0; i < styles->count; i++) {
+        if (strcmp(styles->entries[i].property, prop) == 0) {
+            /* Shift remaining */
+            for (uint32_t j = i; j + 1 < styles->count; j++) {
+                styles->entries[j] = styles->entries[j + 1];
+            }
+            styles->count--;
+            return;
+        }
+    }
+}
+
+/* ================================================================
+ * Class Merging Helpers
+ * ================================================================ */
+
+typedef struct EDClassList {
+    char classes[ED_RENDER_MAX_CLASSES][ED_MAX_PROP_KEY_LEN];
+    uint32_t count;
+} EDClassList;
+
+static void ed_class_list_init(EDClassList* list)
+{
+    if (!list) return;
+    memset(list, 0, sizeof(EDClassList));
+}
+
+static void ed_class_list_add(EDClassList* list, const char* class_name)
+{
+    if (!list || !class_name) return;
+    if (list->count >= ED_RENDER_MAX_CLASSES) return;
+
+    /* Avoid duplicates */
+    for (uint32_t i = 0; i < list->count; i++) {
+        if (strcmp(list->classes[i], class_name) == 0) return;
+    }
+
+    strncpy(list->classes[list->count], class_name, ED_MAX_PROP_KEY_LEN - 1);
+    list->classes[list->count][ED_MAX_PROP_KEY_LEN - 1] = '\0';
+    list->count++;
+}
+
+static void ed_class_list_remove(EDClassList* list, const char* class_name)
+{
+    if (!list || !class_name) return;
+    for (uint32_t i = 0; i < list->count; i++) {
+        if (strcmp(list->classes[i], class_name) == 0) {
+            for (uint32_t j = i; j + 1 < list->count; j++) {
+                strncpy(list->classes[j], list->classes[j + 1], ED_MAX_PROP_KEY_LEN);
+            }
+            list->count--;
+            return;
+        }
+    }
+}
+
+static bool ed_class_list_contains(EDClassList* list, const char* class_name)
+{
+    if (!list || !class_name) return false;
+    for (uint32_t i = 0; i < list->count; i++) {
+        if (strcmp(list->classes[i], class_name) == 0) return true;
+    }
+    return false;
+}
+
+/* Parse a space-separated class string into a class list */
+static void ed_class_list_parse(EDClassList* list, const char* class_str)
+{
+    if (!list || !class_str) return;
+    ed_class_list_init(list);
+
+    char buffer[ED_MAX_PROP_VALUE_LEN];
+    strncpy(buffer, class_str, ED_MAX_PROP_VALUE_LEN - 1);
+    buffer[ED_MAX_PROP_VALUE_LEN - 1] = '\0';
+
+    char* token = strtok(buffer, " \t\n\r");
+    while (token && list->count < ED_RENDER_MAX_CLASSES) {
+        ed_class_list_add(list, token);
+        token = strtok(NULL, " \t\n\r");
+    }
+}
+
+static void ed_class_list_merge(EDClassList* result, EDClassList* a, EDClassList* b)
+{
+    if (!result) return;
+    ed_class_list_init(result);
+    for (uint32_t i = 0; i < a->count; i++) {
+        ed_class_list_add(result, a->classes[i]);
+    }
+    for (uint32_t i = 0; i < b->count; i++) {
+        ed_class_list_add(result, b->classes[i]);
+    }
+}
+
+/* ================================================================
+ * Attribute Setting Helpers
+ * ================================================================ */
+
+typedef struct EDAttributeMap {
+    char keys[ED_RENDER_MAX_ATTRIBUTES][ED_MAX_PROP_KEY_LEN];
+    char values[ED_RENDER_MAX_ATTRIBUTES][ED_MAX_PROP_VALUE_LEN];
+    uint32_t count;
+} EDAttributeMap;
+
+static void ed_attr_map_init(EDAttributeMap* map)
+{
+    if (!map) return;
+    memset(map, 0, sizeof(EDAttributeMap));
+}
+
+static void ed_attr_map_set(EDAttributeMap* map, const char* key, const char* value)
+{
+    if (!map || !key) return;
+    /* Update existing */
+    for (uint32_t i = 0; i < map->count; i++) {
+        if (strcmp(map->keys[i], key) == 0) {
+            if (value) strncpy(map->values[i], value, ED_MAX_PROP_VALUE_LEN - 1);
+            else map->values[i][0] = '\0';
+            map->values[i][ED_MAX_PROP_VALUE_LEN - 1] = '\0';
+            return;
+        }
+    }
+    /* Add new */
+    if (map->count >= ED_RENDER_MAX_ATTRIBUTES) return;
+    strncpy(map->keys[map->count], key, ED_MAX_PROP_KEY_LEN - 1);
+    map->keys[map->count][ED_MAX_PROP_KEY_LEN - 1] = '\0';
+    if (value) strncpy(map->values[map->count], value, ED_MAX_PROP_VALUE_LEN - 1);
+    map->values[map->count][ED_MAX_PROP_VALUE_LEN - 1] = '\0';
+    map->count++;
+}
+
+static const char* ed_attr_map_get(EDAttributeMap* map, const char* key)
+{
+    if (!map || !key) return NULL;
+    for (uint32_t i = 0; i < map->count; i++) {
+        if (strcmp(map->keys[i], key) == 0) return map->values[i];
+    }
+    return NULL;
+}
+
+static void ed_attr_map_remove(EDAttributeMap* map, const char* key)
+{
+    if (!map || !key) return;
+    for (uint32_t i = 0; i < map->count; i++) {
+        if (strcmp(map->keys[i], key) == 0) {
+            for (uint32_t j = i; j + 1 < map->count; j++) {
+                strncpy(map->keys[j], map->keys[j + 1], ED_MAX_PROP_KEY_LEN);
+                strncpy(map->values[j], map->values[j + 1], ED_MAX_PROP_VALUE_LEN);
+            }
+            map->count--;
+            return;
+        }
+    }
+}
+
+/* ================================================================
+ * DOM Manipulation Simulation
+ * ================================================================ */
+
+/* These simulate DOM operations. In a real environment they would
+ * call into the actual DOM API or a native UI toolkit. */
+
+static void ed_dom_set_attribute(void* node, const char* key, const char* value)
+{
+    if (!node || !key) return;
+    g_renderer.total_dom_writes++;
+    /* Simulated: would call DOM API */
+}
+
+static void ed_dom_remove_attribute(void* node, const char* key)
+{
+    if (!node || !key) return;
+    g_renderer.total_dom_writes++;
+}
+
+static void ed_dom_set_style(void* node, const char* prop, const char* value)
+{
+    if (!node || !prop) return;
+    g_renderer.total_dom_writes++;
+}
+
+static void ed_dom_remove_style(void* node, const char* prop)
+{
+    if (!node || !prop) return;
+    g_renderer.total_dom_writes++;
+}
+
+static void ed_dom_insert_child(void* parent, void* child, uint32_t index)
+{
+    if (!parent || !child) return;
+    g_renderer.total_dom_writes++;
+}
+
+static void ed_dom_remove_child(void* parent, void* child)
+{
+    if (!parent || !child) return;
+    g_renderer.total_dom_writes++;
+}
+
+static void ed_dom_set_text_content(void* node, const char* text)
+{
+    if (!node) return;
+    g_renderer.total_dom_writes++;
+}
+
+static void ed_dom_add_class(void* node, const char* class_name)
+{
+    if (!node || !class_name) return;
+    g_renderer.total_dom_writes++;
+}
+
+static void ed_dom_remove_class(void* node, const char* class_name)
+{
+    if (!node || !class_name) return;
+    g_renderer.total_dom_writes++;
+}
+
+static const char* ed_dom_get_attribute(void* node, const char* key)
+{
+    if (!node || !key) return NULL;
+    g_renderer.total_dom_reads++;
+    return NULL;
+}
+
+/* ================================================================
+ * Style Diffing and Computation
+ * ================================================================ */
+
+static EDComputedStyles* ed_compute_styles(EDVirtualNode* node)
+{
+    if (!node) return NULL;
+
+    EDComputedStyles* styles = ed_computed_styles_create();
+    if (!styles) return NULL;
+
+    EDVirtualProp* prop = node->props;
+    while (prop) {
+        if (prop->is_style && strlen(prop->value) > 0) {
+            /* Parse inline style string: "prop1: val1; prop2: val2" */
+            char buf[ED_MAX_PROP_VALUE_LEN];
+            strncpy(buf, prop->value, ED_MAX_PROP_VALUE_LEN - 1);
+            buf[ED_MAX_PROP_VALUE_LEN - 1] = '\0';
+
+            char* decl = strtok(buf, ";");
+            while (decl) {
+                char* colon = strchr(decl, ':');
+                if (colon) {
+                    *colon = '\0';
+                    char* key = decl;
+                    char* val = colon + 1;
+                    /* Trim whitespace */
+                    while (*key == ' ' || *key == '\t') key++;
+                    while (*val == ' ' || *val == '\t') val++;
+                    char* key_end = key + strlen(key) - 1;
+                    while (key_end > key && (*key_end == ' ' || *key_end == '\t')) *key_end-- = '\0';
+                    ed_computed_styles_set(styles, key, val);
+                }
+                decl = strtok(NULL, ";");
+            }
+        }
+        prop = prop->next;
+    }
+
+    return styles;
+}
+
+static void ed_diff_styles(EDComputedStyles* old_styles, EDComputedStyles* new_styles,
+                           void* state_node)
+{
+    if (!state_node) return;
+
+    /* Remove styles that exist in old but not in new */
+    for (uint32_t i = 0; i < old_styles->count; i++) {
+        const char* val = ed_computed_styles_get(new_styles, old_styles->entries[i].property);
+        if (!val) {
+            ed_dom_remove_style(state_node, old_styles->entries[i].property);
+        }
+    }
+
+    /* Set styles that are new or changed */
+    for (uint32_t i = 0; i < new_styles->count; i++) {
+        const char* old_val = ed_computed_styles_get(old_styles, new_styles->entries[i].property);
+        if (!old_val || strcmp(old_val, new_styles->entries[i].value) != 0) {
+            ed_dom_set_style(state_node, new_styles->entries[i].property,
+                             new_styles->entries[i].value);
+        }
+    }
+}
+
+/* ================================================================
+ * Attribute Diffing
+ * ================================================================ */
+
+static void ed_diff_attributes(EDVirtualNode* old_node, EDVirtualNode* new_node,
+                               void* state_node)
+{
+    if (!state_node) return;
+
+    EDAttributeMap old_attrs, new_attrs;
+    ed_attr_map_init(&old_attrs);
+    ed_attr_map_init(&new_attrs);
+
+    /* Collect old attributes */
+    EDVirtualProp* prop = old_node ? old_node->props : NULL;
+    while (prop) {
+        if (!prop->is_style && !prop->is_class && !prop->is_event &&
+            !prop->is_ref && !prop->is_key && !prop->is_children) {
+            ed_attr_map_set(&old_attrs, prop->key, prop->value);
+        }
+        prop = prop->next;
+    }
+
+    /* Collect new attributes */
+    prop = new_node ? new_node->props : NULL;
+    while (prop) {
+        if (!prop->is_style && !prop->is_class && !prop->is_event &&
+            !prop->is_ref && !prop->is_key && !prop->is_children) {
+            ed_attr_map_set(&new_attrs, prop->key, prop->value);
+        }
+        prop = prop->next;
+    }
+
+    /* Remove attributes present in old but not in new */
+    for (uint32_t i = 0; i < old_attrs.count; i++) {
+        if (!ed_attr_map_get(&new_attrs, old_attrs.keys[i])) {
+            ed_dom_remove_attribute(state_node, old_attrs.keys[i]);
+        }
+    }
+
+    /* Set attributes that are new or changed */
+    for (uint32_t i = 0; i < new_attrs.count; i++) {
+        const char* old_val = ed_attr_map_get(&old_attrs, new_attrs.keys[i]);
+        if (!old_val || strcmp(old_val, new_attrs.values[i]) != 0) {
+            ed_dom_set_attribute(state_node, new_attrs.keys[i], new_attrs.values[i]);
+        }
+    }
+}
+
+/* ================================================================
+ * Class Diffing
+ * ================================================================ */
+
+static void ed_diff_classes(EDVirtualNode* old_node, EDVirtualNode* new_node,
+                            void* state_node)
+{
+    if (!state_node) return;
+
+    EDClassList old_classes, new_classes;
+    ed_class_list_init(&old_classes);
+    ed_class_list_init(&new_classes);
+
+    EDVirtualProp* prop = old_node ? old_node->props : NULL;
+    while (prop) {
+        if (prop->is_class && strlen(prop->value) > 0) {
+            ed_class_list_parse(&old_classes, prop->value);
+        }
+        prop = prop->next;
+    }
+
+    prop = new_node ? new_node->props : NULL;
+    while (prop) {
+        if (prop->is_class && strlen(prop->value) > 0) {
+            ed_class_list_parse(&new_classes, prop->value);
+        }
+        prop = prop->next;
+    }
+
+    /* Remove classes in old but not in new */
+    for (uint32_t i = 0; i < old_classes.count; i++) {
+        if (!ed_class_list_contains(&new_classes, old_classes.classes[i])) {
+            ed_dom_remove_class(state_node, old_classes.classes[i]);
+        }
+    }
+
+    /* Add classes in new but not in old */
+    for (uint32_t i = 0; i < new_classes.count; i++) {
+        if (!ed_class_list_contains(&old_classes, new_classes.classes[i])) {
+            ed_dom_add_class(state_node, new_classes.classes[i]);
+        }
+    }
+}
+
+/* ================================================================
+ * Renderer Initialization and Shutdown
+ * ================================================================ */
+
+int ed_renderer_init(EDConfiguration* config)
+{
+    if (g_renderer.is_rendering) {
+        ed_log_error("Cannot reinitialize renderer while rendering");
+        return ED_ERR_INVALID_STATE;
+    }
+
+    memset(&g_renderer, 0, sizeof(EDRendererState));
+
+    if (config) {
+        memcpy(&g_renderer.config, config, sizeof(EDConfiguration));
+    } else {
+        /* Default configuration */
+        g_renderer.config.concurrent_mode = true;
+        g_renderer.config.strict_mode = false;
+        g_renderer.config.profiler_enabled = false;
+        g_renderer.config.suspense_enabled = true;
+        g_renderer.config.error_boundaries_enabled = true;
+        g_renderer.config.dev_tools_enabled = false;
+        g_renderer.config.trace_updates = false;
+        g_renderer.config.validate_props = false;
+        g_renderer.config.max_render_time_ms = 16;
+        g_renderer.config.max_commit_time_ms = 16;
+        g_renderer.config.scheduler_frame_budget_ms = ED_SCHEDULER_FRAME_BUDGET;
+        g_renderer.config.auto_batch_updates = true;
+        g_renderer.config.legacy_context_api = false;
+    }
+
+    /* Create memory pool */
+    g_renderer.pool = ed_pool_create(ED_INITIAL_POOL_SIZE);
+    if (!g_renderer.pool) {
+        ed_log_error("Failed to create renderer memory pool");
+        return ED_ERR_MEMORY;
+    }
+
+    /* Create scheduler */
+    g_renderer.scheduler = ed_scheduler_create();
+    if (!g_renderer.scheduler) {
+        ed_pool_destroy(g_renderer.pool);
+        ed_log_error("Failed to create renderer scheduler");
+        return ED_ERR_MEMORY;
+    }
+
+    /* Create event system */
+    g_renderer.event_system = ed_event_system_create();
+    if (!g_renderer.event_system) {
+        ed_scheduler_destroy(g_renderer.scheduler);
+        ed_pool_destroy(g_renderer.pool);
+        ed_log_error("Failed to create renderer event system");
+        return ED_ERR_MEMORY;
+    }
+
+    /* Create state manager */
+    g_renderer.state_manager = ed_state_manager_create();
+    if (!g_renderer.state_manager) {
+        ed_event_system_destroy(g_renderer.event_system);
+        ed_scheduler_destroy(g_renderer.scheduler);
+        ed_pool_destroy(g_renderer.pool);
+        ed_log_error("Failed to create renderer state manager");
+        return ED_ERR_MEMORY;
+    }
+
+    g_renderer.is_rendering = false;
+    g_renderer.is_committing = false;
+    g_renderer.has_pending_work = false;
+    g_renderer.paint_requested = false;
+    g_renderer.pending_update_count = 0;
+
+    ed_log_info("Renderer initialized (v%s, concurrent=%s)",
+                ed_version(),
+                g_renderer.config.concurrent_mode ? "true" : "false");
+
+    return ED_OK;
+}
+
+void ed_renderer_shutdown(void)
+{
+    if (!g_renderer.pool) return; /* Not initialized */
+
+    ed_log_info("Renderer shutting down");
+
+    /* Flush any remaining work */
+    if (g_renderer.has_pending_work) {
+        ed_renderer_flush_sync();
+    }
+
+    /* Destroy batch queue */
+    EDRenderBatch* batch = g_renderer.batch_head;
+    while (batch) {
+        EDRenderBatch* next = batch->next;
+        ed_renderer_destroy_batch(batch);
+        batch = next;
+    }
+    g_renderer.batch_head = NULL;
+    g_renderer.batch_tail = NULL;
+
+    /* Destroy subsystems */
+    if (g_renderer.state_manager) {
+        ed_state_manager_destroy(g_renderer.state_manager);
+        g_renderer.state_manager = NULL;
+    }
+    if (g_renderer.event_system) {
+        ed_event_system_destroy(g_renderer.event_system);
+        g_renderer.event_system = NULL;
+    }
+    if (g_renderer.scheduler) {
+        ed_scheduler_destroy(g_renderer.scheduler);
+        g_renderer.scheduler = NULL;
+    }
+    if (g_renderer.pool) {
+        ed_pool_destroy(g_renderer.pool);
+        g_renderer.pool = NULL;
+    }
+
+    /* Clear fiber roots */
+    g_renderer.current_root = NULL;
+    g_renderer.work_in_progress_root = NULL;
+    g_renderer.pending_passive_effects = NULL;
+    g_renderer.pending_layout_effects = NULL;
+    g_renderer.pending_insertion_effects = NULL;
+
+    memset(&g_renderer, 0, sizeof(EDRendererState));
+
+    ed_log_info("Renderer shutdown complete");
+}
+
+/* ================================================================
+ * Render Batch
+ * ================================================================ */
+
+EDRenderBatch* ed_renderer_create_batch(void)
+{
+    EDRenderBatch* batch = (EDRenderBatch*)calloc(1, sizeof(EDRenderBatch));
+    if (!batch) return NULL;
+
+    batch->operations = NULL;
+    batch->count = 0;
+    batch->start_time = ed_get_timestamp_ms();
+    batch->end_time = 0;
+    batch->dom_writes = 0;
+    batch->dom_reads = 0;
+    batch->next = NULL;
+
+    return batch;
+}
+
+void ed_renderer_destroy_batch(EDRenderBatch* batch)
+{
+    if (!batch) return;
+
+    /* Free all patch operations in the batch */
+    EDPatchOperation* op = batch->operations;
+    while (op) {
+        EDPatchOperation* next = op->next;
+        free(op);
+        op = next;
+    }
+
+    free(batch);
+}
+
+static void ed_renderer_enqueue_batch(EDRenderBatch* batch)
+{
+    if (!batch) return;
+    batch->end_time = ed_get_timestamp_ms();
+
+    if (!g_renderer.batch_head) {
+        g_renderer.batch_head = batch;
+        g_renderer.batch_tail = batch;
+    } else {
+        g_renderer.batch_tail->next = batch;
+        g_renderer.batch_tail = batch;
+    }
+}
+
+void ed_renderer_commit_batch(EDRenderBatch* batch)
+{
+    if (!batch) return;
+
+    g_renderer.is_committing = true;
+    uint64_t commit_start = ed_get_timestamp_ms();
+
+    /* Apply all patch operations in the batch */
+    EDPatchOperation* op = batch->operations;
+    while (op) {
+        ed_patch_apply(op);
+        g_renderer.total_dom_writes++;
+        op = op->next;
+    }
+
+    uint64_t commit_end = ed_get_timestamp_ms();
+    g_renderer.total_commit_time += (commit_end - commit_start);
+    g_renderer.total_commits++;
+
+    if (g_renderer.on_commit) {
+        g_renderer.on_commit(NULL, NULL); /* Would pass actual fiber and state_node */
+    }
+
+    g_renderer.is_committing = false;
+
+    ed_log_debug("Batch committed: %u ops, %llu ms",
+                 batch->count,
+                 (unsigned long long)(commit_end - commit_start));
+
+    ed_renderer_destroy_batch(batch);
+}
+
+/* ================================================================
+ * Update Scheduling
+ * ================================================================ */
+
+uint32_t ed_renderer_schedule_update(EDFiberNode* fiber, EDSchedulerPriority priority)
+{
+    if (!fiber) return 0;
+
+    ed_fiber_set_flag(fiber, ED_FIBER_FLAG_NEEDS_UPDATE);
+    g_renderer.pending_update_count++;
+    g_renderer.has_pending_work = true;
+
+    if (g_renderer.scheduler) {
+        uint32_t task_id = ed_scheduler_schedule(
+            g_renderer.scheduler, priority,
+            (EDSchedulerCallback)ed_renderer_process_updates,
+            fiber);
+        return task_id;
+    }
+
+    return 0;
+}
+
+void ed_renderer_process_updates(void)
+{
+    if (!g_renderer.has_pending_work) return;
+
+    g_renderer.is_rendering = true;
+    uint64_t render_start = ed_get_timestamp_ms();
+
+    /* Process scheduler work */
+    if (g_renderer.scheduler) {
+        ed_scheduler_work(g_renderer.scheduler);
+    }
+
+    /* Flush state updates */
+    if (g_renderer.state_manager) {
+        ed_state_flush_updates(g_renderer.state_manager);
+    }
+
+    uint64_t render_end = ed_get_timestamp_ms();
+    g_renderer.total_render_time += (render_end - render_start);
+    g_renderer.total_renders++;
+
+    g_renderer.pending_update_count = 0;
+    g_renderer.has_pending_work = false;
+    g_renderer.is_rendering = false;
+
+    /* Request paint if needed */
+    if (g_renderer.paint_requested) {
+        ed_renderer_request_paint();
+    }
+}
+
+void ed_renderer_request_paint(void)
+{
+    g_renderer.paint_requested = true;
+    g_renderer.next_paint_deadline = ed_get_timestamp_ms() +
+        g_renderer.config.scheduler_frame_budget_ms;
+
+    /* In a real implementation, this would requestAnimationFrame or similar */
+    ed_log_debug("Paint requested, deadline=%llu",
+                 (unsigned long long)g_renderer.next_paint_deadline);
+}
+
+/* ================================================================
+ * Effect Flushing
+ * ================================================================ */
+
+static void ed_renderer_run_effect_list(EDFiberNode* head, EDEffectType type)
+{
+    EDFiberNode* fiber = head;
+    while (fiber) {
+        EDHookNode* hook = fiber->memoized_hooks;
+        while (hook) {
+            bool should_run = false;
+            switch (type) {
+                case ED_EFFECT_PASSIVE:
+                    should_run = hook->is_passive && hook->has_effect;
+                    break;
+                case ED_EFFECT_LAYOUT:
+                    should_run = hook->is_layout && hook->has_effect;
+                    break;
+                case ED_EFFECT_INSERTION:
+                    should_run = hook->is_insertion && hook->has_effect;
+                    break;
+                default:
+                    break;
+            }
+
+            if (should_run) {
+                /* Run cleanup first if present */
+                if (hook->cleanup) {
+                    ed_hook_run_cleanup(hook);
+                }
+                ed_hook_run_effect(hook);
+                hook->has_effect = false;
+            }
+
+            hook = hook->next;
+        }
+        fiber = fiber->next_effect;
+    }
+}
+
+void ed_renderer_flush_passive_effects(void)
+{
+    if (g_renderer.pending_passive_effects) {
+        EDFiberNode* effects = g_renderer.pending_passive_effects;
+        g_renderer.pending_passive_effects = NULL;
+        ed_renderer_run_effect_list(effects, ED_EFFECT_PASSIVE);
+    }
+}
+
+void ed_renderer_flush_layout_effects(void)
+{
+    if (g_renderer.pending_layout_effects) {
+        EDFiberNode* effects = g_renderer.pending_layout_effects;
+        g_renderer.pending_layout_effects = NULL;
+        ed_renderer_run_effect_list(effects, ED_EFFECT_LAYOUT);
+    }
+}
+
+void ed_renderer_flush_sync(void)
+{
+    /* Flush all pending work synchronously */
+    ed_renderer_process_updates();
+
+    /* Flush layout effects immediately */
+    ed_renderer_flush_layout_effects();
+
+    /* Flush passive effects */
+    ed_renderer_flush_passive_effects();
+
+    /* Process any remaining scheduler work */
+    if (g_renderer.scheduler) {
+        ed_scheduler_flush_all(g_renderer.scheduler);
+    }
+
+    /* Flush remaining state updates */
+    if (g_renderer.state_manager) {
+        ed_state_flush_updates(g_renderer.state_manager);
+    }
+
+    ed_log_debug("Sync flush complete");
+}
+
+/* ================================================================
+ * Complete Render Phase
+ * ================================================================ */
+
+static void ed_renderer_render_root(EDFiberNode* root)
+{
+    if (!root) return;
+
+    uint64_t start = ed_get_timestamp_ms();
+
+    /* Create work-in-progress tree */
+    g_renderer.work_in_progress_root = root;
+    g_renderer.is_rendering = true;
+
+    /* Process the fiber tree (would call into reconciliation) */
+    EDFiberNode* fiber = root;
+    while (fiber) {
+        ed_fiber_set_flag(fiber, ED_FIBER_FLAG_PERFORMED_WORK);
+
+        /* Move to child first (depth-first) */
+        if (fiber->child) {
+            fiber = fiber->child;
+            continue;
+        }
+
+        /* No child, try sibling */
+        if (fiber->sibling) {
+            fiber = fiber->sibling;
+            continue;
+        }
+
+        /* No sibling, go back up */
+        EDFiberNode* parent = fiber->return_node;
+        while (parent) {
+            if (parent->sibling) {
+                fiber = parent->sibling;
+                break;
+            }
+            parent = parent->return_node;
+        }
+        if (!parent) fiber = NULL;
+    }
+
+    uint64_t end = ed_get_timestamp_ms();
+    g_renderer.total_render_time += (end - start);
+    g_renderer.total_renders++;
+
+    g_renderer.is_rendering = false;
+
+    /* Swap current and WIP */
+    g_renderer.current_root = g_renderer.work_in_progress_root;
+    g_renderer.work_in_progress_root = NULL;
+}
+
+/* ================================================================
+ * Renderer Statistics
+ * ================================================================ */
+
+static uint32_t ed_renderer_get_total_renders(void)
+{
+    return g_renderer.total_renders;
+}
+
+static uint32_t ed_renderer_get_total_commits(void)
+{
+    return g_renderer.total_commits;
+}
+
+static uint64_t ed_renderer_get_total_render_time(void)
+{
+    return g_renderer.total_render_time;
+}
+
+static uint64_t ed_renderer_get_total_commit_time(void)
+{
+    return g_renderer.total_commit_time;
+}
+
+static uint32_t ed_renderer_get_total_dom_writes(void)
+{
+    return g_renderer.total_dom_writes;
+}
+
+static uint32_t ed_renderer_get_total_dom_reads(void)
+{
+    return g_renderer.total_dom_reads;
+}