durable_rules 0.34.02 → 0.34.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6180a0278ca667dd708b04c45359d7d205bb5ee
-  data.tar.gz: 77f98579d75d5a6ede0cf04de0cb030eb75227cd
+  metadata.gz: e2140bced1252c9b280451f9fc98d586b88af859
+  data.tar.gz: 28c6962e51f7d51d22f26aaa374c5f079e46a91c
 SHA512:
-  metadata.gz: 83a19d52b25b82a7369a679d5223b8e3dc2eb848b0c3a9cc4a75882f327f55434fc7a822bc9f2f91387977f8372daebbb19303cc6223516b67011229aebb172a
-  data.tar.gz: 0ec42e6ec72b8e569f632bcdb487787eb9692401c556071393ed2b62cccc46d4064f89d76b72f36c9567c2413eeb796fa03ecfc1cf9506493a5224c20d75bd09
+  metadata.gz: c462a03d557ec58f26df72d5c81b6f3026348fa606f75590882a29ef35a4da226337aebff6315695e27dac7d4251937497a7eac778822972ce70a375cfe868bd
+  data.tar.gz: 229e8f7d619835b4c9902f764798b7099fbf0ebe6c5442c36fd4f5aca136a0be488b65c187273dbf2f18b14e88ff821ef48007499fa41a67e71145f19feb8c3f

data/librb/engine.rb

@@ -40,7 +40,7 @@ module Engine
   end
 
   class Closure
-    attr_reader :host, :handle, :ruleset_name, :_timers, :_cancelled_timers, :_branches, :_messages, :_queues, :_facts, :_retract
+    attr_reader :host, :handle, :ruleset_name, :_timers, :_cancelled_timers, :_branches, :_messages, :_queues, :_facts, :_retract, :_deletes, :_deleted
     attr_accessor :s
 
     def initialize(host, state, message, handle, ruleset_name)
@@ -52,11 +52,13 @@ module Engine
       @_cancelled_timers = {}
       @_messages = {}
       @_queues = {}
+      @_deletes = {}
       @_branches = {}
       @_facts = {}
       @_retract = {}
       @_start_time = Time.now
       @_completed = false
+      @_deleted = false
       if message.kind_of? Hash
         @m = message
       else
@@ -93,6 +95,28 @@ module Engine
       message_list << message
     end
 
+    def delete(ruleset_name = nil, sid = nil)
+      if !ruleset_name
+        ruleset_name = @ruleset_name
+      end
+
+      if !sid
+        sid = @s.sid
+      end
+
+      if (ruleset_name == @ruleset_name) && (sid == @s.sid)
+        @_deleted = true
+      end
+
+      sid_list = []
+      if @_deletes.key? ruleset_name
+        sid_list = @_deletes[ruleset_name]
+      else
+        @_deletes[ruleset_name] = sid_list
+      end
+      sid_list << sid
+    end
+
     def get_queue(ruleset_name)
       if !@_queues.key? ruleset_name
         @_queues[ruleset_name] = Closure_Queue.new
@@ -479,6 +503,10 @@ module Engine
       JSON.parse Rules.get_state(@handle, sid.to_s)
     end
 
+    def delete_state(sid)
+      Rules.delete_state(@handle, sid.to_s)
+    end
+
     def renew_action_lease(sid)
       Rules.renew_action_lease @handle, sid.to_s
     end 
@@ -588,6 +616,10 @@ module Engine
                 end
               end
 
+              for ruleset_name, sid in c._deletes do
+                @host.delete_state ruleset_name, sid
+              end
+
               binding  = 0
               replies = 0
               pending = {action_binding => 0}
@@ -656,6 +688,15 @@ module Engine
               puts e.backtrace
               complete.call e
             end
+
+            if c._deleted
+              begin
+                delete_state c.s.sid
+              rescue Exception => e
+                complete.call e
+              end
+            end
+
           end
         }
         result_container[:async] = true 
@@ -1073,6 +1114,10 @@ module Engine
       get_ruleset(ruleset_name).get_state sid
     end
 
+    def delete_state(ruleset_name, sid)
+      get_ruleset(ruleset_name).delete_state sid
+    end
+
     def post_batch(ruleset_name, *events)
       get_ruleset(ruleset_name).assert_events events
     end

data/src/rules/json.c

@@ -177,6 +177,15 @@ static unsigned int getValue(char *start, char **first, char **last, unsigned ch
             } else {
                 return ERR_PARSE_STRING;
             }
