#define Scalpi_network_tcp_http_WebSocket_Header_Size_medium_header (Scalpi_network_tcp_http_WebSocket_Header_Size_small_header + Scalpi_network_tcp_http_WebSocket_Header_Size_medium_extended_payload_len_size)
            
            // 10 bytes header for sizes more than 65535
                #define Scalpi_network_tcp_http_WebSocket_Header_Size_long 2
                #define Scalpi_network_tcp_http_WebSocket_Header_Size_long_flag 127
                #define Scalpi_network_tcp_http_WebSocket_Header_Size_long_extended_payload_len_size 8
                #define Scalpi_network_tcp_http_WebSocket_Header_Size_long_header (Scalpi_network_tcp_http_WebSocket_Header_Size_small_header + Scalpi_network_tcp_http_WebSocket_Header_Size_long_extended_payload_len_size)
    // auto casting
        #define __OsMem_allocAny__(       ret_data_addr, size)             __OsMem_alloc__(       (uintptr_t*) (ret_data_addr), size)
        #define __OsMem_freeAny__(        ret_data_addr)                   __OsMem_free__(        (uintptr_t)  (ret_data_addr))
        #define __AlignedPtr_allocAny__(  ret_data_addr, mem_align, size)  __AlignedPtr_alloc__(  (uintptr_t*) (ret_data_addr), mem_align, size)
        #define __AlignedPtr_freeAny__(   ret_data_addr, size)             __AlignedPtr_free__(   (uintptr_t)  (ret_data_addr), size)
