theprogrammablemind 7.1.4-beta.3

package/src/config.js

@@ -0,0 +1,2129 @@
+// lookup = (name) => returns <config>
+const { Semantics, normalizeGenerator } = require('./semantics')
+const { Generators } = require('./generators')
+// const { uuid: uuidv4 } = require('uuidv4')
+const client = require('../client')
+const Digraph = require('./digraph')
+const helpers = require('./helpers')
+const deepEqual = require('deep-equal')
+const _ = require('lodash')
+
+const debugBreak = () => {
+  // debugger
+}
+
+const bags = [
+  'generators',
+  'semantics'
+]
+
+const indent = (string, indent) => {
+    return string.replace(/^/gm, ' '.repeat(indent));
+}
+
+if (process.env.DEBUG_HIERARCHY) {
+  global.entodictonDebugHierarchy = JSON.parse(process.env.DEBUG_HIERARCHY)
+}
+
+if (process.env.DEBUG_BRIDGE) {
+  // id/level
+  global.entodictonDebugBridge = process.env.DEBUG_BRIDGE.split('/')
+  if (global.entodictonDebugBridge.length !== 2) {
+    console.log('Expected DEBUG_BRIDGE to be of the form "id/level"');
+  }
+  global.entodictonDebugBridge[1] = int(global.entodictonDebugBridge[1])
+}
+
+const hierarchyCanonical = (element) => {
+    if (element.child && element.parent) {
+      return element
+    } else {
+      return { child: element[0], parent: element[1] }
+    }
+  }
+
+const isValidDef = (word, def, config) => {
+  if (!def.id) {
+    throw `In the KM "${config.name}", for the word ${word} the following definition is missing the "id" property: ${JSON.stringify(def)}`
+  }
+  /*
+  if (!def.initial) {
+    throw `In the KM "${config.name}", for the word ${word} the following definition is missing the "initial" property: ${JSON.stringify(def)}`
+  }
+  */
+}
+
+const hierarchyToCanonical = (edge) => {
+  if (Array.isArray(edge)) {
+    return { child: edge[0], parent: edge[1] }
+  }
+  return edge
+}
+
+const addWord = (baseConfig, config) => ({ word, id, initial }) => {
+  if (!baseConfig.config.words) {
+    baseConfig.config.words = {}
+  }
+  const words = baseConfig.config.words
+  const def = { id, initial, uuid: config.uuid }
+  if (words[word]) {
+    if (!words[word].some((e) => helpers.safeEquals(e, def))) {
+      words[word].unshift(def)
+    }
+  } else {
+    words[word] = [def]
+  }
+}
+
+const normalizeConfig = (config) => {
+  if (config) {
+    for (const bag of bags) {
+      if (config[bag]) {
+        config[bag] = config[bag].map(normalizeGenerator)
+        for (let i = 0; i < config[bag].length; ++i) {
+          config[bag][i].index = i
+          config[bag][i].km = config.name
+        }
+      }
+    }
+  }
+}
+
+/*
+function isLetter (char) {
+  return (/[a-zA-Z]/).test(char)
+}
+*/
+
+function configDup (config, options) {
+  if (config instanceof Config) {
+    return config.copy(options)
+  }
+  return _.cloneDeep(config)
+}
+
+function setWordsUUIDs (words, uuid) {
+  for (const key in words) {
+    words[key] = words[key].map((o) => Object.assign(o, { uuid }))
+  }
+}
+
+function applyUUID (config, uuid) {
+  if (config instanceof Config) {
+    config = config.config
+  }
+
+  if (config.namespaces) {
+    const keys = Object.keys(config.namespaces)
+    if (keys.length > 1) {
+      debugBreak()
+      // throw 'wtf 23'
+    }
+    if (config.namespaces[keys[0]]) {
+      config.namespaces[uuid] = config.namespaces[keys[0]]
+    }
+  }
+  if (config.operators) {
+    config.operators = config.operators.map((o) => Object.assign(o, { uuid }))
+  }
+  if (config.bridges) {
+    config.bridges = config.bridges.map((o) => Object.assign(o, { uuid }))
+  }
+  if (config.words) {
+    setWordsUUIDs(config.words, uuid)
+  }
+  for (const property of bags) {
+    if (config[property]) {
+      config[property].forEach((bag) => { bag.uuid = uuid })
+    }
+  }
+}
+
+/*
+function namespaceValid (namespace) {
+  if (Array.isArray(namespace)) {
+    return true
+  }
+  if (!namespace) {
+    return true
+  }
+  return false
+}
+*/
+
+class KM {
+  toNS (id) {
+    if (this._namespace.length === 0) {
+      return id
+    }
+    return `${this._namespace.join('#')}#${id}`
+  }
+
+  getName (config) {
+    if (config instanceof Config) {
+      return config.config.name
+    } else {
+      return config.name
+    }
+  }
+
+  get name () {
+    return this.toNS(this._name)
+  }
+
+  constructor ({ config, namespace = [], uuid, isSelf = false }) {
+    if (uuid) {
+      this._uuid = uuid
+      this._class = 'KM'
+      this._config = config
+      this._namespace = namespace
+      this._name = this.getName(config)
+      this._isSelf = true // new version the entry is for the containiner class but can't be that due to circularity
+    } else {
+      // this._uuid = uuidv4();
+      if (config instanceof Config) {
+        config.valid()
+        this._name = config.config.name
+        // config.uuid = this._uuid
+        this._uuid = config._uuid
+      } else {
+        // this._uuid = uuidv4()
+        this._name = config.name
+        this._uuid = getCounter(this._name)
+      }
+      this._class = 'KM'
+      this._config = config
+      // applyUUID(this._config, this._uuid)
+      if (this._config instanceof Config) {
+        this._config.valid()
+      }
+      this._namespace = namespace
+      this._isSelf = false // old version the entry is for the containiner class but can't be that due to circularity
+    }
+  }
+
+  valid () {
+    if (this._config.initializerFn && !(this._config instanceof Config)) {
+      debugBreak()
+      return false
+    }
+    if (this._namespace && !Array.isArray(this._namespace)) {
+      debugBreak()
+      return false
+    }
+    if (this._config instanceof Config) {
+      if (!this._config.valid()) {
+        debugBreak()
+        return false
+      }
+    }
+    return true
+  }
+
+  copy2 (options) {
+    // greg -> add a flag to say don't init the api's
+    const config = configDup(this._config, options)
+    const km = new KM({
+      config,
+      name: this._name,
+      _uuid: config._uuid,
+      namespace: this._namespace,
+      isSelf: this._isSelf
+    })
+    return km // copy2()
+  }
+
+  copy () {
+    const km = new KM({
+      name: this._name,
+      config: configDup(this._config),
+      // _uuid: uuidv4(),
+      _uuid: getCounter(this._config._name),
+      namespace: this._namespace,
+      isSelf: this._isSelf
+    })
+    if (km.config instanceof Config) {
+      km.config.valid()
+    }
+    applyUUID(km._config, km._uuid)
+    return km // copy()
+  }
+
+  get api () {
+    return this._config.api
+  }
+
+  toString () {
+    return `KM(${this._name}, ${JSON.stringify(this.config)}, ${this._namespace} isSelf(${this._isSelf}))`
+  }
+
+  get uuid () {
+    return this._uuid
+  }
+
+  get config () {
+    return this._config
+  }
+
+  set config (config) {
+    this._config = config
+  }
+
+  get isSelf () {
+    return this._isSelf
+  }
+
+  get namespace () {
+    return this._namespace
+  }
+
+  set namespace (namespace) {
+    this._namespace = namespace
+  }
+}
+
+const multiApiImpl = (initializer) => {
+  return new Object({
+    multiApi: true,
+
+    // multi functions
+    add: (config, multiApi, api) => {
+      initializer(config, api)
+      const name = api.getName()
+      multiApi.apis[name] = api
+      api.objects = config.get('objects')
+      api.config = () => config
+      multiApi.current = name
+    },
+
+    initialize: ({ config, api: multiApi }) => {
+      for (const apiName in multiApi.apis) {
+        const api = multiApi.apis[apiName]
+        initializer(config, api)
+      }
+    },
+
+    set objects (value) {
+      for (const key in Object.keys(this.apis)) {
+        this.apis[key].objects = value
+      }
+    },
+
+    // "product1": apiInstance(testData1),
+    apis: {
+    },
+
+    // api functions
+    api: (multiApi) => multiApi.apis[multiApi.current]
+  })
+}
+
+let configCounter = 1
+
+const getCounter = (maybeName = '') => {
+  const counter = configCounter
+  configCounter += 1
+  return `${maybeName}${counter}`
+}
+
+class Config {
+  defaultConfig () {
+    this.config = {
+      operators: [], // TODO
+      bridges: [], // Done
+      hierarchy: [], // Done
+      name: '',
+      namespaces: {
+        // "config id" : { namespace: [""], ids: set(ids) }
+      },
+      eqClasses: [],
+      priorities: [], // Done
+      version: '3',
+      debug: false,
+      associations: { // Done
+        negative: [],
+        positive: []
+      },
+      objects: {
+        // this is where the namespaced configs have their objects
+        namespaced: {}
+      },
+      description: '',
+      words: {}, // Done
+      floaters: [],
+      implicits: [],
+      flatten: [],
+      contexts: [], // TODO future
+
+      expected_generated: [],
+      expected_results: [],
+      skipSemantics: false
+    }
+    for (const bag of bags) {
+      this.config[bag] = []
+    }
+    // this.wasInitialized = false
+  }
+
+  // applies only to config sent to the server
+
+  watching() {
+    const props = [
+          'operators',
+          'bridges',
+          'hierarchy',
+          'namespaces',
+          'eqClasses',
+          'priorities',
+          'associations',
+          'words',
+          'floaters',
+          'implicits',
+          'flatten',
+    ];
+    const watching = {}
+    for (let prop of props) {
+      watching[prop] = this.config[prop]
+    }
+    return JSON.stringify(watching)
+  }
+
+  watch() {
+    this.watchStart = this.watching();
+  }
+
+  wasChanged() {
+    return this.watchStart !== this.watching()
+  }
+
+	exists(marker) {
+    for (let bridge of this.config.bridges) {
+	    if (bridge.id == marker) {
+        return true;
+      }
+		}
+  }
+
+  getSemantics (logs = []) {
+    return new Semantics(this.config.semantics || [], logs)
+  }
+
+  getGenerators (logs = []) {
+    return new Generators(this.config.generators || [], logs)
+  }
+
+  warningNotEvaluated (log, value) {
+    const description = 'WARNING: for semantics, implement an evaluations handler, set "value" property of the operator to the value.'
+    const match = `({context}) => context.marker == '${value.marker}' && context.evaluate && <other conditions as you like>`
+    const apply = `({context}) => <do stuff...>; context.value = <value>`
+    const input = indent(JSON.stringify(value, null, 2), 2)
+    const message = `${description}\nThe semantic would be\n  match: ${match}\n  apply: ${apply}\nThe input context would be:\n${input}\n`
+    log.push(indent(message, 4))
+  }
+
+  // value is in response field
+  // TODO maybe generalize out query+evaluate along the lines of set value and set reference
+  /*
+  getEvaluator (s, log, context) {
+    const instance = s({ ...context, evaluate: true })
+    if (!instance.evalue && !instance.verbatim && !instance.value) {
+      this.warningNotEvaluated(log, context);
+    }
+    if (!instance.evalue) {
+      instance.evalue = instance.value
+      instance.edefault = true
+    }
+    delete instance.evaluate
+    instance.instance = true;
+    return instance
+  }
+  */
+  getEvaluator (s, log, context) {
+    const instance = s({ ...context, evaluate: true })
+    if (!instance.evalue && !instance.verbatim && !instance.value) {
+      this.warningNotEvaluated(log, context);
+    }
+    if (!instance.evalue) {
+      instance.evalue = instance.value
+      instance.edefault = true
+    }
+    delete instance.evaluate
+    instance.instance = true;
+    return instance
+  }
+
+
+  fragmentInstantiator (contexts) {
+    return new Object({
+      contexts: () => contexts,
+      instantiate: (mappings) => {
+        const instantiated = _.cloneDeep(contexts)
+        // const todo = [...instantiated]
+        // const todo = [...instantiated]
+        const todo = _.clone(instantiated)
+        while (todo.length > 0) {
+          const context = todo.pop()
+          for (const mapping of mappings) {
+            if (mapping.match({ context })) {
+              mapping.apply({ context })
+            }
+          }
+          for (const key of Object.keys(context)) {
+            // if (['number', 'string', 'boolean'].includes(typeof (context[key]))) {
+            if (!helpers.isCompound(context[key])) {
+              continue
+            }
+            if (context[key].instantiated) {
+              continue;
+            }
+            todo.push(context[key])
+          }
+        }
+        return instantiated
+      }
+    })
+  }
+
+  fragment (query) {
+    for (const instance of (this.instances || [])) {
+      for (const fragment of (instance.fragments || [])) {
+        if (fragment.query === query) {
+          return this.fragmentInstantiator(fragment.contexts)
+        }
+      }
+    }
+  }
+
+  needsRebuild(template, instance, options = { rebuild: false }) {
+    if (options.rebuild) {
+      return true
+    }
+    const toCanonical = (f) => {
+      if (typeof f == 'string') {
+        return { query: f }
+      } else {
+        return f
+      }
+    }
+    const instanceFragments = (instance.fragments || []).map((fragment) => fragment.key || fragment.query).map( toCanonical )
+    const templateFragments = (template.fragments || []).concat(this.dynamicFragments).map( toCanonical )
+    const sameFragments = deepEqual(templateFragments, instanceFragments)
+    const sameQueries = deepEqual((template.queries || []), (instance.queries || []))
+    return !(instance && sameQueries && sameFragments)
+  }
+
+  load (template, instance, options = { rebuild: false } ) {
+    this.logs.push(`loading template for ${this.name}`)
+    if (instance && instance.associations && !options.rebuild) {
+      this.addAssociations(instance.associations)
+    }
+    if (options.rebuild) {
+      // TODO fix beforeQuery
+      template = { fragments: [], queries: [], ...template }
+      template.fragments = template.fragments.concat(this.dynamicFragments)
+      client.build({ config: this, target: this.name, beforeQuery: () => {}, template, ...options })
+    } else {
+      // no change
+      this.initInstances.push(instance)
+      this.instances.push(instance)
+      client.processInstance(this, instance)
+    }
+  }
+
+  addFragments(fragments) {
+    // only run this if not loading as module write error if loading as module and different
+    this.dynamicFragments = this.dynamicFragments.concat(fragments)
+  }
+
+  objects () {
+    return this.config.objects.namespaced[this._uuid]
+  }
+
+  addAssociationsFromTests(tests = []) {
+    for (let test of tests) {
+      this.addAssociations(test.associations || []);
+    }
+  }
+
+
+  addAssociations (associations) {
+    for (let association of associations) {
+      this.addAssociation(association)
+    }
+  }
+
+  addAssociation (association) {
+    if (!this.config.associations) {
+      this.config.associations = {
+        negative: [],
+        positive: []
+      }
+    }
+    if (global.entodictonDebugAssociation) {
+      if (deepEqual(global.entodictonDebugAssociation, association)) {
+        debugger; // debug association hit
+      }
+    }
+    this.config.associations.positive.push(association)
+  }
+
+  // TODO add more error checking to these like addHierarchy has
+  addPriorities (priorities) {
+    if (!this.config.priorities) {
+      this.config.priorities = []
+    }
+    this.config.priorities.push(priorities)
+  }
+ 
+  addHierarchy (child, parent) {
+    if (child && parent || !child || Array.isArray(child) || (typeof child == 'string' && !parent)) {
+      this.addHierarchyChildParent(child, parent)
+      // this.addHierarchyProperties ({ child, parent })
+    } else {
+      this.addHierarchyProperties (child)
+    }
+  }
+
+  addHierarchyProperties (properties) {
+    if (typeof properties.child !== 'string') {
+      throw `addHierarchy expected child property to be a string. got ${JSON.stringify(child)}`
+    }
+    if (typeof properties.parent !== 'string') {
+      throw `addHierarchy expected parent properties to be a string. got ${JSON.stringify(parent)}`
+    }
+    if (!this.config.hierarchy) {
+      this.config.hierarchy = []
+    }
+    // this.config.hierarchy.push([properties.child, properties.parent])
+    this.config.hierarchy.push(properties)
+  }
+
+  addHierarchyChildParent (child, parent) {
+    if (typeof child !== 'string') {
+      throw `addHierarchy expected child to be a string. got ${JSON.stringify(child)}`
+    }
+    if (typeof parent !== 'string') {
+      throw `addHierarchy expected parent to be a string. got ${JSON.stringify(parent)}`
+    }
+    if (!this.config.hierarchy) {
+      this.config.hierarchy = []
+    }
+    if (global.entodictonDebugHierarchy) {
+      if (deepEqual(global.entodictonDebugHierarchy, [child, parent])) {
+        debugger; // debug hierarchy hit
+      }
+    }
+    if (this.config.hierarchy.find( (element) => {
+      const hc = hierarchyCanonical(element) 
+      if (child == hc.child && parent == hc.parent) {
+        return true
+      }
+    })) {
+      return
+    }
+
+    this.config.hierarchy.push([child, parent])
+  }
+
+  getBridge (id, level) {
+    return this.config.bridges.find( (bridge) => bridge.id == id && bridge.level == level )
+  }
+
+  addBridge (bridge) {
+    if (!this.config.bridges) {
+      this.config.bridges = []
+    }
+    const bridges = this.config.bridges
+    const def = Object.assign({}, bridge, { uuid: this._uuid })
+   
+    if (global.entodictonDebugBridge) {
+      if (global.entodictonDebugBridge[0] == bridge.id && global.entodictonDebugBridge[1] == bridge.level) {
+        debugger; // debug hierarchy hit
+      }
+    }
+
+    if (bridge.allowDups) {
+      if (bridges.find( (b) => b.id == bridge.id && b.level == bridge.level && b.bridge == bridge.bridge )) {
+        return;
+      }
+    }
+    if (global.transitoryMode) {
+      def.transitoryMode = true
+    }
+    bridges.push(def)
+    this.checkBridges();
+  }
+
+  addGenerator (match, apply) {
+    let generator = match
+    if ((typeof match === 'function') && (typeof apply === 'function')) {
+      generator = { match, apply }
+    }
+
+    if (!(typeof generator.match === 'function')) {
+      throw 'addGenerator: Expected matcher to be a function'
+    }
+    if (!(typeof generator.apply === 'function')) {
+      throw 'addGenerator: Expected action to be a function'
+    }
+
+    if (!this.config.generators) {
+      this.config.generators = []
+    }
+
+    if (!generator.where) {
+      generator.where = client.where(3)
+    }
+
+    const generators = this.config.generators
+    Object.assign(generator, { uuid: this._uuid, km: this.name, index: generators.length })
+    // used to be unshift
+    generators.unshift(generator)
+  }
+
+  addSemantic (match, apply) {
+    let semantic = match
+    if ((typeof match === 'function') && (typeof apply === 'function')) {
+      semantic = { match, apply }
+    }
+
+    if (!(typeof semantic.match === 'function')) {
+      throw 'addSemantic: Expected match to be a function'
+    }
+    if (!(typeof semantic.apply === 'function')) {
+      throw 'addSemantic: Expected apply to be a function'
+    }
+
+    if (!this.config.semantics) {
+      this.config.semantics = []
+    }
+
+    if (!semantic.where) {
+      semantic.where = client.where(3)
+    }
+
+    const semantics = this.config.semantics
+    Object.assign(semantic, { uuid: this._uuid, km: this.name, index: semantics.length })
+    semantics.unshift(semantic)
+  }
+
+  addOperator (objectOrPattern) {
+    if (!this.config.operators) {
+      this.config.operators = []
+    }
+    const operators = this.config.operators
+
+    let operator;
+    if (typeof objectOrPattern === 'string') {
+      operator = { pattern: objectOrPattern, uuid: this._uuid }
+    } else {
+      operator = Object.assign({}, objectOrPattern, { uuid: this._uuid })
+    }
+
+    if (operator.allowDups) {
+      if (operators.find( (o) => o.pattern == operator.pattern )) {
+        return;
+      }
+    }
+
+    operators.unshift(operator)
+    this.checkOperators()
+  }
+
+  addWord (word, def) {
+    this.addWordInternal(this.config, word, def)
+  }
+
+  addWordInternal (config, word, def) {
+    if (!config.words) {
+      config.words = {}
+    }
+    const words = config.words
+    def = Object.assign({}, def, { uuid: this._uuid })
+    if (words[word]) {
+      if (!words[word].some((e) => helpers.safeEquals(e, def))) {
+        words[word].unshift(def)
+      }
+    } else {
+      words[word] = [def]
+    }
+  }
+
+  getAPI (uuid) {
+    if (this._uuid === uuid) {
+      return this.api
+    }
+    for (const km of this.configs) {
+      if (km._uuid === uuid) {
+        return km.config.api
+      }
+    }
+  }
+
+  getServer() {
+    return this._server
+  }
+
+  getAPIKey() {
+    return this._key
+  }
+
+  server (server, apiKey) {
+    if (server) {
+      this._server = server
+    }
+    if (apiKey) {
+      this._key = apiKey
+    }
+
+    if (this._api && this._api.multiApi) {
+      for (const key of Object.keys(this._api.apis)) {
+        const api = this._api.apis[key]
+        if (api.server) {
+          api.server(server, apiKey)
+        } else {
+          api.credentials = { server, key: apiKey }
+        }
+      }
+    }
+
+    for (const km of (this.configs || [])) {
+      const config = km._config
+      if (config.server) {
+        km._config.server(server, apiKey)
+      }
+    }
+  }
+
+  getParams () {
+    const params = {
+      objects: this.config.objects,
+      config: this
+    }
+    for (const bag of bags) {
+      params[bag] = this.config[bag]
+    }
+    return params
+  }
+
+  processContexts (contexts, params) {
+    client.processContexts(contexts, this.getParams())
+  }
+
+  processContext (context) {
+    return client.processContext(context, this.getParams())
+  }
+
+  process (query, options) {
+    return client.process(this, query, options)
+  }
+
+  initDefaults () {
+    const init = (config) => {
+      if (!config.objects) {
+        config.objects = {
+          namespaced: {
+          }
+        }
+      }
+
+      if (!config.associations) {
+        config.associations = {}
+      }
+
+      if (!config.associations.positive) {
+        config.associations.positive = []
+      }
+
+      if (!config.associations.negative) {
+        config.associations.negative = []
+      }
+    }
+    init(this.config)
+    init(this.initConfig)
+  }
+
+  km (name) {
+    return this.getConfig(name)
+  }
+
+  // set the args in the api's
+  setArgs (args) {
+    const setArgs = (config) => {
+      if (!config._api) {
+        return
+      }
+      if (config._api.multiApi) {
+        for (const api in config._api.multiApi) {
+          config._api.multiApi[api].args = args
+        }
+      } else {
+        config._api.args = args
+      }
+    }
+
+    setArgs(this)
+    for (const config of this.configs) {
+      if (config.config instanceof Config) {
+        setArgs(config.config)
+      }
+    }
+  }
+
+  getConfigs () {
+    const configs = {};
+    configs[this.name] = this
+    for (const config of this.configs) {
+      if (config.config instanceof Config) {
+        configs[config.config.name] = config.config
+      }
+    }
+    return configs;
+  }
+
+  getConfig (name) {
+    if (this.name === name) {
+      return this
+    }
+    for (const config of this.configs) {
+      if (config.config instanceof Config) {
+        if (config.config.nsToString(config.config.name) === name) {
+          return config.config
+        }
+      }
+    }
+  }
+
+  removeDevelopmentElements(config) {
+    if (!config) {
+      return
+    }
+    config.operators = config.operators || []
+    config.bridges = config.bridges || []
+    config.words = config.words || {}
+    config.generators = config.generators || []
+    config.semantics = config.semantics || []
+
+    config.operators = config.operators.filter( (element) => !element.development )
+    config.bridges = config.bridges.filter( (element) => !element.development )
+    config.generators = config.generators.filter( (element) => !element.development )
+    config.semantics = config.semantics.filter( (element) => !element.development )
+    config.hierarchy = (config.hierarchy || []).filter( (element) => !element.development )
+    for (const word in config.words) {
+      const defs = config.words[word] || []
+      config.words[word] = defs.filter( (def) => !def.development )
+      if (config.words[word].length == 0) {
+        delete config.words[word]
+      }
+    }
+  }
+
+  // configs = [ { config, namespace } ... ]
+  constructor (config, module) {
+    if (config instanceof Config) {
+      throw 'Excepted the config argument to be a hash not a Config object'
+    }
+
+    this.addedArgss = []
+    const isProcess = require.main === module
+    this.isModule = !isProcess
+    if (this.isModule) {
+      this.removeDevelopmentElements(config)
+    }
+    this.initInstances = []
+    this.instances = []
+    this.logs = []
+    this.dynamicFragments = []
+    // when running queries any bridges added are marked as transitory so that the associated will ignore those op's
+    this.transitoryMode = false
+
+    // check for duplicate bridges
+    if (config && config.bridges) {
+      let duplicated = new Set()
+      const seen = new Set()
+      for (const bridge of config.bridges) {
+        const id = `${bridge.id}/${bridge.level}`
+        if (seen.has(id)) {
+          duplicated.add(id)
+        } else {
+          seen.add(id)
+        }
+      }
+      duplicated = Array.from(duplicated)
+      if (duplicated.length > 0) {
+        throw `In the KM ${config.name}, the following operators are duplicated in the bridges: ${duplicated}`
+      }
+    }
+
+    if (config && config.words) {
+      for (const word of Object.keys(config.words)) {
+        for (const def of config.words[word]) {
+          isValidDef(word, def, config)
+        }
+      }
+    }
+
+    normalizeConfig(config)
+
+    // set the default server so stuff just works
+    this.server('http://184.67.27.82:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
+
+    this.defaultConfig()
+    this.initializerFn = ({ currentConfig }) => {
+      if (currentConfig instanceof Config) {
+        currentConfig.wasInitialized = true
+      }
+    }
+    if (config) {
+      this.name = config.name
+    }
+    this.motivations = []
+    this.loadOrder = new Digraph()
+    this.wasInitialized = false
+    this.configs = []
+    this._api = undefined
+    this._namespace = []
+    this._eqClasses = []
+    // this._uuid = uuidv4()
+    this._uuid = getCounter(this.name)
+    if (config) {
+      config = _.cloneDeep(config)
+      this.config = config
+      if (!this.config.generators) {
+        this.config.generators = []
+      }
+      if (!this.config.semantics) {
+        this.config.semantics = []
+      }
+      if (!this.config.words) {
+        // this.config.words = {}
+      }
+      for (let bridge of (this.config.bridges || [])) {
+        /*
+        if (bridge.generator) {
+          this.config.generators.push({ 
+            match: ({context}) => bridge.id == context.marker,
+            apply: (args) => bridge.generator(args),
+          })
+        }
+        */
+        if (bridge.isA) {
+          for (let parent of bridge.isA) {
+            this.addHierarchy(bridge.id, parent)
+          }
+        }
+        if (bridge.before) {
+          for (let after of bridge.before) {
+            this.addPriorities([after, [bridge.id, bridge.level]])
+          }
+        }
+        if (bridge.words) {
+          for (let def of bridge.words) {
+            if (typeof def == 'string') {
+              this.addWordInternal(this.config, def, {"id": bridge.id, "initial": "{}" })
+            } else {
+              const word = def.word
+              def = { initial: JSON.stringify(def), id: bridge.id, word: undefined }
+              this.addWordInternal(this.config, word, def)
+            }
+          }
+        }
+        if (bridge.generator) {
+          this.config.generators.unshift(bridge.generator)
+        }
+        if (bridge.generators) {
+          const generators = [...bridge.generators]
+          generators.reverse()
+          for (let generator of generators) {
+            this.config.generators.unshift(generator)
+          }
+        }
+        if (bridge.generatorp) {
+          this.config.generators.unshift({ 
+            where: bridge.generatorp.where || client.where(3),
+            match: ({context}) => bridge.id == context.marker && context.paraphrase,
+            apply: (args) => bridge.generatorp(args),
+          })
+        }
+        if (bridge.generatorr) {
+          this.config.generators.unshift({ 
+            // TODO merge response and isResponse
+            where: bridge.generatorr.where || client.where(3),
+            match: ({context}) => bridge.id == context.marker && !context.paraphrase && (context.response || context.isResponse),
+            apply: (args) => bridge.generatorr(args),
+          })
+        }
+        if (bridge.evaluator) {
+          this.config.semantics.unshift({ 
+            where: bridge.evaluator.where || client.where(3),
+            match: ({context}) => bridge.id == context.marker && context.evaluate,
+            apply: (args) => bridge.evaluator(args),
+          })
+        }
+        if (bridge.semantic) {
+          this.config.semantics.unshift({ 
+            where: bridge.semantic.where || client.where(3),
+            match: ({context}) => bridge.id == context.marker,
+            apply: (args) => bridge.semantic(args),
+          })
+        }
+      }
+      if (config.operators) {
+        config.operators = config.operators.map((operator) => {
+          if (typeof operator === 'string') {
+            return { pattern: operator }
+          } else {
+            return operator
+          }
+        })
+      }
+    }
+    this.initConfig = _.cloneDeep(this.config)
+    this.configs.push(new KM({ config: this.config, uuid: this._uuid }))
+
+    /*
+    if (config) {
+      this.configs.push(new KM({config, isSelf: true}))
+      this.addInternal(Object.assign({}, config), false)
+    } else {
+      this.configs.push( new KM({config: this.config, isSelf: true}) )
+    }
+    */
+
+    this.setUUIDs()
+    this.initDefaults()
+    if (!this.config.objects.namespaced) {
+      this.config.objects.namespaced = {}
+    }
+    this.get('objects').namespaced[this._uuid] = {}
+    this.valid()
+  }
+
+  addArgs(moreArgs) {
+    this.addedArgss.push(moreArgs)
+  }
+
+  getAddedArgs(args) {
+    for (let addedArgs of this.addedArgss) {
+      addedArgs = addedArgs(args)
+      Object.assign(args, addedArgs)
+    }
+  }
+
+  set multiApi (initializer) {
+    this.api = multiApiImpl(initializer)
+  }
+
+  get multiApi () {
+    if (this._api.multiApi) {
+      return this._api
+    } else {
+      return null
+    }
+  }
+
+  get api () {
+    if (this._api && this._api.multiApi) {
+      return this._api.api(this._api)
+    } else {
+      return this._api
+    }
+  }
+
+  addAPI(api) {
+    if (this._api && this._api.multiApi) {
+      this._api.add(this, this._api, api)
+    } else {
+      throw "Can only add apis to a multi-api";
+    }
+  }
+
+  set api (value) {
+    if (this._api && this._api.multiApi) {
+      this._api.add(this, this._api, value)
+    } else {
+      this._api = _.cloneDeep(value)
+      if (this._api) {
+        this._api.objects = this.config.objects
+        this._api.config = () => this
+        this._api.uuid = this._uuid
+      }
+    }
+  }
+
+  set afterTest (value) {
+    this._afterTest = value
+  }
+
+  get uuid () {
+    return this._uuid
+  }
+
+  set uuid (uuid) {
+    const map = { [this._uuid]: uuid }
+    this._uuid = uuid
+    configCounter += 1
+    this.mapUUIDs(map)
+  }
+
+  // remove all added modules and initialize with the init config
+  resetToOne () {
+    /*
+    this.config = _.cloneDeep(this.initConfig)
+    this.configs = [this.configs[0]]
+    this.setUUIDs()
+    this.initDefaults()
+    */
+    this.configs = [this.configs[0]]
+    this.defaultConfig()
+    if (!this.initializeFn) {
+      // TODO move this to the default initializer
+      Object.assign(this.config.objects, _.cloneDeep(this.initConfig.objects || {}))
+    }
+    this.initializeConfigFromConfigs({ others: [], objects: this.config.objects.namespaced, moreNames: [], callInitializers: false })
+    const map = {}
+    for (let i = 0; i < this.configs.length; ++i) {
+      map[this.configs[i].uuid] = this.configs[i].uuid
+    }
+    this.mapUUIDs(map)
+    // this.valid() init was not run because the kms are not all setup yet
+  }
+
+  // motivation === { match, apply, uuid }
+  addMotivation (motivation) {
+    this.motivations.push(motivation)
+  }
+
+  resetMotivations () {
+    this.motivations = []
+  }
+
+  doMotivations (args, context) {
+    args = Object.assign({}, args, { context })
+    args.objects = args.getObjects(this.uuid)
+    const motivations = this.motivations
+    this.motivations = []
+    let done = false
+    for (const motivation of motivations) {
+      if (!done && motivation.match(args)) {
+        motivation.apply(args)
+        if (args.context.controlKeepMotivation || motivation.repeat) {
+          this.motivations.push(motivation)
+        }
+        done = true
+      } else {
+        this.motivations.push(motivation)
+      }
+    }
+    return done
+  }
+
+  // TODO add more details
+  equal(config) {
+    if (JSON.stringify(this.config) != JSON.stringify(config.config)) {
+      debugger;
+      return false;
+    }
+    return true
+  }
+
+  dump(fn) {
+    const fs = require('fs')
+    fs.writeFileSync(fn, JSON.stringify(this.config, 0, 2))
+  }
+
+  copy (options = {}) {
+    this.valid()
+    const cp = new Config()
+    cp.logs = []
+    cp.transitoryMode = this.transitoryMode
+    cp.configs = this.configs.map((km) => km.copy2(Object.assign({}, options, { callInitializers: false })))
+    cp._uuid = cp.configs[0]._uuid
+    cp.initializerFn = this.initializerFn
+    cp.initAfterApi = this.initAfterApi
+    cp._api = _.cloneDeep(this._api)
+    cp._namespace = this._namespace
+    cp._eqClasses = this._eqClasses
+    cp.name = this.name
+    cp.description = this.description
+    cp.tests = this.tests
+    cp.motivations = this.motivations
+    cp.isModule = this.isModule
+    cp.initInstances = this.initInstances.slice()
+    cp.instances = this.instances.slice()
+
+    cp.initConfig = _.cloneDeep(this.initConfig)
+    cp.defaultConfig()
+    // cp.wasInitialized = false;  // since default config GREG
+    cp.resetWasInitialized()
+    if (!this.initializeFn) {
+      // TODO move this to the default initializer
+      Object.assign(cp.config.objects, _.cloneDeep(this.initConfig.objects || {}))
+    }
+    // cp.initializeConfigFromConfigs({ others: [], objects: cp.config.objects.namespaced, moreNames: [], ...options })
+    cp.initializeConfigFromConfigs(Object.assign({ others: [], objects: cp.config.objects.namespaced, moreNames: [] }, options))
+    const map = {}
+    for (let i = 0; i < this.configs.length; ++i) {
+      map[this.configs[i].uuid] = cp.configs[i].uuid
+    }
+    cp.mapUUIDs(map)
+
+    if (cp._api) {
+      cp._api.objects = cp.config.objects
+      cp._api.config = () => (cp instanceof Config) ? cp : cp.config
+      cp._api.uuid = cp._uuid
+    }
+
+    if (!cp.config.objects) {
+      cp.config.objects = { namespaced: {} }
+    } else if (!cp.config.objects.namespaced) {
+      cp.config.objects.namespaced = {}
+    }
+    cp.configs.forEach((km) => {
+      // const namespace = km.namespace
+      cp.config.objects.namespaced[km._uuid] = {}
+    })
+
+    if (options.callInitializers) {
+      cp.rebuild(options)
+    }
+    cp.valid()
+    return cp
+  }
+
+  setUUIDs () {
+    this.config.bridges && this.config.bridges.forEach((bridge) => { bridge.uuid = this._uuid })
+    this.config.words && setWordsUUIDs(this.config.words, this._uuid)
+    this.config.operators && this.config.operators.forEach((operator) => { operator.uuid = this._uuid })
+    const ids = Array.from(new Set((this.config.bridges && this.config.bridges.map((bridge) => bridge.id)) || []))
+    ids.sort()
+    this.config.namespaces = {}
+    // if (true || ids.length > 0) {
+    this.config.namespaces[this.uuid] = { ids, namespace: this._namespace }
+    for (const bag of bags) {
+      if (this.config[bag]) {
+        this.config[bag].forEach((bag) => { bag.uuid = this._uuid })
+      }
+    }
+  }
+
+  mapUUIDs (map) {
+    if (this._eqClasses) {
+      this._eqClasses = this._eqClasses.map((eqclass) => eqclass.map((uuid) => map[uuid] || uuid))
+    }
+
+    if (this.config.namespaces) {
+      const ns = {}
+      for (const uuid of Object.keys(this.config.namespaces)) {
+        const uuidPrime = map[uuid] || uuid
+        ns[uuidPrime] = this.config.namespaces[uuid]
+      }
+      this.config.namespaces = ns
+    }
+
+    if (this.config.words) {
+      const words = this.config.words
+      for (const key in words) {
+        words[key].forEach((o) => {
+          if (o.uuid) {
+            if (map[o.uuid]) {
+              o.uuid = map[o.uuid]
+            }
+          } else {
+            o.uuid = this._uuid
+          }
+        })
+      }
+    }
+
+    if (this.config.bridges) {
+      this.config.bridges.forEach((bridge) => {
+        if (bridge.uuid) {
+          if (map[bridge.uuid]) {
+            bridge.uuid = map[bridge.uuid]
+          }
+        } else {
+          bridge.uuid = this._uuid
+        }
+      })
+    }
+
+    if (this.config.operators) {
+      this.config.operators.forEach((operator) => {
+        if (operator.uuid) {
+          if (map[operator.uuid]) {
+            operator.uuid = map[operator.uuid]
+          }
+        } else {
+          operator.uuid = this._uuid
+        }
+      })
+    }
+
+    for (const bag of bags) {
+      if (this.config[bag]) {
+        this.config[bag].forEach((bag) => {
+          if (bag.uuid) {
+            if (map[bag.uuid]) {
+              bag.uuid = map[bag.uuid]
+            }
+          } else {
+            bag.uuid = this._uuid
+          }
+        })
+      }
+    }
+  }
+
+  initializeFromConfigs () {
+    this.configs.forEach(({ config, namespace, uuid }) => {
+      /*
+      let objects = this.get('objects')
+      if (namespace) {
+        objects = {}
+        this.get('objects')['namespaced'][namespace] = objects
+      }
+      */
+      const objects = {}
+      const km = (name) => this.getConfig(name)
+      if (config instanceof Config) {
+        const aw = addWord(this, config)
+        this.get('objects').namespaced[config._uuid] = objects
+        if (config._api) {
+          config._api.objects = objects
+          config._api.config = () => this
+        }
+        config.initializerFn({ addWord: aw, km, config, baseConfig: this, currentConfig: config, objects, namespace, uuid, api: config.api })
+      } else {
+        const aw = addWord(this, this)
+        this.get('objects').namespaced[this._uuid] = objects
+        if (config._api) {
+          config._api.objects = objects
+          config._api.config = () => this
+        }
+        this.initializerFn({ addWord: aw, km, config: this, baseConfig: this, currentConfig: this, objects, namespace, uuid, api: this.api })
+      }
+    })
+    this.instances.forEach((instance) => client.processInstance(this, instance))
+  }
+
+  initialize ({ force = true } = {}) {
+    if (force || !this.wasInitialized) {
+      const aw = addWord(this, this)
+      const km = (name) => this.getConfig(name)
+      // this.initializerFn({ addWord: aw, km, config: this, baseConfig: this, currentConfig: this, objects: this.get('objects'), uuid: this._uuid, namespace: '', api: this.api })
+      const objects = this.config.objects.namespaced[this._uuid]
+      this.initializerFn({ addWord: aw, km, config: this, baseConfig: this, currentConfig: this, objects, uuid: this._uuid, namespace: '', api: this.api })
+      this.wasInitialized = true
+    }
+  }
+
+  initializer (fn, { initAfterApi = false } = {}) {
+    this.wasInitialized = false
+    this.initAfterApi = initAfterApi
+    this.initializerFn = (args) => {
+      const transitoryMode = global.transitoryMode
+      global.transitoryMode = false
+      // const baseConfig = args.baseConfig
+      const currentConfig = args.currentConfig
+
+      if (currentConfig.api) {
+        currentConfig.api.objects = args.objects
+        currentConfig.api.config = () => this
+        currentConfig.api.uuid = currentConfig._uuid
+      }
+      // this.instances.forEach( (instance) => client.processInstance(this, instance) )
+      fn(args)
+      currentConfig.wasInitialized = true
+      global.transitoryMode = transitoryMode
+    }
+    // this.initializeFromConfigs()
+    this.rebuild()
+  }
+
+  nsToString (id) {
+    return `${this._namespace.concat(id).join('#')}`
+  }
+
+  validBag (bag) {
+    if (bag.match === null) {
+      return false
+    }
+    if (bag.apply === null) {
+      return false
+    }
+    if (bag.uuid === null) {
+      return false
+    }
+    return true
+  }
+
+  valid () {
+    const uuids = this.configs.map((config) => config._uuid)
+
+    if (!this.logs) {
+      debugBreak()
+      return false
+    }
+    for (const bag of bags) {
+      if (this.config[bag]) {
+        const problem = this.config[bag].some((bag) => {
+          if (!this.validBag(bag)) {
+            debugBreak()
+            return true
+          }
+          if (!uuids.includes(bag.uuid)) {
+            debugBreak()
+            return true
+          }
+          return false
+        })
+
+        if (problem) {
+          return false
+        }
+      }
+    }
+
+    if (this._uuid !== this.configs[0].uuid) {
+      debugBreak()
+      return false
+    }
+    if (this.configs[0]._config instanceof Config) {
+      debugBreak()
+      return false
+    }
+
+    if (!this.config.objects) {
+      debugBreak()
+      return false
+    }
+
+    for (const key in this.config.words) {
+      const values = this.config.words[key]
+      if (values.some((word) => (Object.keys(word).includes('uuid') && !word.uuid))) {
+        debugBreak()
+        return false
+      }
+    }
+
+    const kmsUuids = this.configs.map((km) => km.uuid)
+    const bridgesUuids = (this.config.bridges && this.config.bridges.map((bridge) => bridge.uuid).filter((uuid) => uuid)) || []
+    let result = true
+    bridgesUuids.forEach((buuid) => {
+      if (!kmsUuids.includes(buuid)) {
+        debugBreak()
+        result = false
+      }
+    })
+
+    if (this.get('namespaces')) {
+      const namespaceUuids = Object.keys(this.get('namespaces'))
+      namespaceUuids.forEach((uuid) => {
+        if (!kmsUuids.includes(uuid)) {
+          debugBreak() // in namespaces
+          result = false
+        }
+      })
+      if (!result) {
+        debugBreak()
+        return false
+      }
+      kmsUuids.forEach((uuid) => {
+        if (!namespaceUuids.includes(uuid)) {
+          debugBreak() // in namespaces
+          result = false
+        }
+      })
+      if (!result) {
+        debugBreak()
+        return false
+      }
+    }
+
+    if (Object.keys(this.config.namespaces || {}) === ['undefined']) {
+      debugBreak()
+      result = false
+    }
+    if (!result) {
+      debugBreak() // not valid
+      return false
+    }
+
+    result = true
+    this.configs.forEach((km) => {
+      if (!km.valid()) {
+        result = false
+      }
+    })
+    if (!result) {
+      debugBreak() // not valid
+      return false
+    }
+    return result
+  }
+
+  resetWasInitialized () {
+    this.wasInitialized = false
+    this.configs.forEach((km) => {
+      const config = km.config
+      if (config instanceof Config) {
+        config.wasInitialized = false
+      }
+    })
+  }
+
+  rebuild ({ isModule: mainIsModule = false } = {}) {
+    const debug = this.config.debug;
+    this.config = _.cloneDeep(this.initConfig)
+    if (debug) {
+      this.config.debug = debug
+    }
+    // already set
+    // this.isModule = this.isModule || mainIsModule
+    mainIsModule = this.isModule
+    this.config.objects.namespaced = {}
+    this.resetWasInitialized()
+
+    // reorder configs base on load ordering
+    {
+      const ordering = this.loadOrder.order(this.configs.map((km) => km.name || km.uuid))
+      const oconfigs = []
+      for (const nameOrUUID of ordering) {
+        for (const km of this.configs) {
+          if (km.name === nameOrUUID || km.uuid === nameOrUUID) {
+            oconfigs.push(km)
+          }
+        }
+      }
+      this.configs = [...oconfigs]
+    }
+
+    const inits = []
+    const initAfterApis = []
+    this.configs.forEach((km) => {
+      const namespace = km.namespace
+      this.config.objects.namespaced[km._uuid] = {}
+      const namespacedObjects = this.config.objects.namespaced[km._uuid]
+      this.setupNamespace(km)
+      const aw = addWord(km.config, km.config)
+      let config = km.config
+     
+      if (config.addedArgss) { 
+        this.addedArgss = this.addedArgss.concat(config.addedArgss)
+      }
+
+      let isSelf = false
+      let isModule = true
+      if (!(config instanceof Config)) {
+        config = this
+        isSelf = true
+        isModule = mainIsModule
+      }
+      if (!isSelf) {
+        config.config = _.cloneDeep(config.initConfig)
+      }
+      config.wasInitialized = false
+      // TODO change name of config: to baseConfig:
+      const kmFn = (name) => this.getConfig(name)
+      const args = { isModule, addWord: aw, km: kmFn, config, baseConfig: this, currentConfig: config, uuid: config._uuid, objects: namespacedObjects, namespace, api: config.api }
+      config.initializerFn(args)
+      if (config.initAfterApi) {
+        initAfterApis.push({ config, args })
+      }
+      // greg
+      if (config._api) {
+        if (config._api.initialize) {
+          // reverse the list
+          inits.unshift( () => config._api.initialize({ config: this, km: kmFn, api: config._api }) )
+          // config._api.initialize({ config, api: config._api })
+        }
+        config._api.objects = namespacedObjects
+        config._api.config = () => this
+        config._api.uuid = config._uuid
+      }
+      config.setUUIDs()
+      config.applyNamespace(config.config, namespace, config.uuid)
+      if (!isSelf) {
+        this.addInternal(config, true, false, false, true)
+      }
+      km.valid()
+    })
+    // console.log('inits from config', inits)
+    for (const init of inits) {
+      init()
+    }
+    for (let init of initAfterApis) {
+      // init.args.isAfterApi = true
+      init.config.initializerFn({ ...init.args, isAfterApi: true })
+    }
+    this.instances.forEach((instance) => client.processInstance(this, instance))
+    this.valid()
+    this.checkBridges()
+  }
+
+  // name: namespace name
+  // others
+  //    if undefined namespace applies to first loaded config
+  //    if list of name then namespace applied only to those configs
+  //    if true then namespace applies to all loaded configs
+  namespace (moreNames, others) {
+    const config = this.copy()
+    if (!Array.isArray(moreNames)) {
+      moreNames = [moreNames]
+    }
+    config.defaultConfig()
+
+    if (Array.isArray(others)) {
+      config.configs.forEach((km) => {
+        let config = km.config
+        let updateNamespace = false
+        if (!(km.config instanceof Config)) {
+          config = this
+          updateNamespace = true
+        }
+        if (others.includes(config.config.name)) {
+          km.namespace = moreNames.concat(km.namespace)
+          if (updateNamespace) {
+            config._namespace = moreNames.concat(config._namespace)
+          }
+        }
+      })
+    } else if (others) {
+      config.configs.forEach((km) => {
+        km.namespace = moreNames.concat(km.namespace)
+      })
+      config._namespace = moreNames.concat(config._namespace)
+    } else {
+      const km = config.configs[0]
+      km.namespace = moreNames.concat(km.namespace)
+      config._namespace = moreNames.concat(config._namespace)
+    }
+    config.rebuild()
+    return config
+  }
+
+  setupNamespace (km) {
+    let config = km.config
+    if (!(config instanceof Config)) {
+      config = this.initConfig
+    }
+    const bridges = ((config instanceof Config) ? config.config.bridges : config.bridges) || []
+    const ids = Array.from(new Set(bridges.map((bridge) => bridge.id)))
+    this.config.namespaces = this.config.namespaces || {}
+
+    this.config.namespaces[km.uuid] = {
+      ids,
+      namespace: km.namespace
+    }
+  }
+
+  // config.initializerFn({ config: this, objects, namespace })
+  // this goes through all the configs and sets up this.config
+  initializeConfigFromConfigs ({ others, objects, moreNames, callInitializers = true }) {
+    // setup the namespace in the configs
+    let first = true
+    this.configs.forEach((km) => {
+      let config = km.config
+      if (!(config instanceof Config)) {
+        config = this.initConfig
+      }
+      if (!km.namespace) {
+        km.namespace = []
+      }
+      if (config instanceof Config) {
+        // km.namespace = config._namespace
+        config = config.initConfig
+      }
+
+      const configPrime = _.cloneDeep(config)
+
+      if (Array.isArray(others)) {
+        if (others.indexOf(config.name) >= 0) {
+          km.namespace = moreNames.concat(km.namespace)
+        }
+      } else if (others === true || (!others && first)) {
+        km.namespace = moreNames.concat(km.namespace)
+      }
+
+      this.applyNamespace(configPrime, km.namespace, km.uuid)
+      first = false
+      this.addInternal(configPrime, false, true)
+      applyUUID(configPrime, km.uuid)
+    })
+
+    // setup the namespaces mapping for passing to the server side
+
+    this.configs.forEach((km) => {
+      // const namespace = km.namespace
+      // if (true || namespace.length > 0) { this.setupNamespace(km) }
+      this.setupNamespace(km)
+    })
+
+    // initialize the configs in context
+
+    if (callInitializers) {
+      this.configs.forEach(({ namespace, uuid, config, isSelf }) => {
+        if (isSelf) {
+          config = this
+        }
+        let nsobjects = objects
+        if (namespace) {
+          nsobjects = this.pathToNamespace(objects, namespace)
+        }
+        const km = (name) => this.getConfig(name)
+        if (config instanceof Config) {
+          const aw = addWord(this, config)
+          config.initializerFn({ isModule: this.isModule, addWord: aw, baseConfig: this, km, currentConfig: config, config, objects: nsobjects, namespace, uuid, api: config.api })
+        } else {
+          const aw = addWord(this, this)
+          this.initializerFn({ isModule: this.isModule, addWord: aw, baseConfig: this, km, currentConfig: this, config: this, objects: nsobjects, namespace, uuid, api: this.api })
+        }
+      })
+    }
+  }
+
+  applyNamespace (config, namespace, uuid) {
+    const toNS = (id) => {
+      if (namespace.length === 0) {
+        return id
+      }
+      return `${namespace.join('#')}#${id}`
+    }
+    /*
+    if (config.name) {
+      config.name = toNS(config.name)
+    }
+    */
+    if (config.associations) {
+      const map = (associations) => {
+        return associations.map((association) => {
+          return association.map((id) => [toNS(id[0]), id[1]])
+        })
+      }
+      const associations = config.associations
+      if (associations.positive) {
+        associations.positive = map(associations.positive)
+      }
+      if (associations.negative) {
+        associations.negative = map(associations.negative)
+      }
+    }
+
+    if (config.words) {
+      const words = {}
+      for (const word in config.words) {
+        words[word] = config.words[word].map((word) => {
+          return Object.assign({}, word, { id: toNS(word.id), uuid })
+        })
+      }
+      config.words = words
+    }
+
+    if (config.hierarchy) {
+      let hierarchy = config.hierarchy
+      hierarchy = hierarchy.map((h) => {
+        if (Array.isArray(h)) {
+          return h.map((id) => toNS(id))
+        } else {
+          h.child = toNS(h.child)
+          h.parent = toNS(h.parent)
+          return Object.assign({}, h, { child: toNS(h.child), parent: toNS(h.parent) })
+        }
+      })
+      config.hierarchy = hierarchy
+    }
+
+    if (config.priorities) {
+      let priorities = config.priorities
+      priorities = priorities.map((p) => {
+        return p.map((id) => {
+          return [toNS(id[0]), id[1]]
+        })
+      })
+      config.priorities = priorities
+    }
+
+    for (const bag of bags) {
+      if (config[bag]) {
+        config[bag] = config[bag].map((b) => {
+          return Object.assign({}, b, { uuid })
+        })
+      }
+    }
+  }
+
+  checkOperators () {
+    if (!this.config.operators) {
+      return
+    }
+
+    const seen = {}
+    for (let operator of this.config.operators) {
+      if (seen[operator.pattern]) {
+        const key = `${operator.pattern} (namespace: ${operator.uuid})`
+        throw new Error(`Operator '${key}' is defined more than once in the operators`)
+      }
+      seen[operator.pattern] = true
+    }
+  }
+
+  checkBridges () {
+    if (!this.config.bridges) {
+      return
+    }
+
+    /*
+      "namespaces": {
+        "634a678b-8d92-4464-bf65-943a82f404d8": {
+          "ids": [ "tankConcept" ],
+          "namespace": [ "ns1" ]
+        },
+       console.log('before check', JSON.stringify(this._eqClasses, null, 2))
+    */
+
+    const errors = []
+    /*
+    const namespaces = this.config.namespaces
+    const nsToIds = {}
+    for (const uuid in namespaces) {
+      const namespace = namespaces[uuid].namespace
+      const ns = namespace.join('#')
+      if (!nsToIds[ns]) {
+        nsToIds[ns] = new Set()
+      }
+      const ids = nsToIds[ns]
+      for (const id of namespaces[uuid].ids) {
+        if (ids.has(id)) {
+          if (ns === '') {
+            const dups = this.config.bridges.filter( (bridge) => bridge.id == id )
+            errors.push(`Id '${id}' is defined more than once in the bridges of the base namespace of the KM ${this.name}, Dups are ${JSON.stringify(dups)}`)
+          } else {
+            errors.push(`Id '${id}' is defined more than once in the bridges of the ${ns} namespace of the KM ${this.name}`)
+          }
+        } else {
+          ids.add(id)
+        }
+      }
+    }
+    */
+
+    const keyIsPresent = {}
+    for (const bridge of this.config.bridges) {
+      const key = `${bridge.id}/${bridge.level} (namespace: ${bridge.uuid})`
+      if (keyIsPresent[key]) {
+        errors.push(new Error(`Id '${key}' is defined more than once in bridges of the base namespace of the KM ${this.name}`))
+      } else {
+        keyIsPresent[key] = key
+      }
+    }
+
+    if (errors.length > 0) {
+      throw errors
+    }
+  };
+
+  get (property) {
+    return this.config[property]
+  }
+
+  set (property, value) {
+    if (!this.config.hasOwnProperty(property)) {
+      throw `Setting invalid property ${property}`
+    }
+    this.config[property] = value
+    // this.configs[0][property] = value
+  }
+
+  pathToNamespace (objects, path) {
+    let ns = objects
+    path = Object.assign([], path)
+    while (path.length > 0) {
+      const next = path.shift()
+      if (!ns[next]) {
+        ns[next] = {}
+      }
+      ns = ns[next]
+    }
+    return ns
+  }
+
+  addEqClass (existing, other) {
+    for (const eqClass of this._eqClasses) {
+      if (eqClass.includes(other._uuid)) {
+        eqClass.push(other._uuid)
+      }
+    }
+  }
+
+  add (more) {
+    if (more === this) {
+      throw 'Cannot add an object to itself.'
+    }
+    if (!(more instanceof Config)) {
+      more = new Config(more)
+    }
+
+    this.valid()
+    more.valid()
+    // copy so i don't have to copy later
+    more = more.copy()
+    more.server(this._server, this._key)
+
+    this.loadOrder.addList(more.configs.map((km) => km.name || km.uuid))
+
+    // get the new ones
+    // remove the dups
+    // run the initialize one all new ones
+    // this.configs = this.configs.concat(new KM({config: more}));
+    // only set for the first one the rest have it set
+    const namespace = this._namespace.concat(more._namespace)
+    const moreKMs1 = [new KM({ config: more, uuid: more.uuid, namespace })]
+    const moreKMs2 = more.configs.slice(1).map((km) => {
+      return km
+      // const cp = km.copy()
+      // cp.namespace = namespace
+      // return cp;
+    })
+    const moreKMs = moreKMs1.concat(moreKMs2)
+    const eqClass = moreKMs.map((km) => km.uuid)
+    this._eqClasses.push(eqClass)
+    // look for dups and combine them with the eqclasses
+    for (const moreKM of moreKMs) {
+      const existingKM = this.configs.find((km) => moreKM._name && km.name === moreKM.name)
+      if (existingKM) {
+        this.addEqClass(existingKM, moreKM)
+      } else {
+        this.configs.push(moreKM)
+      }
+    }
+    more.resetToOne()
+    this.config.eqClasses = this._eqClasses
+    // greg
+    // setup instances
+    this.instances = []
+    this.configs.forEach((km) => {
+      this.instances = (km._config.instances || this.initInstances.slice()).concat(this.instances)
+    })
+
+    this.rebuild()
+    this.valid()
+    return this
+  }
+
+  // TODO get rid of useOldVersion arg
+  addInternal (more, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false) {
+    if (more instanceof Config) {
+      more.initialize({ force: false })
+      if (useOldVersion) {
+        more = more.config
+      } else {
+        // more = more.initConfig
+        more = _.cloneDeep(more.initConfig)
+      }
+    }
+    for (const key of Object.keys(more)) {
+      const value = more[key]
+      // TODO remove name and description on the config bag
+      const noOverwrite = ['name', 'namespaced']
+      if (!this.config[key]) {
+        if (allowNameToBeNull) {
+          if (noOverwrite.includes(key)) {
+            continue
+          }
+        } else if (this.config[key] && noOverwrite.includes(key)) {
+          continue
+        }
+        this.config[key] = value
+        continue
+      }
+      if (key === 'words') {
+        const configWords = this.config.words
+        const moreWords = more.words
+        for (const word of Object.keys(moreWords)) {
+          if (!configWords[word]) {
+            configWords[word] = []
+          }
+          configWords[word] = configWords[word].concat(moreWords[word])
+        }
+      } else if (key === 'name') {
+        /*
+        if (this.config[key] === '') {
+          this.config[key] = more[key]
+        }
+        */
+      } else if (key === 'namespaces') {
+        if (includeNamespaces) {
+          Object.assign(this.config[key], more[key])
+        }
+      } else if (key === 'debug') {
+        this.config[key] = this.config[key] || more[key]
+      } else if (key === 'description') {
+        this.config[key] += ' ' + more[key].trim()
+      } else if (key === 'objects') {
+        if (!skipObjects) {
+          // namespaced is special
+          const namespaced = this.config.objects.namespaced
+          Object.assign(this.config[key], more[key])
+          this.config.objects.namespaced = namespaced
+        }
+      } else if (key === 'associations') {
+        const configAssociations = this.config.associations
+        const moreAssociations = more.associations
+        if (moreAssociations.positive) {
+          configAssociations.positive = configAssociations.positive.concat(moreAssociations.positive)
+        }
+        if (moreAssociations.negative) {
+          configAssociations.negative = configAssociations.negative.concat(moreAssociations.negative)
+        }
+      } else if (Array.isArray(value)) {
+        // handle allowDups
+        if (key == 'operators') {
+          // TODO what about other props
+          const isDup = (op1, op2) => op1.pattern == op2.pattern
+          for (const newOne of more[key]) {
+            for (let iOldOne = 0; iOldOne < this.config[key].length; ++iOldOne) {
+              const oldOne = this.config[key][iOldOne];
+              if (isDup(newOne, oldOne)) {
+                if (oldOne.allowDups) {
+                  // the old one takes precedence to match what would happen during the original load
+                  this.config[key].splice(iOldOne, 1)
+                  break;
+                }
+              }
+            }
+          }
+        }
+        if (key == 'bridges') {
+          // TODO what about other props
+          const idDup = (b1, b2) => b1.id == b2.id && b1.level == b2.level && b1.bridge == b2.bridge
+          for (const newOne of more[key]) {
+            for (let iOldOne = 0; iOldOne < this.config[key].length; ++iOldOne) {
+              const oldOne = this.config[key][iOldOne];
+              if (newOne.id == oldOne.id) {
+                if (oldOne.allowDups) {
+                  // the old one takes precedence to match what would happen during the original load
+                  this.config[key].splice(iOldOne, 1)
+                  break;
+                }
+              }
+            }
+          }
+        }
+        // console.log('key', key, 'XXX')
+        // console.log('more', JSON.stringify(more, null, 2))
+        this.config[key] = this.config[key].concat(more[key])
+      } else {
+        if (!(key in this.config)) {
+          throw `Unexpected property in config ${key}`
+        }
+        this.config[key] = more[key]
+      }
+    }
+    return this
+  }
+}
+
+module.exports = {
+  Config
+}