+        } else if (start[0] == 'n') {
+            if (strncmp(start, "null", 4) == 0) {
+                *first = start;
+                *last = start + 3;
+                *type = JSON_NIL;
+                return PARSE_OK;
+            } else {
+                return ERR_PARSE_STRING;
+            }
         } else if (start[0] == '{') {
             *type = JSON_OBJECT;
             unsigned int result = getObject(start, first, last);

data/src/rules/net.c

@@ -104,6 +104,7 @@ static unsigned int createIdiom(ruleset *tree, jsonValue *newValue, char **idiom
             if (asprintf(idiomString, "%g", newValue->value.d) == -1) {
                 return ERR_OUT_OF_MEMORY;
             }
+            break;
         case JSON_BOOL:
             if (newValue->value.b == 0) {
                 if (asprintf(idiomString, "false") == -1) {
@@ -304,7 +305,8 @@ static unsigned int createTest(ruleset *tree, expression *expr, char **test, cha
     return RULES_OK;
 }
 
-static unsigned int loadPartitionCommand(ruleset *tree, binding *rulesBinding, char *name) {
+static unsigned int loadPartitionCommand(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
     redisContext *reContext = rulesBinding->reContext;
     redisReply *reply;
     char *lua = NULL;
@@ -335,7 +337,8 @@ static unsigned int loadPartitionCommand(ruleset *tree, binding *rulesBinding, c
     return RULES_OK;
 }
 
-static unsigned int loadRemoveActionCommand(ruleset *tree, binding *rulesBinding, char *name) {
+static unsigned int loadRemoveActionCommand(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
     redisContext *reContext = rulesBinding->reContext;
     redisReply *reply;
     char *lua = NULL;
@@ -386,7 +389,8 @@ static unsigned int loadRemoveActionCommand(ruleset *tree, binding *rulesBinding
     return RULES_OK;
 }
 
-static unsigned int loadTimerCommand(ruleset *tree, binding *rulesBinding, char *name) {
+static unsigned int loadTimerCommand(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
     redisContext *reContext = rulesBinding->reContext;
     redisReply *reply;
     char *lua = NULL;
@@ -419,7 +423,8 @@ static unsigned int loadTimerCommand(ruleset *tree, binding *rulesBinding, char
     return RULES_OK;
 }
 
-static unsigned int loadUpdateActionCommand(ruleset *tree, binding *rulesBinding, char *name) {
+static unsigned int loadUpdateActionCommand(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
     redisContext *reContext = rulesBinding->reContext;
     redisReply *reply;
     char *lua = NULL;
@@ -448,212 +453,137 @@ static unsigned int loadUpdateActionCommand(ruleset *tree, binding *rulesBinding
     return RULES_OK;
 }
 
-static unsigned int setNames(ruleset *tree, binding *rulesBinding, char *name) {
-    int nameLength = strlen(name);
-    char *sessionHashset = malloc((nameLength + 3) * sizeof(char));
-    if (!sessionHashset) {
+static unsigned int loadDeleteSessionCommand(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
+    redisContext *reContext = rulesBinding->reContext;
+    redisReply *reply;
+    char *lua = NULL;
+    char *deleteSessionLua = NULL;
+    deleteSessionLua = (char*)calloc(1, sizeof(char));
+    if (!deleteSessionLua) {
         return ERR_OUT_OF_MEMORY;
     }
 
-    strncpy(sessionHashset, name, nameLength);
-    sessionHashset[nameLength] = '!';
-    sessionHashset[nameLength + 1] = 's';
-    sessionHashset[nameLength + 2] = '\0';
-    rulesBinding->sessionHashset = sessionHashset;
+    for (unsigned int i = 0; i < tree->nodeOffset; ++i) {
+        node *currentNode = &tree->nodePool[i];
+        
+        if (currentNode->type == NODE_ACTION) {
+            char *actionName = &tree->stringPool[currentNode->nameOffset];
+            char *oldDeleteSessionLua = NULL;
+            for (unsigned int ii = 0; ii < currentNode->value.c.joinsLength; ++ii) {
+                unsigned int currentJoinOffset = tree->nextPool[currentNode->value.c.joinsOffset + ii];
+                join *currentJoin = &tree->joinPool[currentJoinOffset];
 
-    char *factsHashset = malloc((nameLength + 3) * sizeof(char));
-    if (!factsHashset) {
-        return ERR_OUT_OF_MEMORY;
-    }
+                oldDeleteSessionLua = deleteSessionLua;
+                if (asprintf(&deleteSessionLua, 
+"%sredis.call(\"del\", \"%s!%d!r!\" .. sid)\n"
+"redis.call(\"del\", \"%s!%d!r!\" .. sid .. \"!d\")\n",
+                            deleteSessionLua,
+                            actionName,
+                            ii,
+                            actionName,
+                            ii)  == -1) {
+                    return ERR_OUT_OF_MEMORY;
+                }  
+                free(oldDeleteSessionLua);
 
-    strncpy(factsHashset, name, nameLength);
-    factsHashset[nameLength] = '!';
-    factsHashset[nameLength + 1] = 'f';
-    factsHashset[nameLength + 2] = '\0';
-    rulesBinding->factsHashset = factsHashset;
+                for (unsigned int iii = 0; iii < currentJoin->expressionsLength; ++iii) {
+                    unsigned int expressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii];
+                    expression *expr = &tree->expressionPool[expressionOffset];
+                    char *currentKey = &tree->stringPool[expr->nameOffset];
 
-    char *eventsHashset = malloc((nameLength + 3) * sizeof(char));
-    if (!eventsHashset) {
-        return ERR_OUT_OF_MEMORY;
+                    oldDeleteSessionLua = deleteSessionLua;
+                    if (asprintf(&deleteSessionLua, 
+"%sdelete_message_keys(\"%s!f!\" .. sid)\n"
+"delete_message_keys(\"%s!e!\" .. sid)\n"
+"delete_closure_keys(\"%s!c!\" .. sid)\n"
+"delete_closure_keys(\"%s!i!\" .. sid)\n",
+                                deleteSessionLua,
+                                currentKey,
+                                currentKey,
+                                currentKey,
+                                currentKey)  == -1) {
+                        return ERR_OUT_OF_MEMORY;
+                    }  
+                    free(oldDeleteSessionLua);
+                }
+            }
+        }
     }
 
-    strncpy(eventsHashset, name, nameLength);
-    eventsHashset[nameLength] = '!';
-    eventsHashset[nameLength + 1] = 'e';
-    eventsHashset[nameLength + 2] = '\0';
-    rulesBinding->eventsHashset = eventsHashset;
 
-    char *timersSortedset = malloc((nameLength + 3) * sizeof(char));
-    if (!timersSortedset) {
+    if (asprintf(&lua, 
+"local sid = ARGV[1]\n"
+"local delete_message_keys = function(events_key)\n"
+"    local all_keys = redis.call(\"keys\", events_key .. \"!m!*\")\n"
+"    for i = 1, #all_keys, 1 do\n"
+"        redis.call(\"del\", all_keys[i])\n"
+"    end\n"
+"    redis.call(\"del\", events_key)\n"
+"end\n"
+"local delete_closure_keys = function(closure_key)\n"
+"    local all_keys = redis.call(\"keys\", closure_key .. \"!*\")\n"
+"    for i = 1, #all_keys, 1 do\n"
+"        redis.call(\"del\", all_keys[i])\n"
+"    end\n"
+"end\n"
+"redis.call(\"hdel\", \"%s!s\", sid)\n"
+"redis.call(\"zrem\", \"%s!a\", sid)\n"
+"redis.call(\"del\", \"%s!a!\" .. sid)\n"
+"redis.call(\"del\", \"%s!e!\" .. sid)\n"
+"redis.call(\"del\", \"%s!f!\" .. sid)\n"
+"redis.call(\"del\", \"%s!v!\" .. sid)\n%s",
+                name,
+                name,
+                name, 
+                name,
+                name, 
+                name,
+                deleteSessionLua)  == -1) {
         return ERR_OUT_OF_MEMORY;
     }
 
-    strncpy(timersSortedset, name, nameLength);
-    timersSortedset[nameLength] = '!';
-    timersSortedset[nameLength + 1] = 't';
-    timersSortedset[nameLength + 2] = '\0';
-    rulesBinding->timersSortedset = timersSortedset;
-    return RULES_OK;
-}
-
-static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
-    char *name = &tree->stringPool[tree->nameOffset];
-    int nameLength = strlen(name);
-    unsigned int result = loadPartitionCommand(tree, rulesBinding, name);
-    if (result != RULES_OK) {
-        return result;
-    }
-
-    // client queues have no commands to load, 
-    if (!tree->stringPool) {
-        return RULES_OK;
-    }
-
-    result = loadRemoveActionCommand(tree, rulesBinding, name);
-    if (result != RULES_OK) {
-        return result;
-    }
-
-    result = loadTimerCommand(tree, rulesBinding, name);
-    if (result != RULES_OK) {
-        return result;
-    }
-
-    result = loadUpdateActionCommand(tree, rulesBinding, name);
-    if (result != RULES_OK) {
-        return result;
+    free(deleteSessionLua);
+    redisAppendCommand(reContext, "SCRIPT LOAD %s", lua);
+    redisGetReply(reContext, (void**)&reply);
+    if (reply->type == REDIS_REPLY_ERROR) {
+        printf("%s\n", reply->str);
+        freeReplyObject(reply);
+        free(lua);
+        return ERR_REDIS_ERROR;
     }
 
-    result = setNames(tree, rulesBinding, name);
-    if (result != RULES_OK) {
-        return result;
-    }
+    strncpy(rulesBinding->deleteSessionHash, reply->str, 40);
+    rulesBinding->deleteSessionHash[40] = '\0';
+    freeReplyObject(reply);
+    free(lua);
+    return RULES_OK;
 
+}
+static unsigned int loadAddMessageCommand(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
     redisContext *reContext = rulesBinding->reContext;
     redisReply *reply;
-#ifdef _WIN32
-    char *actionKey = (char *)_alloca(sizeof(char)*(nameLength + 3));
-    sprintf_s(actionKey, nameLength + 3, "%s!a", name);
-#else
-    char actionKey[nameLength + 3];
-    snprintf(actionKey, nameLength + 3, "%s!a", name);
-#endif
     char *lua = NULL;
-    char *peekActionLua = NULL;
     char *addMessageLua = NULL;
-    char *oldLua;
-    
-    peekActionLua = (char*)calloc(1, sizeof(char));
-    if (!peekActionLua) {
-        return ERR_OUT_OF_MEMORY;
-    }
-
-    lua = (char*)calloc(1, sizeof(char));
-    if (!lua) {
-        return ERR_OUT_OF_MEMORY;
-    }
-
     addMessageLua = (char*)calloc(1, sizeof(char));
     if (!addMessageLua) {
         return ERR_OUT_OF_MEMORY;
     }
 
     for (unsigned int i = 0; i < tree->nodeOffset; ++i) {
-        char *oldPeekActionLua;
         node *currentNode = &tree->nodePool[i];
         
         if (currentNode->type == NODE_ACTION) {
-            char *packFrameLua = NULL;
-            char *unpackFrameLua = NULL;
-            char *oldPackFrameLua = NULL;
-            char *oldUnpackFrameLua = NULL;
             char *oldAddMessageLua = NULL;
-            char *actionName = &tree->stringPool[currentNode->nameOffset];
-            char *actionLastName = strchr(actionName, '!');
-#ifdef _WIN32
-            char *actionAlias = (char *)_alloca(sizeof(char)*(actionLastName - actionName + 1));
-#else
-            char actionAlias[actionLastName - actionName + 1];
-#endif
-            
-            strncpy(actionAlias, actionName, actionLastName - actionName);
-            actionAlias[actionLastName - actionName] = '\0';
-
             for (unsigned int ii = 0; ii < currentNode->value.c.joinsLength; ++ii) {
                 unsigned int currentJoinOffset = tree->nextPool[currentNode->value.c.joinsOffset + ii];
                 join *currentJoin = &tree->joinPool[currentJoinOffset];
-                
-                oldPeekActionLua = peekActionLua;
-                if (asprintf(&peekActionLua, 
-"%sif input_keys[\"%s!%d!r!\"] then\n" 
-"local context = {}\n"
-"context_directory[\"%s!%d!r!\"] = context\n"
-"reviewers = {}\n"
-"context[\"reviewers\"] = reviewers\n"
-"keys = {}\n"
-"context[\"keys\"] = keys\n"
-"primary_frame_keys = {}\n"
-"context[\"primary_frame_keys\"] = primary_frame_keys\n",
-                            peekActionLua,
-                            actionName,
-                            ii,
-                            actionName,
-                            ii)  == -1) {
-                    return ERR_OUT_OF_MEMORY;
-                }  
-                free(oldPeekActionLua);
-
-                oldLua = lua;
-                if (asprintf(&lua, 
-"%stoggle = false\n"
-"context = {}\n"
-"reviewers = {}\n"
-"context[\"reviewers\"] = reviewers\n"
-"frame_packers = {}\n"
-"context[\"frame_packers\"] = frame_packers\n"
-"frame_unpackers = {}\n"
-"context[\"frame_unpackers\"] = frame_unpackers\n"
-"primary_message_keys = {}\n"
-"context[\"primary_message_keys\"] = primary_message_keys\n"
-"primary_frame_keys = {}\n"
-"context[\"primary_frame_keys\"] = primary_frame_keys\n"
-"keys = {}\n"
-"context[\"keys\"] = keys\n"
-"inverse_directory = {}\n"
-"context[\"inverse_directory\"] = inverse_directory\n"
-"directory = {[\"0\"] = 1}\n"
-"context[\"directory\"] = directory\n"
-"context[\"results_key\"] = \"%s!%d!r!\" .. sid\n"
-"context[\"expressions_count\"] = %d\n",
-                            lua,
-                            actionName,
-                            ii,
-                            currentJoin->expressionsLength)  == -1) {
-                    return ERR_OUT_OF_MEMORY;
-                }  
-                free(oldLua);
 
                 for (unsigned int iii = 0; iii < currentJoin->expressionsLength; ++iii) {
                     unsigned int expressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii];
                     expression *expr = &tree->expressionPool[expressionOffset];
-                    char *currentAlias = &tree->stringPool[expr->aliasOffset];
                     char *currentKey = &tree->stringPool[expr->nameOffset];
-                    char *nextKeyTest;
-                    if (iii == (currentJoin->expressionsLength - 1)) {
-                        nextKeyTest = (char*)calloc(1, sizeof(char));
-                        if (!nextKeyTest) {
-                            return ERR_OUT_OF_MEMORY;
-                        }
-                    } else {
-                        unsigned int nextExpressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii + 1];
-                        expression *nextExpr = &tree->expressionPool[nextExpressionOffset];
-                        if (asprintf(&nextKeyTest, 
-"or input_keys[\"%s\"]", 
-                                     &tree->stringPool[nextExpr->nameOffset])  == -1) {
-                            return ERR_OUT_OF_MEMORY;
-                        }
-                    }
-                    
                     if (iii == 0) {
                         oldAddMessageLua = addMessageLua;
                         if (!addMessageLua) {
@@ -672,62 +602,175 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
                             return ERR_OUT_OF_MEMORY;
                         }  
                         free(oldAddMessageLua);
+                    } else {
+                        char *test = NULL;
+                        char *primaryKeyLua = NULL;
+                        char *primaryFrameKeyLua = NULL;
+                        unsigned int result = createTest(tree, expr, &test, &primaryKeyLua, &primaryFrameKeyLua);
+                        if (result != RULES_OK) {
+                            return result;
+                        }
 
-                        if (expr->not) { 
-                            if (asprintf(&packFrameLua,
-"    result[1] = \"$n\"\n")  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
+                        oldAddMessageLua = addMessageLua;
+                        if (asprintf(&addMessageLua, 
+"%sif input_keys[\"%s\"] then\n"
+"    primary_message_keys[\"%s\"] = function(message)\n"
+"        local result = \"\"\n%s"
+"        return result\n"
+"    end\n"
+"end\n",
+                                    addMessageLua,
+                                    currentKey, 
+                                    currentKey, 
+                                    primaryKeyLua)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }  
+                        free(oldAddMessageLua);
+                        free(test);
+                        free(primaryKeyLua);
+                        free(primaryFrameKeyLua);
+                    }
+                }
+            }
+        }
+    }
 
-                            if (asprintf(&unpackFrameLua,
-"    result[\"%s\"] = \"$n\"\n",
-                                        currentAlias)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-
-                            oldLua = lua;
-                            if (asprintf(&lua, 
-"%sif input_keys[\"%s\"] %s then\n"
-"    toggle = true\n"
-"    context_directory[\"%s\"] = context\n"
-"    keys[1] = \"%s\"\n"
-"    inverse_directory[1] = true\n"
-"    directory[\"%s\"] = 1\n"
-"    reviewers[1] = function(message, frame, index)\n"
-"        if not message then\n"
-"            frame[\"%s\"] = \"$n\"\n"
-"            return true\n"
+    if (asprintf(&lua, 
+"local sid = ARGV[1]\n"
+"local assert_fact = tonumber(ARGV[2])\n"
+"local keys_count = tonumber(ARGV[3])\n"
+"local events_hashset = \"%s!e!\" .. sid\n"
+"local facts_hashset = \"%s!f!\" .. sid\n"
+"local visited_hashset = \"%s!v!\" .. sid\n"
+"local message = {}\n"
+"local primary_message_keys = {}\n"
+"local input_keys = {}\n"
+"local save_message = function(current_key, message, events_key, messages_key)\n"
+"    redis.call(\"hsetnx\", messages_key, message[\"id\"], cmsgpack.pack(message))\n"
+"    local primary_key = primary_message_keys[current_key](message)\n"
+"    redis.call(\"lpush\", events_key .. \"!m!\" .. primary_key, message[\"id\"])\n"
+"end\n"
+"for index = 4 + keys_count, #ARGV, 3 do\n"
+"    if ARGV[index + 2] == \"1\" then\n"
+"        message[ARGV[index]] = ARGV[index + 1]\n"
+"    elseif ARGV[index + 2] == \"2\" or  ARGV[index + 2] == \"3\" then\n"
+"        message[ARGV[index]] = tonumber(ARGV[index + 1])\n"
+"    elseif ARGV[index + 2] == \"4\" then\n"
+"        if ARGV[index + 1] == \"true\" then\n"
+"            message[ARGV[index]] = true\n"
+"        else\n"
+"            message[ARGV[index]] = false\n"
 "        end\n"
-"        return false\n"
-"    end\n"
-"    frame_packers[1] = function(frame, full_encode)\n"
-"        local result = {}\n%s"
-"        return cmsgpack.pack(result)\n"
 "    end\n"
-"    frame_unpackers[1] = function(packed_frame)\n"
-"        local frame = cmsgpack.unpack(packed_frame)\n"
-"        local result = {}\n%s"
-"        return result\n"
+"end\n"
+"local mid = message[\"id\"]\n"
+"if redis.call(\"hsetnx\", visited_hashset, message[\"id\"], 1) == 0 then\n"
+"    if assert_fact == 0 then\n"
+"        if not redis.call(\"hget\", events_hashset, mid) then\n"
+"            return false\n"
+"        end\n"
+"    else\n"
+"        if not redis.call(\"hget\", facts_hashset, mid) then\n"
+"            return false\n"
+"        end\n"
 "    end\n"
-"    primary_message_keys[1] = function(message)\n"
-"        return \"\"\n"
+"end\n"
+"for index = 4, 3 + keys_count, 1 do\n"
+"    input_keys[ARGV[index]] = true\n"
+"end\n"
+"%sif assert_fact == 1 then\n"
+"    message[\"$f\"] = 1\n"
+"    for index = 4, 3 + keys_count, 1 do\n"
+"        local key = ARGV[index]\n"
+"        save_message(key, message, key .. \"!f!\" .. sid, facts_hashset)\n"
 "    end\n"
-"    primary_frame_keys[1] = function(frame)\n"
-"        return \"\"\n"
+"else\n"
+"    for index = 4, 3 + keys_count, 1 do\n"
+"        local key = ARGV[index]\n"
+"        save_message(key, message, key .. \"!e!\" .. sid, events_hashset)\n"
 "    end\n"
 "end\n",
-                                         lua,
-                                         currentKey,
-                                         nextKeyTest,
-                                         currentKey,
-                                         currentKey,
-                                         currentKey,
-                                         currentAlias,
-                                         packFrameLua,
-                                         unpackFrameLua)  == -1) {
+                name,
+                name,
+                name, 
+                addMessageLua)  == -1) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    free(addMessageLua);
+    redisAppendCommand(reContext, "SCRIPT LOAD %s", lua);
+    redisGetReply(reContext, (void**)&reply);
+    if (reply->type == REDIS_REPLY_ERROR) {
+        printf("%s\n", reply->str);
+        freeReplyObject(reply);
+        free(lua);
+        return ERR_REDIS_ERROR;
+    }
+
+    strncpy(rulesBinding->addMessageHash, reply->str, 40);
+    rulesBinding->addMessageHash[40] = '\0';
+    freeReplyObject(reply);
+    free(lua);
+    return RULES_OK;
+}
+
+static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
+    redisContext *reContext = rulesBinding->reContext;
+    redisReply *reply;
+    char *lua = NULL;
+    
+    char *peekActionLua = NULL;
+    peekActionLua = (char*)calloc(1, sizeof(char));
+    if (!peekActionLua) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    for (unsigned int i = 0; i < tree->nodeOffset; ++i) {
+        char *oldPeekActionLua;
+        node *currentNode = &tree->nodePool[i];
+        
+        if (currentNode->type == NODE_ACTION) {
+            char *unpackFrameLua = NULL;
+            char *oldUnpackFrameLua = NULL;
+            char *actionName = &tree->stringPool[currentNode->nameOffset];
+            for (unsigned int ii = 0; ii < currentNode->value.c.joinsLength; ++ii) {
+                unsigned int currentJoinOffset = tree->nextPool[currentNode->value.c.joinsOffset + ii];
+                join *currentJoin = &tree->joinPool[currentJoinOffset];
+                
+                oldPeekActionLua = peekActionLua;
+                if (asprintf(&peekActionLua, 
+"%sif input_keys[\"%s!%d!r!\"] then\n" 
+"local context = {}\n"
+"context_directory[\"%s!%d!r!\"] = context\n"
+"reviewers = {}\n"
+"context[\"reviewers\"] = reviewers\n"
+"keys = {}\n"
+"context[\"keys\"] = keys\n"
+"primary_frame_keys = {}\n"
+"context[\"primary_frame_keys\"] = primary_frame_keys\n",
+                            peekActionLua,
+                            actionName,
+                            ii,
+                            actionName,
+                            ii)  == -1) {
+                    return ERR_OUT_OF_MEMORY;
+                }  
+                free(oldPeekActionLua);
+
+                for (unsigned int iii = 0; iii < currentJoin->expressionsLength; ++iii) {
+                    unsigned int expressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii];
+                    expression *expr = &tree->expressionPool[expressionOffset];
+                    char *currentAlias = &tree->stringPool[expr->aliasOffset];
+                    char *currentKey = &tree->stringPool[expr->nameOffset];
+                    
+                    if (iii == 0) {
+                        if (expr->not) { 
+                            if (asprintf(&unpackFrameLua,
+"    result[\"%s\"] = \"$n\"\n",
+                                        currentAlias)  == -1) {
                                 return ERR_OUT_OF_MEMORY;
                             }
-                            free(oldLua);
 
                             oldPeekActionLua = peekActionLua;
                             if (!peekActionLua) {
@@ -750,19 +793,7 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
                                 return ERR_OUT_OF_MEMORY;
                             }  
                             free(oldPeekActionLua);
-                        // not (expr->not)
                         } else {
-                            if (asprintf(&packFrameLua,
-"    message = frame[\"%s\"]\n"
-"    if full_encode and not message[\"$f\"] then\n"
-"        result[1] = message\n"
-"    else\n"
-"        result[1] = message[\"id\"]\n"
-"    end\n",
-                                        currentAlias)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-
                             if (asprintf(&unpackFrameLua,
 "    message = fetch_message(frame[1])\n"
 "    if not message then\n"
@@ -773,87 +804,16 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
                                 return ERR_OUT_OF_MEMORY;
                             }
 
-                            oldLua = lua;
-                            if (asprintf(&lua, 
-"%sif input_keys[\"%s\"] %s then\n"
-"    toggle = true\n"
-"    context_directory[\"%s\"] = context\n"
-"    keys[1] = \"%s\"\n"
-"    inverse_directory[1] = true\n"
-"    directory[\"%s\"] = 1\n"
-"    reviewers[1] = function(message, frame, index)\n"
-"        if message then\n"
-"            frame[\"%s\"] = message\n"
-"            return true\n"
-"        end\n"
-"        return false\n"
-"    end\n"
-"    frame_packers[1] = function(frame, full_encode)\n"
-"        local result = {}\n"
-"        local message\n%s"
-"        return cmsgpack.pack(result)\n"
-"    end\n"
-"    frame_unpackers[1] = function(packed_frame)\n"
-"        local frame = cmsgpack.unpack(packed_frame)\n"
-"        local result = {}\n"
-"        local message\n%s"
-"        return result\n"
-"    end\n"
-"    primary_message_keys[1] = function(message)\n"
-"        return \"\"\n"
-"    end\n"
-"    primary_frame_keys[1] = function(frame)\n"
-"        return \"\"\n"
-"    end\n"
-"end\n",
-                                         lua,
-                                         currentKey,
-                                         nextKeyTest,
-                                         currentKey,
-                                         currentKey,
-                                         currentKey,
-                                         currentAlias,
-                                         packFrameLua,
-                                         unpackFrameLua)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldLua);
                         }
-                    // not (iii == 0)
                     } else {
-                        char *test = NULL;
-                        char *primaryKeyLua = NULL;
-                        char *primaryFrameKeyLua = NULL;
-                        unsigned int result = createTest(tree, expr, &test, &primaryKeyLua, &primaryFrameKeyLua);
-                        if (result != RULES_OK) {
-                            return result;
-                        }
-
-                        oldAddMessageLua = addMessageLua;
-                        if (asprintf(&addMessageLua, 
-"%sif input_keys[\"%s\"] then\n"
-"    primary_message_keys[\"%s\"] = function(message)\n"
-"        local result = \"\"\n%s"
-"        return result\n"
-"    end\n"
-"end\n",
-                                    addMessageLua,
-                                    currentKey, 
-                                    currentKey, 
-                                    primaryKeyLua)  == -1) {
-                            return ERR_OUT_OF_MEMORY;
-                        }  
-                        free(oldAddMessageLua);
-
-                        if (expr->not) { 
-                            oldPackFrameLua = packFrameLua;
-                            if (asprintf(&packFrameLua,
-"%s    result[%d] = \"$n\"\n",
-                                         packFrameLua,
-                                         iii + 1)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
+                        if (expr->not) {
+                            char *test = NULL;
+                            char *primaryKeyLua = NULL;
+                            char *primaryFrameKeyLua = NULL;
+                            unsigned int result = createTest(tree, expr, &test, &primaryKeyLua, &primaryFrameKeyLua);
+                            if (result != RULES_OK) {
+                                return result;
                             }
-                            free(oldPackFrameLua);
 
                             oldUnpackFrameLua = unpackFrameLua;
                             if (asprintf(&unpackFrameLua,
@@ -864,64 +824,6 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
                             }
                             free(oldUnpackFrameLua);
 
-                            oldLua = lua;
-                            if (asprintf(&lua,
-"%sif toggle %s then\n"
-"    toggle = true\n"
-"    context_directory[\"%s\"] = context\n"
-"    keys[%d] = \"%s\"\n"
-"    inverse_directory[%d] = true\n"
-"    directory[\"%s\"] = %d\n"
-"    reviewers[%d] = function(message, frame, index)\n"
-"        if not message or not (%s) then\n"
-"            frame[\"%s\"] = \"$n\"\n"
-"            return true\n"
-"        end\n"
-"        return false\n"
-"    end\n"
-"    frame_packers[%d] = function(frame, full_encode)\n"
-"        local result = {}\n"
-"        local message\n%s"
-"        return cmsgpack.pack(result)\n"
-"    end\n"
-"    frame_unpackers[%d] = function(packed_frame)\n"
-"        local frame = cmsgpack.unpack(packed_frame)\n"
-"        local result = {}\n"
-"        local message\n%s"
-"        return result\n"
-"    end\n"
-"    primary_message_keys[%d] = function(message)\n"
-"        local result = \"\"\n%s"
-"        return result\n"
-"    end\n"
-"    primary_frame_keys[%d] = function(frame)\n"
-"        local result = \"\"\n%s"
-"        return result\n"
-"    end\n"
-"end\n",
-                                         lua,
-                                         nextKeyTest,
-                                         currentKey,
-                                         iii + 1, 
-                                         currentKey,
-                                         iii + 1, 
-                                         currentKey,
-                                         iii + 1,
-                                         iii + 1,
-                                         test,
-                                         currentAlias,
-                                         iii + 1,
-                                         packFrameLua,
-                                         iii + 1,
-                                         unpackFrameLua,
-                                         iii + 1,
-                                         primaryKeyLua,
-                                         iii + 1,
-                                         primaryFrameKeyLua)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldLua);
-
                             oldPeekActionLua = peekActionLua;
                             if (asprintf(&peekActionLua, 
 "%skeys[%d] = \"%s\"\n"
@@ -945,25 +847,10 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
                                 return ERR_OUT_OF_MEMORY;
                             }  
                             free(oldPeekActionLua);
-
-                        // not (expr->not)
+                            free(test);
+                            free(primaryKeyLua);
+                            free(primaryFrameKeyLua);
                         } else {
-                            oldPackFrameLua = packFrameLua;
-                            if (asprintf(&packFrameLua,
-"%s    message = frame[\"%s\"]\n"
-"    if full_encode and not message[\"$f\"] then\n"
-"        result[%d] = message\n"
-"    else\n"
-"        result[%d] = message[\"id\"]\n"
-"    end\n",
-                                         packFrameLua,
-                                         currentAlias,
-                                         iii + 1,
-                                         iii + 1)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldPackFrameLua);
-
                             oldUnpackFrameLua = unpackFrameLua;
                             if (asprintf(&unpackFrameLua,
 "%s    message = fetch_message(frame[%d])\n"
@@ -977,69 +864,7 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
                                 return ERR_OUT_OF_MEMORY;
                             }
                             free(oldUnpackFrameLua);
-
-                            oldLua = lua;
-                            if (asprintf(&lua,
-"%sif toggle %s then\n"
-"    toggle = true\n"
-"    context_directory[\"%s\"] = context\n"
-"    keys[%d] = \"%s\"\n"
-"    directory[\"%s\"] = %d\n"
-"    reviewers[%d] = function(message, frame, index)\n"
-"        if message and %s then\n"
-"            frame[\"%s\"] = message\n"
-"            return true\n"
-"        end\n"
-"        return false\n"
-"    end\n"
-"    frame_packers[%d] = function(frame, full_encode)\n"
-"        local result = {}\n"
-"        local message\n%s"
-"        return cmsgpack.pack(result)\n"
-"    end\n"
-"    frame_unpackers[%d] = function(packed_frame)\n"
-"        local frame = cmsgpack.unpack(packed_frame)\n"
-"        local result = {}\n"
-"        local message\n%s"
-"        return result\n"
-"    end\n"
-"    primary_message_keys[%d] = function(message)\n"
-"        local result = \"\"\n%s"
-"        return result\n"
-"    end\n"
-"    primary_frame_keys[%d] = function(frame)\n"
-"        local result = \"\"\n%s"
-"        return result\n"
-"    end\n"
-"end\n",
-                                         lua,
-                                         nextKeyTest,
-                                         currentKey,
-                                         iii + 1, 
-                                         currentKey,
-                                         currentKey,
-                                         iii + 1,
-                                         iii + 1,
-                                         test,
-                                         currentAlias,
-                                         iii + 1,
-                                         packFrameLua,
-                                         iii + 1,
-                                         unpackFrameLua,
-                                         iii + 1,
-                                         primaryKeyLua,
-                                         iii + 1,
-                                         primaryFrameKeyLua)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldLua);
-                        // done not (expr->not)
                         }
-                        free(nextKeyTest);
-                        free(test);
-                        free(primaryKeyLua);
-                        free(primaryFrameKeyLua);
-                    // done not (iii == 0)
                     }
                 }
 
@@ -1057,103 +882,29 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
                 }  
                 free(oldPeekActionLua);
 
-                if (currentNode->value.c.span > 0) {
-                    oldLua = lua;
-                    if (asprintf(&lua,
-"%sif toggle then\n"
-"    context[\"process_key\"] = process_key_with_span\n"
-"    context[\"process_key_count\"] = %d\n"
-"end\n",
-                                 lua,
-                                 currentNode->value.c.span)  == -1) {
-                        return ERR_OUT_OF_MEMORY;
-                    }
-                    free(oldLua);
-
-                } else if (currentNode->value.c.cap > 0) {
-                    oldLua = lua;
-                    if (asprintf(&lua,
-"%sif toggle then\n"
-"    context[\"process_key\"] = process_key_with_cap\n"
-"    context[\"process_key_count\"] = %d\n"
-"end\n",
-                                 lua,
-                                 currentNode->value.c.cap)  == -1) {
-                        return ERR_OUT_OF_MEMORY;
-                    }
-                    free(oldLua);
-
-                } else {
-                    oldLua = lua;
-                    if (asprintf(&lua,
-"%sif toggle then\n"
-"    context[\"process_key\"] = process_key_with_window\n"
-"    context[\"process_key_count\"] = %d\n"
-"end\n",
-                                 lua,
-                                 currentNode->value.c.count)  == -1) {
-                        return ERR_OUT_OF_MEMORY;
-                    }
-                    free(oldLua);
-                }
             }
 
             free(unpackFrameLua);
-            free(packFrameLua);
         }
     }
 
-    oldLua = lua;
-    if (asprintf(&lua,
-"local sid = ARGV[1]\n"
-"local mid = ARGV[2]\n"
-"local score = tonumber(ARGV[3])\n"
-"local assert_fact = tonumber(ARGV[4])\n"
-"local keys_count = tonumber(ARGV[5])\n"
-"local events_hashset = \"%s!e!\" .. sid\n"
-"local facts_hashset = \"%s!f!\" .. sid\n"
-"local visited_hashset = \"%s!v!\" .. sid\n"
-"local actions_key = \"%s!a\"\n"
+    if (asprintf(&lua, 
+"local facts_key = \"%s!f!\"\n"
+"local events_key = \"%s!e!\"\n"
+"local action_key = \"%s!a\"\n"
 "local state_key = \"%s!s\"\n"
-"local queue_action = false\n"
-"local facts_message_cache = {}\n"
-"local events_message_cache = {}\n"
-"local facts_mids_cache = {}\n"
-"local events_mids_cache = {}\n"
+"local timers_key = \"%s!t\"\n"
 "local context_directory = {}\n"
-"local input_keys = {}\n"
-"local toggle\n"
-"local expressions_count\n"
-"local results\n"
-"local unpacked_results\n"
-"local context\n"
 "local keys\n"
 "local reviewers\n"
-"local frame_packers\n"
-"local frame_unpackers\n"
-"local primary_message_keys\n"
 "local primary_frame_keys\n"
-"local directory\n"
-"local results_key\n"
-"local inverse_directory\n"
-"local key\n"
-"local cleanup_mids = function(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
-"    local event_mids = mids_cache[events_key]\n"
-"    local primary_key = primary_frame_keys[index](frame)\n"
-"    local new_mids = event_mids[primary_key]\n"
-"    local result_mids = {}\n"
-"    for i = 1, #new_mids, 1 do\n"
-"        local new_mid = new_mids[i]\n"
-"        if message_cache[new_mid] ~= false then\n"
-"            table.insert(result_mids, new_mid)\n"
-"        end\n"
-"    end\n"
-"    event_mids[primary_key] = result_mids\n"
-"    redis.call(\"del\", events_key .. \"!m!\" .. primary_key)\n"
-"    for i = 1, #result_mids, 1 do\n"
-"        redis.call(\"rpush\", events_key .. \"!m!\" .. primary_key, result_mids[i])\n"
-"    end\n"
-"end\n"
+"local facts_hashset\n"
+"local events_hashset\n"
+"local events_message_cache = {}\n"
+"local facts_message_cache = {}\n"
+"local facts_mids_cache = {}\n"
+"local events_mids_cache = {}\n"
+"local get_context\n"
 "local get_mids = function(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
 "    local event_mids = mids_cache[events_key]\n"
 "    local primary_key = primary_frame_keys[index](frame)\n"
@@ -1185,412 +936,697 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "    return message\n"
 "end\n"
 "local fetch_message = function(new_mid)\n"
-"    local message = get_message(new_mid, events_hashset, events_message_cache)\n"
-"    if not message then\n"
-"        message = get_message(new_mid, facts_hashset, facts_message_cache)\n"
+"    if type(new_mid) == \"table\" then\n"
+"        return new_mid\n"
 "    end\n"
-"    return message\n"
-"end\n"
-"local save_message = function(index, message, events_key, messages_key)\n"
-"    redis.call(\"hsetnx\", messages_key, message[\"id\"], cmsgpack.pack(message))\n"
-"    local primary_key = primary_message_keys[index](message)\n"
-"    redis.call(\"lpush\", events_key .. \"!m!\" .. primary_key, message[\"id\"])\n"
+"    return get_message(new_mid, facts_hashset, facts_message_cache)\n"
 "end\n"
-"local save_result = function(frame, index)\n"
-"    table.insert(results, 1, frame_packers[index](frame, true))\n"
-"    table.insert(unpacked_results, 1, frame)\n"
-"    for name, message in pairs(frame) do\n"
-"        if message ~= \"$n\" and not message[\"$f\"] then\n"
-"            redis.call(\"hdel\", events_hashset, message[\"id\"])\n"
-// message cache always looked up using strings
-"            events_message_cache[tostring(message[\"id\"])] = false\n"
+"local validate_frame_for_key = function(packed_frame, frame, index, events_list_key, messages_key, mids_cache, message_cache, sid)\n"
+"    local new_mids = get_mids(index, frame, events_list_key, messages_key, mids_cache, message_cache)\n"
+"    for i = 1, #new_mids, 1 do\n"
+"        local message = get_message(new_mids[i], messages_key, message_cache)\n"
+"        if message and not reviewers[index](message, frame, index) then\n"
+"            local frames_key = keys[index] .. \"!i!\" .. sid .. \"!\" .. new_mids[i]\n"
+"            redis.call(\"rpush\", frames_key, packed_frame)\n"
+"            return false\n"
 "        end\n"
 "    end\n"
+"    return true\n"
 "end\n"
-"local is_pure_fact = function(frame, index)\n"
-"    local message_count = 0\n"
-"    for name, message in pairs(frame) do\n"
-"        if message ~= 1 and message[\"$f\"] ~= 1 then\n" 
-"           return false\n"    
-"        end\n"
-"        message_count = message_count + 1\n"   
-"    end\n"    
-"    return (message_count == index - 1)\n"
+"local validate_frame = function(packed_frame, frame, index, sid)\n"
+"    local first_result = validate_frame_for_key(packed_frame, frame, index, keys[index] .. \"!e!\" .. sid, events_hashset, events_mids_cache, events_message_cache, sid)\n"
+"    local second_result = validate_frame_for_key(packed_frame, frame, index, keys[index] ..\"!f!\" .. sid, facts_hashset, facts_mids_cache, facts_message_cache, sid)\n"
+"    return first_result and second_result\n"
 "end\n"
-"local process_frame\n"
-"local process_event_and_frame = function(message, frame, index, use_facts)\n"
-"    local result = 0\n"
-"    local new_frame = {}\n"
-"    for name, new_message in pairs(frame) do\n"
-"        new_frame[name] = new_message\n"
+"local review_frame = function(frame, rule_action_key, sid, max_score)\n"
+"    local indexes = {}\n"
+"    local action_id = string.sub(rule_action_key, 1, (string.len(sid) + 1) * -1)\n"
+"    local context = get_context(action_id)\n"
+"    local full_frame = {}\n"
+"    local cancel = false\n"
+"    events_hashset = events_key .. sid\n"
+"    facts_hashset = facts_key .. sid\n"
+"    keys = context[\"keys\"]\n"
+"    reviewers = context[\"reviewers\"]\n"
+"    primary_frame_keys = context[\"primary_frame_keys\"]\n"
+"    if not context[\"frame_restore\"](frame, full_frame) then\n"
+"        cancel = true\n"
+"    else\n"
+"        for i = 1, #frame, 1 do\n"
+"            if frame[i] == \"$n\" then\n"
+"                if not validate_frame(frame, full_frame, i, sid) then\n"
+"                    cancel = true\n"
+"                    break\n"
+"                end\n"
+"            end\n"
+"        end\n"
 "    end\n"
-"    if reviewers[index](message, new_frame, index) then\n"
-"        if (index == expressions_count) then\n"
-"            save_result(new_frame, index)\n"
-"            return 1\n"
-"        else\n"
-"            result = process_frame(new_frame, index + 1, use_facts)\n"
-"            if result == 0 or use_facts then\n"
-"                local frames_key\n"
-"                local primary_key = primary_frame_keys[index + 1](new_frame)\n"
-"                frames_key = keys[index + 1] .. \"!c!\" .. sid .. \"!\" .. primary_key\n"
-"                redis.call(\"rpush\", frames_key, frame_packers[index](new_frame))\n"
+"    if cancel then\n"
+"        for i = 1, #frame, 1 do\n"
+"            if type(frame[i]) == \"table\" then\n"
+"                redis.call(\"hsetnx\", events_hashset, frame[i][\"id\"], cmsgpack.pack(frame[i]))\n"
+"                redis.call(\"zadd\", timers_key, max_score, \"p:\" .. cjson.encode(frame[i]))\n"
 "            end\n"
 "        end\n"
+"        full_frame = nil\n"
 "    end\n"
-"    return result\n"
+"    return full_frame\n"
 "end\n"
-"local process_frame_for_key = function(frame, index, events_key, use_facts)\n"
-"    local result = nil\n"
-"    local inverse = inverse_directory[index]\n"
-"    local messages_key = events_hashset\n"
-"    local message_cache = events_message_cache\n"
-"    local mids_cache = events_mids_cache\n"
-"    local cleanup = false\n"
-"    if use_facts then\n"
-"       messages_key = facts_hashset\n"
-"       message_cache = facts_message_cache\n"
-"       mids_cache = facts_mids_cache\n"
+"local load_frame_from_rule = function(rule_action_key, raw_count, sid, max_score)\n"
+"    local frames = {}\n"
+"    local packed_frames = {}\n"
+"    local unwrap = true\n"
+"    local count = 1\n"
+"    if raw_count ~= \"single\" then\n"
+"        count = tonumber(raw_count)\n"
+"        unwrap = false\n"
 "    end\n"
-"    if inverse then\n"
-"        local new_frame = {}\n"
-"        for name, new_message in pairs(frame) do\n"
-"            new_frame[name] = new_message\n"
-"        end\n"
-"        local new_mids = get_mids(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
-"        for i = 1, #new_mids, 1 do\n"
-"            local message = get_message(new_mids[i], messages_key, message_cache)\n"
-"            if not message then\n"
-"                cleanup = true\n"
-"            elseif not reviewers[index](message, new_frame, index) then\n"
-"                local frames_key = keys[index] .. \"!i!\" .. sid .. \"!\" .. new_mids[i]\n"
-"                redis.call(\"rpush\", frames_key, frame_packers[index - 1](new_frame))\n"
-"                result = 0\n"
-"                break\n"
+"    if count == 0 then\n"
+"        local packed_frame = redis.call(\"lpop\", rule_action_key)\n"
+"        while packed_frame ~= \"0\" do\n"
+"            local frame = review_frame(cmsgpack.unpack(packed_frame), rule_action_key, sid, max_score)\n"
+"            if frame then\n"
+"                table.insert(frames, frame)\n"
+"                table.insert(packed_frames, packed_frame)\n"
 "            end\n"
+"            packed_frame = redis.call(\"lpop\", rule_action_key)\n"
+"        end\n"
+"        if #packed_frames > 0 then\n"
+"            redis.call(\"lpush\", rule_action_key, 0)\n"
 "        end\n"
 "    else\n"
-"        local new_mids = get_mids(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
-"        for i = 1, #new_mids, 1 do\n"
-"            local message = get_message(new_mids[i], messages_key, message_cache)\n"
-"            if not message then\n"
-"                cleanup = true\n"
+"        while count > 0 do\n"
+"            local packed_frame = redis.call(\"rpop\", rule_action_key)\n"
+"            if not packed_frame then\n"
+"                break\n"
 "            else\n"
-"                local count = process_event_and_frame(message, frame, index, use_facts)\n"
-"                if not result then\n"
-"                    result = 0\n"
-"                end\n"
-"                result = result + count\n"
-"                if not is_pure_fact(frame, index) then\n"
-"                    break\n"
+"                local frame = review_frame(cmsgpack.unpack(packed_frame), rule_action_key, sid, max_score)\n"
+"                if frame then\n"
+"                    table.insert(frames, frame)\n"
+"                    table.insert(packed_frames, packed_frame)\n"
+"                    count = count - 1\n"
 "                end\n"
 "            end\n"
 "        end\n"
 "    end\n"
-"    if cleanup then\n"
-"        cleanup_mids(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
+"    for i = #packed_frames, 1, -1 do\n"
+"        redis.call(\"rpush\", rule_action_key, packed_frames[i])\n"
 "    end\n"
-"    return result\n"
-"end\n"
-"process_frame = function(frame, index, use_facts)\n"
-"    local first_result = process_frame_for_key(frame, index, keys[index] .. \"!e!\" .. sid, false)\n"
-"    local second_result = process_frame_for_key(frame, index, keys[index] .. \"!f!\" .. sid, true)\n"
-"    if not first_result and not second_result then\n"
-"        return process_event_and_frame(nil, frame, index, use_facts)\n"
-"    elseif not first_result then\n"
-"        return second_result\n"
-"    elseif not second_result then\n"
-"        return first_result\n"
+"    if #packed_frames == 0 then\n"
+"        return nil, nil\n"
+"    end\n"
+"    local last_name = string.find(rule_action_key, \"!\") - 1\n"
+"    if unwrap then\n"
+"        return string.sub(rule_action_key, 1, last_name), frames[1]\n"
 "    else\n"
-"        return first_result + second_result\n"
+"        return string.sub(rule_action_key, 1, last_name), frames\n"
 "    end\n"
 "end\n"
-"local process_inverse_event = function(message, index, events_key, use_facts)\n"
-"    local result = 0\n"
-"    local messages_key = events_hashset\n"
-"    if use_facts then\n"
-"        messages_key = facts_hashset\n"
+"local load_frame_from_sid = function(sid, max_score)\n"
+"    local action_list = action_key .. \"!\" .. sid\n"
+"    local rule_action_key = redis.call(\"lpop\", action_list)\n"
+"    if not rule_action_key then\n"
+"        return nil, nil\n"
 "    end\n"
-"    redis.call(\"hdel\", messages_key, mid)\n"
-"    if index == 1 then\n"
-"        result = process_frame({}, 1, use_facts)\n"
-"    else\n"
-"        local frames_key = keys[index] .. \"!i!\" .. sid .. \"!\" .. mid\n"
-"        local packed_frames_len = redis.call(\"llen\", frames_key)\n"
-"        for i = 1, packed_frames_len, 1 do\n"
-"            local packed_frame = redis.call(\"rpop\", frames_key)\n"
-"            local frame = frame_unpackers[index - 1](packed_frame)\n"
-"            if frame then\n"
-"                result = result + process_frame(frame, index, use_facts)\n"
-"            end\n"     
+"    local count = redis.call(\"lpop\", action_list)\n"
+"    local name, frame = load_frame_from_rule(rule_action_key, count, sid, max_score)\n"
+"    while not frame do\n"
+"        rule_action_key = redis.call(\"lpop\", action_list)\n"
+"        if not rule_action_key then\n"
+"            return nil, nil\n"
 "        end\n"
+"        count = redis.call(\"lpop\", action_list)\n"
+"        name, frame = load_frame_from_rule(rule_action_key, count, sid, max_score)\n"
 "    end\n"
-"    return result\n"
+"    redis.call(\"lpush\", action_list, count)\n"
+"    redis.call(\"lpush\", action_list, rule_action_key)\n"
+"    return name, frame\n"
 "end\n"
-"local process_event = function(message, index, events_key, use_facts)\n"
-"    local result = 0\n"
-"    local messages_key = events_hashset\n"
-"    if use_facts then\n"
-"        messages_key = facts_hashset\n"
+"local load_frame = function(max_score)\n"
+"    local current_action = redis.call(\"zrange\", action_key, 0, 0, \"withscores\")\n"
+"    if (#current_action == 0) or (tonumber(current_action[2]) > (max_score + 5)) then\n"
+"        return nil, nil, nil\n"
 "    end\n"
-"    if index == 1 then\n"
-"        result = process_event_and_frame(message, {}, 1, use_facts)\n"
-"    else\n"
-"        local frames_key\n"
-"        local primary_key = primary_message_keys[index](message)\n"
-"        if primary_key then\n"
-"            frames_key = keys[index] .. \"!c!\" .. sid .. \"!\" .. primary_key\n"
-"        else\n"
-"            frames_key = keys[index] .. \"!c!\" .. sid\n"
-"        end\n"
-"        local packed_frames_len = redis.call(\"llen\", frames_key)\n"
-"        for i = 1, packed_frames_len, 1 do\n"
-"            local packed_frame = redis.call(\"rpop\", frames_key)\n"
-"            local frame = frame_unpackers[index - 1](packed_frame)\n"
-"            if frame then\n"
-"                local count = process_event_and_frame(message, frame, index, use_facts)\n"
-"                result = result + count\n"         
-"                if count == 0 or use_facts then\n"
-"                    redis.call(\"lpush\", frames_key, packed_frame)\n"
-"                else\n"
-"                    break\n" 
-"                end\n"
-"            end\n"     
+"    local sid = current_action[1]\n"
+"    local name, frame = load_frame_from_sid(sid, max_score)\n"
+"    while not frame do\n"
+"        redis.call(\"zremrangebyrank\", action_key, 0, 0)\n"
+"        current_action = redis.call(\"zrange\", action_key, 0, 0, \"withscores\")\n"
+"        if #current_action == 0 or (tonumber(current_action[2]) > (max_score + 5)) then\n"
+"            return nil, nil, nil\n"
 "        end\n"
+"        sid = current_action[1]\n"
+"        name, frame = load_frame_from_sid(sid, max_score)\n"
 "    end\n"
-"    if result == 0 or use_facts then\n"
-"        save_message(index, message, events_key, messages_key)\n"
+"    return sid, name, frame\n"
+"end\n"
+"get_context = function(action_key)\n"
+"    if context_directory[action_key] then\n"
+"        return context_directory[action_key]\n"
 "    end\n"
-"    return result\n"
+"    local input_keys = {[action_key] = true}\n%s"
 "end\n"
-"local process_key_with_span = function(message, span)\n"
-"    local index = directory[key]\n"
-"    local queue_lock = false\n"
-"    if index then\n"
-"        local last_score = redis.call(\"get\", results_key .. \"!d\")\n"
-"        if not last_score then\n"
-"            redis.call(\"set\", results_key .. \"!d\", score)\n"
-"        else\n"
-"            local new_score = last_score + span\n"
-"            if score > new_score then\n"
-"                redis.call(\"rpush\", results_key, 0)\n"
-"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
-"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, 0)\n"
-"                local span_count, span_remain = math.modf((score - new_score) / span)\n"
-"                last_score = new_score + span_count * span\n"
-"                redis.call(\"set\", results_key .. \"!d\", last_score)\n"
-"                queue_lock = true\n"
-"            end\n"    
-"        end\n"
-"        local count = 0\n"
-"        if not message then\n"
-"            if assert_fact == 0 then\n"
-"                count = process_inverse_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
-"            else\n"
-"                count = process_inverse_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
-"            end\n"
-"        else\n"
-"            if assert_fact == 0 then\n"
-"                count = process_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
-"            else\n"
-"                count = process_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
-"            end\n"
-"        end\n"
-"        if (count > 0) then\n"
-"            for i = 1, #results, 1 do\n"
-"                redis.call(\"rpush\", results_key, results[i])\n"
-"            end\n"
-"        end\n"
-"    end\n"
-"    return queue_lock\n"
+"local new_sid, action_name, frame\n"
+"if #ARGV == 3 then\n"
+"    new_sid = ARGV[3]\n"
+"    action_name, frame = load_frame_from_sid(new_sid, tonumber(ARGV[2]))\n"
+"else\n"
+"    new_sid, action_name, frame = load_frame(tonumber(ARGV[2]))\n"
 "end\n"
-"local process_key_with_cap = function(message, cap)\n"
-"    local index = directory[key]\n"
-"    local queue_lock = false\n"
-"    if index then\n"
-"        local count = 0\n"
-"        if not message then\n"
-"            if assert_fact == 0 then\n"
-"                count = process_inverse_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
-"            else\n"
-"                count = process_inverse_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
-"            end\n"
-"        else\n"
-"            if assert_fact == 0 then\n"
-"                count = process_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
-"            else\n"
-"                count = process_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
-"            end\n"
-"        end\n"
-"        if (count > 0) then\n"
-"            for i = #results, 1, -1 do\n"
-"                redis.call(\"lpush\", results_key, results[i])\n"
-"            end\n"
-"            local diff\n"
-"            local new_count, new_remain = math.modf(#results / cap)\n"
-"            local new_remain = #results %% cap\n"
-"            if new_count > 0 then\n"
-"                for i = 1, new_count, 1 do\n"
-"                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
-"                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, cap)\n"
-"                end\n"
-"            end\n"
-"            if new_remain > 0 then\n"
-"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
-"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, new_remain)\n"
-"            end\n"
-"            if new_count > 0 or new_remain > 0 then\n"
-"                queue_lock = true\n"
-"            end\n"
-"        end\n"
+"if frame then\n"
+"    redis.call(\"zadd\", action_key, tonumber(ARGV[1]), new_sid)\n"
+"    if #ARGV == 2 then\n"
+"        local state = redis.call(\"hget\", state_key, new_sid)\n"
+"        return {new_sid, state, cjson.encode({[action_name] = frame})}\n"
+"    else\n"
+"        return {new_sid, cjson.encode({[action_name] = frame})}\n"
 "    end\n"
-"    return queue_lock\n"
-"end\n"
-"local process_key_with_window = function(message, window)\n"
-"    local index = directory[key]\n"
-"    local queue_lock = false\n"
-"    if index then\n"
-"        local count = 0\n"
+"end\n",
+                name,
+                name,
+                name,
+                name,
+                name,
+                peekActionLua)  == -1) {
+        return ERR_OUT_OF_MEMORY;
+    }
+    free(peekActionLua);
+    redisAppendCommand(reContext, "SCRIPT LOAD %s", lua);
+    redisGetReply(reContext, (void**)&reply);
+    if (reply->type == REDIS_REPLY_ERROR) {
+        printf("%s\n", reply->str);
+        freeReplyObject(reply);
+        free(lua);
+        return ERR_REDIS_ERROR;
+    }
+
+    strncpy(rulesBinding->peekActionHash, reply->str, 40);
+    rulesBinding->peekActionHash[40] = '\0';
+    freeReplyObject(reply);
+    free(lua);
+    return RULES_OK;
+}
+
+static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
+    int nameLength = strlen(name);
+    redisContext *reContext = rulesBinding->reContext;
+    redisReply *reply;
+    char *lua = NULL;
+    char *oldLua;
+    
+    #ifdef _WIN32
+    char *actionKey = (char *)_alloca(sizeof(char)*(nameLength + 3));
+    sprintf_s(actionKey, nameLength + 3, "%s!a", name);
+#else
+    char actionKey[nameLength + 3];
+    snprintf(actionKey, nameLength + 3, "%s!a", name);
+#endif
+    
+    lua = (char*)calloc(1, sizeof(char));
+    if (!lua) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    for (unsigned int i = 0; i < tree->nodeOffset; ++i) {
+        node *currentNode = &tree->nodePool[i];
+        
+        if (currentNode->type == NODE_ACTION) {
+            char *packFrameLua = NULL;
+            char *unpackFrameLua = NULL;
+            char *oldPackFrameLua = NULL;
+            char *oldUnpackFrameLua = NULL;
+            char *actionName = &tree->stringPool[currentNode->nameOffset];
+            char *actionLastName = strchr(actionName, '!');
+#ifdef _WIN32
+            char *actionAlias = (char *)_alloca(sizeof(char)*(actionLastName - actionName + 1));
+#else
+            char actionAlias[actionLastName - actionName + 1];
+#endif
+            
+            strncpy(actionAlias, actionName, actionLastName - actionName);
+            actionAlias[actionLastName - actionName] = '\0';
+
+            for (unsigned int ii = 0; ii < currentNode->value.c.joinsLength; ++ii) {
+                unsigned int currentJoinOffset = tree->nextPool[currentNode->value.c.joinsOffset + ii];
+                join *currentJoin = &tree->joinPool[currentJoinOffset];
+                oldLua = lua;
+                if (asprintf(&lua, 
+"%stoggle = false\n"
+"context = {}\n"
+"reviewers = {}\n"
+"context[\"reviewers\"] = reviewers\n"
+"frame_packers = {}\n"
+"context[\"frame_packers\"] = frame_packers\n"
+"frame_unpackers = {}\n"
+"context[\"frame_unpackers\"] = frame_unpackers\n"
+"primary_message_keys = {}\n"
+"context[\"primary_message_keys\"] = primary_message_keys\n"
+"primary_frame_keys = {}\n"
+"context[\"primary_frame_keys\"] = primary_frame_keys\n"
+"keys = {}\n"
+"context[\"keys\"] = keys\n"
+"inverse_directory = {}\n"
+"context[\"inverse_directory\"] = inverse_directory\n"
+"directory = {[\"0\"] = 1}\n"
+"context[\"directory\"] = directory\n"
+"context[\"results_key\"] = \"%s!%d!r!\" .. sid\n"
+"context[\"expressions_count\"] = %d\n",
+                            lua,
+                            actionName,
+                            ii,
+                            currentJoin->expressionsLength)  == -1) {
+                    return ERR_OUT_OF_MEMORY;
+                }  
+                free(oldLua);
+
+                for (unsigned int iii = 0; iii < currentJoin->expressionsLength; ++iii) {
+                    unsigned int expressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii];
+                    expression *expr = &tree->expressionPool[expressionOffset];
+                    char *currentAlias = &tree->stringPool[expr->aliasOffset];
+                    char *currentKey = &tree->stringPool[expr->nameOffset];
+                    char *nextKeyTest;
+                    if (iii == (currentJoin->expressionsLength - 1)) {
+                        nextKeyTest = (char*)calloc(1, sizeof(char));
+                        if (!nextKeyTest) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
+                    } else {
+                        unsigned int nextExpressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii + 1];
+                        expression *nextExpr = &tree->expressionPool[nextExpressionOffset];
+                        if (asprintf(&nextKeyTest, 
+"or input_keys[\"%s\"]", 
+                                     &tree->stringPool[nextExpr->nameOffset])  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
+                    }
+                    
+                    if (iii == 0) {
+                        if (expr->not) { 
+                            if (asprintf(&packFrameLua,
+"    result[1] = \"$n\"\n")  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+
+                            if (asprintf(&unpackFrameLua,
+"    result[\"%s\"] = \"$n\"\n",
+                                        currentAlias)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+
+                            oldLua = lua;
+                            if (asprintf(&lua, 
+"%sif input_keys[\"%s\"] %s then\n"
+"    toggle = true\n"
+"    context_directory[\"%s\"] = context\n"
+"    keys[1] = \"%s\"\n"
+"    inverse_directory[1] = true\n"
+"    directory[\"%s\"] = 1\n"
+"    reviewers[1] = function(message, frame, index)\n"
 "        if not message then\n"
-"            if assert_fact == 0 then\n"
-"                count = process_inverse_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
-"            else\n"
-"                count = process_inverse_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
-"            end\n"
-"        else\n"
-"            if assert_fact == 0 then\n"
-"                count = process_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
-"            else\n"
-"                count = process_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
-"            end\n"
+"            frame[\"%s\"] = \"$n\"\n"
+"            return true\n"
 "        end\n"
-"        if (count > 0) then\n"
-"            for i = #results, 1, -1 do\n"
-"                redis.call(\"lpush\", results_key, results[i])\n"
-"            end\n"
-"            local diff\n"
-"            local length = redis.call(\"llen\", results_key)\n"
-"            local prev_count, prev_remain = math.modf((length - count) / window)\n"
-"            local new_count, prev_remain = math.modf(length / window)\n"
-"            diff = new_count - prev_count\n"
-"            if diff > 0 then\n"
-"                for i = 0, diff - 1, 1 do\n"
-"                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
-"                    if window == 1 then\n"
-"                        redis.call(\"rpush\", actions_key .. \"!\" .. sid, \"single\")\n"
-"                    else\n"
-"                        redis.call(\"rpush\", actions_key .. \"!\" .. sid, window)\n"
-"                    end\n"
-"                end\n"
-"                queue_lock = true\n"
-"             end\n"
+"        return false\n"
+"    end\n"
+"    frame_packers[1] = function(frame, full_encode)\n"
+"        local result = {}\n%s"
+"        return cmsgpack.pack(result)\n"
+"    end\n"
+"    frame_unpackers[1] = function(packed_frame)\n"
+"        local frame = cmsgpack.unpack(packed_frame)\n"
+"        local result = {}\n%s"
+"        return result\n"
+"    end\n"
+"    primary_message_keys[1] = function(message)\n"
+"        return \"\"\n"
+"    end\n"
+"    primary_frame_keys[1] = function(frame)\n"
+"        return \"\"\n"
+"    end\n"
+"end\n",
+                                         lua,
+                                         currentKey,
+                                         nextKeyTest,
+                                         currentKey,
+                                         currentKey,
+                                         currentKey,
+                                         currentAlias,
+                                         packFrameLua,
+                                         unpackFrameLua)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+                            free(oldLua);
+                        // not (expr->not)
+                        } else {
+                            if (asprintf(&packFrameLua,
+"    message = frame[\"%s\"]\n"
+"    if full_encode and not message[\"$f\"] then\n"
+"        result[1] = message\n"
+"    else\n"
+"        result[1] = message[\"id\"]\n"
+"    end\n",
+                                        currentAlias)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+
+                            if (asprintf(&unpackFrameLua,
+"    message = fetch_message(frame[1])\n"
+"    if not message then\n"
+"        return nil\n"
+"    end\n"
+"    result[\"%s\"] = message\n",
+                                        currentAlias)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+
+                            oldLua = lua;
+                            if (asprintf(&lua, 
+"%sif input_keys[\"%s\"] %s then\n"
+"    toggle = true\n"
+"    context_directory[\"%s\"] = context\n"
+"    keys[1] = \"%s\"\n"
+"    inverse_directory[1] = true\n"
+"    directory[\"%s\"] = 1\n"
+"    reviewers[1] = function(message, frame, index)\n"
+"        if message then\n"
+"            frame[\"%s\"] = message\n"
+"            return true\n"
 "        end\n"
+"        return false\n"
 "    end\n"
-"    return queue_lock\n"
-"end\n"
-"local message = nil\n"
-"if #ARGV > (6 + keys_count) then\n"
-"    message = {}\n"
-"    for index = 6 + keys_count, #ARGV, 3 do\n"
-"        if ARGV[index + 2] == \"1\" then\n"
-"            message[ARGV[index]] = ARGV[index + 1]\n"
-"        elseif ARGV[index + 2] == \"2\" or  ARGV[index + 2] == \"3\" then\n"
-"            message[ARGV[index]] = tonumber(ARGV[index + 1])\n"
-"        elseif ARGV[index + 2] == \"4\" then\n"
-"            if ARGV[index + 1] == \"true\" then\n"
-"                message[ARGV[index]] = true\n"
-"            else\n"
-"                message[ARGV[index]] = false\n"
-"            end\n"
-"        end\n"
+"    frame_packers[1] = function(frame, full_encode)\n"
+"        local result = {}\n"
+"        local message\n%s"
+"        return cmsgpack.pack(result)\n"
 "    end\n"
-"    if assert_fact == 1 then\n"
-"        message[\"$f\"] = 1\n"
+"    frame_unpackers[1] = function(packed_frame)\n"
+"        local frame = cmsgpack.unpack(packed_frame)\n"
+"        local result = {}\n"
+"        local message\n%s"
+"        return result\n"
 "    end\n"
-"end\n"
-"if redis.call(\"hsetnx\", visited_hashset, mid, 1) == 0 then\n"
-"    if assert_fact == 0 then\n"
-"        if message and redis.call(\"hexists\", events_hashset, mid) == 0 then\n"
-"            return false\n"
+"    primary_message_keys[1] = function(message)\n"
+"        return \"\"\n"
+"    end\n"
+"    primary_frame_keys[1] = function(frame)\n"
+"        return \"\"\n"
+"    end\n"
+"end\n",
+                                         lua,
+                                         currentKey,
+                                         nextKeyTest,
+                                         currentKey,
+                                         currentKey,
+                                         currentKey,
+                                         currentAlias,
+                                         packFrameLua,
+                                         unpackFrameLua)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+                            free(oldLua);
+                        }
+                    // not (iii == 0)
+                    } else {
+                        char *test = NULL;
+                        char *primaryKeyLua = NULL;
+                        char *primaryFrameKeyLua = NULL;
+                        unsigned int result = createTest(tree, expr, &test, &primaryKeyLua, &primaryFrameKeyLua);
+                        if (result != RULES_OK) {
+                            return result;
+                        }
+
+                        if (expr->not) { 
+                            oldPackFrameLua = packFrameLua;
+                            if (asprintf(&packFrameLua,
+"%s    result[%d] = \"$n\"\n",
+                                         packFrameLua,
+                                         iii + 1)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+                            free(oldPackFrameLua);
+
+                            oldUnpackFrameLua = unpackFrameLua;
+                            if (asprintf(&unpackFrameLua,
+"%s    result[\"%s\"] = \"$n\"\n",
+                                        unpackFrameLua,
+                                        currentAlias)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+                            free(oldUnpackFrameLua);
+
+                            oldLua = lua;
+                            if (asprintf(&lua,
+"%sif toggle %s then\n"
+"    toggle = true\n"
+"    context_directory[\"%s\"] = context\n"
+"    keys[%d] = \"%s\"\n"
+"    inverse_directory[%d] = true\n"
+"    directory[\"%s\"] = %d\n"
+"    reviewers[%d] = function(message, frame, index)\n"
+"        if not message or not (%s) then\n"
+"            frame[\"%s\"] = \"$n\"\n"
+"            return true\n"
 "        end\n"
+"        return false\n"
+"    end\n"
+"    frame_packers[%d] = function(frame, full_encode)\n"
+"        local result = {}\n"
+"        local message\n%s"
+"        return cmsgpack.pack(result)\n"
+"    end\n"
+"    frame_unpackers[%d] = function(packed_frame)\n"
+"        local frame = cmsgpack.unpack(packed_frame)\n"
+"        local result = {}\n"
+"        local message\n%s"
+"        return result\n"
+"    end\n"
+"    primary_message_keys[%d] = function(message)\n"
+"        local result = \"\"\n%s"
+"        return result\n"
+"    end\n"
+"    primary_frame_keys[%d] = function(frame)\n"
+"        local result = \"\"\n%s"
+"        return result\n"
+"    end\n"
+"end\n",
+                                         lua,
+                                         nextKeyTest,
+                                         currentKey,
+                                         iii + 1, 
+                                         currentKey,
+                                         iii + 1, 
+                                         currentKey,
+                                         iii + 1,
+                                         iii + 1,
+                                         test,
+                                         currentAlias,
+                                         iii + 1,
+                                         packFrameLua,
+                                         iii + 1,
+                                         unpackFrameLua,
+                                         iii + 1,
+                                         primaryKeyLua,
+                                         iii + 1,
+                                         primaryFrameKeyLua)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+                            free(oldLua);
+
+                        // not (expr->not)
+                        } else {
+                            oldPackFrameLua = packFrameLua;
+                            if (asprintf(&packFrameLua,
+"%s    message = frame[\"%s\"]\n"
+"    if full_encode and not message[\"$f\"] then\n"
+"        result[%d] = message\n"
 "    else\n"
-"        if message and redis.call(\"hexists\", facts_hashset, mid) == 0 then\n"
-"            return false\n"
+"        result[%d] = message[\"id\"]\n"
+"    end\n",
+                                         packFrameLua,
+                                         currentAlias,
+                                         iii + 1,
+                                         iii + 1)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+                            free(oldPackFrameLua);
+
+                            oldUnpackFrameLua = unpackFrameLua;
+                            if (asprintf(&unpackFrameLua,
+"%s    message = fetch_message(frame[%d])\n"
+"    if not message then\n"
+"        return nil\n"
+"    end\n"
+"    result[\"%s\"] = message\n",
+                                         unpackFrameLua,
+                                         iii + 1,
+                                         currentAlias)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+                            free(oldUnpackFrameLua);
+
+                            oldLua = lua;
+                            if (asprintf(&lua,
+"%sif toggle %s then\n"
+"    toggle = true\n"
+"    context_directory[\"%s\"] = context\n"
+"    keys[%d] = \"%s\"\n"
+"    directory[\"%s\"] = %d\n"
+"    reviewers[%d] = function(message, frame, index)\n"
+"        if message and %s then\n"
+"            frame[\"%s\"] = message\n"
+"            return true\n"
 "        end\n"
+"        return false\n"
 "    end\n"
-"end\n"
-"for index = 6, 5 + keys_count, 1 do\n"
-"    input_keys[ARGV[index]] = true\n"
-"end\n"
-"%sfor index = 6, 5 + keys_count, 1 do\n"
-"    results = {}\n"
-"    unpacked_results = {}\n"
-"    key = ARGV[index]\n"
-"    context = context_directory[key]\n"
-"    keys = context[\"keys\"]\n"
-"    reviewers = context[\"reviewers\"]\n"
-"    frame_packers = context[\"frame_packers\"]\n"
-"    frame_unpackers = context[\"frame_unpackers\"]\n"
-"    primary_message_keys = context[\"primary_message_keys\"]\n"
-"    primary_frame_keys = context[\"primary_frame_keys\"]\n"
-"    directory = context[\"directory\"]\n"
-"    results_key = context[\"results_key\"]\n"
-"    inverse_directory = context[\"inverse_directory\"]\n"
-"    expressions_count = context[\"expressions_count\"]\n"
-"    local process_key = context[\"process_key\"]\n"
-"    local process_key_count = context[\"process_key_count\"]\n"
-"    queue_action = process_key(message, process_key_count)\n"
-"    if assert_fact == 0 and events_message_cache[tostring(message[\"id\"])] == false then\n"
-"        break\n"
+"    frame_packers[%d] = function(frame, full_encode)\n"
+"        local result = {}\n"
+"        local message\n%s"
+"        return cmsgpack.pack(result)\n"
 "    end\n"
-"end\n"
-"if queue_action then\n"
-"    if not redis.call(\"zscore\", actions_key, sid) then\n"
-"        redis.call(\"zadd\", actions_key , score, sid)\n"
+"    frame_unpackers[%d] = function(packed_frame)\n"
+"        local frame = cmsgpack.unpack(packed_frame)\n"
+"        local result = {}\n"
+"        local message\n%s"
+"        return result\n"
 "    end\n"
-"end\n"
-"return nil\n",
-                 name,
-                 name,
-                 name,
-                 name,
-                 name,
-                 lua)  == -1) {
-        return ERR_OUT_OF_MEMORY;
-    }
+"    primary_message_keys[%d] = function(message)\n"
+"        local result = \"\"\n%s"
+"        return result\n"
+"    end\n"
+"    primary_frame_keys[%d] = function(frame)\n"
+"        local result = \"\"\n%s"
+"        return result\n"
+"    end\n"
+"end\n",
+                                         lua,
+                                         nextKeyTest,
+                                         currentKey,
+                                         iii + 1, 
+                                         currentKey,
+                                         currentKey,
+                                         iii + 1,
+                                         iii + 1,
+                                         test,
+                                         currentAlias,
+                                         iii + 1,
+                                         packFrameLua,
+                                         iii + 1,
+                                         unpackFrameLua,
+                                         iii + 1,
+                                         primaryKeyLua,
+                                         iii + 1,
+                                         primaryFrameKeyLua)  == -1) {
+                                return ERR_OUT_OF_MEMORY;
+                            }
+                            free(oldLua);
+                        // done not (expr->not)
+                        }
+                        free(nextKeyTest);
+                        free(test);
+                        free(primaryKeyLua);
+                        free(primaryFrameKeyLua);
+                    // done not (iii == 0)
+                    }
+                }
 
-    free(oldLua);
-    redisAppendCommand(reContext, "SCRIPT LOAD %s", lua);
-    redisGetReply(reContext, (void**)&reply);
-    if (reply->type == REDIS_REPLY_ERROR) {
-        printf("%s\n", reply->str);
-        freeReplyObject(reply);
-        free(lua);
-        return ERR_REDIS_ERROR;
-    }
+                if (currentNode->value.c.span > 0) {
+                    oldLua = lua;
+                    if (asprintf(&lua,
+"%sif toggle then\n"
+"    context[\"process_key\"] = process_key_with_span\n"
+"    context[\"process_key_count\"] = %d\n"
+"end\n",
+                                 lua,
+                                 currentNode->value.c.span)  == -1) {
+                        return ERR_OUT_OF_MEMORY;
+                    }
+                    free(oldLua);
 
-    strncpy(rulesBinding->evalMessageHash, reply->str, 40);
-    rulesBinding->evalMessageHash[40] = '\0';
-    freeReplyObject(reply);
-    free(lua);
+                } else if (currentNode->value.c.cap > 0) {
+                    oldLua = lua;
+                    if (asprintf(&lua,
+"%sif toggle then\n"
+"    context[\"process_key\"] = process_key_with_cap\n"
+"    context[\"process_key_count\"] = %d\n"
+"end\n",
+                                 lua,
+                                 currentNode->value.c.cap)  == -1) {
+                        return ERR_OUT_OF_MEMORY;
+                    }
+                    free(oldLua);
 
-    if (asprintf(&lua, 
-"local facts_key = \"%s!f!\"\n"
-"local events_key = \"%s!e!\"\n"
-"local action_key = \"%s!a\"\n"
+                } else {
+                    oldLua = lua;
+                    if (asprintf(&lua,
+"%sif toggle then\n"
+"    context[\"process_key\"] = process_key_with_window\n"
+"    context[\"process_key_count\"] = %d\n"
+"end\n",
+                                 lua,
+                                 currentNode->value.c.count)  == -1) {
+                        return ERR_OUT_OF_MEMORY;
+                    }
+                    free(oldLua);
+                }
+            }
+
+            free(unpackFrameLua);
+            free(packFrameLua);
+        }
+    }
+
+    oldLua = lua;
+    if (asprintf(&lua,
+"local sid = ARGV[1]\n"
+"local mid = ARGV[2]\n"
+"local score = tonumber(ARGV[3])\n"
+"local assert_fact = tonumber(ARGV[4])\n"
+"local keys_count = tonumber(ARGV[5])\n"
+"local events_hashset = \"%s!e!\" .. sid\n"
+"local facts_hashset = \"%s!f!\" .. sid\n"
+"local visited_hashset = \"%s!v!\" .. sid\n"
+"local actions_key = \"%s!a\"\n"
 "local state_key = \"%s!s\"\n"
-"local timers_key = \"%s!t\"\n"
+"local queue_action = false\n"
+"local facts_message_cache = {}\n"
+"local events_message_cache = {}\n"
+"local facts_mids_cache = {}\n"
+"local events_mids_cache = {}\n"
 "local context_directory = {}\n"
+"local input_keys = {}\n"
+"local toggle\n"
+"local expressions_count\n"
+"local results\n"
+"local unpacked_results\n"
+"local context\n"
 "local keys\n"
 "local reviewers\n"
+"local frame_packers\n"
+"local frame_unpackers\n"
+"local primary_message_keys\n"
 "local primary_frame_keys\n"
-"local facts_hashset\n"
-"local events_hashset\n"
-"local events_message_cache = {}\n"
-"local facts_message_cache = {}\n"
-"local facts_mids_cache = {}\n"
-"local events_mids_cache = {}\n"
-"local get_context\n"
+"local directory\n"
+"local results_key\n"
+"local inverse_directory\n"
+"local key\n"
+"local cleanup_mids = function(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
+"    local event_mids = mids_cache[events_key]\n"
+"    local primary_key = primary_frame_keys[index](frame)\n"
+"    local new_mids = event_mids[primary_key]\n"
+"    local result_mids = {}\n"
+"    for i = 1, #new_mids, 1 do\n"
+"        local new_mid = new_mids[i]\n"
+"        if message_cache[new_mid] ~= false then\n"
+"            table.insert(result_mids, new_mid)\n"
+"        end\n"
+"    end\n"
+"    event_mids[primary_key] = result_mids\n"
+"    redis.call(\"del\", events_key .. \"!m!\" .. primary_key)\n"
+"    for i = 1, #result_mids, 1 do\n"
+"        redis.call(\"rpush\", events_key .. \"!m!\" .. primary_key, result_mids[i])\n"
+"    end\n"
+"end\n"
 "local get_mids = function(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
 "    local event_mids = mids_cache[events_key]\n"
 "    local primary_key = primary_frame_keys[index](frame)\n"
@@ -1622,258 +1658,381 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "    return message\n"
 "end\n"
 "local fetch_message = function(new_mid)\n"
-"    if type(new_mid) == \"table\" then\n"
-"        return new_mid\n"
+"    local message = get_message(new_mid, events_hashset, events_message_cache)\n"
+"    if not message then\n"
+"        message = get_message(new_mid, facts_hashset, facts_message_cache)\n"
 "    end\n"
-"    return get_message(new_mid, facts_hashset, facts_message_cache)\n"
+"    return message\n"
 "end\n"
-"local validate_frame_for_key = function(packed_frame, frame, index, events_list_key, messages_key, mids_cache, message_cache, sid)\n"
-"    local new_mids = get_mids(index, frame, events_list_key, messages_key, mids_cache, message_cache)\n"
-"    for i = 1, #new_mids, 1 do\n"
-"        local message = get_message(new_mids[i], messages_key, message_cache)\n"
-"        if message and not reviewers[index](message, frame, index) then\n"
-"            local frames_key = keys[index] .. \"!i!\" .. sid .. \"!\" .. new_mids[i]\n"
-"            redis.call(\"rpush\", frames_key, packed_frame)\n"
-"            return false\n"
+"local save_message = function(index, message, events_key, messages_key)\n"
+"    redis.call(\"hsetnx\", messages_key, message[\"id\"], cmsgpack.pack(message))\n"
+"    local primary_key = primary_message_keys[index](message)\n"
+"    redis.call(\"lpush\", events_key .. \"!m!\" .. primary_key, message[\"id\"])\n"
+"end\n"
+"local save_result = function(frame, index)\n"
+"    table.insert(results, 1, frame_packers[index](frame, true))\n"
+"    table.insert(unpacked_results, 1, frame)\n"
+"    for name, message in pairs(frame) do\n"
+"        if message ~= \"$n\" and not message[\"$f\"] then\n"
+"            redis.call(\"hdel\", events_hashset, message[\"id\"])\n"
+// message cache always looked up using strings
+"            events_message_cache[tostring(message[\"id\"])] = false\n"
 "        end\n"
 "    end\n"
-"    return true\n"
 "end\n"
-"local validate_frame = function(packed_frame, frame, index, sid)\n"
-"    local first_result = validate_frame_for_key(packed_frame, frame, index, keys[index] .. \"!e!\" .. sid, events_hashset, events_mids_cache, events_message_cache, sid)\n"
-"    local second_result = validate_frame_for_key(packed_frame, frame, index, keys[index] ..\"!f!\" .. sid, facts_hashset, facts_mids_cache, facts_message_cache, sid)\n"
-"    return first_result and second_result\n"
-"end\n"
-"local review_frame = function(frame, rule_action_key, sid, max_score)\n"
-"    local indexes = {}\n"
-"    local action_id = string.sub(rule_action_key, 1, (string.len(sid) + 1) * -1)\n"
-"    local context = get_context(action_id)\n"
-"    local full_frame = {}\n"
-"    local cancel = false\n"
-"    events_hashset = events_key .. sid\n"
-"    facts_hashset = facts_key .. sid\n"
-"    keys = context[\"keys\"]\n"
-"    reviewers = context[\"reviewers\"]\n"
-"    primary_frame_keys = context[\"primary_frame_keys\"]\n"
-"    if not context[\"frame_restore\"](frame, full_frame) then\n"
-"        cancel = true\n"
-"    else\n"
-"        for i = 1, #frame, 1 do\n"
-"            if frame[i] == \"$n\" then\n"
-"                if not validate_frame(frame, full_frame, i, sid) then\n"
-"                    cancel = true\n"
-"                    break\n"
-"                end\n"
-"            end\n"
+"local is_pure_fact = function(frame, index)\n"
+"    local message_count = 0\n"
+"    for name, message in pairs(frame) do\n"
+"        if message ~= 1 and message[\"$f\"] ~= 1 then\n" 
+"           return false\n"    
 "        end\n"
+"        message_count = message_count + 1\n"   
+"    end\n"    
+"    return (message_count == index - 1)\n"
+"end\n"
+"local process_frame\n"
+"local process_event_and_frame = function(message, frame, index, use_facts)\n"
+"    local result = 0\n"
+"    local new_frame = {}\n"
+"    for name, new_message in pairs(frame) do\n"
+"        new_frame[name] = new_message\n"
 "    end\n"
-"    if cancel then\n"
-"        for i = 1, #frame, 1 do\n"
-"            if type(frame[i]) == \"table\" then\n"
-"                redis.call(\"hsetnx\", events_hashset, frame[i][\"id\"], cmsgpack.pack(frame[i]))\n"
-"                redis.call(\"zadd\", timers_key, max_score, \"p:\" .. cjson.encode(frame[i]))\n"
+"    if reviewers[index](message, new_frame, index) then\n"
+"        if (index == expressions_count) then\n"
+"            save_result(new_frame, index)\n"
+"            return 1\n"
+"        else\n"
+"            result = process_frame(new_frame, index + 1, use_facts)\n"
+"            if result == 0 or use_facts then\n"
+"                local frames_key\n"
+"                local primary_key = primary_frame_keys[index + 1](new_frame)\n"
+"                frames_key = keys[index + 1] .. \"!c!\" .. sid .. \"!\" .. primary_key\n"
+"                redis.call(\"rpush\", frames_key, frame_packers[index](new_frame))\n"
 "            end\n"
 "        end\n"
-"        full_frame = nil\n"
 "    end\n"
-"    return full_frame\n"
+"    return result\n"
 "end\n"
-"local load_frame_from_rule = function(rule_action_key, raw_count, sid, max_score)\n"
-"    local frames = {}\n"
-"    local packed_frames = {}\n"
-"    local unwrap = true\n"
-"    local count = 1\n"
-"    if raw_count ~= \"single\" then\n"
-"        count = tonumber(raw_count)\n"
-"        unwrap = false\n"
+"local process_frame_for_key = function(frame, index, events_key, use_facts)\n"
+"    local result = nil\n"
+"    local inverse = inverse_directory[index]\n"
+"    local messages_key = events_hashset\n"
+"    local message_cache = events_message_cache\n"
+"    local mids_cache = events_mids_cache\n"
+"    local cleanup = false\n"
+"    if use_facts then\n"
+"       messages_key = facts_hashset\n"
+"       message_cache = facts_message_cache\n"
+"       mids_cache = facts_mids_cache\n"
 "    end\n"
-"    if count == 0 then\n"
-"        local packed_frame = redis.call(\"lpop\", rule_action_key)\n"
-"        while packed_frame ~= \"0\" do\n"
-"            local frame = review_frame(cmsgpack.unpack(packed_frame), rule_action_key, sid, max_score)\n"
-"            if frame then\n"
-"                table.insert(frames, frame)\n"
-"                table.insert(packed_frames, packed_frame)\n"
+"    if inverse then\n"
+"        local new_frame = {}\n"
+"        for name, new_message in pairs(frame) do\n"
+"            new_frame[name] = new_message\n"
+"        end\n"
+"        local new_mids = get_mids(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
+"        for i = 1, #new_mids, 1 do\n"
+"            local message = get_message(new_mids[i], messages_key, message_cache)\n"
+"            if not message then\n"
+"                cleanup = true\n"
+"            elseif not reviewers[index](message, new_frame, index) then\n"
+"                local frames_key = keys[index] .. \"!i!\" .. sid .. \"!\" .. new_mids[i]\n"
+"                redis.call(\"rpush\", frames_key, frame_packers[index - 1](new_frame))\n"
+"                result = 0\n"
+"                break\n"
 "            end\n"
-"            packed_frame = redis.call(\"lpop\", rule_action_key)\n"
-"        end\n"
-"        if #packed_frames > 0 then\n"
-"            redis.call(\"lpush\", rule_action_key, 0)\n"
 "        end\n"
 "    else\n"
-"        while count > 0 do\n"
-"            local packed_frame = redis.call(\"rpop\", rule_action_key)\n"
-"            if not packed_frame then\n"
-"                break\n"
+"        local new_mids = get_mids(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
+"        for i = 1, #new_mids, 1 do\n"
+"            local message = get_message(new_mids[i], messages_key, message_cache)\n"
+"            if not message then\n"
+"                cleanup = true\n"
 "            else\n"
-"                local frame = review_frame(cmsgpack.unpack(packed_frame), rule_action_key, sid, max_score)\n"
-"                if frame then\n"
-"                    table.insert(frames, frame)\n"
-"                    table.insert(packed_frames, packed_frame)\n"
-"                    count = count - 1\n"
+"                local count = process_event_and_frame(message, frame, index, use_facts)\n"
+"                if not result then\n"
+"                    result = 0\n"
+"                end\n"
+"                result = result + count\n"
+"                if not is_pure_fact(frame, index) then\n"
+"                    break\n"
 "                end\n"
 "            end\n"
 "        end\n"
 "    end\n"
-"    for i = #packed_frames, 1, -1 do\n"
-"        redis.call(\"rpush\", rule_action_key, packed_frames[i])\n"
-"    end\n"
-"    if #packed_frames == 0 then\n"
-"        return nil, nil\n"
+"    if cleanup then\n"
+"        cleanup_mids(index, frame, events_key, messages_key, mids_cache, message_cache)\n"
 "    end\n"
-"    local last_name = string.find(rule_action_key, \"!\") - 1\n"
-"    if unwrap then\n"
-"        return string.sub(rule_action_key, 1, last_name), frames[1]\n"
+"    return result\n"
+"end\n"
+"process_frame = function(frame, index, use_facts)\n"
+"    local first_result = process_frame_for_key(frame, index, keys[index] .. \"!e!\" .. sid, false)\n"
+"    local second_result = process_frame_for_key(frame, index, keys[index] .. \"!f!\" .. sid, true)\n"
+"    if not first_result and not second_result then\n"
+"        return process_event_and_frame(nil, frame, index, use_facts)\n"
+"    elseif not first_result then\n"
+"        return second_result\n"
+"    elseif not second_result then\n"
+"        return first_result\n"
 "    else\n"
-"        return string.sub(rule_action_key, 1, last_name), frames\n"
+"        return first_result + second_result\n"
 "    end\n"
 "end\n"
-"local load_frame_from_sid = function(sid, max_score)\n"
-"    local action_list = action_key .. \"!\" .. sid\n"
-"    local rule_action_key = redis.call(\"lpop\", action_list)\n"
-"    if not rule_action_key then\n"
-"        return nil, nil\n"
+"local process_inverse_event = function(message, index, events_key, use_facts)\n"
+"    local result = 0\n"
+"    local messages_key = events_hashset\n"
+"    if use_facts then\n"
+"        messages_key = facts_hashset\n"
 "    end\n"
-"    local count = redis.call(\"lpop\", action_list)\n"
-"    local name, frame = load_frame_from_rule(rule_action_key, count, sid, max_score)\n"
-"    while not frame do\n"
-"        rule_action_key = redis.call(\"lpop\", action_list)\n"
-"        if not rule_action_key then\n"
-"            return nil, nil\n"
+"    redis.call(\"hdel\", messages_key, mid)\n"
+"    if index == 1 then\n"
+"        result = process_frame({}, 1, use_facts)\n"
+"    else\n"
+"        local frames_key = keys[index] .. \"!i!\" .. sid .. \"!\" .. mid\n"
+"        local packed_frames_len = redis.call(\"llen\", frames_key)\n"
+"        for i = 1, packed_frames_len, 1 do\n"
+"            local packed_frame = redis.call(\"rpop\", frames_key)\n"
+"            local frame = frame_unpackers[index - 1](packed_frame)\n"
+"            if frame then\n"
+"                result = result + process_frame(frame, index, use_facts)\n"
+"            end\n"     
 "        end\n"
-"        count = redis.call(\"lpop\", action_list)\n"
-"        name, frame = load_frame_from_rule(rule_action_key, count, sid, max_score)\n"
 "    end\n"
-"    redis.call(\"lpush\", action_list, count)\n"
-"    redis.call(\"lpush\", action_list, rule_action_key)\n"
-"    return name, frame\n"
+"    return result\n"
 "end\n"
-"local load_frame = function(max_score)\n"
-"    local current_action = redis.call(\"zrange\", action_key, 0, 0, \"withscores\")\n"
-"    if (#current_action == 0) or (tonumber(current_action[2]) > (max_score + 5)) then\n"
-"        return nil, nil, nil\n"
+"local process_event = function(message, index, events_key, use_facts)\n"
+"    local result = 0\n"
+"    local messages_key = events_hashset\n"
+"    if use_facts then\n"
+"        messages_key = facts_hashset\n"
 "    end\n"
-"    local sid = current_action[1]\n"
-"    local name, frame = load_frame_from_sid(sid, max_score)\n"
-"    while not frame do\n"
-"        redis.call(\"zremrangebyrank\", action_key, 0, 0)\n"
-"        current_action = redis.call(\"zrange\", action_key, 0, 0, \"withscores\")\n"
-"        if #current_action == 0 or (tonumber(current_action[2]) > (max_score + 5)) then\n"
-"            return nil, nil, nil\n"
+"    if index == 1 then\n"
+"        result = process_event_and_frame(message, {}, 1, use_facts)\n"
+"    else\n"
+"        local frames_key\n"
+"        local primary_key = primary_message_keys[index](message)\n"
+"        if primary_key then\n"
+"            frames_key = keys[index] .. \"!c!\" .. sid .. \"!\" .. primary_key\n"
+"        else\n"
+"            frames_key = keys[index] .. \"!c!\" .. sid\n"
+"        end\n"
+"        local packed_frames_len = redis.call(\"llen\", frames_key)\n"
+"        for i = 1, packed_frames_len, 1 do\n"
+"            local packed_frame = redis.call(\"rpop\", frames_key)\n"
+"            local frame = frame_unpackers[index - 1](packed_frame)\n"
+"            if frame then\n"
+"                local count = process_event_and_frame(message, frame, index, use_facts)\n"
+"                result = result + count\n"         
+"                if count == 0 or use_facts then\n"
+"                    redis.call(\"lpush\", frames_key, packed_frame)\n"
+"                else\n"
+"                    break\n" 
+"                end\n"
+"            end\n"     
 "        end\n"
-"        sid = current_action[1]\n"
-"        name, frame = load_frame_from_sid(sid, max_score)\n"
 "    end\n"
-"    return sid, name, frame\n"
-"end\n"
-"get_context = function(action_key)\n"
-"    if context_directory[action_key] then\n"
-"        return context_directory[action_key]\n"
+"    if result == 0 or use_facts then\n"
+"        save_message(index, message, events_key, messages_key)\n"
 "    end\n"
-"    local input_keys = {[action_key] = true}\n%s"
-"end\n"
-"local new_sid, action_name, frame\n"
-"if #ARGV == 3 then\n"
-"    new_sid = ARGV[3]\n"
-"    action_name, frame = load_frame_from_sid(new_sid, tonumber(ARGV[2]))\n"
-"else\n"
-"    new_sid, action_name, frame = load_frame(tonumber(ARGV[2]))\n"
+"    return result\n"
 "end\n"
-"if frame then\n"
-"    redis.call(\"zadd\", action_key, tonumber(ARGV[1]), new_sid)\n"
-"    if #ARGV == 2 then\n"
-"        local state = redis.call(\"hget\", state_key, new_sid)\n"
-"        return {new_sid, state, cjson.encode({[action_name] = frame})}\n"
-"    else\n"
-"        return {new_sid, cjson.encode({[action_name] = frame})}\n"
+"local process_key_with_span = function(message, span)\n"
+"    local index = directory[key]\n"
+"    local queue_lock = false\n"
+"    if index then\n"
+"        local last_score = redis.call(\"get\", results_key .. \"!d\")\n"
+"        if not last_score then\n"
+"            redis.call(\"set\", results_key .. \"!d\", score)\n"
+"        else\n"
+"            local new_score = last_score + span\n"
+"            if score > new_score then\n"
+"                redis.call(\"rpush\", results_key, 0)\n"
+"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
+"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, 0)\n"
+"                local span_count, span_remain = math.modf((score - new_score) / span)\n"
+"                last_score = new_score + span_count * span\n"
+"                redis.call(\"set\", results_key .. \"!d\", last_score)\n"
+"                queue_lock = true\n"
+"            end\n"    
+"        end\n"
+"        local count = 0\n"
+"        if not message then\n"
+"            if assert_fact == 0 then\n"
+"                count = process_inverse_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
+"            else\n"
+"                count = process_inverse_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
+"            end\n"
+"        else\n"
+"            if assert_fact == 0 then\n"
+"                count = process_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
+"            else\n"
+"                count = process_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
+"            end\n"
+"        end\n"
+"        if (count > 0) then\n"
+"            for i = 1, #results, 1 do\n"
+"                redis.call(\"rpush\", results_key, results[i])\n"
+"            end\n"
+"        end\n"
 "    end\n"
-"end\n",
-                name,
-                name,
-                name,
-                name,
-                name,
-                peekActionLua)  == -1) {
-        return ERR_OUT_OF_MEMORY;
-    }
-    free(peekActionLua);
-    redisAppendCommand(reContext, "SCRIPT LOAD %s", lua);
-    redisGetReply(reContext, (void**)&reply);
-    if (reply->type == REDIS_REPLY_ERROR) {
-        printf("%s\n", reply->str);
-        freeReplyObject(reply);
-        free(lua);
-        return ERR_REDIS_ERROR;
-    }
-
-    strncpy(rulesBinding->peekActionHash, reply->str, 40);
-    rulesBinding->peekActionHash[40] = '\0';
-    freeReplyObject(reply);
-    free(lua);
-
-    if (asprintf(&lua, 
-"local sid = ARGV[1]\n"
-"local assert_fact = tonumber(ARGV[2])\n"
-"local keys_count = tonumber(ARGV[3])\n"
-"local events_hashset = \"%s!e!\" .. sid\n"
-"local facts_hashset = \"%s!f!\" .. sid\n"
-"local visited_hashset = \"%s!v!\" .. sid\n"
-"local message = {}\n"
-"local primary_message_keys = {}\n"
-"local input_keys = {}\n"
-"local save_message = function(current_key, message, events_key, messages_key)\n"
-"    redis.call(\"hsetnx\", messages_key, message[\"id\"], cmsgpack.pack(message))\n"
-"    local primary_key = primary_message_keys[current_key](message)\n"
-"    redis.call(\"lpush\", events_key .. \"!m!\" .. primary_key, message[\"id\"])\n"
+"    return queue_lock\n"
+"end\n"
+"local process_key_with_cap = function(message, cap)\n"
+"    local index = directory[key]\n"
+"    local queue_lock = false\n"
+"    if index then\n"
+"        local count = 0\n"
+"        if not message then\n"
+"            if assert_fact == 0 then\n"
+"                count = process_inverse_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
+"            else\n"
+"                count = process_inverse_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
+"            end\n"
+"        else\n"
+"            if assert_fact == 0 then\n"
+"                count = process_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
+"            else\n"
+"                count = process_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
+"            end\n"
+"        end\n"
+"        if (count > 0) then\n"
+"            for i = #results, 1, -1 do\n"
+"                redis.call(\"lpush\", results_key, results[i])\n"
+"            end\n"
+"            local diff\n"
+"            local new_count, new_remain = math.modf(#results / cap)\n"
+"            local new_remain = #results %% cap\n"
+"            if new_count > 0 then\n"
+"                for i = 1, new_count, 1 do\n"
+"                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
+"                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, cap)\n"
+"                end\n"
+"            end\n"
+"            if new_remain > 0 then\n"
+"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
+"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, new_remain)\n"
+"            end\n"
+"            if new_count > 0 or new_remain > 0 then\n"
+"                queue_lock = true\n"
+"            end\n"
+"        end\n"
+"    end\n"
+"    return queue_lock\n"
 "end\n"
-"for index = 4 + keys_count, #ARGV, 3 do\n"
-"    if ARGV[index + 2] == \"1\" then\n"
-"        message[ARGV[index]] = ARGV[index + 1]\n"
-"    elseif ARGV[index + 2] == \"2\" or  ARGV[index + 2] == \"3\" then\n"
-"        message[ARGV[index]] = tonumber(ARGV[index + 1])\n"
-"    elseif ARGV[index + 2] == \"4\" then\n"
-"        if ARGV[index + 1] == \"true\" then\n"
-"            message[ARGV[index]] = true\n"
+"local process_key_with_window = function(message, window)\n"
+"    local index = directory[key]\n"
+"    local queue_lock = false\n"
+"    if index then\n"
+"        local count = 0\n"
+"        if not message then\n"
+"            if assert_fact == 0 then\n"
+"                count = process_inverse_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
+"            else\n"
+"                count = process_inverse_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
+"            end\n"
 "        else\n"
-"            message[ARGV[index]] = false\n"
+"            if assert_fact == 0 then\n"
+"                count = process_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
+"            else\n"
+"                count = process_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
+"            end\n"
+"        end\n"
+"        if (count > 0) then\n"
+"            for i = #results, 1, -1 do\n"
+"                redis.call(\"lpush\", results_key, results[i])\n"
+"            end\n"
+"            local diff\n"
+"            local length = redis.call(\"llen\", results_key)\n"
+"            local prev_count, prev_remain = math.modf((length - count) / window)\n"
+"            local new_count, prev_remain = math.modf(length / window)\n"
+"            diff = new_count - prev_count\n"
+"            if diff > 0 then\n"
+"                for i = 0, diff - 1, 1 do\n"
+"                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
+"                    if window == 1 then\n"
+"                        redis.call(\"rpush\", actions_key .. \"!\" .. sid, \"single\")\n"
+"                    else\n"
+"                        redis.call(\"rpush\", actions_key .. \"!\" .. sid, window)\n"
+"                    end\n"
+"                end\n"
+"                queue_lock = true\n"
+"             end\n"
 "        end\n"
 "    end\n"
+"    return queue_lock\n"
 "end\n"
-"local mid = message[\"id\"]\n"
-"if redis.call(\"hsetnx\", visited_hashset, message[\"id\"], 1) == 0 then\n"
+"local message = nil\n"
+"if #ARGV > (6 + keys_count) then\n"
+"    message = {}\n"
+"    for index = 6 + keys_count, #ARGV, 3 do\n"
+"        if ARGV[index + 2] == \"1\" then\n"
+"            message[ARGV[index]] = ARGV[index + 1]\n"
+"        elseif ARGV[index + 2] == \"2\" or  ARGV[index + 2] == \"3\" then\n"
+"            message[ARGV[index]] = tonumber(ARGV[index + 1])\n"
+"        elseif ARGV[index + 2] == \"4\" then\n"
+"            if ARGV[index + 1] == \"true\" then\n"
+"                message[ARGV[index]] = true\n"
+"            else\n"
+"                message[ARGV[index]] = false\n"
+"            end\n"
+"        end\n"
+"    end\n"
+"    if assert_fact == 1 then\n"
+"        message[\"$f\"] = 1\n"
+"    end\n"
+"end\n"
+"if redis.call(\"hsetnx\", visited_hashset, mid, 1) == 0 then\n"
 "    if assert_fact == 0 then\n"
-"        if not redis.call(\"hget\", events_hashset, mid) then\n"
+"        if message and redis.call(\"hexists\", events_hashset, mid) == 0 then\n"
 "            return false\n"
 "        end\n"
 "    else\n"
-"        if not redis.call(\"hget\", facts_hashset, mid) then\n"
+"        if message and redis.call(\"hexists\", facts_hashset, mid) == 0 then\n"
 "            return false\n"
 "        end\n"
 "    end\n"
 "end\n"
-"for index = 4, 3 + keys_count, 1 do\n"
+"for index = 6, 5 + keys_count, 1 do\n"
 "    input_keys[ARGV[index]] = true\n"
 "end\n"
-"%sif assert_fact == 1 then\n"
-"    message[\"$f\"] = 1\n"
-"    for index = 4, 3 + keys_count, 1 do\n"
-"        local key = ARGV[index]\n"
-"        save_message(key, message, key .. \"!f!\" .. sid, facts_hashset)\n"
+"%sfor index = 6, 5 + keys_count, 1 do\n"
+"    results = {}\n"
+"    unpacked_results = {}\n"
+"    key = ARGV[index]\n"
+"    context = context_directory[key]\n"
+"    keys = context[\"keys\"]\n"
+"    reviewers = context[\"reviewers\"]\n"
+"    frame_packers = context[\"frame_packers\"]\n"
+"    frame_unpackers = context[\"frame_unpackers\"]\n"
+"    primary_message_keys = context[\"primary_message_keys\"]\n"
+"    primary_frame_keys = context[\"primary_frame_keys\"]\n"
+"    directory = context[\"directory\"]\n"
+"    results_key = context[\"results_key\"]\n"
+"    inverse_directory = context[\"inverse_directory\"]\n"
+"    expressions_count = context[\"expressions_count\"]\n"
+"    local process_key = context[\"process_key\"]\n"
+"    local process_key_count = context[\"process_key_count\"]\n"
+"    queue_action = process_key(message, process_key_count)\n"
+"    if assert_fact == 0 and events_message_cache[tostring(message[\"id\"])] == false then\n"
+"        break\n"
 "    end\n"
-"else\n"
-"    for index = 4, 3 + keys_count, 1 do\n"
-"        local key = ARGV[index]\n"
-"        save_message(key, message, key .. \"!e!\" .. sid, events_hashset)\n"
+"end\n"
+"if queue_action then\n"
+"    if not redis.call(\"zscore\", actions_key, sid) then\n"
+"        redis.call(\"zadd\", actions_key , score, sid)\n"
 "    end\n"
-"end\n",
-                name,
-                name,
-                name, 
-                addMessageLua)  == -1) {
+"end\n"
+"return nil\n",
+                 name,
+                 name,
+                 name,
+                 name,
+                 name,
+                 lua)  == -1) {
         return ERR_OUT_OF_MEMORY;
     }
 
-    free(addMessageLua);
+    free(oldLua);
     redisAppendCommand(reContext, "SCRIPT LOAD %s", lua);
     redisGetReply(reContext, (void**)&reply);
     if (reply->type == REDIS_REPLY_ERROR) {
@@ -1883,10 +2042,112 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
         return ERR_REDIS_ERROR;
     }
 
-    strncpy(rulesBinding->addMessageHash, reply->str, 40);
-    rulesBinding->addMessageHash[40] = '\0';
+    strncpy(rulesBinding->evalMessageHash, reply->str, 40);
+    rulesBinding->evalMessageHash[40] = '\0';
     freeReplyObject(reply);
     free(lua);
+    return RULES_OK;
+}
+
+static unsigned int setNames(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
+    int nameLength = strlen(name);
+    char *sessionHashset = malloc((nameLength + 3) * sizeof(char));
+    if (!sessionHashset) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    strncpy(sessionHashset, name, nameLength);
+    sessionHashset[nameLength] = '!';
+    sessionHashset[nameLength + 1] = 's';
+    sessionHashset[nameLength + 2] = '\0';
+    rulesBinding->sessionHashset = sessionHashset;
+
+    char *factsHashset = malloc((nameLength + 3) * sizeof(char));
+    if (!factsHashset) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    strncpy(factsHashset, name, nameLength);
+    factsHashset[nameLength] = '!';
+    factsHashset[nameLength + 1] = 'f';
+    factsHashset[nameLength + 2] = '\0';
+    rulesBinding->factsHashset = factsHashset;
+
+    char *eventsHashset = malloc((nameLength + 3) * sizeof(char));
+    if (!eventsHashset) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    strncpy(eventsHashset, name, nameLength);
+    eventsHashset[nameLength] = '!';
+    eventsHashset[nameLength + 1] = 'e';
+    eventsHashset[nameLength + 2] = '\0';
+    rulesBinding->eventsHashset = eventsHashset;
+
+    char *timersSortedset = malloc((nameLength + 3) * sizeof(char));
+    if (!timersSortedset) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    strncpy(timersSortedset, name, nameLength);
+    timersSortedset[nameLength] = '!';
+    timersSortedset[nameLength + 1] = 't';
+    timersSortedset[nameLength + 2] = '\0';
+    rulesBinding->timersSortedset = timersSortedset;
+    return RULES_OK;
+}
+
+static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
+    unsigned int result = loadPartitionCommand(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    // client queues have no commands to load, 
+    if (!tree->stringPool) {
+        return RULES_OK;
+    }
+
+    result = loadTimerCommand(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = loadEvalMessageCommand(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = loadAddMessageCommand(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }    
+
+    result = loadPeekActionCommand(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = loadUpdateActionCommand(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = loadRemoveActionCommand(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = loadDeleteSessionCommand(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = setNames(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
 
     return RULES_OK;
 }
@@ -2719,6 +2980,34 @@ unsigned int getSession(void *rulesBinding, char *sid, char **state) {
     return REDIS_OK;
 }
 
+unsigned int deleteSession(void *rulesBinding, char *sid) {
+    binding *currentBinding = (binding*)rulesBinding;
+    redisContext *reContext = currentBinding->reContext; 
+
+    int result = redisAppendCommand(reContext, 
+                                    "evalsha %s 0 %s", 
+                                    currentBinding->deleteSessionHash,
+                                    sid); 
+    if (result != REDIS_OK) {
+        return ERR_REDIS_ERROR;
+    }
+    
+    redisReply *reply;
+    result = tryGetReply(reContext, &reply);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    if (reply->type == REDIS_REPLY_ERROR) {
+        printf("deleteSession err string %s\n", reply->str);
+        freeReplyObject(reply);
+        return ERR_REDIS_ERROR;
+    }
+
+    freeReplyObject(reply);  
+    return REDIS_OK;
+}
+
 unsigned int updateAction(void *rulesBinding, char *sid) {
     binding *currentBinding = (binding*)rulesBinding;
     redisContext *reContext = currentBinding->reContext;