// structs
    // core
        // memory
            // # __AlignedPtr__
                /* its a virtual struct becouse C not have "anytype" type.
                // struct __AlignedPtr__ {
                //     char    gap[padding];  // for aligning data. can be 0.
                //     anytype your_data;
                //     uint8_t size_of_gap;
                    struct __AlignedPtr__ {
                        char    gap[gap_size] // padding for aligning data. gap_size can be 0.
                        anytype your_data     // <- the pointer that the alloc function returns will be pointed here.
                        uint8_t gap_size
                // }
                //
            // __ScalpiMemListLink__
                    }
                */ 
            // # __ScalpiMemListLink__
                struct __ScalpiMemListLink__ {
                    struct __ScalpiMemListLink__* prev;
                    struct __ScalpiMemListLink__* next;
                    struct __ScalpiMemList__*     list;
                };
            // __ScalpiMemList__
            // # __ScalpiMemList__
                struct __ScalpiMemList__ {
                    struct __ScalpiMemListLink__* first;
                    struct __ScalpiMemListLink__* last;
                    size_t                        count;
                };
            // Slice
            // # Slice
                struct Slice {
                    char* ptr;
                    size_t len;
                };
            // Finder
            // # Finder
                struct Finder {
                    struct Slice text;
                    struct Slice desired;
                    size_t pos;
                };
    // Os
        // system specifics 

            };
        // text
            struct Scalpi_Text_Splitter {
                struct Finder finder;
                bool stop;
                size_t last_pos;
            };
        // var Scalpi_Logger
        // # Scalpi_Logger
            struct Scalpi_Logger {
                // write to terminal, console, file or to all together, but no real check "bytes is writen"
                struct __Scalpi_Writer__ writers[4]; // Scalpi_Logger_writers
            };
        // Console
            // __Scalpi_Console_ansi_input_Key_SequenceParser__
                struct __Scalpi_Console_ansi_input_Key_SequenceParser__ {

        // # App
            struct App {
                struct __OsHelper__    __App_osHelper__;
                struct Scalpi_Logger   logger;
                uint64_t               tick;
            };
// function prototypes
    bool   __OsFile_exist__(const char* file_name, size_t file_name_len);
    bool   __Os_allocBytes__(char**ret, size_t size); // todo rename to __OsMem_alloc__
    void   __Os_freeBytes__(char* ptr);
    size_t __OsFallbackConsole_write__(void* unused_ctx, char* data, size_t len);
    bool   __OsFile_exist__(             const char* file_name, size_t file_name_len);
    bool   __OsMem_alloc__(              uintptr_t *ret_data_addr, size_t size); // todo rename to __OsMem_alloc__
    void   __OsMem_free__(               uintptr_t ret_data_addr);
    size_t __OsFallbackConsole_write__(  void* unused_ctx, char* data, size_t len);
// globals
    struct App global_app;
// functions
    // core
        // mem
            // bits operations
                uint8_t bits_rotl8(uint8_t value, unsigned int shift) {

            // bytes operations
                // # __ScalpiMem_fill__
                    void __ScalpiMem_fill__(char* dest, char symbol, size_t len) {
                        for (size_t pos = 0; pos < len; pos++) {
                            dest[pos] = symbol;
                        }
                    }
                // # __ScalpiMem_copyBackward__
                    void __ScalpiMem_copyBackward__(char* dest, const char* src, size_t size) {
                // # __ScalpiMem_copy__
                    void __ScalpiMem_copy__( // todo create macros __ScalpiMem_copyAny__
                        size_t pos = size;
                        while(pos > 0) {
                            pos--;
                            dest[pos] = src[pos];
                        char        *dest,
                        }
                    }
                // # __ScalpiMem_reverse__
                    void __ScalpiMem_reverse__(char dest[], const char src[], size_t len) {
                        const char* source = &src[len - 1];
                        size_t iter = 0;
                        for(; iter < len; iter++, dest++, source--) {
                        const char  *src,
                        size_t size
                    ) {
                            *dest = *source;
                        }
                    }
                // # __ScalpiMem_copy__
                    void __ScalpiMem_copy__(char* dest, const char* src, size_t size) {
                        // i use this instead memcpy becouse clang-in-zig just replace memcpy to crash-zig-bloated-version code
                        size_t pos = 0;
                        while(pos < size) {
                            dest[pos] = src[pos];
                            pos++;
                        }
                    }
                // # __ScalpiMem_copyBackward__
                    void __ScalpiMem_copyBackward__(char* dest, const char* src, size_t size) {
                        size_t pos = size;
                        while(pos > 0) {
                            pos-=1;
                            dest[pos] = src[pos];
                        }
                    }
                // # __ScalpiMem_reverse__
                    void __ScalpiMem_reverse__(
                        char       *dest,
                        const char *src,
                        size_t len
                    ) {
                        src = &src[len - 1];
                        size_t iter = 0;
                        for(; iter < len; iter++, dest++, src--) {
                            *dest = *src;
                        }
                    }
                    
                // # __ScalpiMem_findDiffOrLen__
                    size_t __ScalpiMem_findDiffOrLen__(const char a[], const char b[], size_t len) {
                        size_t pos = 0;
                        while(pos < len) {
                            if (a[pos] != b[pos]) break;
                            pos++;
                        }

                        ;
                    }
                // # writeWithOffset
                    void writeWithOffset(char* dest, size_t* writed, char* data, size_t data_len) {
                        __ScalpiMem_copy__(&dest[*writed], data, data_len);
                        *writed += data_len;
                    }
            // AlignedPtr
            // __AlignedPtr__
                // # __AlignedPtr_alloc__
                    bool __AlignedPtr_alloc__(
                        __AlignedPtr__ *ret,
                        uint8_t        mem_align,   // expected >= 1
                        size_t         size         // expected >= 1
                        uintptr_t  *ret_data_addr,
                        uint8_t    data_align,   // expected >= 1
                        size_t     data_size     // expected >= 1
                    ) {
                        bool ok = true;
                            uint8_t   gap_size       = 0;
                            size_t     len = size + (mem_align - 1) + 1;
                            uintptr_t  origin;
                            if (__Os_allocBytes__((void*) &origin, len)) {
                                uint8_t offset = 0;
                                uint8_t nodled = origin % mem_align;
                                if (nodled) {
                                    offset = mem_align - nodled;
                                }
                            size_t    allocated_size = data_size + (data_align - 1) + sizeof(gap_size);
                            uintptr_t allocated_addr;
                            if (__OsMem_allocAny__(&allocated_addr, allocated_size)) {
                                // calc size of gap
                                    uint8_t nodled  = allocated_addr % data_align;
                                    if (nodled) {
                                        gap_size = data_align - nodled;
                                    }
                                
                                // write ret_data_addr
                                uintptr_t  data_ptr   = origin + offset;
                                uint8_t*   offset_ptr = (uint8_t*) (data_ptr + size);
                                *offset_ptr = offset;
                                *ret = (void*)data_ptr;
                                    uintptr_t data_addr  = allocated_addr + gap_size;
                                    *ret_data_addr = data_addr;
                                
                                // save gap size
                                    * (uint8_t*) (data_addr + data_size) = gap_size;
                                
                                if (!ok) __Os_freeBytes__((void*)origin);
                                if (!ok) __OsMem_freeAny__(allocated_addr);
                            } else {
                                ok = false;
                            }
                        return ok;
                    }
                // # __AlignedPtr_free__
                    void __AlignedPtr_free__(
                        __AlignedPtr__  ptr,
                        size_t          size
                        uintptr_t data_addr,
                        size_t    data_size
                    ) {
                        uint8_t offset = ptr[size];
                        uint8_t gap_size = * (uint8_t*) (data_addr + data_size);
                        char*   origin = (char*)((uintptr_t) ptr - offset);
                        free(origin);
                        __OsMem_freeAny__(data_addr - gap_size);
                    }
            // format_number
                bool cpu_checkNumberFormat() {
                    char current_endians = 0;
                    int n = 1;
                    if (* (char *) &n == 1) {
                        current_endians = __TargetMemoryType_endiansLittle__;
                    } else {
                        current_endians = __TargetMemoryType_endiansBig__;
                    }
                    
                    if (__target_memory_type__ == current_endians) {
                        return true;
                    } else {
                        printf("%d wrong MEMORY_TYPE !\r\n", __LINE__);
                    }
                    return false;
                }
                
                #if __target_memory_type__ == __TargetMemoryType_endiansBig__
                    #define nativeToBig16(dest, src) __ScalpiMem_copy__(dest, src, 2)
                    #define nativeToBig(dest, src, size)    __ScalpiMem_copy__(dest, src, size)
                    #define nativeToBig32(dest, src) __ScalpiMem_copy__(dest, src, 4)
                    #define nativeToBig64(dest, src) __ScalpiMem_copy__(dest, src, 8)
                    
                    #define nativeToLittle16(dest, src) __ScalpiMem_reverse__(dest, src, 2)
                    #define nativeToLittle(dest, src, size) __ScalpiMem_reverse__(dest, src, size)
                    #define nativeToLittle32(dest, src) __ScalpiMem_reverse__(dest, src, 4)
                    #define nativeToLittle64(dest, src) __ScalpiMem_reverse__(dest, src, 8)
                #elif __target_memory_type__ == __TargetMemoryType_endiansLittle__
                    #define nativeToBig16(dest, src) __ScalpiMem_reverse__(dest, src, 2)
                    #define nativeToBig(dest, src, size)    __ScalpiMem_reverse__(dest, src, size)
                    #define nativeToBig32(dest, src) __ScalpiMem_reverse__(dest, src, 4)
                    #define nativeToBig64(dest, src) __ScalpiMem_reverse__(dest, src, 8)
                    
                    #define nativeToLittle16(dest, src) __ScalpiMem_copy__(dest, src, 2)
                    #define nativeToLittle(dest, src, size) __ScalpiMem_copy__(dest, src, size)
                    #define nativeToLittle32(dest, src) __ScalpiMem_copy__(dest, src, 4)
                    #define nativeToLittle64(dest, src) __ScalpiMem_copy__(dest, src, 8)
                #else
                    #error "please define __target_memory_type__ with __TargetMemoryType_ (you can test endings with cpu_checkNumberFormat function)"
                #endif
                
                // read unaligned memory
                    // big
                        uint16_t readBig16(char* src) {
                            uint16_t ret;
                            nativeToBig16( (char*) &ret, src );
                            nativeToBig( (char*) &ret, src, 2);
                            return ret;
                        }
                        
                        uint32_t readBig32(char* src) {
                            uint32_t ret;
                            nativeToBig32( (char*) &ret, src );
                            nativeToBig( (char*) &ret, src, 4);
                            return ret;
                        }
                        
                        uint64_t readBig64(char* src) {
                            uint64_t ret;
                            nativeToBig64( (char*) &ret, src );
                            nativeToBig( (char*) &ret, src, 8);
                            return ret;
                        }
                    
                    // little
                        uint16_t readLittle16(char* src) {
                            uint16_t ret;
                            nativeToLittle16( (char*) &ret, src );
                            nativeToLittle( (char*) &ret, src, 2);
                            return ret;
                        }
                        
                        uint32_t readLittle32(char* src) {
                            uint32_t ret;
                            nativeToLittle32( (char*) &ret, src );
                            nativeToLittle( (char*) &ret, src, 4);
                            return ret;
                        }
                        
                        uint64_t readLittle64(char* src) {
                            uint64_t ret;
                            nativeToLittle64( (char*) &ret, src );
                            nativeToLittle( (char*) &ret, src, 8);
                            return ret;
                        }
                // write unaligned memory
                    // big
                        // var writeBig16
                        // # writeBig16
                            void writeBig16(
                                char *dest,
                                char     *dest,
                                uint16_t value
                            ) {
                                nativeToBig16( dest, (char*)&value );
                                nativeToBig( dest, (char*)&value, 2);
                            }
                        // var writeBig32
                        // # writeBig32
                            void writeBig32(
                                char* dest,
                                char     *dest,
                                uint32_t value
                            ) {
                                nativeToBig32(dest, (char*)&value);
                                nativeToBig(dest, (char*)&value, 4);
                            }
                        // var writeBig64
                        // # writeBig64
                            void writeBig64(
                                char* dest,
                                char     *dest,
                                uint64_t value
                            ) {
                                nativeToBig64(dest, (char*)&value);
                                nativeToBig(dest, (char*)&value, 8);
                            }
                    // little
                        // var writeLittle16
                        // # writeLittle16
                            void writeLittle16(
                                char* dest,
                                char     *dest,
                                uint16_t value
                            ) {
                                nativeToLittle16(dest, (char*)&value);
                                nativeToLittle(dest, (char*)&value, 2);
                            }
                        // var writeLittle32
                        // # writeLittle32
                            void writeLittle32(
                                char* dest,
                                char     *dest,
                                uint32_t value
                            ) {
                                nativeToLittle32(dest, (char*)&value);
                                nativeToLittle(dest, (char*)&value, 4);
                            }
                        // var writeLittle64
                        // # writeLittle64
                            void writeLittle64(
                                char* dest,
                                char     *dest,
                                uint64_t value
                            ) {
                                nativeToLittle64(dest, (char*)&value);
                                nativeToLittle(dest, (char*)&value, 8);
                            }
            // Slice
                // # Slice_debug
                    void Slice_debug(struct Slice* slice, char* name, size_t line) {
                        if (slice->len == 0) {
                            printf("%zu: %s is NULL. \r\n", line, name);
                        } else {

            // # C_Text_writeToWriteFn
                size_t C_Text_writeToWriteFn(__WriteFnPtr__ fn_write, void* context, const char text[]) {
                    const size_t len = __ZText_countLen__(text);
                    return fn_write(context, text, len);
                }
    // Os
        // mem
            // # __Os_allocBytes__
                bool __Os_allocBytes__(
                    char*   *ret,
                    size_t  size
            // # __OsMem_alloc__
                bool __OsMem_alloc__( // TODO use real system alloc?
                    uintptr_t  *ret,
                    size_t     size
                ) {
                    bool ok = true;
                        char*  ptr = malloc(size);
                        char* ptr = malloc(size);
                        if (ptr) {
                            *ret = ptr;
                            *ret = (uintptr_t) ptr;
                        } else {
                            ok = false;
                            // TODO print debug
                        }
                    return ok;
                }
            
            // # __Os_freeBytes__
                void __Os_freeBytes__(char* ptr) {
                    free(ptr);
            // # __OsMem_free__
                void __OsMem_free__(uintptr_t ptr) {
                    free((void*) ptr);
                }
        // enviroment
            // # __OsEnvHome_getLen__
                size_t __OsEnvHome_getLen__() {
                    size_t len = 0;
                        #if __target_os__ == __TargetOs_windows__
                            char* home_drive = getenv("HOMEDRIVE");

                            } else {
                                ok = false;
                            } 
                        #else
                            #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
                        #endif
                    return ok;
                }
            // # __OsFile_openOrCreate__
                bool __OsFile_openOrCreate__(
                    __OsFile__   *ret,
                    const char   file_name[],
                    size_t       file_name_len // expected < __OsFilePathLen_max__
                ) {
                    if (__OsFile_exist__(file_name, file_name_len)) {
                        return __OsFile_open__(ret, file_name, file_name_len);
                    } else {
                        return __OsFile_create__(ret, file_name, file_name_len);
                    }
                }
            // # __OsFile_close__
                void __OsFile_close__(
                    __OsFile__ file
                ) {
                    #if __target_os__ == __TargetOs_windows__
                        CloseHandle(file);

            }
    // App
        // AppEditorHistoryNote
            // # __AppEditorHistoryNote_free__
                void __AppEditorHistoryNote_free__(
                    struct __AppEditorHistoryNote__* ptr
                ) {
                    __AlignedPtr_free__((void*)ptr, sizeof(struct __AppEditorHistoryNote__));
                    __AlignedPtr_freeAny__(ptr, sizeof(struct __AppEditorHistoryNote__));
                }
            // # __AppEditorHistoryNote_alloc__
                bool __AppEditorHistoryNote_alloc__(
                    struct __AppEditorHistoryNote__* *ptr
                    struct __AppEditorHistoryNote__  **ptr
                ) {
                    return __AlignedPtr_alloc__( 
                        (void*) ptr,
                        __alignOf__(struct __AppEditorHistoryNote__),
                    return __AlignedPtr_allocAny__( ptr, __alignOf__(struct __AppEditorHistoryNote__), sizeof(struct __AppEditorHistoryNote__) );
                        sizeof(struct __AppEditorHistoryNote__)
                    );
                }
        // # App_init
            bool App_init(struct App* t) {
                bool ok = true;
                    Scalpi_Logger_init(&t->logger); // preinit console output for debug
                    
                    if (__OsHelper_init__(&t->__App_osHelper__)) {