theprogrammablemind_4wp 7.5.8 → 7.6.0-beta.0

package/src/config.js

@@ -1,10 +1,11 @@
 // lookup = (name) => returns <config>
 const { Semantics, normalizeGenerator } = require('./semantics')
 const { Generators } = require('./generators')
-// const { uuid: uuidv4 } = require('uuidv4')
+const { v4 : uuidv4 } = require('uuid');
 const client = require('../client')
 const DigraphInternal = require('./digraph_internal')
 const helpers = require('./helpers')
+const { ecatch } = require('./helpers')
 const runtime = require('../runtime')
 const _ = require('lodash')
 
@@ -21,106 +22,332 @@ const indent = (string, indent) => {
     return string.replace(/^/gm, ' '.repeat(indent));
 }
 
-const handleBridgeProps = (config, bridge) => {
-  if (!bridge.bridge) {
-    bridge.bridge = "{ ...next(operator) }"
-  }
-  if (!bridge.level) {
-    bridge.level = 0
+const config_toServer = (config) => {
+}
+
+const debugPriority = (priority) => {
+  if (global.entodictonDebugPriority) {
+    if (helpers.safeEquals(entodictonDebugPriority, priority)) {
+      debugger; // debug hierarchy hit
+    }
   }
-  if (bridge.children) {
-    for (let child of bridge.children) {
-      config.addHierarchy(child, bridge.id)
+}
+
+const debugAssociation = (association) => {
+  if (global.entodictonDebugAssociation) {
+    if (helpers.safeEquals(global.entodictonDebugAssociation, association)) {
+      debugger; // debug association hit
     }
   }
-  if (bridge.parents) {
-    for (let parent of bridge.parents) {
-      config.addHierarchy(bridge.id, parent)
+}
+
+const debugHierarchy = (pair) => {
+  if (global.entodictonDebugHierarchy) {
+    if (helpers.safeEquals(global.entodictonDebugHierarchy, pair)) {
+      debugger; // debug hierarchy hit
     }
   }
-  if (bridge.isA) {
-    for (let parent of bridge.isA) {
-      config.addHierarchy(bridge.id, parent)
+}
+
+const debugBridge = (bridge) => { 
+  if (global.entodictonDebugBridge) {
+    if (global.entodictonDebugBridge[0] == bridge.id && global.entodictonDebugBridge[1] == bridge.level) {
+      debugger; // debug hierarchy hit
     }
   }
-  if (bridge.before) {
-    for (let after of bridge.before) {
-      if (typeof after == 'string') {
-        after = [after, 0]
-      }
-      config.addPriorities([after, [bridge.id, bridge.level]])
+}
+
+const debugOperator = (operator) => {
+  if (global.entodictonDebugOperator) {
+    if ((operator.pattern || operator) === global.entodictonDebugOperator) {
+      debugger; // debug operator hit
     }
   }
-  if (bridge.words) {
-    for (let def of bridge.words) {
-      if (typeof def == 'string') {
-        config.addWordInternal(def, {"id": bridge.id, "initial": `{ value: "${def}"}` })
-      } else {
-        const word = def.word
-        def = { initial: JSON.stringify(def), id: bridge.id, word: undefined }
-        config.addWordInternal(word, def)
+}
+
+const debugConfigProps = (config) => {
+  if (!config) {
+    return
+  }
+  const checkProps = [
+    { property: 'priorities', check: (v) => debugPriority(v) },
+    { property: 'association', check: (v) => debugAssociation(v) },
+    { property: 'hierarchy', check: (v) => debugHierarchy(v) },
+    { property: 'operators', check: (v) => debugOperator(v) },
+    { property: 'bridges', check: (v) => debugBridge(v) },
+  ]
+  for (const { property, check } of checkProps) {
+    if (config[property]) {
+      for (const value of config[property]) {
+        check(value)
       }
     }
   }
-  if (bridge.generator) {
-    config.config.generators.unshift(bridge.generator)
-  }
-  if (bridge.generators) {
-    const generators = [...bridge.generators]
-    generators.reverse()
-    for (let generator of generators) {
-      config.config.generators.unshift(generator)
-    }
+}
+
+const validConfigProps = (config) => {
+  const valid = [ 
+    'hierarchy', 
+    'objects', 
+    'bridges', 
+    'operators', 
+    'words', 
+    'priorities', 
+    'associations', 
+    'name', 
+    'version', 
+    'generatorp', 
+    'generators', 
+    'semantics', 
+    'where', 
+    'floaters', 
+    'debug',
+
+    // TODO Fix these from the test app
+    'implicits',
+    'convolution',
+    'expected_generated',
+    'expected_results',
+    'skipSemantics',
+    'description',
+    'contexts',
+    'utterances',
+    'flatten',
+
+    'namespaces',
+    'eqClasses',
+  ]
+  helpers.validProps(valid, config, 'config')
+}
+
+const setupInitializerFNArgs = (config, args) => {
+  const aw = (word, def) => config.addWord(word, def, args.uuid)
+  const ag = (generator) => config.addGenerator(generator, args.uuid, config.name)
+  const km = (name) => config.getConfig(name)
+  const apis = (name) => config.getConfig(name).api
+
+  return {
+    ...args,
+    addWord: aw,
+    addGenerator: ag,
+    config: config.getPseudoConfig(args.uuid, args.currentConfig),
+    km,
+    baseConfig: config,
+    apis,
   }
-  if (bridge.generatorpr) {
-    bridge.generatorp = bridge.generatorpr
-    bridge.generatorr = bridge.generatorpr
+}
+
+const operatorKey_valid = (key) => {
+  if (
+        !_.isArray(key) ||
+        key.length != 2 ||
+        !_.isString(key[0]) ||
+        !_.isInteger(key[1]) ||
+        key[1] < 0
+     ) {
+
+    let details = ''
+    if (!_.isArray(key)) {
+      details = "Expected an array."
+    } else if (key.length != 2) {
+      details = "Expected an array of length two."
+    } else if (!_.isString(key[0])) {
+      details = "Expected element zero to be a string that is an operator id."
+    } else if (!_.isInteger(key[1])) {
+      details = "Expected element one to be a number that is an operator level."
+    } else if (key[1] < 0) {
+      details = "Expected element one to be a number that is an operator level which is greater than zero."
+    }
+    throw new Error(`${JSON.stringify(key)} is not a valid operator key. Values are of the form [<operatorId>, <operatorLevel>]. ${details}`)
   }
-  if (bridge.generatorp) {
-    config.config.generators.unshift({ 
-      where: bridge.generatorp.where || bridge.where || client.where(4),
-      match: ({context}) => bridge.id == context.marker && context.paraphrase,
-      apply: (args) => bridge.generatorp(args),
-      applyWrapped: bridge.generatorp,
-      property: 'generatorp',
-    })
+}
+
+const elist = (list, check, prefix) => {
+  for ([index, element] of list.entries()) {
+    try {
+      check(element)
+    } catch( e ) {
+      throw new Error(prefix(index, e))
+    }
   }
-  if (bridge.generatorr) {
-    config.config.generators.unshift({ 
-      // TODO merge response and isResponse
-      where: bridge.generatorr.where || bridge.where || client.where(3),
-      match: ({context}) => bridge.id == context.marker && !context.paraphrase && (context.response || context.isResponse),
-      apply: (args) => bridge.generatorr(args),
-      applyWrapped: bridge.generatorr,
-      property: 'generatorr',
-    })
+}
+const priorities_valid = (cps) => {
+  elist(cps, (cp) => priority_valid(cp),  (index, e) => `priorities has an invalid priority at position ${index}. ${e}`)
+}
+
+const priority_valid = (cp) => {
+  if (!cp.context) {
+    throw new Error(`The priority ${JSON.stringify(cp)} is missing the "context" property. That is a list of the operator keys that are to be prioritized differently.`)
   }
-  if (bridge.evaluator) {
-    config.config.semantics.unshift({ 
-      where: bridge.evaluator.where || bridge.where || client.where(3),
-      match: ({context}) => bridge.id == context.marker && context.evaluate,
-      apply: (args) => bridge.evaluator(args),
-      applyWrapped: bridge.evaluator,
-      property: 'evaluator',
-    })
+  if (!_.isArray(cp.context)) {
+    throw new Error(`The priority ${JSON.stringify(cp)} has an invalid "context" value. That is a list of the operator keys that are to be prioritized differently.`)
   }
-  if (bridge.semantic) {
-    config.config.semantics.unshift({ 
-      where: bridge.semantic.where || bridge.where || client.where(3),
-      match: ({context}) => bridge.id == context.marker,
-      apply: (args) => bridge.semantic(args),
-      applyWrapped: bridge.semantic,
-      property: 'semantic',
-    })
+  elist(cp.context, (element) => operatorKey_valid(element), (index, e) => `The priority ${JSON.stringify(cp)} has an invalid operator key at position ${index}. ${e}`)
+  if (!_.isArray(cp.choose)) {
+    throw new Error(`The priority ${JSON.stringify(cp)} has an invalid "choose" value. The value should be a list of the operators in the context to consider for prioritization.`)
   }
+  elist(cp.choose, 
+      (element) => {
+        if (!element && element !== 0) {
+          throw new Error(`The value should be an index into the "context" property of the operator that is to be considered for prioritization.`)
+        }
+        if (!_.isInteger(element) || element < 0 || element >= cp.context.length) {
+          throw new Error(`The value should be an index into the "context" property of the operator that is to be considered for prioritization. Valid values are between 0 and ${cp.context.length-1}.`)
+        }
+      }, 
+      (index, e) => `The choose property in the priority ${JSON.stringify(cp)} has an invalid index at position ${index}. ${e}`
+  )
 }
 
-const handleCalculatedProps = (baseConfig, moreConfig) => {
-  for (let bridge of moreConfig.bridges) {
-    const valid = [ 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
-                    'level', 'optional', 'selector', 'semantic',  'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where' ]
+const handleBridgeProps = (config, bridge, addFirst) => {
+  ecatch(`While processing the bridge for ${bridge.id}#${bridge.level}`,
+    () => {
+      if (!bridge.bridge) {
+        bridge.bridge = "{ ...next(operator) }"
+      }
+      if (!bridge.level) {
+        bridge.level = 0
+      }
+      if (bridge.children) {
+        for (let child of bridge.children) {
+          config.addHierarchy(child, bridge.id)
+        }
+      }
+      if (bridge.parents) {
+        for (let parent of bridge.parents) {
+          config.addHierarchy(bridge.id, parent)
+        }
+      }
+      if (bridge.isA) {
+        for (let parent of bridge.isA) {
+          config.addHierarchy(bridge.id, parent)
+        }
+      }
+      if (bridge.before) {
+        for (let after of bridge.before) {
+          if (typeof after == 'string') {
+            after = [after, 0]
+          }
+          config.addPriority({ context: [[bridge.id, bridge.level], after], choose: [0] })
+        }
+      }
+      if (bridge.after) {
+        for (let before of bridge.after) {
+          if (typeof before == 'string') {
+            before = [before, 0]
+          }
+          config.addPriority({ context: [before, [bridge.id, bridge.level]], choose: [0] })
+        }
+      }
+      if (bridge.words) {
+        for (let def of bridge.words) {
+          if (typeof def == 'string') {
+            config.addWordInternal(def, {"id": bridge.id, "initial": `{ value: "${def}"}` })
+          } else {
+            const word = def.word
+            def = { initial: JSON.stringify(def), id: bridge.id, word }
+            config.addWordInternal(word, def)
+          }
+        }
+      }
+      /*
+      if (bridge.generator) {
+        if (addFirst) {
+          config.config.generators.unshift(bridge.generator)
+        } else {
+          config.config.generators.push(bridge.generator)
+        }
+      }
+      */
+      if (bridge.generators) {
+        const generators = [...bridge.generators]
+        generators.reverse()
+        for (let generator of generators) {
+          if (addFirst) {
+            config.config.generators.unshift(generator)
+          } else {
+            config.config.generators.push(generator)
+          }
+        }
+      }
+      if (bridge.generatorpr) {
+        bridge.generatorp = bridge.generatorpr
+        bridge.generatorr = bridge.generatorpr
+      }
+      if (bridge.generatorp) {
+        const match = bridge.generatorp.match || (() => true)
+        const apply = typeof bridge.generatorp == 'function' ? bridge.generatorp : bridge.generatorp.apply || bridge.generatorp
+        const level = bridge.generatorp.level >= 0 ? bridge.generatorp.level : bridge.level + 1
+       
+        const generator = {
+          where: bridge.generatorp.where || bridge.where || client.where(4),
+          match: (args) => bridge.id == args.context.marker && args.context.level == level && args.context.paraphrase && match(args),
+          apply: (args) => apply(args),
+          applyWrapped: apply,
+          property: 'generatorp',
+        }
+        if (addFirst) {
+          config.config.generators.unshift(generator)
+        } else {
+          config.config.generators.push(generator)
+        }
+
+      }
+      if (bridge.generatorr) {
+        const match = bridge.generatorr.match || (() => true)
+        const apply = typeof bridge.generatorr == 'function' ? bridge.generatorr : bridge.generatorr.apply || bridge.generatorr
+        const level = bridge.generatorr.level >= 0 ? bridge.generatorr.level : bridge.level + 1
+        const generator = {
+          where: bridge.generatorr.where || bridge.where || client.where(4),
+          match: (args) => bridge.id == args.context.marker && args.context.level == level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && match(args),
+          apply: (args) => apply(args),
+          applyWrapped: apply,
+          property: 'generatorr',
+        }
+        if (addFirst) {
+          config.config.generators.unshift(generator)
+        } else {
+          config.config.generators.push(generator)
+        }
+      }
+      if (bridge.evaluator) {
+        const semantic = {
+          where: bridge.evaluator.where || bridge.where || client.where(3),
+          match: ({context}) => bridge.id == context.marker && context.evaluate,
+          apply: (args) => bridge.evaluator(args),
+          applyWrapped: bridge.evaluator,
+          property: 'evaluator',
+        }
+        if (addFirst) {
+          config.config.semantics.unshift(semantic)
+        } else {
+          config.config.semantics.push(semantic)
+        }
+      }
+      if (bridge.semantic) {
+        const semantic = {
+          where: bridge.semantic.where || bridge.where || client.where(3),
+          match: ({context}) => bridge.id == context.marker,
+          apply: (args) => bridge.semantic(args),
+          applyWrapped: bridge.semantic,
+          property: 'semantic',
+        }
+        if (addFirst) {
+          config.config.semantics.unshift(semantic)
+        } else {
+          config.config.semantics.push(semantic)
+        }
+      }
+    }
+  )
+}
+
+const handleCalculatedProps = (baseConfig, moreConfig, addFirst) => {
+  for (let bridge of (moreConfig.bridges || [])) {
+    const valid = [ 'after', 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
+                    'level', 'optional', 'selector', 'semantic',  'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where', 'uuid' ]
     helpers.validProps(valid, bridge, 'bridge')
-    handleBridgeProps(baseConfig, bridge)
+    handleBridgeProps(baseConfig, bridge, addFirst)
   }
   if (moreConfig.operators) {
     moreConfig.operators = moreConfig.operators.map((operator) => {
@@ -137,13 +364,31 @@ if (runtime.process.env.DEBUG_HIERARCHY) {
   global.entodictonDebugHierarchy = JSON.parse(runtime.process.env.DEBUG_HIERARCHY)
 }
 
+
+// i keep randomly doing one of the other so I will just make both work the same way
+if (runtime.process.env.DEBUG_PRIORITIES) {
+  global.entodictonDebugPriority = JSON.parse(runtime.process.env.DEBUG_PRIORITIES)
+}
+if (runtime.process.env.DEBUG_PRIORITY) {
+  global.entodictonDebugPriority = JSON.parse(runtime.process.env.DEBUG_PRIORITY)
+}
+
+if (runtime.process.env.DEBUG_CONTEXTUAL_PRIORITY) {
+  global.entodictonDebugContextualPriority = JSON.parse(runtime.process.env.DEBUG_CONTEXTUAL_PRIORITY)
+}
+
+if (runtime.process.env.DEBUG_ASSOCIATION) {
+  global.entodictonDebugAssociation = JSON.parse(runtime.process.env.DEBUG_ASSOCIATION)
+}
+
 if (runtime.process.env.DEBUG_BRIDGE) {
   // id/level
   global.entodictonDebugBridge = runtime.process.env.DEBUG_BRIDGE.split('/')
   if (global.entodictonDebugBridge.length !== 2) {
     console.log('Expected DEBUG_BRIDGE to be of the form "id/level"');
+    process.exit(-1)
   }
-  global.entodictonDebugBridge[1] = int(global.entodictonDebugBridge[1])
+  global.entodictonDebugBridge[1] = parseInt(global.entodictonDebugBridge[1])
 }
 
 if (runtime.process.env.DEBUG_OPERATOR) {
@@ -161,7 +406,7 @@ const hierarchyCanonical = (element) => {
 
 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)}`
+    throw new Error(`In the KM "${config.name}", for the word ${word} the following definition is missing the "id" property: ${JSON.stringify(def)}`)
   }
   /*
   if (!def.initial) {
@@ -214,6 +459,14 @@ const normalizeConfig = (config) => {
         }
       }
     }
+
+    if (config.semantics) {
+      for (let semantic of config.semantics) {
+        if (semantic.oneShot) {
+          semantic.id = uuid()
+        }
+      }
+    }
   }
 }
 
@@ -421,8 +674,8 @@ const multiApiImpl = (initializer) => {
       initializer(config, api)
       const name = api.getName()
       multiApi.apis[name] = api
-      api.objects = config.get('objects')
-      api.config = () => config
+      // api.objects = config.get('objects')
+      // api.config = () => config
       multiApi.current = name
     },
 
@@ -433,11 +686,13 @@ const multiApiImpl = (initializer) => {
       }
     },
 
+    /*
     set objects (value) {
       for (const key in Object.keys(this.apis)) {
         this.apis[key].objects = value
       }
     },
+    */
 
     // "product1": apiInstance(testData1),
     apis: {
@@ -451,6 +706,47 @@ const multiApiImpl = (initializer) => {
 
 class Config {
 
+  toServer (config) {
+    return config_toServer(config)
+  }
+
+  base () {
+    const base = new Config()
+    for (let km of this.configs.reverse()) {
+      if (km.isSelf) {
+        continue
+      }
+      base.add(km.config)
+    }
+    return base
+  }
+
+  getPseudoConfig (uuid, config) {
+    return {
+      description: "this is a pseudo config that has limited functionality due to being available in the initializer function context",
+      addAssociation: (...args) => this.addAssociation(...args),
+      addAssociations: (...args) => this.addAssociations(...args),
+      addBridge: (...args) => this.addBridge(...args, uuid),
+      addGenerator: (...args) => this.addGenerator(...args, uuid, config.name),
+      addHierarchy: (...args) => this.addHierarchy(...args),
+      addOperator: (...args) => this.addOperator(...args, uuid),
+      addPriority: (...args) => this.addPriority(...args),
+      addPriorities: (...args) => this.addPriorities(...args),
+      addSemantic: (...args) => this.addSemantic(...args, uuid, config.name),
+      removeSemantic: (...args) => this.removeSemantic(...args, uuid, config.name),
+      addWord: (...args) => this.addWord(...args, uuid),
+
+      getHierarchy: (...args) => this.config.hierarchy,
+      getBridges: (...args) => this.config.bridges,
+
+      addArgs: (...args) => this.addArgs(...args),
+      getBridge: (...args) => this.getBridge(...args),
+      fragment: (...args) => this.fragment(...args),
+      exists: (...args) => this.exists(...args),
+      addAPI: (...args) => this.addAPI(...args),
+    }
+  }
+
   inDevelopmentMode (call) {
     config.developmentModeOn += 1
     try {
@@ -489,9 +785,6 @@ class Config {
   }
 
   setTestConfig(testConfig) {
-    if (this.name == 'ui') {
-      console.log('ui setting testConfig')
-    }
     this.testConfig = testConfig
   }
 
@@ -614,8 +907,9 @@ class Config {
     return instance
   }
   */
-  getEvaluator (s, log, context) {
+  getEvaluator (s, calls, log, context) {
     const instance = s({ ...context, evaluate: true })
+    calls.touch(instance)
     if (!instance.evalue && !instance.verbatim && !instance.value) {
       this.warningNotEvaluated(log, context);
     }
@@ -670,7 +964,8 @@ class Config {
     }
   }
 
-  needsRebuild(template, instance, options = { rebuild: false }) {
+  // { rebuild: false, isModule: false }
+  needsRebuild(template, instance, options) {
     if (options.rebuild) {
       return true
     }
@@ -684,7 +979,103 @@ class Config {
     const instanceFragments = (instance.fragments || []).map((fragment) => fragment.key || fragment.query).map( toCanonical )
     const templateFragments = (template.fragments || []).concat(this.dynamicFragments).map( toCanonical )
     const sameFragments = helpers.safeEquals(templateFragments, instanceFragments)
-    const sameQueries = helpers.safeEquals((template.queries || []).map(helpers.updateQueries), (instance.queries || []))
+    const toCanonicalQuery = (queryOrConfig) => {
+      if (typeof queryOrConfig == 'string') {
+        const query = queryOrConfig
+        return query
+      } else {
+        const config = { ...queryOrConfig }
+        delete config.where
+        config.operators = (config.operators || []).map( (operator) => {
+          if (typeof operator == 'string') {
+            return { pattern: operator }
+          } else {
+            operator = { ...operator }
+            delete operator.uuid
+            return operator
+          }
+        })
+        config.bridges = (config.bridges || []).map( (bridge) => {
+          bridge = { ...bridge },
+          bridge.level = bridge.level || 0
+          delete bridge.uuid
+          return bridge
+        })
+        if (options.isModule) {
+          // things like webpack rewrite the functions if there are constants so this compare does not work
+          delete config.generators;
+          delete config.semantics;
+          config.bridges = (config.bridges || []).map((bridge) => {
+            bridge = {...bridge}
+            delete bridge.where
+            delete bridge.generatorp
+            delete bridge.generatorr
+            delete bridge.generatorpr
+            delete bridge.evaluator
+            delete bridge.semantic
+            return bridge
+          });
+        } else {
+          config.generators = (config.generators || []).map((generator) => {
+            generator = {...generator}
+            delete generator.where
+            generator.match = generator.match.toString()
+            generator.apply = generator.apply.toString()
+            return generator
+          })
+          config.semantics = (config.semantics || []).map((semantic) => {
+            semantic = {...semantic}
+            delete semantic.where
+            semantic.match = semantic.match.toString()
+            semantic.apply = semantic.apply.toString()
+            return semantic
+          })
+          config.bridges = (config.bridges || []).map((bridge) => {
+            bridge = {...bridge}
+            delete bridge.where
+            if (bridge.generatorp) {
+              bridge.generatorp = bridge.generatorp.toString()
+            }
+            if (bridge.generatorr) {
+              bridge.generatorr = bridge.generatorr.toString()
+            }
+            if (bridge.generatorpr) {
+              bridge.generatorpr = bridge.generatorpr.toString()
+            }
+            if (bridge.evaluator) {
+              bridge.evaluator = bridge.evaluator.toString()
+            }
+            if (bridge.semantic) {
+              bridge.semantic = bridge.semantic.toString()
+            }
+            return bridge
+          })
+        }
+        return config
+      }
+    }
+    const toCanonicalQueries = (elements) => {
+      return elements.map( toCanonicalQuery )
+    }
+
+    const sameQueries = helpers.safeEquals(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), toCanonicalQueries(instance.queries || []))
+
+    const debug = false
+    if (debug) {
+      if (!(instance && sameQueries && sameFragments)) {
+        if (!sameQueries) {
+          debugger
+          debugger
+        }
+        console.log("instance", instance)
+        console.log("sameQueries", sameQueries)
+        console.log("sameFragments", sameFragments)
+        console.log("templateFragments", templateFragments)
+        console.log("instanceFragments", instanceFragments)
+        console.log('template.queries', JSON.stringify(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), null, 2))
+        console.log("instance.queries", JSON.stringify(toCanonicalQueries(instance.queries || []), null, 2))
+      }
+    }
     return !(instance && sameQueries && sameFragments)
   }
 
@@ -700,18 +1091,21 @@ class Config {
     }
   }
 
+  toData (data) {
+    Object.assign(data, this.config)
+    config_toServer(data)
+  }
+
+  // loadTemplate
   load (template, instance, options = { rebuild: false } ) {
     this.validifyTemplate(template)
     instance.template = template
     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 })
+      client.rebuildTemplate({ config: this, target: this.name, beforeQuery: () => {}, template, ...options })
     } else {
       // no change
       // this.initInstances.push({ ...instance, name: config.name })
@@ -723,13 +1117,13 @@ class Config {
           "semantics",
           "associations",
         ]
-        return !properties.find( (property) => instance[property].length > 0 )
+        return !properties.find( (property) => instance[property] && instance[property].length > 0 )
       }
       if (!isEmpty(instance)) {
         instance.name = this.name
         this.initInstances.push(instance)
         this.instances.push(instance)
-        client.processInstance(this, instance)
+        client.loadInstance(this, instance)
       }
     }
   }
@@ -749,13 +1143,15 @@ class Config {
     }
   }
 
-
   addAssociations (associations) {
     for (let association of associations) {
       this.addAssociation(association)
     }
   }
 
+  debugConfig() {
+  }
+
   addAssociation (association) {
     if (!this.config.associations) {
       this.config.associations = {
@@ -763,24 +1159,30 @@ class Config {
         positive: []
       }
     }
-    if (global.entodictonDebugAssociation) {
-      if (helpers.safeEquals(global.entodictonDebugAssociation, association)) {
-        debugger; // debug association hit
-      }
-    }
+    debugAssociation(association)
     this.config.associations.positive.push(association)
     this._delta.json.associations.push({ action: 'add', association })
   }
 
   // TODO add more error checking to these like addHierarchy has
-  addPriorities (priorities) {
+  // TODO change name from priorities to priority
+  // [ context: <list of [id, level]>, choose: [<indexes of prioritized operator>], [ordered: [true|false]] ]
+  addPriority (priority) {
     if (!this.config.priorities) {
       this.config.priorities = []
     }
-    this.config.priorities.push(priorities)
-    this._delta.json.priorities.push({ action: 'add', priorities })
+    debugPriority(priority)
+    priority_valid(priority)
+    this.config.priorities.push(priority)
+    this._delta.json.priorities.push({ action: 'add', priority })
   }
- 
+
+  addPriorities (priorities) {
+    for (let priority of priorities) {
+      this.addPriority(priority)
+    }
+  }
+
   addHierarchy (child, parent) {
     if (child && parent || !child || Array.isArray(child) || (typeof child == 'string' && !parent)) {
       this.addHierarchyChildParent(child, parent)
@@ -793,16 +1195,12 @@ class Config {
   addHierarchyProperties (edge) {
     const { child, parent } = edge
     if (typeof child !== 'string') {
-      throw `addHierarchy expected child property to be a string. got ${JSON.stringify(child)}`
+      throw new Error(`addHierarchy expected child property to be a string. got ${JSON.stringify(child)}`)
     }
     if (typeof parent !== 'string') {
-      throw `addHierarchy expected parent property to be a string. got ${JSON.stringify(parent)}`
-    }
-    if (global.entodictonDebugHierarchy) {
-      if ((helpers.safeEquals.entodictonDebugHierarchy, [child, parent])) {
-        debugger; // debug hierarchy hit
-      }
+      throw new Error(`addHierarchy expected parent property to be a string. got ${JSON.stringify(parent)}`)
     }
+    debugHierarchy([child, parent])
     this.config.hierarchy.push(edge)
     // TODO greg11 this.hierarchy.addEdge(edge)
     this._delta.json.hierarchy.push([child, parent])
@@ -810,18 +1208,12 @@ class Config {
 
   addHierarchyChildParent (child, parent) {
     if (typeof child !== 'string') {
-      throw `addHierarchy expected child to be a string. got ${JSON.stringify(child)}`
+      throw new Error(`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)}`
+      throw new Error(`addHierarchy expected parent to be a string. got ${JSON.stringify(parent)}`)
     }
-
-    if (global.entodictonDebugHierarchy) {
-      if (helpers.safeEquals(global.entodictonDebugHierarchy, [child, parent])) {
-        debugger; // debug hierarchy hit
-      }
-    }
-
+    debugHierarchy([child, parent])
     if (this.config.hierarchy.find( (element) => {
       const hc = hierarchyCanonical(element) 
       if (child == hc.child && parent == hc.parent) {
@@ -837,24 +1229,24 @@ class Config {
   }
 
   getBridge (id, level) {
-    return this.config.bridges.find( (bridge) => bridge.id == id && bridge.level == level )
+    if (level) {
+      return this.config.bridges.find( (bridge) => bridge.id == id && bridge.level == level )
+    } else {
+      return this.config.bridges.find( (bridge) => bridge.id == id)
+    }
   }
 
-  addBridge (bridge) {
+  addBridge (bridge, uuid) {
     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
-      }
-    }
-
+    const def = Object.assign({}, bridge, { uuid: uuid || this._uuid })
+ 
+    debugBridge(bridge)
     if (bridge.allowDups) {
-      if (bridges.find( (b) => b.id == bridge.id && b.level == bridge.level && b.bridge == bridge.bridge )) {
+      // if (bridges.find( (b) => b.id == bridge.id && b.level == bridge.level && b.bridge == bridge.bridge )) {
+      if (bridges.find( (b) => b.id == bridge.id && b.level == bridge.level)) {
         return;
       }
     }
@@ -867,17 +1259,12 @@ class Config {
     this._delta.json.bridges.push({ action: 'add', bridge: def })
   }
 
-  addGenerator (match, apply) {
-    let generator = match
-    if ((typeof match === 'function') && (typeof apply === 'function')) {
-      generator = { match, apply }
-    }
-
+  addGenerator (generator, uuid, name) {
     if (!(typeof generator.match === 'function')) {
-      throw 'addGenerator: Expected matcher to be a function'
+      throw new Error('addGenerator: Expected matcher to be a function')
     }
     if (!(typeof generator.apply === 'function')) {
-      throw 'addGenerator: Expected action to be a function'
+      throw new Error('addGenerator: Expected action to be a function')
     }
 
     if (!this.config.generators) {
@@ -889,22 +1276,18 @@ class Config {
     }
 
     const generators = this.config.generators
-    Object.assign(generator, { uuid: this._uuid, km: this.name, index: generators.length })
+    Object.assign(generator, { uuid: uuid || this._uuid, km: name || 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 }
-    }
-
+  addSemantic (semantic, uuid, name) {
     if (!(typeof semantic.match === 'function')) {
-      throw 'addSemantic: Expected match to be a function'
+      throw new Error('addSemantic: Expected match to be a function')
     }
+
     if (!(typeof semantic.apply === 'function')) {
-      throw 'addSemantic: Expected apply to be a function'
+      throw new Error('addSemantic: Expected apply to be a function')
     }
 
     if (!this.config.semantics) {
@@ -916,11 +1299,18 @@ class Config {
     }
 
     const semantics = this.config.semantics
-    Object.assign(semantic, { uuid: this._uuid, km: this.name, index: semantics.length })
+    Object.assign(semantic, { uuid: uuid || semantic.uuid || this._uuid, km: name || this.name, index: semantics.length, id: semantic.id || uuidv4() })
     semantics.unshift(semantic)
   }
 
-  addOperator (objectOrPattern) {
+  removeSemantic(deleteSemantic) {
+    const index = this.config.semantics.findIndex( (semantic) => semantic.id === deleteSemantic.id )
+    if (index >= 0) {
+      this.config.semantics.splice(index, 1)
+    }
+  }
+
+  addOperator (objectOrPattern, uuid) {
     if (!this.config.operators) {
       this.config.operators = []
     }
@@ -929,16 +1319,12 @@ class Config {
 
     let operator;
     if (typeof objectOrPattern === 'string') {
-      operator = { pattern: objectOrPattern, uuid: this._uuid }
+      operator = { pattern: objectOrPattern, uuid: uuid || this._uuid }
     } else {
-      operator = Object.assign({}, objectOrPattern, { uuid: this._uuid })
+      operator = Object.assign({}, objectOrPattern, { uuid: uuid || this._uuid })
     }
 
-    if (global.entodictonDebugOperator) {
-      if (operator.pattern === global.entodictonDebugOperator) {
-        debugger; // debug operator hit
-      }
-    }
+    debugOperator(operator)
 
     if (operator.allowDups) {
       if (operators.find( (o) => o.pattern == operator.pattern )) {
@@ -952,16 +1338,16 @@ class Config {
     this._delta.json.operators.push({ action: 'add', operator })
   }
 
-  addWord (word, def) {
-    this.addWordInternal(word, def)
+  addWord (word, def, uuid) {
+    this.addWordInternal(word, def, uuid)
   }
 
-  addWordInternal (word, def) {
+  addWordInternal (word, def, uuid) {
     if (!this.config.words) {
       this.config.words = {}
     }
     const words = this.config.words
-    def = Object.assign({}, def, { uuid: this._uuid })
+    def = Object.assign({}, def, { uuid: uuid || this._uuid })
     if (words[word]) {
       if (!words[word].some((e) => helpers.safeEquals(e, def))) {
         words[word].unshift(def)
@@ -1178,37 +1564,11 @@ class Config {
   // configs = [ { config, namespace } ... ]
   constructor (config, module) {
     if (config instanceof Config) {
-      throw 'Excepted the config argument to be a hash not a Config object'
+      throw new Error('Excepted the config argument to be a hash not a Config object')
     }
 
     if (config) {
-      const valid = [ 
-        'hierarchy', 
-        'objects', 
-        'bridges', 
-        'operators', 
-        'words', 
-        'priorities', 
-        'associations', 
-        'name', 
-        'version', 
-        'generators', 
-        'semantics', 
-        'floaters', 
-        'debug',
-
-        // TODO Fix these from the test app
-        'implicits',
-        'convolution',
-        'expected_generated',
-        'expected_results',
-        'skipSemantics',
-        'description',
-        'contexts',
-        'utterances',
-        'flatten',
-      ]
-      helpers.validProps(valid, config, 'config')
+      validConfigProps(config)
 
       config.operators = config.operators || []
       config.bridges = config.bridges || []
@@ -1259,7 +1619,7 @@ class Config {
       }
       duplicated = Array.from(duplicated)
       if (duplicated.length > 0) {
-        throw `In the KM ${config.name}, the following operators are duplicated in the bridges: ${duplicated}`
+        throw new Error(`In the KM ${config.name}, the following operators are duplicated in the bridges: ${duplicated}`)
       }
     }
 
@@ -1271,6 +1631,10 @@ class Config {
       }
     }
 
+    if (config && config.priorities) {
+      priorities_valid(config.priorities)
+    }
+
     normalizeConfig(config)
 
     // set the default server so stuff just works
@@ -1286,7 +1650,6 @@ class Config {
     if (config) {
       this.name = config.name
     }
-    this.motivations = []
     this.loadOrder = new DigraphInternal()
     this.wasInitialized = false
     this.configs = []
@@ -1311,6 +1674,7 @@ class Config {
     }
     this.get('objects').namespaced[this._uuid] = {}
     this.valid()
+    debugConfigProps(this.config)
   }
 
   addArgs(moreArgs) {
@@ -1341,7 +1705,10 @@ class Config {
   }
 
   delta () {
-    return { cacheKey: this._delta.cacheKey, json: this._delta.json }
+    return { 
+      cacheKey: this._delta.cacheKey, 
+      json: this._delta.json 
+    }
   }
 
   resetDelta (cacheKey) {
@@ -1374,24 +1741,26 @@ class Config {
     if (this._api && this._api.multiApi) {
       this._api.add(this, this._api, api)
     } else {
-      throw "Can only add apis to a multi-api";
+      throw new Error("Can only add apis to a multi-api")
     }
   }
 
   set api (value) {
     if (!value.initialize) {
-      throw `Expected the API to have an initialize function for ${this.name}.`
+      throw new Error(`Expected the API to have an initialize function for ${this.name}.`)
     }
 
     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
+        // this._api.objects = this.config.objects
+        // this._api.config = () => this
+        // this._api.uuid = this._uuid
       }
+      */
       this.rebuild()
     }
   }
@@ -1434,40 +1803,6 @@ class Config {
     // this.valid() init was not run because the kms are not all setup yet
   }
 
-  // motivation === { match, apply, uuid }
-  addMotivation (motivation) {
-    if (!motivation.uuid) {
-      motivation.uuid = this.uuid
-    }
-    this.motivations.push(motivation)
-  }
-
-  resetMotivations () {
-    this.motivations = []
-  }
-
-  doMotivations (args, context) {
-    args = Object.assign({}, args, { context })
-    // console.log('src/config doMotivations this.uuid', this.uuid)
-    // args.objects = args.getObjects(this.uuid)
-    const motivations = this.motivations
-    this.motivations = []
-    let done = false
-    for (const motivation of motivations) {
-      args.objects = args.getObjects(motivation.uuid)
-      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)) {
@@ -1481,6 +1816,9 @@ class Config {
     runtime.fs.writeFileSync(fn, JSON.stringify(this.config, 0, 2))
   }
 
+  copy (options = { callInitializers: true }) {
+  }
+
   copy (options = { callInitializers: true }) {
     this.valid()
     const cp = new Config()
@@ -1490,15 +1828,14 @@ class Config {
     cp.transitoryMode = this.transitoryMode
     cp.configs = this.configs.map((km) => km.copy2(Object.assign({}, options, { getCounter: (name) => cp.getCounter(name), callInitializers: false })))
     cp._uuid = cp.configs[0]._uuid
+    // update uuid here set the uuid in the objects and add error checking
     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.loadedForTesting = this.loadedForTesting
     cp.initInstances = this.initInstances.slice()
@@ -1523,25 +1860,38 @@ class Config {
     }
     cp.mapUUIDs(map)
 
+    if (cp._uuid == 'concept2') {
+        // debugger
+    }
     if (options.callInitializers) {
       cp.rebuild(options)
-    }
-    if (cp._api) {
-      cp._api.objects = cp.config.objects
-      cp._api.config = () => (cp instanceof Config) ? cp : cp.config
-      cp._api.uuid = cp._uuid
-    }
+    } else {
+      // this mess is for duplicate into a KM after resetToOne was called
+      /*
+      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 = {}
+      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 (cp._uuid == 'concept2') {
+        if (!cp.api.objects.defaultTypesForHierarchy) {
+          debugger
+        }
+      }
+    */
     }
-    cp.configs.forEach((km) => {
-      // const namespace = km.namespace
-      cp.config.objects.namespaced[km._uuid] = {}
-    })
-
     cp.valid()
     return cp
   }
@@ -1641,38 +1991,33 @@ class Config {
       }
       */
       const objects = {}
-      const km = (name) => this.getConfig(name)
       if (config instanceof Config) {
-        // const aw = addWord(this.config, config.uuid)
-        const aw = (word, def) => this.addWord(word, def)
         this.get('objects').namespaced[config._uuid] = objects
+        /*
         if (config._api) {
-          config._api.objects = objects
-          config._api.config = () => this
+          // config._api.objects = objects
+          // config._api.config = () => this
         }
-        config.initializerFn({ addWord: aw, km, config, baseConfig: this, currentConfig: config, objects, namespace, uuid, api: config.api })
+        */
+        config.initializerFn(setupInitializerFNArgs(this, { testConfig: config, currentConfig: config, objects, namespace, uuid }))
       } else {
-        // const aw = addWord(this.config, this.uuid)
-        const aw = (word, def) => this.addWord(word, def)
         this.get('objects').namespaced[this._uuid] = objects
+        /*
         if (config._api) {
-          config._api.objects = objects
-          config._api.config = () => this
+          // 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.initializerFn(setupInitializerFNArgs(this, { testConfig: this, currentConfig: this, objects, namespace, uuid }))
       }
     })
-    this.instances.forEach((instance) => client.processInstance(this, instance))
+    this.instances.forEach((instance) => client.loadInstance(this, instance))
   }
 
   initialize ({ force = true } = {}) {
     if (force || !this.wasInitialized) {
-      // const aw = addWord(this.config, this.uuid)
-      const aw = (word, def) => this.addWord(word, def)
-      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.initializerFn(setupInitializerFNArgs(this, { testConfig: this, currentConfig: this, objects, uuid: this._uuid, namespace: '' }))
       this.wasInitialized = true
     }
   }
@@ -1680,29 +2025,22 @@ class Config {
   initializer (fn, options = {}) {
     if (options) {
       for (let option of Object.keys(options)) {
-        const validOptions = ['initAfterApi']
-        if (!['initAfterApi'].includes(option)) {
-          throw `For Config.initializer, unrecognized option ${option}. The valid options are ${validOptions}`
+        const validOptions = []
+        if (!validOptions.includes(option)) {
+          throw new Error(`For Config.initializer, unrecognized option ${option}. The valid options are ${validOptions}`)
         }
       }
     }
-    const { initAfterApi = false } = options;
     this.wasInitialized = false
-    this.initAfterApi = initAfterApi
-    this.initializerFn = (args) => {
+    this.initializerFn = (args, { dontCallFn } = {}) => {
       const transitoryMode = global.transitoryMode
       global.transitoryMode = false
       // const baseConfig = args.baseConfig
       const currentConfig = args.currentConfig
 
-      if (currentConfig.api) {
-        currentConfig.api.objects = args.objects
-        // GREG42 currentConfig.api.config = () => this
-        currentConfig.api.config = () => args.baseConfig
-        currentConfig.api.uuid = currentConfig._uuid
+      if (args.isAfterApi) {
+        fn(args)
       }
-      // this.instances.forEach( (instance) => client.processInstance(this, instance) )
-      fn(args)
       currentConfig.wasInitialized = true
       global.transitoryMode = transitoryMode
     }
@@ -1869,7 +2207,6 @@ class Config {
     }
     this.config.objects.namespaced = {}
     this.resetWasInitialized()
-    this.resetMotivations()
 
     // reorder configs base on load ordering
     {
@@ -1895,8 +2232,8 @@ class Config {
       this.config.objects.namespaced[km._uuid] = {}
       const namespacedObjects = this.config.objects.namespaced[km._uuid]
       this.setupNamespace(km)
-      // const aw = addWord(km.config.config ? km.config.config : km.config, km.config.uuid)
-      const aw = (word, def) => this.addWord(word, def)
+      // const aw = (word, def) => this.addWord(word, def)
+      // const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
       let config = km.config
      
       if (config.addedArgss) { 
@@ -1917,32 +2254,51 @@ class Config {
       }
       config.wasInitialized = false
       // TODO change name of config: to baseConfig:
-      const kmFn = (name) => this.getConfig(name)
+      const kmFn = (name) => {
+        const config = this.getConfig(name)
+        return config
+      }
       // const hierarchy = new DigraphInternal((config.config || {}).hierarchy)
-      const args = { isModule, addWord: aw, km: kmFn, hierarchy: this.hierarchy, config, baseConfig: this, currentConfig: config, uuid: config._uuid, objects: namespacedObjects, namespace, api: config.api }
-      config.initializerFn(args)
-      if (config.initAfterApi) {
-        // reverse the list
-        initAfterApis.unshift({ config, args })
-      } else {
-        if (interleaved) {
-          initAfterApis.unshift(null)
-        }
+      const args = new Object(setupInitializerFNArgs(this, { 
+        isModule, 
+        hierarchy: this.hierarchy, 
+        testConfig: config,
+        currentConfig: config, 
+        uuid: config._uuid, 
+        objects: namespacedObjects, 
+        namespace, 
+        api: config.api,
+      }))
+
+      const currentConfig = args.currentConfig
+
+      /*
+      if (args.currentConfig.api) {
+        // args.currentConfig.api.objects = args.objects
+        // TODO assign pseudo config?
+        // args.currentConfig.api.config = () => args.baseConfig
+        // args.currentConfig.api.uuid = args.currentConfig._uuid
+        args.currentConfig.wasInitialized = true
       }
-      // greg
+      */
+      // debugger
+      // greg55
+      config.initializerFn(args, { dontCallFn: true })
+        initAfterApis.unshift({ config, args })
       if (config._api) {
         if (config._api.initialize) {
           // reverse the list
-          inits.unshift( () => config._api.initialize({ config: this, km: kmFn, api: config._api }) )
+          // TODO sync up the args with initialize of config
+          inits.unshift( () => config._api.initialize({ config: this, km: kmFn, ...args, api: config._api }) )
           // config._api.initialize({ config, api: config._api })
         } else {
           if (interleaved) {
             inits.unshift(null)
           }
         }
-        config._api.objects = namespacedObjects
-        config._api.config = () => this
-        config._api.uuid = config._uuid
+        // config._api.objects = namespacedObjects
+        // config._api.config = () => this
+        // config._api.uuid = config._uuid
       } else {
         if (interleaved) {
           inits.unshift(null)
@@ -1984,10 +2340,9 @@ class Config {
         init()
       }
       for (let init of initAfterApis) {
-        // init.args.isAfterApi = true
         init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi: true })
       }
-      this.instances.forEach((instance) => client.processInstance(this, instance))
+      this.instances.forEach((instance) => client.loadInstance(this, instance))
     } else {
       const base = {
         operators: this.config.operators,
@@ -2016,19 +2371,19 @@ class Config {
         }
         // console.log('name -------------', name)
         if (inits[i]) {
+          // greg55
           inits[i]()
         }
         if (initAfterApis[i]) {
           const init = initAfterApis[i]
-          init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi: true })
+          init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi: true})
         }
         const instance = this.instances.find((instance) => instance.name == name)
         if (instance) {
-          client.processInstance(this, instance)
+          client.loadInstance(this, instance)
         }
         this.hierarchy.edges = this.config.hierarchy
       }
-      // this.instances.forEach((instance) => client.processInstance(this, instance))
     }
 
     if (reverseIt) {
@@ -2151,13 +2506,9 @@ class Config {
         }
         const km = (name) => this.getConfig(name)
         if (config instanceof Config) {
-          // const aw = addWord(this.config, config.uuid)
-          const aw = (word, def) => this.addWord(word, def)
-          config.initializerFn({ isModule: this.isModule, addWord: aw, baseConfig: this, km, currentConfig: config, config, objects: nsobjects, namespace, uuid, api: config.api })
+          config.initializerFn(setupInitializerFNArgs(this, { isModule: this.isModule, currentConfig: config, testConfig: config, objects: nsobjects, namespace, uuid }))
         } else {
-          // const aw = addWord(this.config, this.uuid)
-          const aw = (word, def) => this.addWord(word, def)
-          this.initializerFn({ isModule: this.isModule, addWord: aw, baseConfig: this, km, currentConfig: this, config: this, objects: nsobjects, namespace, uuid, api: this.api })
+          this.initializerFn(setupInitializerFNArgs(this, { isModule: this.isModule, currentConfig: this, testConfig: this, objects: nsobjects, namespace, uuid }))
         }
       })
     }
@@ -2214,10 +2565,18 @@ class Config {
 
     if (config.priorities) {
       let priorities = config.priorities
-      priorities = priorities.map((p) => {
-        return p.map((id) => {
-          return [toNS(id[0]), id[1]]
-        })
+      priorities = priorities.map((cp) => {
+        const { context, choose, ordered } = cp
+        const priority = {
+          context: context.map((id) => {
+            return [toNS(id[0]), id[1]]
+          }),
+          choose,
+        }
+        if (ordered) {
+          priority.ordered = ordered
+        }
+        return priority
       })
       config.priorities = priorities
     }
@@ -2307,14 +2666,14 @@ class Config {
 
   set (property, value) {
     if (!this.config.hasOwnProperty(property)) {
-      throw `Setting invalid property ${property}`
+      throw new Error(`Setting invalid property ${property}`)
     }
 
     if ('words' == property) {
       for (let word in value) {
         for (let def of value[word]) {
           if (!def['uuid']) {
-            throw `All definitions for '${property}' must have the uuid property set (config.uuid). uuid is missing from ${JSON.stringify(def)} for the word '${word}'`
+            throw new Error(`All definitions for '${property}' must have the uuid property set (config.uuid). uuid is missing from ${JSON.stringify(def)} for the word '${word}'`)
           }
         }
       }
@@ -2323,7 +2682,7 @@ class Config {
     if (['operators', 'bridges'].includes(property)) {
       for (let def of value) {
         if (!def['uuid']) {
-          throw `All definitions for '${property}' must have the uuid property set (config.uuid). uuid is missing from ${JSON.stringify(def)}`
+          throw new Error(`All definitions for '${property}' must have the uuid property set (config.uuid). uuid is missing from ${JSON.stringify(def)}`)
         }
       }
     }
@@ -2355,7 +2714,7 @@ class Config {
 
   add (more) {
     if (more === this) {
-      throw 'Cannot add an object to itself.'
+      throw new Error('Cannot add an object to itself.')
     }
     if (!(more instanceof Config)) {
       more = new Config(more)
@@ -2416,7 +2775,8 @@ class Config {
   }
 
   // TODO get rid of useOldVersion arg
-  addInternal (more, { useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false, handleCalculatedProps : hcps = false } = {}) {
+  addInternal (more, { addFirst = false, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false, handleCalculatedProps : hcps = false } = {}) {
+    validConfigProps(more)
     if (more instanceof Config) {
       more.initialize({ force: false })
       if (useOldVersion) {
@@ -2426,8 +2786,10 @@ class Config {
         more = _.cloneDeep(more.initConfig)
       }
     }
+    debugConfigProps(more)
+
     if (hcps) {
-      handleCalculatedProps(this, more)
+      handleCalculatedProps(this, more, addFirst)
       applyUUID(more, this._uuid)
     }
     for (const key of Object.keys(more)) {
@@ -2452,7 +2814,11 @@ class Config {
           if (!configWords[word]) {
             configWords[word] = []
           }
-          configWords[word] = configWords[word].concat(moreWords[word])
+          if (addFirst) {
+            configWords[word] = moreWords[word].concat(configWords[word])
+          } else {
+            configWords[word] = configWords[word].concat(moreWords[word])
+          }
         }
       } else if (key === 'name') {
         /*
@@ -2514,16 +2880,21 @@ class Config {
                   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])
+        if (addFirst) {
+          this.config[key] = more[key].concat(this.config[key])
+        } else {
+          this.config[key] = this.config[key].concat(more[key])
+        }
       } else {
         if (!(key in this.config)) {
-          throw `Unexpected property in config ${key}`
+          throw new Error(`Unexpected property in config ${key}`)
         }
         this.config[key] = more[key]
       }
@@ -2641,7 +3012,7 @@ class Config {
         this.config[key] = more[key].concat(this.config[key])
       } else {
         if (!(key in this.config)) {
-          throw `Unexpected property in config ${key}`
+          throw new Error(`Unexpected property in config ${key}`)
         }
         this.config[key] = more[key]
       }
@@ -2651,5 +3022,8 @@ class Config {
 }
 
 module.exports = {
-  Config
+  Config,
+  config_toServer,
+  operatorKey_valid,
+  handleBridgeProps,
 }