diff --git a/src/gallery-dispatcher/README b/src/gallery-dispatcher/README
index a05bc92ace..1c4cdb4b1c 100644
--- a/src/gallery-dispatcher/README
+++ b/src/gallery-dispatcher/README
@@ -5,6 +5,11 @@ Dispatcher
     More info at http://yuilibrary.com/gallery/show/dispatcher
 
 HEAD
+    * Tested on YUI 3.3.0
+    * Fixing the inline script tag execution on FF4:
+      http://yuilibrary.com/forum/viewtopic.php?f=134&t=7529
+
+2011.03.02-20-58
     * Internal refactor to provide access to some of the process during the 
       dispatcher phase through protected methods: _executeScript, _getScript, 
       _setContent, _purgeContent. More info about this here:
diff --git a/src/gallery-dispatcher/js/gallery-dispatcher.js b/src/gallery-dispatcher/js/gallery-dispatcher.js
index 3cd0132969..335e6485af 100644
--- a/src/gallery-dispatcher/js/gallery-dispatcher.js
+++ b/src/gallery-dispatcher/js/gallery-dispatcher.js
@@ -172,10 +172,11 @@ Y.Dispatcher = Y.Base.create(DISPATCHER, Y.Base, [], {
      * @param {Node} n A reference to the original SCRIPT tag Node, in case you want to get more specific attributes
      */
     _executeScript: function (text, jsNode) {
-        var d = ( jsNode ? jsNode.get('ownerDocument') : null ) || Y.one('doc'),
+        var doc = Y.config.doc,
+            d = ( jsNode ? jsNode.get('ownerDocument') : null ) || doc,
             h = d.one('head') || d.get('documentElement'),
             // creating a new script node to execute the inline javascrip code
-            newScript = Y.Node.create('<' + SC + '></' + SC + '>');
+            newScript = Y.one(doc.createElement(SC));
 
         Y.log('inline script tag: ' + text, 'info', DISPATCHER);
         if (text) {
@@ -271,6 +272,15 @@ Y.Dispatcher = Y.Base.create(DISPATCHER, Y.Base, [], {
             q.add({
                 fn: function() {
                     instance._purgeContent();
+                    /**
+                     * Notification event right after purging all the event listeners associated to the 
+                     * Node that will be updated to avoid memory leaks. At this point, you can also destroy
+                     * any object associated to that content. Immidiately after this, the new content will be
+                     * injected. Use this event to clean up the mess before injecting new content.
+                     *
+                     * @event purge
+                     * @param n {Node} a reference to the Node that was updated.
+                     */
                     instance.fire(DISPATCHER_PURGE, n);
                 }
             });
@@ -279,6 +289,15 @@ Y.Dispatcher = Y.Base.create(DISPATCHER, Y.Base, [], {
         q.add({
             fn: function() {
                 instance._setContent(o.content);
+                /**
+                 * Notification event right before starting the execution of the script tags associated
+                 * to the current content. At this point, the content (without script tags) was already
+                 * injected within the node, so, you can enhance that content right before process to the
+                 * execution process.
+                 *
+                 * @event beforeExecute
+                 * @param n {Node} a reference to the Node that was updated.
+                 */
                 instance.fire(DISPATCHER_BEFOREEXECUTE, n);
             }
         });
@@ -297,7 +316,14 @@ Y.Dispatcher = Y.Base.create(DISPATCHER, Y.Base, [], {
         });
         q.add({
             fn: function() {
-                instance.fire(DISPATCHER_READY);
+                /**
+                 * Notification event when the new content gets injected and scripts loaded and executed
+                 * as well. This is the event that you should listen for to continue your programm after 
+                 * dispatcher finishes the whole process.
+                 *
+                 * @event ready
+                 */
+                 instance.fire(DISPATCHER_READY);
             }
         });
         // executing the queue
@@ -344,6 +370,14 @@ Y.Dispatcher = Y.Base.create(DISPATCHER, Y.Base, [], {
             failure: function(tid, o) {
                 Y.log('Failure: ' + uri, 'warn', DISPATCHER);
                 _propagateIOEvent ('failure', defIOConfig, arguments);
+                /**
+                 * Notification event when dispatcher fails to load the new url
+                 * using io, or fails to load an external script using Y.Get.script.
+                 * Use this event to fallback if an error occur.
+                 *
+                 * @event error
+                 * @param o {object} error object from IO or Get.
+                 */
                 instance.fire(DISPATCHER_ERROR, o);
             },
             end: function() {
@@ -461,9 +495,25 @@ Y.Dispatcher = Y.Base.create(DISPATCHER, Y.Base, [], {
                 var instance = this;
                 Y.log('setting status to ' + v, 'info', DISPATCHER);
                 if (v) {
+                    /**
+                     * Notification event when dispatcher starts the loading process
+                     * using io. Equivalent to Y.on('io:start'). Right before this event, dispatcher 
+                     * adds the loading class from the node. This event will be triggered before the 
+                     * function defined under attribute "ioConfig.start". 
+                     *
+                     * @event fetch
+                     */
                     instance.fire(DISPATCHER_FETCH);
                     instance.get(ATTR_NODE).addClass(CLASS_DISPATCHER_LOADING);
                 } else {
+                    /**
+                     * Notification event when dispatcher finishes the loading process
+                     * using io. Equivalent to Y.on('io:end'). Right after this event, dispatcher 
+                     * removes the loading class from the node.This event will be triggered before the 
+                     * function defined under attribute "ioConfig.end".
+                     *
+                     * @event load
+                     */
                     instance.fire(DISPATCHER_LOAD);
                     instance.get(ATTR_NODE).removeClass(CLASS_DISPATCHER_LOADING);
                 }
diff --git a/src/gallery-dispatcher/tests/dispatcher.html b/src/gallery-dispatcher/tests/dispatcher.html
index 4f1df5311b..ba5b409e8e 100644
--- a/src/gallery-dispatcher/tests/dispatcher.html
+++ b/src/gallery-dispatcher/tests/dispatcher.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <title>Dispatcher Tests</title>
-<script type="text/javascript" src="http://yui.yahooapis.com/3.2.0/build/yui/yui-min.js"></script>
+<script type="text/javascript" src="http://yui.yahooapis.com/3.3.0/build/yui/yui-debug.js"></script>
 </head>
 <body class="yui3-skin-sam">
 
@@ -11,225 +11,287 @@ <h1>Dispatcher Tests</h1>
       <p>Placeholder for dispatcher tests</p>
     </div>
 
-<script type="text/javascript" src="../../../build/gallery-dispatcher/gallery-dispatcher-min.js"></script>
+<script type="text/javascript" src="../../../build/gallery-dispatcher/gallery-dispatcher-debug.js"></script>
 <script type="text/javascript">
 YUI({
+    filter: 'debug',
     useConsoleOutput: true,
     logInclude: { TestRunner: true }
 }).use('test', 'console', 'gallery-dispatcher', function (Y) {
 
-  (new Y.Console({
-      verbose: true,
-      newestOnTop: false,
-      height: '500px',
-      width: '99%',
-      style: 'block'
-  })).render();
-  
-  Y.namespace("Tests");
-
-  Y.Tests.Dispatcher = (function() {
-
-      var Assert = Y.Assert,
-          ObjectAssert = Y.ObjectAssert;
-
-      //-------------------------------------------------------------------------
-      // Base Test Suite
-      //-------------------------------------------------------------------------
-      var suite = new Y.Test.Suite("Dispatcher Tests");
-
-      //-------------------------------------------------------------------------
-      // Test Case for encoding
-      //-------------------------------------------------------------------------
-      inlinecounter = 0;
-      
-      suite.add(new Y.Test.Case({
-
-          name: "Dispatcher Inline Tests",
-
-          //---------------------------------------------
-          // Setup and tear down
-          //---------------------------------------------
-          setUp: function() {
-              // global variable
-              this.disp = new Y.Dispatcher({
-                  node: '#demo'
-              });
-              Y.one('#demo').set('innerHTML', 'placeholder');
-              Y.one('body').set('overflow', 'visible');
-          },
-
-          tearDown: function() {
-          },
-
-          //---------------------------------------------------------------------
-          // Tests
-          //---------------------------------------------------------------------
-
-          testBasicHtmlContent: function() {
-              var newcontent = "simple content";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  var result = Y.one('#demo').get('innerHTML');
-                  Assert.areEqual(newcontent, result, 'The new content was not properly injected.');
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('content', newcontent);
-              this.wait();
-          },
-
-          testInlineScript: function() {
-              var newcontent = "<p>simple content</p><script>window.flag = true;<\/script>";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  Assert.isTrue(flag, 'The script was not executed.');
-                  var result = Y.one('#demo p').get('innerHTML');
-                  Assert.areEqual('simple content', result, 'The script tag was not removed from the original content');
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('content', newcontent);
-              this.wait();
-          },
-
-          testInlineScriptGlobalVar: function() {
-              var newcontent = "<p>simple content</p><script>var data = 1;<\/script>";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  Assert.areEqual(1, data, 'The script fails for a global variable called DATA.');
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('content', newcontent);
-              this.wait();
-          },
-
-          testInlineScriptAssumingGlobal: function() {
-              var newcontent = "<p>simple content</p><script>data = 2;<\/script>";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  Assert.areEqual(2, data, 'The script fails while assuming a global variable called DATA.');
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('content', newcontent);
-              this.wait();
-          },
-
-          testInlineScriptCounter: function() {
-              var newcontent = "<p>simple content</p><script>inlinecounter++;<\/script>";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  Assert.areEqual(1, inlinecounter, 'The script was executed more than one time.');
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('content', newcontent);
-              this.wait();
-          },    
-
-          testInlineCSSOnHeader: function() {
-              var newcontent = "<html><head><style>body{overflow: hidden;}<\/style><\/head><body><p>simple content<\/p><\/body><\/html>";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  var result = Y.one('body').getStyle('overflow');
-                  Assert.areEqual('hidden', result, 'The script was executed more than one time.');
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('normalize', true).set('content', newcontent);
-              this.wait();
-          },
-
-          testInlineScriptOnHeader: function() {
-              var newcontent = "<html><head><script>data = 3;<\/script><\/head><body><p>simple content<\/p><\/body><\/html>";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  Assert.areEqual(3, data, 'The script was executed more than one time.');
-                  var result = Y.one('#demo > p').get('innerHTML');
-                  Assert.areEqual('simple content', result, 'The html, body and head tags were not removed from the original content');
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('normalize', true).set('content', newcontent);
-              this.wait();
-          }
-
-      }));
-
-      counter = 0;
-
-      suite.add(new Y.Test.Case({
-
-          name: "Dispatcher External Tests",
-
-          //---------------------------------------------
-          // Setup and tear down
-          //---------------------------------------------
-          setUp: function() {
-              // global variable
-              this.disp = new Y.Dispatcher({
-                  node: '#demo'
-              });
-              Y.one('#demo').set('innerHTML', 'placeholder');
-          },
-
-          tearDown: function() {
-          },
-
-          //---------------------------------------------------------------------
-          // Tests
-          //---------------------------------------------------------------------
-          testExternalScript: function() {
-              var newcontent = "<p>simple content</p><script src='external.js'><\/script>";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  Assert.isTrue(flag, 'The script was not executed.');
-                  var result = Y.one('#demo p').get('innerHTML');
-                  Assert.areEqual('simple content', result);
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('content', newcontent);
-              this.wait();
-          },
-
-          testExternalScriptCache: function() {
-              var newcontent = "<p>simple content</p><script src='external.js'><\/script>";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  Assert.isTrue(flag, 'The script was not executed twice, dispatcher is caching it.');
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('content', newcontent);
-              this.wait();
-          },
-
-          testExternalScriptGlobalVar: function() {
-              var newcontent = "<p>simple content</p><script src='external.js'><\/script>";
-              // dispatcher uses a queue, it will take a while to inject the content
-              this.disp.on('ready', function() {
-                  this.resume();
-                  Assert.areEqual(3, data, 'The script fails for a global variable called DATA.');
-              }, this);
-              // using the dispatcher object to set a new content
-              this.disp.set('content', newcontent);
-              this.wait();
-          }
-
-      }));
-
-      //return it
-      return suite;
-
-  })();
-
-  //add to the testrunner and run
-  Y.Test.Runner.add(Y.Tests.Dispatcher);
-  Y.Test.Runner.run();
-  
+    (new Y.Console({
+        verbose: true,
+        newestOnTop: false,
+        height: '500px',
+        width: '99%',
+        style: 'block'
+    })).render();
+
+    Y.namespace("Tests");
+
+    Y.Tests.Dispatcher = (function() {
+
+        var Assert = Y.Assert,
+        ObjectAssert = Y.ObjectAssert;
+
+        //-------------------------------------------------------------------------
+        // Base Test Suite
+        //-------------------------------------------------------------------------
+        var suite = new Y.Test.Suite("Dispatcher Tests");
+
+        //-------------------------------------------------------------------------
+        // Test Case for encoding
+        //-------------------------------------------------------------------------
+        inlinecounter = 0;
+
+        suite.add(new Y.Test.Case({
+
+            name: "Dispatcher Inline Tests",
+
+            //---------------------------------------------
+            // Setup and tear down
+            //---------------------------------------------
+            setUp: function() {
+                // global variable
+                this.disp = new Y.Dispatcher({
+                    node: '#demo'
+                });
+                Y.one('#demo').set('innerHTML', 'placeholder');
+                Y.one('body').set('overflow', 'visible');
+            },
+
+            tearDown: function() {
+            },
+
+            //---------------------------------------------------------------------
+            // Tests
+            //---------------------------------------------------------------------
+            testBasicHtmlContent: function() {
+                var newcontent = "simple content",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        var result = Y.one('#demo').get('innerHTML');
+                        Assert.areEqual(newcontent, result, 'The new content was not properly injected.');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('content', newcontent);
+                instance.wait();
+            },
+
+            testInlineScript: function() {
+                var newcontent = "<p>simple content</p><script>window.flag = true;<\/script>",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        Assert.isTrue(flag, 'The script was not executed.');
+                        var result = Y.one('#demo p').get('innerHTML');
+                        Assert.areEqual('simple content', result, 'The script tag was not removed from the original content');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('content', newcontent);
+                instance.wait();
+            },
+
+            testInlineScriptGlobalVar: function() {
+                var newcontent = "<p>simple content</p><script>var data = 1;<\/script>",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        Assert.areEqual(1, data, 'The script fails for a global variable called DATA.');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('content', newcontent);
+                instance.wait();
+            },
+
+            testInlineScriptAssumingGlobal: function() {
+                var newcontent = "<p>simple content</p><script>data = 2;<\/script>",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        Assert.areEqual(2, data, 'The script fails while assuming a global variable called DATA.');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('content', newcontent);
+                instance.wait();
+            },
+
+            testInlineScriptCounter: function() {
+                var newcontent = "<p>simple content</p><script>inlinecounter++;<\/script>",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        Assert.areEqual(1, inlinecounter, 'The script was executed more than one time.');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('content', newcontent);
+                instance.wait();
+            },
+
+            testInlineCSSOnHeader: function() {
+                var newcontent = "<html><head><style>body{overflow: hidden;}<\/style><\/head><body><p>simple content<\/p><\/body><\/html>",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        var result = Y.one('body').getStyle('overflow');
+                        Assert.areEqual('hidden', result, 'The script was executed more than one time.');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('normalize', true).set('content', newcontent);
+                instance.wait();
+            },
+
+            testInlineScriptOnHeader: function() {
+                var newcontent = "<html><head><script>data = 3;<\/script><\/head><body><p>simple content<\/p><\/body><\/html>",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        Assert.areEqual(3, data, 'The script was executed more than one time.');
+                        var result = Y.one('#demo > p').get('innerHTML');
+                        Assert.areEqual('simple content', result, 'The html, body and head tags were not removed from the original content');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('normalize', true).set('content', newcontent);
+                instance.wait();
+            },
+
+            "test injecting empty content": function() {
+                var newcontent = "",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        var result = Y.one('#demo').get('innerHTML');
+                        Assert.areEqual('', result, 'Empty content is not being injected correctly.');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp._dispatch(newcontent);
+                instance.wait();
+            },
+
+            "test injecting the same content twice": function() {
+                var newcontent = "same content twice",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        var result = Y.one('#demo').get('innerHTML');
+                        Assert.areEqual(newcontent, result, 'Injecting the same content twice should do the exact same.');
+                    });
+                });
+                // injecting the same content again manually
+                instance.disp._dispatch(newcontent);
+                instance.wait();
+            }
+
+        }));
+
+        counter = 0;
+
+        suite.add(new Y.Test.Case({
+
+            name: "Dispatcher External Tests",
+
+            //---------------------------------------------
+            // Setup and tear down
+            //---------------------------------------------
+            setUp: function() {
+                // global variable
+                this.disp = new Y.Dispatcher({
+                    node: '#demo'
+                });
+                Y.one('#demo').set('innerHTML', 'placeholder');
+            },
+
+            tearDown: function() {
+                },
+
+            //---------------------------------------------------------------------
+            // Tests
+            //---------------------------------------------------------------------
+            testExternalScript: function() {
+                var newcontent = "<p>simple content</p><script src='external.js'><\/script>",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        Assert.isTrue(flag, 'The script was not executed.');
+                        var result = Y.one('#demo p').get('innerHTML');
+                        Assert.areEqual('simple content', result);
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('content', newcontent);
+                instance.wait();
+            },
+
+            testExternalScriptCache: function() {
+                var newcontent = "<p>simple content</p><script src='external.js'><\/script>",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        Assert.isTrue(flag, 'The script was not executed twice, dispatcher is caching it.');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('content', newcontent);
+                instance.wait();
+            },
+
+            testExternalScriptGlobalVar: function() {
+                var newcontent = "<p>simple content</p><script src='external.js'><\/script>",
+                    instance = this;
+                // dispatcher uses a queue, it will take a while to inject the content
+                instance.disp.on('ready', function() {
+                    instance.resume(function() {
+                        // resuming the test
+                        Assert.areEqual(3, data, 'The script fails for a global variable called DATA.');
+                    });
+                });
+                // using the dispatcher object to set a new content
+                instance.disp.set('content', newcontent);
+                instance.wait();
+            }
+
+        }));
+
+        //return it
+        return suite;
+
+    })();
+
+    //add to the testrunner and run
+    Y.Test.Runner.add(Y.Tests.Dispatcher);
+    Y.Test.Runner.run();
+
 });
 </script>
 </body>