theprogrammablemind_4wp 7.5.8-beta.7 → 7.5.8-beta.71

package/src/config.js

@@ -1,7 +1,7 @@
 // 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')
@@ -22,7 +22,210 @@ const indent = (string, indent) => {
     return string.replace(/^/gm, ' '.repeat(indent));
 }
 
-const handleBridgeProps = (config, bridge) => {
+const config_toServer = (config) => {
+  if (config.contextual_priorities) {
+    config.contextual_priorities = config.contextual_priorities.map((cp) => {
+      return [cp.context, cp.choose]
+    })
+  }
+}
+
+const debugPriority = (priority) => {
+  if (global.entodictonDebugPriority) {
+    if (helpers.safeEquals(entodictonDebugPriority, priority)) {
+      debugger; // debug hierarchy hit
+    }
+  }
+}
+
+const debugAssociation = (association) => {
+  if (global.entodictonDebugAssociation) {
+    if (helpers.safeEquals(global.entodictonDebugAssociation, association)) {
+      debugger; // debug association hit
+    }
+  }
+}
+
+const debugContextualPriority = (contextual_priority) => {
+  if (global.entodictonDebugContextualPriority) {
+    if (helpers.safeEquals(entodictonDebugContextualPriority, contextual_priorities)) {
+      debugger; // debug hierarchy hit
+    }
+  }
+}
+
+const debugHierarchy = (pair) => {
+  if (global.entodictonDebugHierarchy) {
+    if (helpers.safeEquals(global.entodictonDebugHierarchy, pair)) {
+      debugger; // debug hierarchy hit
+    }
+  }
+}
+
+const debugBridge = (bridge) => { 
+  if (global.entodictonDebugBridge) {
+    if (global.entodictonDebugBridge[0] == bridge.id && global.entodictonDebugBridge[1] == bridge.level) {
+      debugger; // debug hierarchy hit
+    }
+  }
+}
+
+const debugOperator = (operator) => {
+  if (global.entodictonDebugOperator) {
+    if ((operator.pattern || operator) === global.entodictonDebugOperator) {
+      debugger; // debug operator hit
+    }
+  }
+}
+
+const debugConfigProps = (config) => {
+  const checkProps = [
+    { property: 'priorities', check: (v) => debugPriority(v) },
+    { property: 'association', check: (v) => debugAssociation(v) },
+    { property: 'contextual_priorities', check: (v) => debugContextualPriority(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)
+      }
+    }
+  }
+}
+
+const validConfigProps = (config) => {
+  const valid = [ 
+    'hierarchy', 
+    'objects', 
+    'bridges', 
+    'operators', 
+    'words', 
+    'priorities', 
+    'contextual_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,
+  }
+}
+
+const contextual_priorities_toServer = (cp) => {
+  if (cp.context && cp.choose) {
+    return [cp.context, cp.choose]
+  }
+  return cp
+}
+
+const contextual_priorities_toClient = (cp) => {
+  if (cp.context && cp.choose) {
+    return cp
+  }
+  return { context: cp[0], choose: cp[1] }
+}
+
+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}`)
+  }
+}
+
+const elist = (list, check, prefix) => {
+  for ([index, element] of list.entries()) {
+    try {
+      check(element)
+    } catch( e ) {
+      throw new Error(prefix(index, e))
+    }
+  }
+}
+const contextual_priorities_valid = (cps) => {
+  elist(cps, (cp) => contextual_priority_valid(cp),  (index, e) => `contextual_priorities has an invalid contextual priority at position ${index}. ${e}`)
+}
+
+const contextual_priority_valid = (cp) => {
+  if (!cp.context) {
+    throw new Error(`The contextual priority ${JSON.stringify(cp)} is missing the "context" property. That is a list of the operator keys that are to be prioritized differently.`)
+  }
+  if (!_.isArray(cp.context)) {
+    throw new Error(`The contextual priority ${JSON.stringify(cp)} has an invalid "context" value. That is a list of the operator keys that are to be prioritized differently.`)
+  }
+  elist(cp.context, (element) => operatorKey_valid(element), (index, e) => `The contextual priority ${JSON.stringify(cp)} has an invalid operator key at position ${index}. ${e}`)
+  if (!_.isArray(cp.choose)) {
+    throw new Error(`The contextual 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 contextual priority ${JSON.stringify(cp)} has an invalid index at position ${index}. ${e}`
+  )
+}
+
+const handleBridgeProps = (config, bridge, addFirst) => {
   ecatch(`While processing the bridge for ${bridge.id}#${bridge.level}`,
     () => {
       if (!bridge.bridge) {
@@ -51,7 +254,7 @@ const handleBridgeProps = (config, bridge) => {
           if (typeof after == 'string') {
             after = [after, 0]
           }
-          config.addPriorities([after, [bridge.id, bridge.level]])
+          config.addPriorities([[bridge.id, bridge.level], after])
         }
       }
       if (bridge.after) {
@@ -59,7 +262,7 @@ const handleBridgeProps = (config, bridge) => {
           if (typeof before == 'string') {
             before = [before, 0]
           }
-          config.addPriorities([[bridge.id, bridge.level], before])
+          config.addPriorities([before, [bridge.id, bridge.level]])
         }
       }
       if (bridge.words) {
@@ -68,19 +271,29 @@ const handleBridgeProps = (config, bridge) => {
             config.addWordInternal(def, {"id": bridge.id, "initial": `{ value: "${def}"}` })
           } else {
             const word = def.word
-            def = { initial: JSON.stringify(def), id: bridge.id, word: undefined }
+            def = { initial: JSON.stringify(def), id: bridge.id, word }
             config.addWordInternal(word, def)
           }
         }
       }
