AOP/Injectable Proto

    CLASS Dispatcher EXTENDS StaticObject
    {
        protected static function prototypeRun($request, $options)
        {
            $class  = get_called_class();
            $params = compact('request', 'options');
            $router = 'bla\blaz\Router';
            $result = $router.'::process('.$request.')';

            //if (($result = $router::process($request)) instanceof Response)
                return $result;

            $params = $class::applyRules($result->params);

            if(!$params)
                throw new DispatchException('Could not route request.');

            $callable = $class::ctrl($result, $params, $options);
            return $class::dispatch($callable, $result, $params);
        }

        public static function run($request, array $options = array())
        {
            //$params = compact('request', 'options');
            return static::prototype(__FUNCTION__, get_defined_vars());
        }

        protected static function prototypeCtrl($request, $params, $options)
        {
            var_dump('_CALLABLE: void');
            var_dump(func_get_args());
        }

        protected static function ctrl($request, $params, $options)
        {
            return static::prototype(__FUNCTION__, get_defined_vars());
        }

        protected static function prototypeDispatch($callable, $request, $params)
        {
            if(is_callable($callable))
                return $callable($request, $params);

            var_dump('_CALL');
            var_dump(func_get_args());

            return 'lala';
        }

        protected static function dispatch($callable, $request, $params)
        {
            return static::prototype(__FUNCTION__, get_defined_vars());
        }
    }

    CLASS StaticObject
    {
        public static function prototype($__function, array $__parameters = [])
        {
            $__class = get_called_class();

            if(isset($__parameters['this']))
                unset($__parameters['this']);

            if(TRUE === static::Core_StaticObject_tAdapter_exists($__function))
                return static::Core_StaticObject_tAdapter_emit($__function, $__parameters);

            $__parameters = static::Core_StaticObject_tFilter_emit($__function, 'PARAMS', $__parameters, ['return' => $__parameters]);

            static::Core_StaticObject_tSignal_emit($__function, 'PRE_EVENT', [$__parameters], ['return' => $__parameters]);

            $__result = static::Core_StaticObject_tMethodFacade_emit($__function, $__parameters, function(array $__params, Filter $__chain) use ($__class, $__function)
            {
                $result = NULL;

                if(TRUE === static::Core_StaticObject_tMethod_exists($__function))
                {
                    $result = static::Core_StaticObject_tMethod_emit($__function, $__params);
                }
                else
                if(TRUE === static::Core_StaticObject_tMethodProto_exists($__function))
                {
                    $result = static::Core_StaticObject_tMethodProto_emit($__function, $params);
                }
                else
                {
                    $proto = 'prototype'.$__function;

                    if($proto === $__function)
                    {
                    }
                    else
                    if(method_exists($__class, $proto))
                    {
                        $result = static::Core_StaticObject_tInvoke_method('prototype'.$__function, $__params);
                    }
                }

                return $result;
            });

            $__result = static::Core_StaticObject_tFilter_emit($__function, 'RETURN', $__result, ['return' => $__result]);

            static::Core_StaticObject_tObserver_emit($__function, [$__result, $__parameters]);
            static::Core_StaticObject_tSignal_emit($__function, 'POST_EVENT',  [$__result, $__parameters], ['return' => $__result]);

            return $__result;
        }

    ...