elementdrawing 1.0.0

package/src/core/hooks.c

@@ -0,0 +1,919 @@
+/*
+ * hooks.c - ElementDrawing Core: Hook System
+ *
+ * Implements the React-like hook system for the ElementDrawing engine.
+ * Supports useState, useReducer, useEffect, useLayoutEffect,
+ * useCallback, useMemo, useRef, useContext, and other hook types.
+ * Includes hook queue management, dependency tracking, effect
+ * scheduling, and cleanup execution.
+ */
+
+#include "bridge.h"
+
+/* ================================================================
+ * Internal Hook State
+ * ================================================================ */
+
+/* Current fiber being rendered (hook context) */
+static EDFiberNode* g_current_rendering_fiber = NULL;
+/* Current hook being processed */
+static EDHookNode* g_current_hook = NULL;
+/* Hook index within current component */
+static uint32_t g_hook_index = 0;
+/* Whether we are currently rendering (for hook rule enforcement) */
+static bool g_is_rendering = false;
+/* Number of hook rule violations detected */
+static uint32_t g_hook_violations = 0;
+
+/* ================================================================
+ * Hook Context Management
+ * ================================================================ */
+
+static void ed_hook_enter_render(EDFiberNode* fiber)
+{
+    g_current_rendering_fiber = fiber;
+    g_current_hook = fiber ? fiber->memoized_hooks : NULL;
+    g_hook_index = 0;
+    g_is_rendering = true;
+}
+
+static void ed_hook_exit_render(void)
+{
+    g_current_rendering_fiber = NULL;
+    g_current_hook = NULL;
+    g_hook_index = 0;
+    g_is_rendering = false;
+}
+
+static EDHookNode* ed_hook_get_next(void)
+{
+    if (!g_current_rendering_fiber) return NULL;
+
+    if (g_current_hook) {
+        g_current_hook = g_current_hook->next;
+    }
+
+    if (g_current_hook) {
+        /* Reuse existing hook during update */
+        return g_current_hook;
+    }
+
+    return NULL;
+}
+
+static void ed_hook_append(EDFiberNode* fiber, EDHookNode* hook)
+{
+    if (!fiber || !hook) return;
+
+    hook->index = g_hook_index;
+
+    if (!fiber->memoized_hooks) {
+        fiber->memoized_hooks = hook;
+    } else {
+        EDHookNode* tail = fiber->memoized_hooks;
+        while (tail->next) {
+            tail = tail->next;
+        }
+        tail->next = hook;
+    }
+
+    g_current_hook = hook;
+    g_hook_index++;
+}
+
+/* ================================================================
+ * Hook Creation and Destruction
+ * ================================================================ */
+
+EDHookNode* ed_hook_create(EDHookType type, uint32_t index)
+{
+    EDHookNode* hook = (EDHookNode*)calloc(1, sizeof(EDHookNode));
+    if (!hook) {
+        ed_log_error("Failed to allocate hook node (type=%d)", type);
+        return NULL;
+    }
+
+    hook->type = type;
+    hook->index = index;
+    hook->memoized_state = NULL;
+    hook->queue = NULL;
+    hook->base_queue = NULL;
+    hook->next = NULL;
+    hook->has_effect = false;
+    hook->is_layout = false;
+    hook->is_passive = false;
+    hook->is_insertion = false;
+    hook->cleanup = NULL;
+    hook->effect_callback = NULL;
+    hook->deps = NULL;
+    hook->deps_count = 0;
+    hook->fiber = NULL;
+
+    return hook;
+}
+
+void ed_hook_destroy(EDHookNode* hook)
+{
+    if (!hook) return;
+
+    /* Run cleanup if present */
+    if (hook->cleanup) {
+        ed_hook_run_cleanup(hook);
+    }
+
+    /* Free dependency array */
+    if (hook->deps) {
+        free(hook->deps);
+        hook->deps = NULL;
+    }
+
+    /* Free update queue */
+    if (hook->queue) {
+        free(hook->queue);
+        hook->queue = NULL;
+    }
+    if (hook->base_queue) {
+        free(hook->base_queue);
+        hook->base_queue = NULL;
+    }
+
+    /* Free memoized state for certain hook types */
+    if (hook->memoized_state) {
+        switch (hook->type) {
+            case ED_HOOK_STATE:
+            case ED_HOOK_REDUCER:
+                /* State values are user-managed, don't free */
+                break;
+            case ED_HOOK_EFFECT:
+            case ED_HOOK_LAYOUT_EFFECT:
+            case ED_HOOK_INSERTION_EFFECT:
+                /* Effect data is user-managed */
+                break;
+            default:
+                break;
+        }
+    }
+
+    /* Note: hook->next is NOT freed here - it's a linked list
+     * managed by the fiber's hook chain */
+
+    free(hook);
+}
+
+/* ================================================================
+ * Hook Queue Implementation
+ * ================================================================ */
+
+EDHookQueue* ed_hook_queue_create(void)
+{
+    EDHookQueue* queue = (EDHookQueue*)calloc(1, sizeof(EDHookQueue));
+    if (!queue) return NULL;
+    queue->head = NULL;
+    queue->tail = NULL;
+    queue->count = 0;
+    return queue;
+}
+
+void ed_hook_queue_push(EDHookQueue* queue, EDHookNode* hook)
+{
+    if (!queue || !hook) return;
+
+    hook->next = NULL;
+
+    if (!queue->tail) {
+        queue->head = hook;
+        queue->tail = hook;
+    } else {
+        queue->tail->next = hook;
+        queue->tail = hook;
+    }
+    queue->count++;
+}
+
+EDHookNode* ed_hook_queue_pop(EDHookQueue* queue)
+{
+    if (!queue || !queue->head) return NULL;
+
+    EDHookNode* hook = queue->head;
+    queue->head = hook->next;
+    if (!queue->head) {
+        queue->tail = NULL;
+    }
+    hook->next = NULL;
+    queue->count--;
+
+    return hook;
+}
+
+/* ================================================================
+ * Hook State Management
+ * ================================================================ */
+
+typedef struct EDHookStateValue {
+    void* value;
+    void* base_value;
+    uint32_t version;
+    EDStateUpdater reducer;
+} EDHookStateValue;
+
+void ed_hook_set_state(EDHookNode* hook, void* state)
+{
+    if (!hook) return;
+
+    switch (hook->type) {
+        case ED_HOOK_STATE:
+        case ED_HOOK_REDUCER: {
+            EDHookStateValue* sv = (EDHookStateValue*)hook->memoized_state;
+            if (sv) {
+                sv->base_value = sv->value;
+                sv->value = state;
+                sv->version++;
+            } else {
+                sv = (EDHookStateValue*)calloc(1, sizeof(EDHookStateValue));
+                if (sv) {
+                    sv->value = state;
+                    sv->base_value = NULL;
+                    sv->version = 1;
+                    hook->memoized_state = sv;
+                }
+            }
+            break;
+        }
+        default:
+            hook->memoized_state = state;
+            break;
+    }
+}
+
+void* ed_hook_get_state(EDHookNode* hook)
+{
+    if (!hook) return NULL;
+
+    switch (hook->type) {
+        case ED_HOOK_STATE:
+        case ED_HOOK_REDUCER: {
+            EDHookStateValue* sv = (EDHookStateValue*)hook->memoized_state;
+            return sv ? sv->value : NULL;
+        }
+        default:
+            return hook->memoized_state;
+    }
+}
+
+/* ================================================================
+ * Hook Effect Management
+ * ================================================================ */
+
+typedef struct EDHookEffectData {
+    void* callback;
+    void* cleanup;
+    void* deps;
+    uint32_t deps_count;
+    bool has_run;
+} EDHookEffectData;
+
+void ed_hook_set_effect(EDHookNode* hook, void* callback, void* deps, uint32_t deps_count)
+{
+    if (!hook) return;
+
+    EDHookEffectData* effect_data = (EDHookEffectData*)hook->memoized_state;
+    if (!effect_data) {
+        effect_data = (EDHookEffectData*)calloc(1, sizeof(EDHookEffectData));
+        if (!effect_data) return;
+        hook->memoized_state = effect_data;
+    }
+
+    effect_data->callback = callback;
+    effect_data->deps = deps;
+    effect_data->deps_count = deps_count;
+    effect_data->has_run = false;
+
+    hook->effect_callback = callback;
+    hook->cleanup = NULL; /* Will be set after first run */
+    hook->deps = deps;
+    hook->deps_count = deps_count;
+
+    /* Determine effect type */
+    switch (hook->type) {
+        case ED_HOOK_EFFECT:
+        case ED_HOOK_DEFERRED_VALUE:
+            hook->is_passive = true;
+            hook->is_layout = false;
+            hook->is_insertion = false;
+            break;
+        case ED_HOOK_LAYOUT_EFFECT:
+            hook->is_layout = true;
+            hook->is_passive = false;
+            hook->is_insertion = false;
+            break;
+        case ED_HOOK_INSERTION_EFFECT:
+            hook->is_insertion = true;
+            hook->is_layout = false;
+            hook->is_passive = false;
+            break;
+        default:
+            hook->is_passive = true;
+            break;
+    }
+
+    /* Check if deps changed to determine if effect should run */
+    if (hook->deps && hook->deps_count > 0) {
+        EDHookEffectData* prev = (EDHookEffectData*)hook->memoized_state;
+        /* For first run, always mark as having effect */
+        if (!prev || !prev->has_run) {
+            hook->has_effect = true;
+        } else {
+            hook->has_effect = ed_hook_deps_changed(
+                prev->deps, deps, deps_count);
+        }
+    } else {
+        /* No deps = run every render */
+        hook->has_effect = true;
+    }
+}
+
+void ed_hook_run_effect(EDHookNode* hook)
+{
+    if (!hook) return;
+
+    EDHookEffectData* effect_data = (EDHookEffectData*)hook->memoized_state;
+    if (!effect_data) return;
+
+    /* Run cleanup from previous effect first */
+    if (effect_data->cleanup) {
+        ed_hook_run_cleanup(hook);
+    }
+
+    /* Execute the effect callback */
+    if (effect_data->callback) {
+        /* In a real implementation, this would call the JS/native effect */
+        ed_log_debug("Running effect (hook type=%d, index=%u)",
+                     hook->type, hook->index);
+        effect_data->has_run = true;
+    }
+
+    hook->has_effect = false;
+}
+
+void ed_hook_run_cleanup(EDHookNode* hook)
+{
+    if (!hook) return;
+
+    EDHookEffectData* effect_data = (EDHookEffectData*)hook->memoized_state;
+    if (!effect_data || !effect_data->cleanup) return;
+
+    ed_log_debug("Running cleanup for hook (type=%d, index=%u)",
+                 hook->type, hook->index);
+
+    /* Execute cleanup function */
+    /* In a real implementation, this would call the cleanup callback */
+    effect_data->cleanup = NULL;
+    hook->cleanup = NULL;
+}
+
+/* ================================================================
+ * Dependency Comparison
+ * ================================================================ */
+
+bool ed_hook_deps_changed(void* prev_deps, void* next_deps, uint32_t count)
+{
+    if (count == 0) return true; /* No deps = always changed */
+    if (!prev_deps || !next_deps) return true;
+    if (prev_deps == next_deps) return false; /* Same pointer = same deps */
+
+    /* Compare dependency arrays byte-by-byte */
+    /* In a real implementation, deps would be an array of values
+     * with known types. Here we do a simple pointer/value comparison. */
+    uintptr_t* prev = (uintptr_t*)prev_deps;
+    uintptr_t* next = (uintptr_t*)next_deps;
+
+    for (uint32_t i = 0; i < count; i++) {
+        if (prev[i] != next[i]) return true;
+    }
+
+    return false;
+}
+
+/* ================================================================
+ * useState Implementation
+ * ================================================================ */
+
+typedef struct EDUseStateResult {
+    void* value;
+    void (*setter)(void* new_value);
+    EDHookNode* hook;
+} EDUseStateResult;
+
+static EDUseStateResult ed_use_state_impl(EDFiberNode* fiber, void* initial_value)
+{
+    EDUseStateResult result = {0};
+
+    if (!fiber) {
+        g_hook_violations++;
+        ed_log_error("useState called outside of render");
+        return result;
+    }
+
+    EDHookNode* hook = ed_hook_get_next();
+
+    if (hook) {
+        /* Update: reuse existing state */
+        if (hook->type != ED_HOOK_STATE) {
+            g_hook_violations++;
+            ed_log_error("Hook type mismatch: expected STATE, got %d", hook->type);
+            return result;
+        }
+    } else {
+        /* Mount: create new hook */
+        hook = ed_hook_create(ED_HOOK_STATE, g_hook_index);
+        if (!hook) return result;
+
+        EDHookStateValue* sv = (EDHookStateValue*)calloc(1, sizeof(EDHookStateValue));
+        if (sv) {
+            sv->value = initial_value;
+            sv->base_value = initial_value;
+            sv->version = 0;
+            sv->reducer = NULL;
+        }
+        hook->memoized_state = sv;
+        hook->fiber = fiber;
+
+        ed_hook_append(fiber, hook);
+    }
+
+    EDHookStateValue* sv = (EDHookStateValue*)hook->memoized_state;
+    result.value = sv ? sv->value : NULL;
+    result.hook = hook;
+    /* setter would be a closure in a real implementation */
+
+    return result;
+}
+
+/* ================================================================
+ * useReducer Implementation
+ * ================================================================ */
+
+typedef struct EDUseReducerResult {
+    void* value;
+    void (*dispatch)(void* action);
+    EDHookNode* hook;
+} EDUseReducerResult;
+
+static EDUseReducerResult ed_use_reducer_impl(EDFiberNode* fiber,
+                                               EDStateUpdater reducer,
+                                               void* initial_value)
+{
+    EDUseReducerResult result = {0};
+
+    if (!fiber || !reducer) {
+        g_hook_violations++;
+        return result;
+    }
+
+    EDHookNode* hook = ed_hook_get_next();
+
+    if (hook) {
+        if (hook->type != ED_HOOK_REDUCER) {
+            g_hook_violations++;
+            ed_log_error("Hook type mismatch: expected REDUCER, got %d", hook->type);
+            return result;
+        }
+    } else {
+        hook = ed_hook_create(ED_HOOK_REDUCER, g_hook_index);
+        if (!hook) return result;
+
+        EDHookStateValue* sv = (EDHookStateValue*)calloc(1, sizeof(EDHookStateValue));
+        if (sv) {
+            sv->value = initial_value;
+            sv->base_value = initial_value;
+            sv->version = 0;
+            sv->reducer = reducer;
+        }
+        hook->memoized_state = sv;
+        hook->fiber = fiber;
+
+        ed_hook_append(fiber, hook);
+    }
+
+    EDHookStateValue* sv = (EDHookStateValue*)hook->memoized_state;
+    result.value = sv ? sv->value : NULL;
+    result.hook = hook;
+
+    return result;
+}
+
+/* ================================================================
+ * useEffect / useLayoutEffect / useInsertionEffect Implementation
+ * ================================================================ */
+
+static void ed_use_effect_impl(EDFiberNode* fiber, EDHookType type,
+                                void* callback, void* deps, uint32_t deps_count)
+{
+    if (!fiber) {
+        g_hook_violations++;
+        ed_log_error("useEffect called outside of render");
+        return;
+    }
+
+    EDHookNode* hook = ed_hook_get_next();
+
+    if (hook) {
+        /* Update existing hook */
+        bool deps_changed = true;
+        if (hook->deps && deps && hook->deps_count == deps_count) {
+            deps_changed = ed_hook_deps_changed(hook->deps, deps, deps_count);
+        }
+
+        ed_hook_set_effect(hook, callback, deps, deps_count);
+
+        if (deps_changed) {
+            hook->has_effect = true;
+            ed_fiber_set_flag(fiber, ED_FIBER_FLAG_HAS_EFFECT);
+
+            /* Add to appropriate effect list */
+            ed_fiber_add_effect(fiber, fiber);
+        }
+    } else {
+        /* Mount: create new effect hook */
+        hook = ed_hook_create(type, g_hook_index);
+        if (!hook) return;
+
+        hook->fiber = fiber;
+        ed_hook_set_effect(hook, callback, deps, deps_count);
+        hook->has_effect = true; /* Always run on mount */
+
+        ed_fiber_set_flag(fiber, ED_FIBER_FLAG_HAS_EFFECT);
+        ed_fiber_add_effect(fiber, fiber);
+
+        ed_hook_append(fiber, hook);
+    }
+}
+
+/* ================================================================
+ * useMemo Implementation
+ * ================================================================ */
+
+typedef struct EDMemoValue {
+    void* value;
+    void* deps;
+    uint32_t deps_count;
+} EDMemoValue;
+
+static void* ed_use_memo_impl(EDFiberNode* fiber, void* (*factory)(void),
+                               void* deps, uint32_t deps_count)
+{
+    if (!fiber) {
+        g_hook_violations++;
+        return NULL;
+    }
+
+    EDHookNode* hook = ed_hook_get_next();
+
+    if (hook) {
+        if (hook->type != ED_HOOK_MEMO) {
+            g_hook_violations++;
+            return NULL;
+        }
+
+        EDMemoValue* memo = (EDMemoValue*)hook->memoized_state;
+        if (memo) {
+            bool changed = ed_hook_deps_changed(memo->deps, deps, deps_count);
+            if (!changed) {
+                return memo->value; /* Return cached value */
+            }
+
+            /* Recompute */
+            if (memo->deps) free(memo->deps);
+            memo->deps = deps;
+            memo->deps_count = deps_count;
+            if (factory) {
+                memo->value = factory();
+            }
+            return memo->value;
+        }
+    }
+
+    /* Mount */
+    hook = ed_hook_create(ED_HOOK_MEMO, g_hook_index);
+    if (!hook) return NULL;
+
+    EDMemoValue* memo = (EDMemoValue*)calloc(1, sizeof(EDMemoValue));
+    if (memo) {
+        memo->deps = deps;
+        memo->deps_count = deps_count;
+        if (factory) {
+            memo->value = factory();
+        }
+    }
+    hook->memoized_state = memo;
+    hook->fiber = fiber;
+    ed_hook_append(fiber, hook);
+
+    return memo ? memo->value : NULL;
+}
+
+/* ================================================================
+ * useCallback Implementation
+ * ================================================================ */
+
+typedef struct EDCallbackValue {
+    void* callback;
+    void* deps;
+    uint32_t deps_count;
+} EDCallbackValue;
+
+static void* ed_use_callback_impl(EDFiberNode* fiber, void* callback,
+                                   void* deps, uint32_t deps_count)
+{
+    if (!fiber) {
+        g_hook_violations++;
+        return NULL;
+    }
+
+    EDHookNode* hook = ed_hook_get_next();
+
+    if (hook) {
+        if (hook->type != ED_HOOK_CALLBACK) {
+            g_hook_violations++;
+            return NULL;
+        }
+
+        EDCallbackValue* cb = (EDCallbackValue*)hook->memoized_state;
+        if (cb) {
+            bool changed = ed_hook_deps_changed(cb->deps, deps, deps_count);
+            if (!changed) {
+                return cb->callback; /* Return cached callback */
+            }
+
+            if (cb->deps) free(cb->deps);
+            cb->callback = callback;
+            cb->deps = deps;
+            cb->deps_count = deps_count;
+            return callback;
+        }
+    }
+
+    /* Mount */
+    hook = ed_hook_create(ED_HOOK_CALLBACK, g_hook_index);
+    if (!hook) return NULL;
+
+    EDCallbackValue* cb = (EDCallbackValue*)calloc(1, sizeof(EDCallbackValue));
+    if (cb) {
+        cb->callback = callback;
+        cb->deps = deps;
+        cb->deps_count = deps_count;
+    }
+    hook->memoized_state = cb;
+    hook->fiber = fiber;
+    ed_hook_append(fiber, hook);
+
+    return callback;
+}
+
+/* ================================================================
+ * useRef Implementation
+ * ================================================================ */
+
+typedef struct EDRefValue {
+    void* current;
+} EDRefValue;
+
+static EDRefValue* ed_use_ref_impl(EDFiberNode* fiber, void* initial_value)
+{
+    if (!fiber) {
+        g_hook_violations++;
+        return NULL;
+    }
+
+    EDHookNode* hook = ed_hook_get_next();
+
+    if (hook) {
+        return (EDRefValue*)hook->memoized_state;
+    }
+
+    /* Mount */
+    hook = ed_hook_create(ED_HOOK_REF, g_hook_index);
+    if (!hook) return NULL;
+
+    EDRefValue* ref = (EDRefValue*)calloc(1, sizeof(EDRefValue));
+    if (ref) {
+        ref->current = initial_value;
+    }
+    hook->memoized_state = ref;
+    hook->fiber = fiber;
+    ed_hook_append(fiber, hook);
+
+    return ref;
+}
+
+/* ================================================================
+ * useContext Implementation
+ * ================================================================ */
+
+typedef struct EDContextValue {
+    void* value;
+    EDFiberNode* provider;
+} EDContextValue;
+
+static void* ed_use_context_impl(EDFiberNode* fiber, void* context)
+{
+    if (!fiber) {
+        g_hook_violations++;
+        return NULL;
+    }
+
+    EDHookNode* hook = ed_hook_get_next();
+
+    if (hook) {
+        EDContextValue* ctx = (EDContextValue*)hook->memoized_state;
+        return ctx ? ctx->value : NULL;
+    }
+
+    /* Mount */
+    hook = ed_hook_create(ED_HOOK_CONTEXT, g_hook_index);
+    if (!hook) return NULL;
+
+    EDContextValue* ctx = (EDContextValue*)calloc(1, sizeof(EDContextValue));
+    if (ctx) {
+        ctx->value = context;
+        ctx->provider = NULL; /* Would be resolved in a real impl */
+    }
+    hook->memoized_state = ctx;
+    hook->fiber = fiber;
+    ed_hook_append(fiber, hook);
+
+    return ctx ? ctx->value : NULL;
+}
+
+/* ================================================================
+ * Hook Rule Enforcement
+ * ================================================================ */
+
+static bool ed_hook_check_rules(const char* hook_name)
+{
+    if (!g_is_rendering) {
+        g_hook_violations++;
+        ed_log_error("%s called outside of render phase (violation #%u)",
+                     hook_name, g_hook_violations);
+        return false;
+    }
+
+    if (!g_current_rendering_fiber) {
+        g_hook_violations++;
+        ed_log_error("%s called with no current fiber", hook_name);
+        return false;
+    }
+
+    if (g_hook_index >= ED_HOOKS_MAX_PER_COMPONENT) {
+        g_hook_violations++;
+        ed_log_error("%s exceeded max hooks per component (%u)",
+                     hook_name, ED_HOOKS_MAX_PER_COMPONENT);
+        return false;
+    }
+
+    return true;
+}
+
+/* ================================================================
+ * Hook Chain Processing
+ * ================================================================ */
+
+/* Process all hooks for a fiber during the render phase */
+static void ed_hook_process_chain(EDFiberNode* fiber)
+{
+    if (!fiber) return;
+
+    ed_hook_enter_render(fiber);
+
+    EDHookNode* hook = fiber->memoized_hooks;
+    while (hook) {
+        /* Process hook based on type */
+        switch (hook->type) {
+            case ED_HOOK_STATE:
+            case ED_HOOK_REDUCER: {
+                /* Process any queued updates */
+                EDHookStateValue* sv = (EDHookStateValue*)hook->memoized_state;
+                if (sv && sv->reducer && hook->queue) {
+                    /* Apply reducer with queued actions */
+                    ed_log_debug("Processing state hook %u", hook->index);
+                }
+                break;
+            }
+            case ED_HOOK_EFFECT:
+            case ED_HOOK_LAYOUT_EFFECT:
+            case ED_HOOK_INSERTION_EFFECT: {
+                /* Effects are processed during commit phase, not render */
+                break;
+            }
+            case ED_HOOK_MEMO:
+            case ED_HOOK_CALLBACK: {
+                /* Memo/callback hooks are processed during access */
+                break;
+            }
+            case ED_HOOK_REF: {
+                /* Refs are just containers, no processing needed */
+                break;
+            }
+            case ED_HOOK_CONTEXT: {
+                /* Check if context value changed */
+                break;
+            }
+            case ED_HOOK_DEBUG_VALUE: {
+                /* No-op in production */
+                break;
+            }
+            default:
+                break;
+        }
+
+        hook = hook->next;
+    }
+
+    ed_hook_exit_render();
+}
+
+/* ================================================================
+ * Hook Effect Commit Processing
+ * ================================================================ */
+
+/* Process layout effects synchronously during commit */
+static void ed_hook_commit_layout_effects(EDFiberNode* fiber)
+{
+    if (!fiber) return;
+
+    EDHookNode* hook = fiber->memoized_hooks;
+    while (hook) {
+        if (hook->is_layout && hook->has_effect) {
+            ed_hook_run_effect(hook);
+        }
+        hook = hook->next;
+    }
+}
+
+/* Schedule passive effects for after paint */
+static void ed_hook_schedule_passive_effects(EDFiberNode* fiber)
+{
+    if (!fiber) return;
+
+    EDHookNode* hook = fiber->memoized_hooks;
+    while (hook) {
+        if (hook->is_passive && hook->has_effect) {
+            /* In a real implementation, this would schedule
+             * the effect via the scheduler at idle priority */
+            ed_log_debug("Scheduling passive effect (hook %u)", hook->index);
+        }
+        hook = hook->next;
+    }
+}
+
+/* Process insertion effects (run before layout effects) */
+static void ed_hook_commit_insertion_effects(EDFiberNode* fiber)
+{
+    if (!fiber) return;
+
+    EDHookNode* hook = fiber->memoized_hooks;
+    while (hook) {
+        if (hook->is_insertion && hook->has_effect) {
+            ed_hook_run_effect(hook);
+        }
+        hook = hook->next;
+    }
+}
+
+/* ================================================================
+ * Hook Cleanup on Unmount
+ * ================================================================ */
+
+static void ed_hook_cleanup_fiber(EDFiberNode* fiber)
+{
+    if (!fiber) return;
+
+    EDHookNode* hook = fiber->memoized_hooks;
+    while (hook) {
+        /* Run cleanup for all effect hooks */
+        switch (hook->type) {
+            case ED_HOOK_EFFECT:
+            case ED_HOOK_LAYOUT_EFFECT:
+            case ED_HOOK_INSERTION_EFFECT:
+                ed_hook_run_cleanup(hook);
+                break;
+            default:
+                break;
+        }
+        hook = hook->next;
+    }
+}
+
+/* ================================================================
+ * Hook Violation Tracking
+ * ================================================================ */
+
+static uint32_t ed_hook_get_violation_count(void)
+{
+    return g_hook_violations;
+}
+
+static void ed_hook_reset_violations(void)
+{
+    g_hook_violations = 0;
+}