+      /*
       if (bridge.generator) {
-        config.config.generators.unshift(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) {
-          config.config.generators.unshift(generator)
+          if (addFirst) {
+            config.config.generators.unshift(generator)
+          } else {
+            config.config.generators.push(generator)
+          }
         }
       }
       if (bridge.generatorpr) {
@@ -91,66 +304,76 @@ const handleBridgeProps = (config, bridge) => {
         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
-        config.config.generators.unshift({ 
+       
+        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
-        config.config.generators.unshift({ 
+        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 (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',
-        })
+        }
+        if (addFirst) {
+          config.config.generators.unshift(generator)
+        } else {
+          config.config.generators.push(generator)
+        }
       }
-      */
       if (bridge.evaluator) {
-        config.config.semantics.unshift({ 
+        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) {
-        config.config.semantics.unshift({ 
+        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) => {
-  for (let bridge of moreConfig.bridges) {
+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' ]
+                    '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) => {
@@ -171,6 +394,10 @@ 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)
 }
@@ -252,6 +479,14 @@ const normalizeConfig = (config) => {
         }
       }
     }
+
+    if (config.semantics) {
+      for (let semantic of config.semantics) {
+        if (semantic.oneShot) {
+          semantic.id = uuid()
+        }
+      }
+    }
   }
 }
 
@@ -459,8 +694,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
     },
 
@@ -471,11 +706,13 @@ const multiApiImpl = (initializer) => {
       }
     },
 
+    /*
     set objects (value) {
       for (const key in Object.keys(this.apis)) {
         this.apis[key].objects = value
       }
     },
+    */
 
     // "product1": apiInstance(testData1),
     apis: {
@@ -489,6 +726,46 @@ 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),
+      addContextualPriority: (...args) => this.addContextualPriority(...args),
+      addGenerator: (...args) => this.addGenerator(...args, uuid, config.name),
+      addHierarchy: (...args) => this.addHierarchy(...args),
+      addOperator: (...args) => this.addOperator(...args, uuid),
+      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),
+      addAPI: (...args) => this.addAPI(...args),
+    }
+  }
+
   inDevelopmentMode (call) {
     config.developmentModeOn += 1
     try {
@@ -527,9 +804,6 @@ class Config {
   }
 
   setTestConfig(testConfig) {
-    if (this.name == 'ui') {
-      console.log('ui setting testConfig')
-    }
     this.testConfig = testConfig
   }
 
@@ -548,6 +822,7 @@ class Config {
       },
       eqClasses: [],
       priorities: [], // Done
+      contextual_priorities: [],
       version: '3',
       debug: false,
       associations: { // Done
@@ -586,6 +861,7 @@ class Config {
           'namespaces',
           'eqClasses',
           'priorities',
+          'contextual_priorities',
           'associations',
           'words',
           'floaters',
@@ -709,7 +985,8 @@ class Config {
     }
   }
 
-  needsRebuild(template, instance, options = { rebuild: false }) {
+  // { rebuild: false, isModule: false }
+  needsRebuild(template, instance, options) {
     if (options.rebuild) {
       return true
     }
@@ -723,7 +1000,41 @@ 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
+        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
+        } 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
+          })
+        }
+        return config
+      }
+    }
+    const toCanonicalQueries = (elements) => {
+      return elements.map( toCanonicalQuery )
+    }
+
+    const sameQueries = helpers.safeEquals(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), toCanonicalQueries(instance.queries || []))
     return !(instance && sameQueries && sameFragments)
   }
 
