/zfs/rec_32bit 


/const 
    MAX_SIZE   1024*4*1000      //max file size 
    BLOCK_SIZE 1024*4
    REC_SIZE   256 
    REC_SIZE   256 

/doc 

    data 
        store       block file_format 
        process     code 
        present     render 
        share       by port IP etc 

/db_file 
    block.db     
    rec.db 
    blockmap.db 


/code_files 

    z_auth 
    zreq_email      //all email base request handel it 

    z_rec           //all data store and process 
    z_server 
    z_client

/zreq_str 
    :reqCode flag  //serverPath /path 
    ~//  
    .// 
    z@ 

/zreq_code  
    doc1
         
        mkdir   rmdir 
        touch   rm  
        ls      cd      pwd 
        cp      mv      ln 
        cat     head    tail 
        find    locate  
        stat    grep  
        <write  <<append 

    
    server z_code 
        
                 | :exe       | :in_rec   |  :rm        | 0-4 
        :r_rec   | :r_block   | :r        |  :r_iblock  | 4-8     write 
        :w_rec   | :w_block   | :w        |  :a         | 8-12    read 
        
        :mk      | :rm        | :r_file   |  :w_file    | 16
        :ls      | :append    |

    clint z_code
        :cp     :mv     
        :pwd 
        :cd 
        :tnz           //tnz lib to print in console         
        :view|:open    //view file image vid etc but dont save 
        

        


    reqNum  FID     RID
    00  
    01  exec_cmd        [FID][z_data]

    02  insert record   [req]
    03  remove record   [FID]                   
     
    04  r_record    [FID]
    05  r_block     [FID|blockNum]
    06  r_file      [FID|0]
    07  r_iblock    [FID|iblock]
     
    08  w_record    [sign][FID]
    09  w_block     [sign][FID|blockNum]   [payload]
    10  w_file      [sign][FID|0]          [payload]
    11  append_data [sign][FID|iblock]     [z_data]
                                         
    12  mk_ifile    
    13  rm_ifile
    13  r_ifile 
    15  w_ifile

    comm_voice 
    conn_vid 
    comm_livechat
    comm_share 

    IP_read 
    IP_write 
    IP_rw 
    IP_comm 
    IP_append 

    <keyClass>
        
        00:  FID pub_key 
        01:  RID pub_key 
        02:  PID pub_key
        03:  

        04  FID email 
        05  RID email 


/rec_type 
    .ext        .zz .zls  .zli 
    %dtype      %u   %i   %f   %c 
    {}          obj 
    <struct>    [dtype%4B|len%4B]   table_data 
    zseq
    u/          usr_record
    t/          z_thread 
    s/          store 
    z@          tpp 
    x@          nsfw

/zreq/email
    from   : zreq@zshlo.com 
    to     : zreq@zshlo.com 
    subject: zpath 
    body   : <msg>



    case - email z_req for order 
        from:   me@email.com   
        to  :   zreq@zshlo.com 
        sub :   s/store/order.zls 
        body:   <order_detail>

        order.zls/ << '\n;timestamp; me@email.com; <order_msg>


/struct/rec_32bit
    <rec_32>%union

        | FID   | RID   | size  | iblock  |   int32_t   4*4=16
        | ctime | mtime | u8*4  | recType |   uint32_t  4*4=16
        | k     | k     | k     |  k      |   uint64_t  4*8=32
        | str |z_data                     |   64
        |                                 |   64
        |               |IP1_v16| IP0_v16 |   64        

        //archive 
        | ctime | mtime |       | recType |   uint32_t  4*4=16


    <rec_64>%union
        | FID   | RID   | size  | iblock  |   int64     8*4=16
        | ctime | mtime | atime | <...>   |   uint32_t  8*4=16
        | str |data                       |   64
        |                                 |   64
        |               |IP1_v16| IP0_v16 |   64        
      

    <...>

        len         1Byte       256 
        reqType     1Byte 
        keyType     1byte       
        pFlag       1Byte       ANE|FID|RID     <rwa>

        recType     4Byte 

    <permissionFlag> 1B 
        0 0 0     
            1     read data
          1       write data 
        1         append data 

        bit_config 
        0 |0 |000|000      
        SK|AN|RID|FID   

        Anon_email  has one flag append data use in add record in zls 

    <keyType>   1B
        pub_key 
        RID 
        email   
        phone   
        hash_email 
        hash_phone

        password      //discourage because its make system to complicated and centralize 
    

    <field>
        +FID     public rec 
        -FID     private rec 

        +size    size 
        -size    len 

        +iblock  zfs_data 
        -iblock  inode_file
            block_bit         block_size 
            0   00  4               4KB 
            1   01  4*8            32KB 
            2   10  4*8*8         256KB
            3   11  4*8*8*8      2048KB

        data  [0|PID| r* | :* ]   
            :       str
            :[]     arr
            :{}     obj 

        
    [FID  |RID  |size |iblock ] 
    [ctime|mtime|atime|recType]
    [data] 

    nth_34

        [ 16 |   8   |  8   ] 
        [ IP | s_key | mtime] IP base login 
        [ IP | RID   | mtime] use file synch for server 
        [ IP | RID   | key  ]


        [ IP         | RID     | FID     ]
        [ zshlo.com/ | u/xyz/  | filPath ]

        [ RID  | IP         | FID     ]
        [ xyz@ | zshlo.com/ | filPath ]



