A package for communications between packages - v2 This is basically the registry pattern and a pub/sub event system.

Very simple and minimalist.  Looking for general feedback.

/***************************************************************************************************
**COMMS
 - provides registry and event system
 - reduces dependencies
***************************************************************************************************/

// self used to hold client or server side global
(function (self) {

    "use strict";

    // holds (Pub)lic properties
    var Pub = {},

        // holds (Priv)ate properties
        Priv = {},

        // holds "imported" library properties
        $A;

    (function manageGlobal() {

        // Priv.g holds the single global variable, used to hold all packages
        Priv.g = '$A';

        if (self[Priv.g] &amp;&amp; self[Priv.g].pack &amp;&amp; self[Priv.g].pack.utility) {
            self[Priv.g].pack.comms = true;
            $A = self[Priv.g];
        } else {
            throw new Error("comms requires utility module");
        }
    }());

    Pub.Reg = (function () {
        var publik = {},
            register = {};
        publik.get = function (key) {
            return register[key];
        };
        publik.set = function (key, value) {
            register[key] = value;
        };
        publik.setMany = function (o) {
            $A.someKey(o, function (val, key) {
                register[key] = val;
            });
        };
        publik.getMany = function () {
            return register;
        };
        return publik;
    }());

    Pub.Event = (function () {
        var publik = {},
            events = {};
        publik.add = function (name, callback) {
            if (!events[name]) {
                events[name] = [];
            }
            events[name].push(callback);
        };
        publik.remove = function (name, callback) {
            if (name &amp;&amp; callback) {
                delete events[name][callback];
            } else if (name) {
                delete events[name];
            }
        };
        publik.trigger = function (name) {
            if (events[name]) {
                $A.someIndex(events[name], function (val) {
                    val();
                });
            }
        };
        return publik;
    }());
    self[Priv.g] = $A.extendSafe(self[Priv.g], Pub);
}(this));
It looks good overall IMO. I won't comment on the bootstrap code as I'm not familiar with your library, but I would change a few things. Inside the closures that you create you could simply return the public object, without defining publik, it looks a bit cleaner. Then I added some annotation and changed the control flow a bit: 

Pub.Reg = (function() {
  var register = {};
  return {
    get: function(key) {
      return register[key];
    },
    set: function(key, value) {
      register[key] = value;
    },
    setMany: function(o) {
      $A.someKey(o, function (val, key) {
        register[key] = val;
      });
    },
    getMany: function() {
      return register;
    }
  };
}());

Pub.Event = (function() {
  var events = {};
  return {
    add: function(name, callback) {
      // A bit more concise
      (events[name] = events[name]||[]).push(callback);
    },
    remove: function(name, callback) {
      // It's faster to set the value to `null`
      // than using the `delete` operator
      // but this depends on your use case;
      // the properties would still show up
      // in a `for..in` loop, but it's fine
      // if you use it merely as a dictionary
      if (!callback) {
        events[name] = null;
        return;
      }
      events[name][callback] = null;
    },
    trigger: function(name) {
      if (events[name]) {
        $A.someIndex(events[name], function (val) {
          val();
        });
      }
    }
  };
}());