elementdrawing 1.0.0

package/src/core/bridge.h

@@ -0,0 +1,855 @@
+#ifndef ELEMENTDRAWING_BRIDGE_H
+#define ELEMENTDRAWING_BRIDGE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdarg.h>
+
+/* ============================================================
+ * ElementDrawing C-Core Engine Bridge Header
+ * High-performance rendering engine for the ElementDrawing framework
+ * ============================================================ */
+
+/* ---- Version Information ---- */
+#define ED_VERSION_MAJOR 1
+#define ED_VERSION_MINOR 0
+#define ED_VERSION_PATCH 0
+#define ED_VERSION_STRING "1.0.0"
+
+/* ---- Memory Management Constants ---- */
+#define ED_INITIAL_POOL_SIZE (1024 * 1024)
+#define ED_MAX_POOL_SIZE (64 * 1024 * 1024)
+#define ED_POOL_BLOCK_SIZE 4096
+#define ED_GC_THRESHOLD 0.75
+#define ED_GC_INCREMENTAL_STEP 256
+#define ED_WEAK_REF_TABLE_SIZE 1024
+#define ED_STRING_TABLE_SIZE 4096
+#define ED_STRING_CACHE_SIZE 1024
+#define ED_SYMBOL_TABLE_SIZE 2048
+
+/* ---- Virtual DOM Constants ---- */
+#define ED_MAX_CHILDREN 65536
+#define ED_MAX_DEPTH 1024
+#define ED_MAX_PROPS 512
+#define ED_MAX_PROP_KEY_LEN 256
+#define ED_MAX_PROP_VALUE_LEN 4096
+#define ED_MAX_TAG_NAME_LEN 128
+#define ED_MAX_TEXT_LEN 1048576
+#define ED_MAX_EVENT_HANDLERS 256
+#define ED_MAX_REF_COUNT 65536
+#define ED_MAX_KEY_LEN 256
+
+/* ---- Fiber Constants ---- */
+#define ED_FIBER_POOL_SIZE 4096
+#define ED_FIBER_MAX_SIBLINGS 1024
+#define ED_FIBER_WORK_EXPIRATION 5000
+#define ED_FIBER_PRIORITY_IMMEDIATE 1
+#define ED_FIBER_PRIORITY_USER_BLOCKING 2
+#define ED_FIBER_PRIORITY_NORMAL 3
+#define ED_FIBER_PRIORITY_LOW 4
+#define ED_FIBER_PRIORITY_IDLE 5
+
+/* ---- Scheduler Constants ---- */
+#define ED_SCHEDULER_MAX_QUEUE_SIZE 8192
+#define ED_SCHEDULER_MAX_CALLBACKS 2048
+#define ED_SCHEDULER_FRAME_BUDGET 16
+#define ED_SCHEDULER_YIELD_AFTER 5
+#define ED_SCHEDULER_MIN_PRIORITY 1
+#define ED_SCHEDULER_MAX_PRIORITY 5
+
+/* ---- Diff/Patch Constants ---- */
+#define ED_DIFF_MAX_OPERATIONS 8192
+#define ED_PATCH_QUEUE_SIZE 4096
+#define ED_DIFF_KEY_CACHE_SIZE 2048
+#define ED_DIFF_MAX_MOVED_NODES 1024
+
+/* ---- Rendering Constants ---- */
+#define ED_RENDER_MAX_STYLES 512
+#define ED_RENDER_MAX_CLASSES 256
+#define ED_RENDER_MAX_ATTRIBUTES 256
+#define ED_RENDER_BATCH_SIZE 64
+#define ED_RENDER_FLUSH_INTERVAL 16
+
+/* ---- Event Constants ---- */
+#define ED_EVENT_MAX_LISTENERS 4096
+#define ED_EVENT_BUBBLE_DEPTH 64
+#define ED_EVENT_CAPTURE_PHASE 1
+#define ED_EVENT_BUBBLE_PHASE 2
+#define ED_EVENT_DEFAULT_PHASE 3
+
+/* ---- Hooks Constants ---- */
+#define ED_HOOKS_MAX_PER_COMPONENT 256
+#define ED_HOOKS_STATE_SLOTS 1024
+#define ED_HOOKS_EFFECT_SLOTS 1024
+#define ED_HOOKS_REF_SLOTS 512
+#define ED_HOOKS_MEMO_SLOTS 512
+#define ED_HOOKS_CALLBACK_SLOTS 512
+
+/* ---- Error Codes ---- */
+#define ED_OK 0
+#define ED_ERR_MEMORY -1
+#define ED_ERR_NULL_PTR -2
+#define ED_ERR_INVALID_ARG -3
+#define ED_ERR_OUT_OF_BOUNDS -4
+#define ED_ERR_TYPE_MISMATCH -5
+#define ED_ERR_MAX_DEPTH -6
+#define ED_ERR_MAX_CHILDREN -7
+#define ED_ERR_POOL_EXHAUSTED -8
+#define ED_ERR_GC_FAILED -9
+#define ED_ERR_INVALID_STATE -10
+#define ED_ERR_SCHEDULE_FAILED -11
+#define ED_ERR_DIFF_FAILED -12
+#define ED_ERR_PATCH_FAILED -13
+#define ED_ERR_RENDER_FAILED -14
+#define ED_ERR_EVENT_FAILED -15
+#define ED_ERR_HOOK_VIOLATION -16
+
+/* ---- Node Types ---- */
+typedef enum {
+    ED_NODE_ELEMENT = 0,
+    ED_NODE_TEXT = 1,
+    ED_NODE_COMMENT = 2,
+    ED_NODE_FRAGMENT = 3,
+    ED_NODE_PORTAL = 4,
+    ED_NODE_SUSPENSE = 5,
+    ED_NODE_LAZY = 6,
+    ED_NODE_MEMO = 7,
+    ED_NODE_FORWARD_REF = 8,
+    ED_NODE_CONTEXT_PROVIDER = 9,
+    ED_NODE_CONTEXT_CONSUMER = 10,
+    ED_NODE_PROFILER = 11,
+    ED_NODE_STRICT_MODE = 12,
+    ED_NODE_CONCURRENT_MODE = 13
+} EDNodeType;
+
+/* ---- Fiber Tags ---- */
+typedef enum {
+    ED_FIBER_HOST_ROOT = 0,
+    ED_FIBER_HOST_COMPONENT = 1,
+    ED_FIBER_HOST_TEXT = 2,
+    ED_FIBER_CLASS_COMPONENT = 3,
+    ED_FIBER_FUNCTION_COMPONENT = 4,
+    ED_FIBER_INDIRECT_COMPONENT = 5,
+    ED_FIBER_CONTEXT_PROVIDER = 6,
+    ED_FIBER_CONTEXT_CONSUMER = 7,
+    ED_FIBER_FORWARD_REF = 8,
+    ED_FIBER_FRAGMENT = 9,
+    ED_FIBER_MODE = 10,
+    ED_FIBER_PROFILER = 11,
+    ED_FIBER_SUSPENSE_COMPONENT = 12,
+    ED_FIBER_SUSPENSE_LIST = 13,
+    ED_FIBER_MEMO_COMPONENT = 14,
+    ED_FIBER_LAZY_COMPONENT = 15,
+    ED_FIBER_SCOPE = 16,
+    ED_FIBER_OFFSCREEN = 17,
+    ED_FIBER_LEGACY_HIDDEN = 18,
+    ED_FIBER_CACHE = 19,
+    ED_FIBER_TRACING_MARKER = 20
+} EDFiberTag;
+
+/* ---- Fiber Flags (bitmask) ---- */
+typedef enum {
+    ED_FIBER_FLAG_NONE = 0,
+    ED_FIBER_FLAG_PERFORMED_WORK = 1 << 0,
+    ED_FIBER_FLAG_PLACEMENT = 1 << 1,
+    ED_FIBER_FLAG_UPDATE = 1 << 2,
+    ED_FIBER_FLAG_DELETION = 1 << 3,
+    ED_FIBER_FLAG_CHILD_DELETION = 1 << 4,
+    ED_FIBER_FLAG_REF = 1 << 5,
+    ED_FIBER_FLAG_CALLBACK = 1 << 6,
+    ED_FIBER_FLAG_DID_CAPTURE = 1 << 7,
+    ED_FIBER_FLAG_SHOULD_DELETE = 1 << 8,
+    ED_FIBER_FLAG_CONTENT_RESET = 1 << 9,
+    ED_FIBER_FLAG_TRIGGERED = 1 << 10,
+    ED_FIBER_FLAG_ERRORED = 1 << 11,
+    ED_FIBER_FLAG_FORCE_UPDATE = 1 << 12,
+    ED_FIBER_FLAG_PASSIVE = 1 << 13,
+    ED_FIBER_FLAG_LAYOUT = 1 << 14,
+    ED_FIBER_FLAG_HAS_EFFECT = 1 << 15,
+    ED_FIBER_FLAG_INCOMPLETE = 1 << 16,
+    ED_FIBER_FLAG_SHOULD_SUSPEND = 1 << 17,
+    ED_FIBER_FLAG_NEEDS_UPDATE = 1 << 18,
+    ED_FIBER_FLAG_MUTATION = 1 << 19,
+    ED_FIBER_FLAG_PERSISTED = 1 << 20,
+    ED_FIBER_FLAG_HIDDEN = 1 << 21,
+    ED_FIBER_FLAG_VISIBLE = 1 << 22,
+    ED_FIBER_FLAG_FORKED = 1 << 23,
+    ED_FIBER_FLAG_CLONED = 1 << 24,
+    ED_FIBER_FLAG_URGENT = 1 << 25,
+    ED_FIBER_FLAG_SCHEDULED = 1 << 26,
+    ED_FIBER_FLAG_REUSABLE = 1 << 27,
+    ED_FIBER_FLAG_WORK_IN_PROGRESS = 1 << 28
+} EDFiberFlags;
+
+/* ---- Scheduler Priority ---- */
+typedef enum {
+    ED_PRIORITY_IMMEDIATE = 1,
+    ED_PRIORITY_USER_BLOCKING = 2,
+    ED_PRIORITY_NORMAL = 3,
+    ED_PRIORITY_LOW = 4,
+    ED_PRIORITY_IDLE = 5
+} EDSchedulerPriority;
+
+/* ---- Effect Types ---- */
+typedef enum {
+    ED_EFFECT_MUTATION = 0,
+    ED_EFFECT_LAYOUT = 1,
+    ED_EFFECT_PASSIVE = 2,
+    ED_EFFECT_INSERTION = 3
+} EDEffectType;
+
+/* ---- Diff Operation Types ---- */
+typedef enum {
+    ED_DIFF_NONE = 0,
+    ED_DIFF_INSERT = 1,
+    ED_DIFF_DELETE = 2,
+    ED_DIFF_REPLACE = 3,
+    ED_DIFF_UPDATE = 4,
+    ED_DIFF_MOVE = 5,
+    ED_DIFF_REORDER = 6,
+    ED_DIFF_PROP_UPDATE = 7,
+    ED_DIFF_PROP_ADD = 8,
+    ED_DIFF_PROP_REMOVE = 9,
+    ED_DIFF_TEXT_UPDATE = 10
+} EDDiffOpType;
+
+/* ---- Patch Operation Types ---- */
+typedef enum {
+    ED_PATCH_SET_ATTRIBUTE = 0,
+    ED_PATCH_REMOVE_ATTRIBUTE = 1,
+    ED_PATCH_SET_STYLE = 2,
+    ED_PATCH_REMOVE_STYLE = 3,
+    ED_PATCH_ADD_CLASS = 4,
+    ED_PATCH_REMOVE_CLASS = 5,
+    ED_PATCH_INSERT_CHILD = 6,
+    ED_PATCH_REMOVE_CHILD = 7,
+    ED_PATCH_REPLACE_CHILD = 8,
+    ED_PATCH_MOVE_CHILD = 9,
+    ED_PATCH_SET_TEXT = 10,
+    ED_PATCH_SET_EVENT = 11,
+    ED_PATCH_REMOVE_EVENT = 12,
+    ED_PATCH_SET_REF = 13,
+    ED_PATCH_REMOVE_REF = 14
+} EDPatchOpType;
+
+/* ---- Event Phases ---- */
+typedef enum {
+    ED_EVENT_PHASE_NONE = 0,
+    ED_EVENT_PHASE_CAPTURE = 1,
+    ED_EVENT_PHASE_AT_TARGET = 2,
+    ED_EVENT_PHASE_BUBBLE = 3
+} EDEventPhase;
+
+/* ---- Hook Types ---- */
+typedef enum {
+    ED_HOOK_STATE = 0,
+    ED_HOOK_REDUCER = 1,
+    ED_HOOK_EFFECT = 2,
+    ED_HOOK_LAYOUT_EFFECT = 3,
+    ED_HOOK_CALLBACK = 4,
+    ED_HOOK_MEMO = 5,
+    ED_HOOK_REF = 6,
+    ED_HOOK_CONTEXT = 7,
+    ED_HOOK_DEBUG_VALUE = 8,
+    ED_HOOK_DEFERRED_VALUE = 9,
+    ED_HOOK_TRANSITION = 10,
+    ED_HOOK_ID = 11,
+    ED_HOOK_INSERTION_EFFECT = 12,
+    ED_HOOK_SYNC_EXTERNAL_STORE = 13,
+    ED_HOOK_USE = 14
+} EDHookType;
+
+/* ---- Forward Declarations ---- */
+typedef struct EDVirtualNode EDVirtualNode;
+typedef struct EDVirtualProp EDVirtualProp;
+typedef struct EDFiberNode EDFiberNode;
+typedef struct EDFiberPool EDFiberPool;
+typedef struct EDScheduler EDScheduler;
+typedef struct EDSchedulerTask EDSchedulerTask;
+typedef struct EDDiffResult EDDiffResult;
+typedef struct EDDiffOperation EDDiffOperation;
+typedef struct EDPatchOperation EDPatchOperation;
+typedef struct EDPatchQueue EDPatchQueue;
+typedef struct EDEvent EDEvent;
+typedef struct EDEventListener EDEventListener;
+typedef struct EDEventSystem EDEventSystem;
+typedef struct EDHookNode EDHookNode;
+typedef struct EDHookQueue EDHookQueue;
+typedef struct EDStateNode EDStateNode;
+typedef struct EDStateManager EDStateManager;
+typedef struct EDRenderBatch EDRenderBatch;
+typedef struct EDStringEntry EDStringEntry;
+typedef struct EDPoolBlock EDPoolBlock;
+typedef struct EDMemoryPool EDMemoryPool;
+typedef struct EDWeakRef EDWeakRef;
+typedef struct EDSymbolEntry EDSymbolEntry;
+
+/* ---- Property Structure ---- */
+struct EDVirtualProp {
+    char key[ED_MAX_PROP_KEY_LEN];
+    char value[ED_MAX_PROP_VALUE_LEN];
+    uint32_t hash;
+    uint8_t type;                   /* 0=string, 1=number, 2=bool, 3=function, 4=object, 5=array */
+    bool is_event;
+    bool is_style;
+    bool is_class;
+    bool is_ref;
+    bool is_key;
+    bool is_children;
+    bool is_dangerous_html;
+    EDVirtualProp* next;
+};
+
+/* ---- Virtual Node Structure ---- */
+struct EDVirtualNode {
+    EDNodeType type;
+    char tag[ED_MAX_TAG_NAME_LEN];
+    char text[ED_MAX_TEXT_LEN];
+    char key[ED_MAX_KEY_LEN];
+    uint32_t ref_id;
+
+    /* Properties */
+    EDVirtualProp* props;
+    uint32_t prop_count;
+
+    /* Children */
+    EDVirtualNode** children;
+    uint32_t child_count;
+    uint32_t child_capacity;
+
+    /* Tree structure */
+    EDVirtualNode* parent;
+    EDVirtualNode* sibling;
+    EDVirtualNode* first_child;
+    EDVirtualNode* last_child;
+
+    /* State */
+    uint32_t version;
+    uint32_t hash;
+    bool is_dirty;
+    bool is_committed;
+    bool is_suspended;
+    bool is_hidden;
+
+    /* Memory management */
+    uint32_t ref_count;
+    EDVirtualNode* next_free;
+
+    /* Component info */
+    void* component_instance;
+    void* component_state;
+    void* context_value;
+
+    /* Performance tracking */
+    uint64_t render_start_time;
+    uint64_t render_end_time;
+    uint64_t commit_start_time;
+    uint64_t commit_end_time;
+};
+
+/* ---- Fiber Node Structure ---- */
+struct EDFiberNode {
+    EDFiberTag tag;
+    EDFiberFlags flags;
+    EDSchedulerPriority priority;
+
+    /* Tree structure */
+    EDFiberNode* parent;
+    EDFiberNode* child;
+    EDFiberNode* sibling;
+    EDFiberNode* alternate;
+
+    /* Work */
+    EDVirtualNode* pending_props;
+    EDVirtualNode* memoized_props;
+    EDVirtualNode* memoized_state;
+    EDHookNode* memoized_hooks;
+
+    /* DOM reference */
+    void* state_node;
+    void* ref_value;
+
+    /* Key for reconciliation */
+    char key[ED_MAX_KEY_LEN];
+    uint32_t key_hash;
+
+    /* Effect lists */
+    EDFiberNode* first_effect;
+    EDFiberNode* last_effect;
+    EDFiberNode* next_effect;
+
+    /* Dependency tracking */
+    EDFiberNode* dependencies;
+    uint32_t lanes;
+    uint32_t child_lanes;
+
+    /* Update queue */
+    void* update_queue;
+    uint32_t update_count;
+
+    /* Return node */
+    EDFiberNode* return_node;
+
+    /* Index for sibling tracking */
+    int32_t index;
+
+    /* Scheduling info */
+    uint64_t expiration_time;
+    uint64_t start_time;
+    uint64_t finish_time;
+
+    /* Error boundary */
+    EDFiberNode* error_boundary;
+    void* error_boundary_info;
+
+    /* Offscreen tracking */
+    bool is_hidden;
+    bool is_offscreen;
+
+    /* Pool management */
+    bool is_active;
+    EDFiberNode* next_free;
+};
+
+/* ---- Fiber Pool ---- */
+struct EDFiberPool {
+    EDFiberNode* nodes;
+    EDFiberNode* free_list;
+    uint32_t capacity;
+    uint32_t used_count;
+    uint32_t peak_usage;
+    uint32_t alloc_count;
+    uint32_t free_count;
+    uint32_t reuse_count;
+};
+
+/* ---- Scheduler Task ---- */
+struct EDSchedulerTask {
+    uint32_t id;
+    EDSchedulerPriority priority;
+    void (*callback)(void* data);
+    void* data;
+    uint64_t expiration_time;
+    uint64_t start_time;
+    bool is_running;
+    bool is_cancelled;
+    bool is_recurring;
+    uint32_t interval_ms;
+    EDSchedulerTask* next;
+};
+
+/* ---- Scheduler ---- */
+struct EDScheduler {
+    EDSchedulerTask* queues[6];
+    uint32_t queue_sizes[6];
+    uint32_t total_tasks;
+    uint32_t completed_tasks;
+    uint32_t cancelled_tasks;
+    uint64_t frame_start;
+    uint64_t frame_deadline;
+    bool is_working;
+    bool should_yield;
+    uint32_t current_priority;
+    EDSchedulerTask* current_task;
+    uint32_t next_task_id;
+};
+
+/* ---- Diff Operation ---- */
+struct EDDiffOperation {
+    EDDiffOpType type;
+    uint32_t index;
+    uint32_t new_index;
+    EDVirtualNode* node;
+    EDVirtualNode* new_node;
+    EDVirtualProp* prop_changes;
+    uint32_t prop_change_count;
+    EDDiffOperation* next;
+};
+
+/* ---- Diff Result ---- */
+struct EDDiffResult {
+    EDDiffOperation* operations;
+    uint32_t operation_count;
+    uint32_t insert_count;
+    uint32_t delete_count;
+    uint32_t update_count;
+    uint32_t move_count;
+    uint32_t reorder_count;
+    bool has_changes;
+};
+
+/* ---- Patch Operation ---- */
+struct EDPatchOperation {
+    EDPatchOpType type;
+    void* target_node;
+    char key[ED_MAX_PROP_KEY_LEN];
+    char value[ED_MAX_PROP_VALUE_LEN];
+    uint32_t index;
+    void* data;
+    EDPatchOperation* next;
+};
+
+/* ---- Patch Queue ---- */
+struct EDPatchQueue {
+    EDPatchOperation* head;
+    EDPatchOperation* tail;
+    uint32_t count;
+    uint32_t capacity;
+};
+
+/* ---- Event ---- */
+struct EDEvent {
+    char type[64];
+    EDEventPhase phase;
+    void* target;
+    void* current_target;
+    bool bubbles;
+    bool cancelable;
+    bool default_prevented;
+    bool propagation_stopped;
+    bool immediate_propagation_stopped;
+    uint64_t timestamp;
+    void* native_event;
+    EDEvent* synthetic_parent;
+    int32_t event_phase;
+};
+
+/* ---- Event Listener ---- */
+struct EDEventListener {
+    char event_type[64];
+    void (*handler)(EDEvent* event, void* user_data);
+    void* user_data;
+    bool capture;
+    bool passive;
+    bool once;
+    uint32_t priority;
+    EDEventListener* next;
+};
+
+/* ---- Event System ---- */
+struct EDEventSystem {
+    EDEventListener* listeners[ED_EVENT_MAX_LISTENERS];
+    uint32_t listener_counts[ED_EVENT_MAX_LISTENERS];
+    void* delegation_root;
+    bool is_dispatching;
+    uint32_t active_event_count;
+    uint64_t total_events_processed;
+    EDEvent* current_event;
+};
+
+/* ---- Hook Node ---- */
+struct EDHookNode {
+    EDHookType type;
+    uint32_t index;
+    void* memoized_state;
+    void* queue;
+    void* base_queue;
+    EDHookNode* next;
+    bool has_effect;
+    bool is_layout;
+    bool is_passive;
+    bool is_insertion;
+    void* cleanup;
+    void* effect_callback;
+    void* deps;
+    uint32_t deps_count;
+    EDFiberNode* fiber;
+};
+
+/* ---- Hook Queue ---- */
+struct EDHookQueue {
+    EDHookNode* head;
+    EDHookNode* tail;
+    uint32_t count;
+};
+
+/* ---- State Node ---- */
+struct EDStateNode {
+    void* value;
+    void* updater;
+    uint32_t version;
+    uint64_t last_update_time;
+    bool is_pending;
+    EDStateNode* next;
+};
+
+/* ---- State Manager ---- */
+struct EDStateManager {
+    EDStateNode* states[ED_HOOKS_STATE_SLOTS];
+    uint32_t state_counts[ED_HOOKS_STATE_SLOTS];
+    uint32_t total_states;
+    uint32_t active_states;
+    uint64_t total_updates;
+    uint64_t batched_updates;
+    bool is_batching;
+    void* batch_callback;
+};
+
+/* ---- Render Batch ---- */
+struct EDRenderBatch {
+    EDPatchOperation* operations;
+    uint32_t count;
+    uint64_t start_time;
+    uint64_t end_time;
+    uint32_t dom_writes;
+    uint32_t dom_reads;
+    EDRenderBatch* next;
+};
+
+/* ---- String Interning ---- */
+struct EDStringEntry {
+    char* str;
+    uint32_t len;
+    uint32_t hash;
+    uint32_t ref_count;
+    EDStringEntry* next;
+};
+
+/* ---- Memory Pool Block ---- */
+struct EDPoolBlock {
+    uint8_t* data;
+    uint32_t size;
+    uint32_t used;
+    EDPoolBlock* next;
+};
+
+/* ---- Memory Pool ---- */
+struct EDMemoryPool {
+    EDPoolBlock* blocks;
+    uint32_t total_size;
+    uint32_t used_size;
+    uint32_t peak_usage;
+    uint32_t block_count;
+    uint32_t alloc_count;
+    uint32_t free_count;
+    bool is_initialized;
+};
+
+/* ---- Weak Reference ---- */
+struct EDWeakRef {
+    void* target;
+    uint32_t id;
+    bool is_alive;
+    EDWeakRef* next;
+};
+
+/* ---- Symbol Table ---- */
+struct EDSymbolEntry {
+    char name[128];
+    uint32_t id;
+    void* value;
+    EDSymbolEntry* next;
+};
+
+/* ---- Function Pointer Types ---- */
+typedef void (*EDRenderCallback)(EDVirtualNode* tree, void* context);
+typedef void (*EDCommitCallback)(EDFiberNode* fiber, void* state_node);
+typedef void (*EDReconcileCallback)(EDFiberNode* current, EDFiberNode* work_in_progress);
+typedef void (*EDEffectCallback)(void* effect, void* cleanup);
+typedef void* (*EDStateUpdater)(void* prev_state, void* action);
+typedef bool (*EDShouldUpdateFunc)(EDVirtualNode* prev, EDVirtualNode* next);
+typedef void (*EDErrorHandler)(int error_code, const char* message, void* context);
+typedef void (*EDSchedulerCallback)(void* data);
+typedef void (*EDEventCallback)(EDEvent* event, void* user_data);
+typedef void (*EDHookCallback)(EDHookNode* hook, EDFiberNode* fiber);
+typedef uint64_t (*EDTimestampFunc)(void);
+
+/* ---- Global Configuration ---- */
+typedef struct {
+    bool concurrent_mode;
+    bool strict_mode;
+    bool profiler_enabled;
+    bool suspense_enabled;
+    bool error_boundaries_enabled;
+    bool dev_tools_enabled;
+    bool trace_updates;
+    bool validate_props;
+    uint32_t max_render_time_ms;
+    uint32_t max_commit_time_ms;
+    uint32_t scheduler_frame_budget_ms;
+    bool auto_batch_updates;
+    bool legacy_context_api;
+    EDErrorHandler on_error;
+    void* error_context;
+    EDTimestampFunc get_timestamp;
+} EDConfiguration;
+
+/* ---- API Functions - Virtual DOM ---- */
+EDVirtualNode* ed_vnode_create(EDNodeType type, const char* tag, const char* key);
+void ed_vnode_destroy(EDVirtualNode* node);
+void ed_vnode_add_child(EDVirtualNode* parent, EDVirtualNode* child);
+void ed_vnode_remove_child(EDVirtualNode* parent, EDVirtualNode* child);
+void ed_vnode_insert_child(EDVirtualNode* parent, EDVirtualNode* child, uint32_t index);
+void ed_vnode_replace_child(EDVirtualNode* parent, EDVirtualNode* new_child, EDVirtualNode* old_child);
+void ed_vnode_set_prop(EDVirtualNode* node, const char* key, const char* value, uint8_t type);
+void ed_vnode_remove_prop(EDVirtualNode* node, const char* key);
+EDVirtualProp* ed_vnode_get_prop(EDVirtualNode* node, const char* key);
+void ed_vnode_set_text(EDVirtualNode* node, const char* text);
+void ed_vnode_set_key(EDVirtualNode* node, const char* key);
+uint32_t ed_vnode_hash(EDVirtualNode* node);
+bool ed_vnode_equals(EDVirtualNode* a, EDVirtualNode* b);
+EDVirtualNode* ed_vnode_clone(EDVirtualNode* node);
+void ed_vnode_mark_dirty(EDVirtualNode* node);
+void ed_vnode_clear_dirty(EDVirtualNode* node);
+uint32_t ed_vnode_depth(EDVirtualNode* node);
+uint32_t ed_vnode_count(EDVirtualNode* node);
+void ed_vnode_traverse(EDVirtualNode* node, void (*visitor)(EDVirtualNode*, void*), void* data);
+void ed_vnode_traverse_bfs(EDVirtualNode* node, void (*visitor)(EDVirtualNode*, void*), void* data);
+
+/* ---- API Functions - Fiber ---- */
+EDFiberNode* ed_fiber_create(EDFiberTag tag, EDFiberFlags flags);
+void ed_fiber_destroy(EDFiberNode* fiber);
+EDFiberPool* ed_fiber_pool_create(uint32_t capacity);
+void ed_fiber_pool_destroy(EDFiberPool* pool);
+EDFiberNode* ed_fiber_pool_alloc(EDFiberPool* pool);
+void ed_fiber_pool_free(EDFiberPool* pool, EDFiberNode* fiber);
+EDFiberNode* ed_fiber_clone(EDFiberNode* fiber);
+void ed_fiber_add_child(EDFiberNode* parent, EDFiberNode* child);
+void ed_fiber_add_sibling(EDFiberNode* a, EDFiberNode* b);
+void ed_fiber_set_props(EDFiberNode* fiber, EDVirtualNode* props);
+void ed_fiber_set_state(EDFiberNode* fiber, EDVirtualNode* state);
+void ed_fiber_add_effect(EDFiberNode* fiber, EDFiberNode* effect);
+void ed_fiber_add_dependency(EDFiberNode* fiber, EDFiberNode* dep);
+void ed_fiber_set_priority(EDFiberNode* fiber, EDSchedulerPriority priority);
+uint32_t ed_fiber_count_descendants(EDFiberNode* fiber);
+uint32_t ed_fiber_count_effects(EDFiberNode* fiber);
+bool ed_fiber_has_effect(EDFiberNode* fiber, EDFiberFlags flag);
+void ed_fiber_set_flag(EDFiberNode* fiber, EDFiberFlags flag);
+void ed_fiber_clear_flag(EDFiberNode* fiber, EDFiberFlags flag);
+
+/* ---- API Functions - Scheduler ---- */
+EDScheduler* ed_scheduler_create(void);
+void ed_scheduler_destroy(EDScheduler* scheduler);
+uint32_t ed_scheduler_schedule(EDScheduler* scheduler, EDSchedulerPriority priority, EDSchedulerCallback callback, void* data);
+bool ed_scheduler_cancel(EDScheduler* scheduler, uint32_t task_id);
+void ed_scheduler_work(EDScheduler* scheduler);
+bool ed_scheduler_should_yield(EDScheduler* scheduler);
+void ed_scheduler_flush_all(EDScheduler* scheduler);
+void ed_scheduler_advance(EDScheduler* scheduler);
+EDSchedulerPriority ed_scheduler_get_current_priority(EDScheduler* scheduler);
+void ed_scheduler_start_profiling(EDScheduler* scheduler);
+void ed_scheduler_stop_profiling(EDScheduler* scheduler);
+uint64_t ed_scheduler_get_frame_deadline(EDScheduler* scheduler);
+uint32_t ed_scheduler_get_pending_count(EDScheduler* scheduler);
+
+/* ---- API Functions - Diff ---- */
+EDDiffResult* ed_diff_compute(EDVirtualNode* old_tree, EDVirtualNode* new_tree);
+void ed_diff_result_destroy(EDDiffResult* result);
+EDDiffOperation* ed_diff_operation_create(EDDiffOpType type, uint32_t index);
+void ed_diff_operation_destroy(EDDiffOperation* op);
+uint32_t ed_diff_count_operations(EDDiffResult* result);
+bool ed_diff_has_changes(EDDiffResult* result);
+
+/* ---- API Functions - Patch ---- */
+EDPatchQueue* ed_patch_queue_create(uint32_t capacity);
+void ed_patch_queue_destroy(EDPatchQueue* queue);
+void ed_patch_queue_push(EDPatchQueue* queue, EDPatchOperation* op);
+EDPatchOperation* ed_patch_queue_pop(EDPatchQueue* queue);
+void ed_patch_queue_flush(EDPatchQueue* queue);
+uint32_t ed_patch_queue_count(EDPatchQueue* queue);
+bool ed_patch_queue_is_empty(EDPatchQueue* queue);
+void ed_patch_apply(EDPatchOperation* op);
+void ed_patch_apply_all(EDPatchQueue* queue);
+
+/* ---- API Functions - Reconciliation ---- */
+EDFiberNode* ed_reconcile_children(EDFiberNode* current, EDFiberNode* work_in_progress);
+void ed_reconcile_child_fibers(EDFiberNode* current, EDFiberNode* work_in_progress, EDVirtualNode* next_children);
+EDFiberNode* ed_reconcile_single_element(EDFiberNode* current, EDFiberNode* work_in_progress, EDVirtualNode* element);
+EDFiberNode* ed_reconcile_single_text(EDFiberNode* current, EDFiberNode* work_in_progress, EDVirtualNode* text);
+EDFiberNode* ed_reconcile_children_array(EDFiberNode* current, EDFiberNode* work_in_progress, EDVirtualNode** next_children, uint32_t count);
+void ed_place_child(EDFiberNode* new_fiber, EDFiberFlags flags, uint32_t index);
+EDFiberNode* ed_update_slot(EDFiberNode* current, uint32_t index, EDVirtualNode* element);
+EDFiberNode* ed_create_child(EDVirtualNode* element, uint32_t index);
+EDFiberNode* ed_use_fiber(EDFiberNode* current, EDVirtualNode* pending_props);
+uint32_t ed_delete_remaining_children(EDFiberNode* current);
+
+/* ---- API Functions - Hooks ---- */
+EDHookNode* ed_hook_create(EDHookType type, uint32_t index);
+void ed_hook_destroy(EDHookNode* hook);
+void ed_hook_queue_push(EDHookQueue* queue, EDHookNode* hook);
+EDHookNode* ed_hook_queue_pop(EDHookQueue* queue);
+void ed_hook_set_state(EDHookNode* hook, void* state);
+void* ed_hook_get_state(EDHookNode* hook);
+void ed_hook_set_effect(EDHookNode* hook, void* callback, void* deps, uint32_t deps_count);
+void ed_hook_run_effect(EDHookNode* hook);
+void ed_hook_run_cleanup(EDHookNode* hook);
+bool ed_hook_deps_changed(void* prev_deps, void* next_deps, uint32_t count);
+
+/* ---- API Functions - State ---- */
+EDStateManager* ed_state_manager_create(void);
+void ed_state_manager_destroy(EDStateManager* manager);
+EDStateNode* ed_state_create(void* initial_value);
+void ed_state_destroy(EDStateNode* state);
+void ed_state_update(EDStateNode* state, void* new_value);
+void ed_state_batch_update(EDStateManager* manager, EDStateNode** states, void** values, uint32_t count);
+void ed_state_flush_updates(EDStateManager* manager);
+uint32_t ed_state_version(EDStateNode* state);
+
+/* ---- API Functions - Event System ---- */
+EDEventSystem* ed_event_system_create(void);
+void ed_event_system_destroy(EDEventSystem* system);
+uint32_t ed_event_add_listener(EDEventSystem* system, const char* event_type, EDEventCallback handler, void* user_data, bool capture);
+bool ed_event_remove_listener(EDEventSystem* system, uint32_t listener_id);
+void ed_event_dispatch(EDEventSystem* system, EDEvent* event);
+EDEvent* ed_event_create(const char* type, bool bubbles, bool cancelable);
+void ed_event_destroy(EDEvent* event);
+void ed_event_stop_propagation(EDEvent* event);
+void ed_event_prevent_default(EDEvent* event);
+
+/* ---- API Functions - Renderer ---- */
+int ed_renderer_init(EDConfiguration* config);
+void ed_renderer_shutdown(void);
+EDRenderBatch* ed_renderer_create_batch(void);
+void ed_renderer_destroy_batch(EDRenderBatch* batch);
+void ed_renderer_commit_batch(EDRenderBatch* batch);
+uint32_t ed_renderer_schedule_update(EDFiberNode* fiber, EDSchedulerPriority priority);
+void ed_renderer_process_updates(void);
+void ed_renderer_request_paint(void);
+void ed_renderer_flush_passive_effects(void);
+void ed_renderer_flush_layout_effects(void);
+void ed_renderer_flush_sync(void);
+
+/* ---- API Functions - Memory Pool ---- */
+EDMemoryPool* ed_pool_create(uint32_t initial_size);
+void ed_pool_destroy(EDMemoryPool* pool);
+void* ed_pool_alloc(EDMemoryPool* pool, uint32_t size);
+void ed_pool_free(EDMemoryPool* pool, void* ptr);
+void ed_pool_reset(EDMemoryPool* pool);
+uint32_t ed_pool_available(EDMemoryPool* pool);
+void ed_pool_gc(EDMemoryPool* pool);
+uint32_t ed_pool_defragment(EDMemoryPool* pool);
+
+/* ---- API Functions - String Interning ---- */
+const char* ed_string_intern(const char* str);
+void ed_string_release(const char* str);
+uint32_t ed_string_hash(const char* str);
+bool ed_string_equals_interned(const char* a, const char* b);
+
+/* ---- Utility Functions ---- */
+uint64_t ed_get_timestamp_ms(void);
+uint32_t ed_hash_djb2(const char* str);
+uint32_t ed_hash_fnv1a(const char* str);
+bool ed_str_equals(const char* a, const char* b);
+char* ed_str_duplicate(const char* str);
+uint32_t ed_next_power_of_2(uint32_t n);
+void ed_log_info(const char* format, ...);
+void ed_log_warn(const char* format, ...);
+void ed_log_error(const char* format, ...);
+void ed_log_debug(const char* format, ...);
+const char* ed_version(void);
+const char* ed_node_type_name(EDNodeType type);
+const char* ed_fiber_tag_name(EDFiberTag tag);
+const char* ed_error_message(int error_code);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ELEMENTDRAWING_BRIDGE_H */