z_req(req)  

            [ 4 | 4 | 4  | 4    ] [ 4     | 4   | 4   | 4     ] [32]  [ 192 ]
    $rec    [FID|RID|size|iblock] [ctime|mtime|atime  | recType] [key] [data] [payload]
    $req    [FID|RID|size|iblock] [ctime|mtime|       | <req_h>] [32]  [data] [payload]
    $res    [FID|RID|size|iblock] [ctime|mtime|atime  | recType] [key] [data] [payload]
    <req_h> [reqType|keyClass|len]
            [ 1     | 1      | 2 ]          
    
    
    $RID         { 0:root  1:tpp,  2:public 3-16}   16 reserve 
    $rec_map     <rec>
    $block_map   {uint64_t d 4K}
    $blockh_map  {FID



    
    //---------------------------------------------------
    //read public data from server 
    if rec_map[FID]->FID > 0: 
    
        switch(reqType)
        :04  ret  rec_map[FID]      //read record    
        :08  jmp :read_file         //read file 
        :12  jmp :read_block        //read block 
           

    //-----------------------------------------------------
    :verify_req 
        //key class to verify signature
        switch(keyClass)
        0:  v_key = (ID < rec_len) ? rec_map[FID]->key : 0;
        1:  v_key = (ID < rec_len) ? rec_map[RID]->key : 0;
        2:  v_key = (ID < rec_len) ? rec_map[PID]->key : 0;
        3:  v_key = req->key                

        //verify req auth than further process 
        if !verify(key signature): 
                ret [ERROR] verify_req fail 


    switch(reqType) 



        



    //------------------------------------------------------//

    r_record       [sign][04|len|size][FID]     


    

    //------------------------------------------------------//
    
    r_record    




    13  mk_ifile     
    13  rm_ifile 
    14  r_ifile 
    15  w_ifile 


req_email 
    email_struct 
        from: zreq@email.com 
        to: 
        subject::req_type zpath 
        body   :msg 


    case:order 
        subject: :append |FID| s/store 
        body:    <msg> 

    req_form 
        key 
        keyType 
        FID = get_FID(zpath)
        rec = rec_map[FID]
        
    //call zreq for furtho process 
    zreq(req)    



    //-----------------------------------------------------
:verify_req [sign]
    
    //key class to verify signature
    switch(keyClass)
    0:  v_key = (ID < rec_len) ? rec_map[FID]->key : 0;
    1:  v_key = (ID < rec_len) ? rec_map[RID]->key : 0;
    2:  v_key = (ID < rec_len) ? rec_map[PID]->key : 0;
    3:  v_key = req->key                

    //verify req auth than further process 
    if !verify(key signature): 
        ret [ERROR] verify_req fail 

///////////////////////////////////////////////////////////////////////
     0-1     insert record
     4-8     read 
     8-12    write 
    12-16    inode_file 

    reqNum  FID     RID
    00  
    01  exec_cmd        [FID][z_data]

    02  insert record   [req]
    03  remove record   [FID]                   
     
    04  r_record    [FID]
    05  r_block     [FID|blockNum]
    06  r_file      [FID|0]
    07  r_iblock    [FID|iblock]
     
    08  w_record    [sign][FID]
    09  w_block     [sign][FID|blockNum]   [payload]
    10  w_file      [sign][FID|0]          [payload]
    11  append_data [sign][FID|iblock]     [z_data]
                                         
    12  mk_ifile    
    13  rm_ifile
    13  r_ifile 
    15  w_ifile

[:exec_cmd|FID|RID=1,data]      //run cmd to manage server 
    
    if rec_map[FID].RID=1
        ret exec(req.data)
    

[:insert_record|RID|str][payload]    //create zls file  

    >zreq  pak.z@turkishDrama/t/Pyar+Ka+Fasana << 'Fwz_V8XnF6A; Pyar Ka Fasana | Episode 2 | Turkish Drama | Love And Hate | Seversin | 2 March 2026'
    
    block_0th   iblock_arr  4KB 
    block_1th   des         4KB         //des 
    block_      thumb       4KB*96      //store thumb 
    block*      zls         4KB*900     //store zls item 
    block_nth   zls_index   4KB 

    //:insert_record  [sign] [00|len|size][FID|RID]    
    //  SN  RID     des     //AL registry use it 
    //   0  0x00    insert public root record
    //   1  0x01    insert public record
    //   2  0x02    z@  tpp_record 
    //   3  0x03    t/  tpp_branch_record 
    //-----------------------------------------
    //  14  0xfe    insert private record
    //  15  0xff    insert private root record
        
    FID        = rec0.len++
    now        = time()
    rec        = req
    rec.FID    = FID 
    rec.iblock = 0
    rec.ctime  = now 
    rec.mtime  = now 
    rec.atime  = now 

[:rm_record|FID]


[:r_file | FID ]    

    size         = rec_map[FID]->size
    iblock       = rec_map[FID]->iblock
    iblock_arr   = block_map[iblock]
    arr_ids      = block_map[iblock_arr[-999]]     
    blockNum     = arr_ids[recNum]/4k
    iblock       = blockNum_arr[blockNum]
    block        = block_map[iblock]
    return block

        r_file         [sign] [08|len|size][FID]    
        size    = rec_map[FID]->num
        iblock  = rec_map[FID]->iblock
        data    = block_map[iblock]

        //return 0th block 
        if size < 4KB: ret_net data 
        
        //return whole file  
        loop 1K 
            if idx == 0: return
            ret_net block_map[idx]


[:r_record | FID ]    
    return       = rec_map[FID]
    

[:r_block|FID| blockNum ]  
    iblock = rec_map[FID]->iblock
    iblock = block_map[iblock][blockNum]
    ret  block_map[iblock]


[:r_iblock|FID|iblock]

    if rec_map[iblock] > 0
        ret block[iblock]


[:w_block|FID|block_data]
        iblock = rec_map[FID]->iblock
        iblock = block_map[iblock][blockNum]
        block_map[iblock] = block


[:append_data|FID|len|data]       //append_data 
        if size+data_len > 4MB: 
            ret 'ERROR max file size 4MB'

        size       = rec_map[FID]->size
        iblock     = rec_map[FID]->iblock
        iblock_arr = block_map[iblock]
        blockNum   = size/4k 
        offset     = size%4K 
        iblock     = iblock_arr[blockNum]
        block      = block_map[iblock]
        memcp( block_map, offset, data)    

    :11  [sign] [11|len|size|FID]       //append_list_item

        PID        = rec_map[FID]->PID
        RID        = rec_map[FID]->RID 
        size       = rec_map[FID]->num
        iblock     = rec_map[FID]->iblock
        iblock_arr = block_map[iblock]
        block_0th  = block_map[iblock_arr[0]]           //meta data 
        block_nth  = block_map[iblock_arr[999]]         //zli_index 

        //read block where to write 
        size       = block_nth[999-num]
        blockNum   = size/4k 
        offset     = size%4K 
        block      = block_map[iblock_arr[blockNum]]

        block_nth[999-(num+1)] = size+data_len      #wite record 

        memcp(block_map, offset, data)
    

////////////////////////////////////////////////////////////////

req: add_IP 
    01234567
    IP base read or write  record 
    rec[7]  = 
    rec[-2] = IP 
    rec[-1] = IP 


req: append
    keyType: email
    msg 


////////////////////////////////////////////////////////////////

/case []
    [0th ...  nth]

    0th     index of block 
    ...     block store string data or z_path 
    nth     index of list-item 

    [offset|FID|iblock]
        offset  
        FID         
        iblock  




/req_case
    ---- 
    /path       read file 
    /path<<*    write 
    /zpath\n*
    ----
    u/<xyz>             //z_server base 
    u/+91123456789      //mobile_num base 
    u/xyz@email.com     //email base 
    -----
    z@<tpp> 
    z@<tpp>/zz 
    z@<tpp>/zls 
    z@<tpp>/t/thread
    ----
    s/<store>/order.zc/vikas.zm: +9189\0 | member add ecord in .zc file 
    s/<store>/
    ----
    zls/<zlsId>:title 
    zli/<zlsId>-<zliId>:title
    ----
    ytv/<ytvId>:[duration,channelId, vidType, title]; iblock
    ytc/<ytcId>:title
    ----

    PID/title           //that use in case to store lot of records or path break 
    PID/img-2024-05-13  
    PID/JC-2024-05-03
    PID#orderNum 
    ----
    +u/xyz/wallet.txt\n     public rccord   so user read punlic if protect than use clinet side encrapt so other people dont read it  
    -u/xyz/wallet.txt       private record 
    PID/wallet.txt\n        user whole path not store so it easy to


/case 

    len | pak.z@turkishDrama/t/Pyar+Ka+Fasana
    len | pak.z@turkishDrama/t/Azize+(Urdu+Dub)+|+Hande+Erçel+&+Buğra+Gülsoy+|+Turkish+Drama+2026+|+Aan+TV

    >zreq  pak.z@turkishDrama/t/Pyar+Ka+Fasana << 'Fwz_V8XnF6A; Pyar Ka Fasana | Episode 2 | Turkish Drama | Love And Hate | Seversin | 2 March 2026'