@@ -739,6 +1050,12 @@ 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
@@ -750,7 +1067,7 @@ class Config {
       // 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 })
@@ -768,7 +1085,7 @@ class Config {
         instance.name = this.name
         this.initInstances.push(instance)
         this.instances.push(instance)
-        client.processInstance(this, instance)
+        client.loadInstance(this, instance)
       }
     }
   }
@@ -795,6 +1112,9 @@ class Config {
     }
   }
 
+  debugConfig() {
+  }
+
   addAssociation (association) {
     if (!this.config.associations) {
       this.config.associations = {
@@ -802,29 +1122,34 @@ 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
+  // TODO change name from priorities to priority
   addPriorities (priorities) {
     if (!this.config.priorities) {
       this.config.priorities = []
     }
-    if (global.entodictonDebugPriority) {
-      if (helpers.safeEquals(entodictonDebugPriority, priorities)) {
-        debugger; // debug hierarchy hit
-      }
-    }
+    debugPriority(priorities)
     this.config.priorities.push(priorities)
     this._delta.json.priorities.push({ action: 'add', priorities })
   }
 
+  // [ operators: <list of [id, level]>, select: <index of prioritized operator> ]
+  addContextualPriority(contextual_priority) {
+    if (!this.config.contextual_priorities) {
+      this.config.contextual_priorities = []
+    }
+    debugContextualPriority(contextual_priority)
+    contextual_priority_valid(contextual_priority)
+    this.config.contextual_priorities.push(contextual_priority)
+    const cpServer = contextual_priorities_toServer(contextual_priority)
+    this._delta.json.contextual_priorities.push({ action: 'add', contextual_priority: cpServer })
+  }
+
   addHierarchy (child, parent) {
     if (child && parent || !child || Array.isArray(child) || (typeof child == 'string' && !parent)) {
       this.addHierarchyChildParent(child, parent)
@@ -842,11 +1167,7 @@ class Config {
     if (typeof parent !== 'string') {
       throw new Error(`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
-      }
-    }
+    debugHierarchy([child, parent])
     this.config.hierarchy.push(edge)
     // TODO greg11 this.hierarchy.addEdge(edge)
     this._delta.json.hierarchy.push([child, parent])
@@ -859,13 +1180,7 @@ class Config {
     if (typeof parent !== 'string') {
       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) {
@@ -881,22 +1196,21 @@ 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 )) {
         return;
@@ -911,12 +1225,7 @@ 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 new Error('addGenerator: Expected matcher to be a function')
     }
@@ -933,20 +1242,16 @@ 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 new Error('addSemantic: Expected match to be a function')
     }
+
     if (!(typeof semantic.apply === 'function')) {
       throw new Error('addSemantic: Expected apply to be a function')
     }
@@ -960,11 +1265,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 = []
     }
@@ -973,16 +1285,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 )) {
@@ -996,16 +1304,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)
@@ -1226,33 +1534,7 @@ class Config {
     }
 
     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 || []
@@ -1262,6 +1544,7 @@ class Config {
       config.hierarchy = config.hierarchy || []
       config.associations = config.associations || { negative: [], positive: [] }
       config.priorities = config.priorities || []
+      config.contextual_priorities = config.contextual_priorities || []
     }
 
     this.maxDepth = 20 // for generators and semantics
@@ -1315,6 +1598,10 @@ class Config {
       }
     }
 
+    if (config && config.contextual_priorities) {
+      contextual_priorities_valid(config.contextual_priorities)
+    }
+
     normalizeConfig(config)
 
     // set the default server so stuff just works
@@ -1330,7 +1617,6 @@ class Config {
     if (config) {
       this.name = config.name
     }
-    this.motivations = []
     this.loadOrder = new DigraphInternal()
     this.wasInitialized = false
     this.configs = []
@@ -1385,7 +1671,10 @@ class Config {
   }
 
   delta () {
-    return { cacheKey: this._delta.cacheKey, json: this._delta.json }
+    return { 
+      cacheKey: this._delta.cacheKey, 
+      json: this._delta.json 
+    }
   }
 
   resetDelta (cacheKey) {
@@ -1397,6 +1686,7 @@ class Config {
         bridges: [],
         associations: [],
         priorities: [],
+        contextual_priorities: [],
         hierarchy: [],
       }
     }
@@ -1431,11 +1721,13 @@ class Config {
       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()
     }
   }
@@ -1478,40 +1770,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, api: this.api })
-    // 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)) {
@@ -1525,6 +1783,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()
@@ -1534,15 +1795,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()
@@ -1567,25 +1827,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
   }
@@ -1685,38 +1958,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
     }
   }
@@ -1724,29 +1992,22 @@ class Config {
   initializer (fn, options = {}) {
     if (options) {
       for (let option of Object.keys(options)) {
-        const validOptions = ['initAfterApi']
-        if (!['initAfterApi'].includes(option)) {
+        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
     }
@@ -1913,7 +2174,6 @@ class Config {
     }
     this.config.objects.namespaced = {}
     this.resetWasInitialized()
-    this.resetMotivations()
 
     // reorder configs base on load ordering
     {
@@ -1939,8 +2199,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) { 
@@ -1961,45 +2221,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 = { 
+      const args = new Object(setupInitializerFNArgs(this, { 
         isModule, 
-        addWord: aw, 
-        km: kmFn, 
         hierarchy: this.hierarchy, 
-        config, 
-        baseConfig: this, 
+        testConfig: config,
         currentConfig: config, 
         uuid: config._uuid, 
         objects: namespacedObjects, 
         namespace, 
-        motivation: (m) => config.addMotivation(m),
-        api: config.api 
+        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
       }
-      config.initializerFn(args)
-      if (config.initAfterApi) {
-        // reverse the list
+      */
+      // debugger
+      // greg55
+      config.initializerFn(args, { dontCallFn: true })
         initAfterApis.unshift({ config, args })
-      } else {
-        if (interleaved) {
-          initAfterApis.unshift(null)
-        }
-      }
-      // greg
       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)
@@ -2041,16 +2307,16 @@ 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,
         bridges: this.config.bridges,
         hierarchy: this.config.hierarchy,
         priorities: this.config.priorities,
+        contextual_priorities: this.config.contextual_priorities,
         associations: this.config.associations,
         words: this.config.words
       }
@@ -2059,6 +2325,7 @@ class Config {
       this.config.bridges = []
       this.config.hierarchy = []
       this.config.priorities = []
+      this.config.contextual_priorities = []
       this.config.associations = { positive: [], negative: [] }
       this.config.words = {}
 
@@ -2073,19 +2340,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) {
@@ -2208,13 +2475,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 }))
         }
       })
     }
@@ -2279,6 +2542,20 @@ class Config {
       config.priorities = priorities
     }
 
+    if (config.contextual_priorities) {
+      let contextual_priorities = config.contextual_priorities
+      contextual_priorities = contextual_priorities.map((cp) => {
+        const { context, choose } = cp
+        return {
+          context: context.map((id) => {
+            return [toNS(id[0]), id[1]]
+          }),
+          choose
+        }
+      })
+      config.contextual_priorities = contextual_priorities
+    }
+
     for (const bag of bags) {
       if (config[bag]) {
         config[bag] = config[bag].map((b) => {
@@ -2473,7 +2750,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) {
@@ -2483,8 +2761,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)) {
@@ -2509,7 +2789,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') {
         /*
@@ -2571,13 +2855,18 @@ 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 new Error(`Unexpected property in config ${key}`)
@@ -2708,5 +2997,8 @@ class Config {
 }
 
 module.exports = {
-  Config
+  Config,
+  config_toServer,
+  operatorKey_valid,
+  handleBridgeProps,
 }