theprogrammablemind 7.10.0-beta.9 → 7.10.1-beta.0

package/src/config.js

@@ -1,7 +1,7 @@
 // lookup = (name) => returns <config>
 const { Semantics, normalizeGenerator } = require('./semantics')
 const { Generators } = require('./generators')
-const { v4 : uuidv4 } = require('uuid');
+const { v4: uuidv4 } = require('uuid')
 const client = require('../client')
 const DigraphInternal = require('./digraph_internal')
 const helpers = require('./helpers')
@@ -19,7 +19,7 @@ const bags = [
 ]
 
 const indent = (string, indent) => {
-    return string.replace(/^/gm, ' '.repeat(indent));
+  return string.replace(/^/gm, ' '.repeat(indent))
 }
 
 const config_toServer = (config) => {
@@ -29,7 +29,7 @@ const config_toServer = (config) => {
 const debugPriority = (priority) => {
   if (global.entodictonDebugPriority) {
     if (helpers.subPriority(entodictonDebugPriority, priority)) {
-      debugger; // debug hierarchy hit
+      debugger // debug hierarchy hit
     }
   }
 }
@@ -37,7 +37,7 @@ const debugPriority = (priority) => {
 const debugAssociation = (association) => {
   if (global.entodictonDebugAssociation) {
     if (helpers.safeEquals(global.entodictonDebugAssociation, association)) {
-      debugger; // debug association hit
+      debugger // debug association hit
     }
   }
 }
@@ -45,15 +45,15 @@ const debugAssociation = (association) => {
 const debugHierarchy = (pair) => {
   if (global.entodictonDebugHierarchy) {
     if (helpers.safeEquals(global.entodictonDebugHierarchy, pair)) {
-      debugger; // debug hierarchy hit
+      debugger // debug hierarchy hit
     }
   }
 }
 
-const debugBridge = (bridge) => { 
+const debugBridge = (bridge) => {
   if (global.entodictonDebugBridge) {
     if (global.entodictonDebugBridge[0] == bridge.id && global.entodictonDebugBridge[1] == bridge.level) {
-      debugger; // debug hierarchy hit
+      debugger // debug hierarchy hit
     }
   }
 }
@@ -61,7 +61,7 @@ const debugBridge = (bridge) => {
 const debugOperator = (operator) => {
   if (global.entodictonDebugOperator) {
     if ((operator.pattern || operator) === global.entodictonDebugOperator) {
-      debugger; // debug operator hit
+      debugger // debug operator hit
     }
   }
 }
@@ -75,7 +75,7 @@ const debugConfigProps = (config) => {
     { property: 'association', check: (v) => debugAssociation(v) },
     { property: 'hierarchy', check: (v) => debugHierarchy(v) },
     { property: 'operators', check: (v) => debugOperator(v) },
-    { property: 'bridges', check: (v) => debugBridge(v) },
+    { property: 'bridges', check: (v) => debugBridge(v) }
   ]
   for (const { property, check } of checkProps) {
     if (config[property]) {
@@ -87,21 +87,21 @@ const debugConfigProps = (config) => {
 }
 
 const validConfigProps = (config) => {
-  const valid = [ 
-    'hierarchy', 
-    'objects', 
-    'bridges', 
-    'operators', 
-    'words', 
-    'priorities', 
-    'associations', 
-    'name', 
-    'version', 
-    'generatorp', 
-    'generators', 
-    'semantics', 
-    'where', 
-    'floaters', 
+  const valid = [
+    'hierarchy',
+    'objects',
+    'bridges',
+    'operators',
+    'words',
+    'priorities',
+    'associations',
+    'name',
+    'version',
+    'generatorp',
+    'generators',
+    'semantics',
+    'where',
+    'floaters',
     'debug',
 
     // TODO Fix these from the test app
@@ -116,7 +116,7 @@ const validConfigProps = (config) => {
     'flatten',
 
     'namespaces',
-    'eqClasses',
+    'eqClasses'
   ]
   helpers.validProps(valid, config, 'config')
 }
@@ -134,30 +134,29 @@ const setupInitializerFNArgs = (config, args) => {
     config: config.getPseudoConfig(args.uuid, args.currentConfig),
     km,
     baseConfig: config,
-    apis,
+    apis
   }
 }
 
 const operatorKey_valid = (key) => {
   if (
-        !_.isArray(key) ||
+    !_.isArray(key) ||
         key.length != 2 ||
         !_.isString(key[0]) ||
         !_.isInteger(key[1]) ||
         key[1] < 0
-     ) {
-
+  ) {
     let details = ''
     if (!_.isArray(key)) {
-      details = "Expected an array."
+      details = 'Expected an array.'
     } else if (key.length != 2) {
-      details = "Expected an array of length two."
+      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."
+      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."
+      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."
+      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}`)
   }
@@ -167,13 +166,13 @@ const elist = (list, check, prefix) => {
   for ([index, element] of list.entries()) {
     try {
       check(element)
-    } catch( e ) {
+    } catch (e) {
       throw new Error(prefix(index, e))
     }
   }
 }
 const priorities_valid = (cps) => {
-  elist(cps, (cp) => priority_valid(cp),  (index, e) => `priorities has an invalid priority at position ${index}. ${e}`)
+  elist(cps, (cp) => priority_valid(cp), (index, e) => `priorities has an invalid priority at position ${index}. ${e}`)
 }
 
 const priority_valid = (cp) => {
@@ -187,16 +186,16 @@ const priority_valid = (cp) => {
   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}`
+  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}`
   )
 }
 
@@ -204,29 +203,29 @@ const handleBridgeProps = (config, bridge, addFirst) => {
   ecatch(`While processing the bridge for ${bridge.id}#${bridge.level}`,
     () => {
       if (!bridge.bridge) {
-        bridge.bridge = "{ ...next(operator) }"
+        bridge.bridge = '{ ...next(operator) }'
       }
       if (!bridge.level) {
         bridge.level = 0
       }
       if (bridge.children) {
-        for (let child of bridge.children) {
+        for (const child of bridge.children) {
           config.addHierarchy(child, bridge.id)
         }
       }
       if (bridge.parents) {
-        for (let parent of bridge.parents) {
+        for (const parent of bridge.parents) {
           config.addHierarchy(bridge.id, parent)
         }
       }
       if (bridge.isA) {
-        for (let parent of bridge.isA) {
+        for (const parent of bridge.isA) {
           config.addHierarchy(bridge.id, parent)
         }
       }
       if (bridge.before) {
         for (let after of bridge.before) {
-          if (typeof after == 'string') {
+          if (typeof after === 'string') {
             after = [after, 0]
           }
           config.addPriority({ context: [[bridge.id, bridge.level], after], choose: [0] })
@@ -234,7 +233,7 @@ const handleBridgeProps = (config, bridge, addFirst) => {
       }
       if (bridge.after) {
         for (let before of bridge.after) {
-          if (typeof before == 'string') {
+          if (typeof before === 'string') {
             before = [before, 0]
           }
           config.addPriority({ context: [before, [bridge.id, bridge.level]], choose: [0] })
@@ -242,8 +241,8 @@ const handleBridgeProps = (config, bridge, addFirst) => {
       }
       if (bridge.words) {
         for (let def of bridge.words) {
-          if (typeof def == 'string') {
-            config.addWordInternal(def, {"id": bridge.id, "initial": `{ value: "${def}"}` })
+          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 }
@@ -263,7 +262,7 @@ const handleBridgeProps = (config, bridge, addFirst) => {
       if (bridge.generators) {
         const generators = [...bridge.generators]
         generators.reverse()
-        for (let generator of generators) {
+        for (const generator of generators) {
           if (addFirst) {
             config.config.generators.unshift(generator)
           } else {
@@ -277,33 +276,32 @@ const handleBridgeProps = (config, bridge, addFirst) => {
       }
       if (bridge.generatorp) {
         const match = bridge.generatorp.match || (() => true)
-        const apply = typeof bridge.generatorp == 'function' ? bridge.generatorp : bridge.generatorp.apply || bridge.generatorp
+        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',
+          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 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',
+          property: 'generatorr'
         }
         if (addFirst) {
           config.config.generators.unshift(generator)
@@ -314,10 +312,10 @@ const handleBridgeProps = (config, bridge, addFirst) => {
       if (bridge.evaluator) {
         const semantic = {
           where: bridge.evaluator.where || bridge.where || client.where(3),
-          match: ({context}) => bridge.id == context.marker && context.evaluate,
+          match: ({ context }) => bridge.id == context.marker && context.evaluate,
           apply: (args) => bridge.evaluator(args),
           applyWrapped: bridge.evaluator,
-          property: 'evaluator',
+          property: 'evaluator'
         }
         if (addFirst) {
           config.config.semantics.unshift(semantic)
@@ -328,10 +326,10 @@ const handleBridgeProps = (config, bridge, addFirst) => {
       if (bridge.semantic) {
         const semantic = {
           where: bridge.semantic.where || bridge.where || client.where(3),
-          match: ({context}) => bridge.id == context.marker,
+          match: ({ context }) => bridge.id == context.marker,
           apply: (args) => bridge.semantic(args),
           applyWrapped: bridge.semantic,
-          property: 'semantic',
+          property: 'semantic'
         }
         if (addFirst) {
           config.config.semantics.unshift(semantic)
@@ -344,11 +342,15 @@ const handleBridgeProps = (config, bridge, addFirst) => {
 }
 
 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, addFirst)
+  if (moreConfig.bridges) {
+    moreConfig.bridges = moreConfig.bridges.map((bridge) => {
+      bridge = { ...bridge }
+      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, addFirst)
+      return bridge
+    })
   }
   if (moreConfig.operators) {
     moreConfig.operators = moreConfig.operators.map((operator) => {
@@ -365,7 +367,6 @@ 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)
@@ -386,7 +387,7 @@ 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"');
+    console.log('Expected DEBUG_BRIDGE to be of the form "id/level"')
     process.exit(-1)
   }
   global.entodictonDebugBridge[1] = parseInt(global.entodictonDebugBridge[1])
@@ -398,12 +399,12 @@ if (runtime.process.env.DEBUG_OPERATOR) {
 }
 
 const hierarchyCanonical = (element) => {
-    if (element.child && element.parent) {
-      return element
-    } else {
-      return { child: element[0], parent: element[1] }
-    }
+  if (element.child && element.parent) {
+    return element
+  } else {
+    return { child: element[0], parent: element[1] }
   }
+}
 
 const isValidDef = (word, def, config) => {
   if (!def.id) {
@@ -448,21 +449,20 @@ const normalizeConfig = (config) => {
           config[bag][i].km = config.name
         }
       }
-      
     }
-    if (config['bridges']) {
-      for (let bridge of config['bridges']) {
+    if (config.bridges) {
+      for (const bridge of config.bridges) {
         if (!bridge.level) {
           bridge.level = 0
         }
         if (!bridge.bridge) {
-          bridge.bridge = "{ ...next(operator) }"
+          bridge.bridge = '{ ...next(operator) }'
         }
       }
     }
 
     if (config.semantics) {
-      for (let semantic of config.semantics) {
+      for (const semantic of config.semantics) {
         if (semantic.oneShot) {
           semantic.id = uuid()
         }
@@ -607,7 +607,7 @@ class KM {
     const config = configDup(this._config, options)
     const km = new KM({
       config,
-      getCounter: options.getCounter, 
+      getCounter: options.getCounter,
       name: this._name,
       _uuid: config._uuid,
       namespace: this._namespace,
@@ -704,16 +704,14 @@ const multiApiImpl = (initializer) => {
   })
 }
 
-
 class Config {
-
   toServer (config) {
     return config_toServer(config)
   }
 
   base () {
     const base = new Config()
-    for (let km of this.configs.reverse()) {
+    for (const km of this.configs.reverse()) {
       if (km.isSelf) {
         continue
       }
@@ -733,8 +731,8 @@ class Config {
     }
     const templateQueries = []
     if (this.instances && this.instances.length > 0) {
-      for (let query of this.instances.slice(-1)[0].queries) {
-        if (typeof query == 'string') {
+      for (const query of this.instances.slice(-1)[0].queries) {
+        if (typeof query === 'string') {
           templateQueries.push(query)
         }
       }
@@ -745,7 +743,7 @@ class Config {
 
   getPseudoConfig (uuid, config) {
     return {
-      description: "this is a pseudo config that has limited functionality due to being available in the initializer function context",
+      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),
@@ -765,7 +763,7 @@ class Config {
       getBridge: (...args) => this.getBridge(...args),
       fragment: (...args) => this.fragment(...args),
       exists: (...args) => this.exists(...args),
-      addAPI: (...args) => this.addAPI(...args),
+      addAPI: (...args) => this.addAPI(...args)
     }
   }
 
@@ -779,7 +777,7 @@ class Config {
   }
 
   // return the config with just the elements from the included KM's
-  baseConfig() {
+  baseConfig () {
     const operators = this.config.operators.filter((operator) => {
       return operator.uuid !== this.uuid
     })
@@ -787,8 +785,8 @@ class Config {
       return bridge.uuid !== this.uuid
     })
     const words = {}
-    for (let word in this.config.words) {
-      const defs = this.config.words[word].filter( (def) => def.uuid !== this.uuid )
+    for (const word in this.config.words) {
+      const defs = this.config.words[word].filter((def) => def.uuid !== this.uuid)
       if (defs.length > 0) {
         words[word] = defs
       }
@@ -806,11 +804,11 @@ class Config {
     return `${maybeName}${counter}`
   }
 
-  setTestConfig(testConfig) {
+  setTestConfig (testConfig) {
     this.testConfig = testConfig
   }
 
-  getTestConfig() {
+  getTestConfig () {
     return this.testConfig
   }
 
@@ -855,44 +853,44 @@ class Config {
 
   // applies only to config sent to the server
 
-  watching() {
+  watching () {
     const props = [
-          'operators',
-          'bridges',
-          'hierarchy',
-          'namespaces',
-          'eqClasses',
-          'priorities',
-          'associations',
-          'words',
-          'floaters',
-          'implicits',
-          'flatten',
-    ];
+      'operators',
+      'bridges',
+      'hierarchy',
+      'namespaces',
+      'eqClasses',
+      'priorities',
+      'associations',
+      'words',
+      'floaters',
+      'implicits',
+      'flatten'
+    ]
     const watching = {}
-    for (let prop of props) {
+    for (const prop of props) {
       watching[prop] = this.config[prop]
     }
     return JSON.stringify(watching)
   }
 
-  watch() {
-    this.watchStart = this.watching();
+  watch () {
+    this.watchStart = this.watching()
   }
 
-  wasChanged() {
+  wasChanged () {
     if (!this.watchStart) {
-      return false;
+      return false
     }
     return this.watchStart !== this.watching()
   }
 
-	exists(marker) {
-    for (let bridge of this.config.bridges) {
+  exists (marker) {
+    for (const bridge of this.config.bridges) {
 	    if (bridge.id == marker) {
-        return true;
+        return true
       }
-		}
+    }
   }
 
   getSemantics (logs = []) {
@@ -906,7 +904,7 @@ class Config {
   warningNotEvaluated (log, value) {
     const description = 'WARNING: for semantics, implement an evaluations handler, set "value" property of the operator to the value.'
     const match = `({context}) => context.marker == '${value.marker}' && context.evaluate && <other conditions as you like>`
-    const apply = `({context}) => <do stuff...>; context.value = <value>`
+    const apply = '({context}) => <do stuff...>; context.value = <value>'
     const input = indent(JSON.stringify(value, null, 2), 2)
     const message = `${description}\nThe semantic would be\n  match: ${match}\n  apply: ${apply}\nThe input context would be:\n${input}\n`
     log.push(indent(message, 4))
@@ -933,18 +931,17 @@ class Config {
     const instance = s({ ...context, evaluate: true })
     calls.touch(instance)
     if (!instance.evalue && !instance.verbatim && !instance.value) {
-      this.warningNotEvaluated(log, context);
+      this.warningNotEvaluated(log, context)
     }
     if (!instance.evalue) {
       instance.evalue = instance.value
       instance.edefault = true
     }
     delete instance.evaluate
-    instance.instance = true;
+    instance.instance = true
     return instance
   }
 
-
   fragmentInstantiator (contexts) {
     return new Object({
       contexts: () => contexts,
@@ -966,7 +963,7 @@ class Config {
               continue
             }
             if (context[key].instantiated) {
-              continue;
+              continue
             }
             todo.push(context[key])
           }
@@ -992,20 +989,20 @@ class Config {
       return true
     }
     const toCanonical = (f) => {
-      if (typeof f == 'string') {
+      if (typeof f === 'string') {
         return { query: f }
       } else {
         return f
       }
     }
-    const instanceFragments = (instance.fragments || []).map((fragment) => fragment.key || fragment.query).map( toCanonical )
-    const templateFragments = (template.fragments || []).concat(this.dynamicFragments).map( toCanonical )
+    const 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 toCanonicalQuery = (queryOrConfig) => {
-      if (typeof queryOrConfig == 'string') {
+      if (typeof queryOrConfig === 'string') {
         const query = queryOrConfig
         return query
-      } else if (typeof queryOrConfig == 'function') {
+      } else if (typeof queryOrConfig === 'function') {
         if (options.isModule) {
           return { apply: 'function in the browser has webpack rewrites so can not be compared' }
         } else {
@@ -1020,8 +1017,8 @@ class Config {
       } else {
         const config = { ...queryOrConfig }
         delete config.where
-        config.operators = (config.operators || []).map( (operator) => {
-          if (typeof operator == 'string') {
+        config.operators = (config.operators || []).map((operator) => {
+          if (typeof operator === 'string') {
             return { pattern: operator }
           } else {
             operator = { ...operator }
@@ -1029,7 +1026,7 @@ class Config {
             return operator
           }
         })
-        config.bridges = (config.bridges || []).map( (bridge) => {
+        config.bridges = (config.bridges || []).map((bridge) => {
           bridge = { ...bridge },
           bridge.level = bridge.level || 0
           delete bridge.uuid
@@ -1037,10 +1034,10 @@ class Config {
         })
         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;
+          delete config.generators
+          delete config.semantics
           config.bridges = (config.bridges || []).map((bridge) => {
-            bridge = {...bridge}
+            bridge = { ...bridge }
             delete bridge.where
             delete bridge.generatorp
             delete bridge.generatorr
@@ -1048,24 +1045,24 @@ class Config {
             delete bridge.evaluator
             delete bridge.semantic
             return bridge
-          });
+          })
         } else {
           config.generators = (config.generators || []).map((generator) => {
-            generator = {...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}
+            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}
+            bridge = { ...bridge }
             delete bridge.where
             if (bridge.generatorp) {
               bridge.generatorp = bridge.generatorp.toString()
@@ -1089,13 +1086,13 @@ class Config {
       }
     }
     const toCanonicalQueries = (elements) => {
-      return elements.map( toCanonicalQuery )
+      return elements.map(toCanonicalQuery)
     }
 
     const templateQueries = toCanonicalQueries(template.queries || []).map(helpers.updateQueries)
     const instanceQueries = toCanonicalQueries(instance.queries || [])
     let sameQueries = true
-    let startOfChanges;
+    let startOfChanges
     for (let iq = 0; iq < templateQueries.length; ++iq) {
       if (!helpers.safeEquals(templateQueries[iq], instanceQueries[iq])) {
         sameQueries = false
@@ -1105,8 +1102,8 @@ class Config {
 
     const debug = true
     if (debug && startOfChanges) {
-      console.log('templateQueries[startOfChanges]', templateQueries[startOfChanges]);
-      console.log('instanceQueries[startOfChanges]', instanceQueries[startOfChanges]);
+      console.log('templateQueries[startOfChanges]', templateQueries[startOfChanges])
+      console.log('instanceQueries[startOfChanges]', instanceQueries[startOfChanges])
     }
 
     // things were deleted case
@@ -1122,8 +1119,8 @@ class Config {
           debugger
         }
         // console.log("instance", instance)
-        console.log("sameQueries", sameQueries)
-        console.log("sameFragments", sameFragments)
+        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))
@@ -1141,8 +1138,8 @@ class Config {
     if (!template.queries && !template.fragments) {
       throw new Error(`Expected the template for ${this.name} to be an object that can have the properties: queries and fragments`)
     }
-    for (let query of template.queries || []) {
-      if (typeof query == 'string') {
+    for (const query of template.queries || []) {
+      if (typeof query === 'string') {
       } else if (query instanceof Config) {
         throw new Error(`For the template for ${this.name}, each element in queries should be either a string or a structure with a config (not a Config object).`)
       }
@@ -1155,7 +1152,7 @@ class Config {
   }
 
   // loadTemplate
-  load (template, instance, options = { rebuild: false, previousResultss: undefined, startOfChanges: undefined } ) {
+  load (template, instance, options = { rebuild: false, previousResultss: undefined, startOfChanges: undefined }) {
     this.validifyTemplate(template)
     instance.template = template
     this.logs.push(`loading template for ${this.name}`)
@@ -1167,15 +1164,15 @@ class Config {
     } else {
       // no change
       // this.initInstances.push({ ...instance, name: config.name })
-      const isEmpty = ( instance ) => {
+      const isEmpty = (instance) => {
         const properties = [
-          "queries",
-          "resultss",
-          "fragments",
-          "semantics",
-          "associations",
+          'queries',
+          'resultss',
+          'fragments',
+          'semantics',
+          'associations'
         ]
-        return !properties.find( (property) => instance[property] && instance[property].length > 0 )
+        return !properties.find((property) => instance[property] && instance[property].length > 0)
       }
       if (!isEmpty(instance)) {
         // fix up apply functions
@@ -1193,7 +1190,7 @@ class Config {
     }
   }
 
-  addFragments(fragments) {
+  addFragments (fragments) {
     // only run this if not loading as module write error if loading as module and different
     this.dynamicFragments = this.dynamicFragments.concat(fragments)
   }
@@ -1203,12 +1200,12 @@ class Config {
   }
 
   addAssociations (associations) {
-    for (let association of associations) {
+    for (const association of associations) {
       this.addAssociation(association)
     }
   }
 
-  debugConfig() {
+  debugConfig () {
   }
 
   addAssociation (association) {
@@ -1237,17 +1234,17 @@ class Config {
   }
 
   addPriorities (priorities) {
-    for (let priority of priorities) {
+    for (const priority of priorities) {
       this.addPriority(priority)
     }
   }
 
   addHierarchy (child, parent) {
-    if (child && parent || !child || Array.isArray(child) || (typeof child == 'string' && !parent)) {
+    if (child && parent || !child || Array.isArray(child) || (typeof child === 'string' && !parent)) {
       this.addHierarchyChildParent(child, parent)
       // this.addHierarchyProperties ({ child, parent })
     } else {
-      this.addHierarchyProperties (child)
+      this.addHierarchyProperties(child)
     }
   }
 
@@ -1273,8 +1270,8 @@ class Config {
       throw new Error(`addHierarchy expected parent to be a string. got ${JSON.stringify(parent)}`)
     }
     debugHierarchy([child, parent])
-    if (this.config.hierarchy.find( (element) => {
-      const hc = hierarchyCanonical(element) 
+    if (this.config.hierarchy.find((element) => {
+      const hc = hierarchyCanonical(element)
       if (child == hc.child && parent == hc.parent) {
         return true
       }
@@ -1289,9 +1286,9 @@ class Config {
 
   getBridge (id, level) {
     if (level) {
-      return this.config.bridges.find( (bridge) => bridge.id == id && bridge.level == level )
+      return this.config.bridges.find((bridge) => bridge.id == id && bridge.level == level)
     } else {
-      return this.config.bridges.find( (bridge) => bridge.id == id)
+      return this.config.bridges.find((bridge) => bridge.id == id)
     }
   }
 
@@ -1301,12 +1298,12 @@ class Config {
     }
     const bridges = this.config.bridges
     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)) {
-        return;
+      if (bridges.find((b) => b.id == bridge.id && b.level == bridge.level)) {
+        return
       }
     }
     if (global.transitoryMode) {
@@ -1314,7 +1311,7 @@ class Config {
     }
     handleBridgeProps(this, def)
     bridges.push(def)
-    this.checkBridges();
+    this.checkBridges()
     this._delta.json.bridges.push({ action: 'add', bridge: def })
   }
 
@@ -1362,8 +1359,8 @@ class Config {
     semantics.unshift(semantic)
   }
 
-  removeSemantic(deleteSemantic) {
-    const index = this.config.semantics.findIndex( (semantic) => semantic.id === deleteSemantic.id )
+  removeSemantic (deleteSemantic) {
+    const index = this.config.semantics.findIndex((semantic) => semantic.id === deleteSemantic.id)
     if (index >= 0) {
       this.config.semantics.splice(index, 1)
     }
@@ -1376,7 +1373,7 @@ class Config {
 
     const operators = this.config.operators
 
-    let operator;
+    let operator
     if (typeof objectOrPattern === 'string') {
       operator = { pattern: objectOrPattern, uuid: uuid || this._uuid }
     } else {
@@ -1386,8 +1383,8 @@ class Config {
     debugOperator(operator)
 
     if (operator.allowDups) {
-      if (operators.find( (o) => o.pattern == operator.pattern )) {
-        return;
+      if (operators.find((o) => o.pattern == operator.pattern)) {
+        return
       }
     }
 
@@ -1446,19 +1443,19 @@ class Config {
     }
   }
 
-  getServer() {
+  getServer () {
     return this._server
   }
 
-  getAPIKey() {
+  getAPIKey () {
     return this._key
   }
 
-  getQueryParams() {
+  getQueryParams () {
     return this._queryParams
   }
 
-  setQueryParams(queryParams) {
+  setQueryParams (queryParams) {
     this._queryParams = queryParams
   }
 
@@ -1566,14 +1563,14 @@ class Config {
   }
 
   getConfigs () {
-    const configs = {};
+    const configs = {}
     configs[this.name] = this
     for (const config of this.configs) {
       if (config.config instanceof Config) {
         configs[config.config.name] = config.config
       }
     }
-    return configs;
+    return configs
   }
 
   getConfigByUUID (uuid) {
@@ -1602,18 +1599,18 @@ class Config {
     }
   }
 
-  removeDevelopmentElements(config) {
+  removeDevelopmentElements (config) {
     if (!config) {
       return
     }
-    config.operators = config.operators.filter( (element) => !element.development )
-    config.bridges = config.bridges.filter( (element) => !element.development )
-    config.generators = config.generators.filter( (element) => !element.development )
-    config.semantics = config.semantics.filter( (element) => !element.development )
-    config.hierarchy = (config.hierarchy).filter( (element) => !element.development )
+    config.operators = config.operators.filter((element) => !element.development)
+    config.bridges = config.bridges.filter((element) => !element.development)
+    config.generators = config.generators.filter((element) => !element.development)
+    config.semantics = config.semantics.filter((element) => !element.development)
+    config.hierarchy = (config.hierarchy).filter((element) => !element.development)
     for (const word in config.words) {
       const defs = config.words[word] || []
-      config.words[word] = defs.filter( (def) => !def.development )
+      config.words[word] = defs.filter((def) => !def.development)
       if (config.words[word].length == 0) {
         delete config.words[word]
       }
@@ -1736,11 +1733,11 @@ class Config {
     debugConfigProps(this.config)
   }
 
-  addArgs(moreArgs) {
+  addArgs (moreArgs) {
     this.addedArgss.push(moreArgs)
   }
 
-  getAddedArgs(args) {
+  getAddedArgs (args) {
     for (let addedArgs of this.addedArgss) {
       addedArgs = addedArgs(args)
       Object.assign(args, addedArgs)
@@ -1764,9 +1761,9 @@ class Config {
   }
 
   delta () {
-    return { 
-      cacheKey: this._delta.cacheKey, 
-      json: this._delta.json 
+    return {
+      cacheKey: this._delta.cacheKey,
+      json: this._delta.json
     }
   }
 
@@ -1779,7 +1776,7 @@ class Config {
         bridges: [],
         associations: [],
         priorities: [],
-        hierarchy: [],
+        hierarchy: []
       }
     }
   }
@@ -1796,11 +1793,11 @@ class Config {
     }
   }
 
-  addAPI(api) {
+  addAPI (api) {
     if (this._api && this._api.multiApi) {
       this._api.add(this, this._api, api)
     } else {
-      throw new Error("Can only add apis to a multi-api")
+      throw new Error('Can only add apis to a multi-api')
     }
   }
 
@@ -1863,15 +1860,15 @@ class Config {
   }
 
   // TODO add more details
-  equal(config) {
+  equal (config) {
     if (JSON.stringify(this.config) != JSON.stringify(config.config)) {
-      debugger;
-      return false;
+      debugger
+      return false
     }
     return true
   }
 
-  dump(fn) {
+  dump (fn) {
     runtime.fs.writeFileSync(fn, JSON.stringify(this.config, 0, 2))
   }
 
@@ -1883,7 +1880,7 @@ class Config {
     const cp = new Config()
     cp.logs = []
     cp.maxDepth = this.maxDepth
-    cp.debugLoops  = this.debugLoops
+    cp.debugLoops = this.debugLoops
     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
@@ -1920,7 +1917,7 @@ class Config {
     cp.mapUUIDs(map)
 
     if (cp._uuid == 'concept2') {
-        // debugger
+      // debugger
     }
     if (options.callInitializers) {
       cp.rebuild(options)
@@ -1943,7 +1940,7 @@ class Config {
         // const namespace = km.namespace
         cp.config.objects.namespaced[km._uuid] = {}
       })
-/*
+      /*
       if (cp._uuid == 'concept2') {
         if (!cp.api.objects.defaultTypesForHierarchy) {
           debugger
@@ -2083,7 +2080,7 @@ class Config {
 
   initializer (fn, options = {}) {
     if (options) {
-      for (let option of Object.keys(options)) {
+      for (const option of Object.keys(options)) {
         const validOptions = []
         if (!validOptions.includes(option)) {
           throw new Error(`For Config.initializer, unrecognized option ${option}. The valid options are ${validOptions}`)
@@ -2249,7 +2246,7 @@ class Config {
   // rebuild ({ isModule: mainIsModule = false } = {}) {
   rebuild ({ isModule: mainIsModule } = {}) {
     this.resetDelta()
-    const debug = this.config.debug;
+    const debug = this.config.debug
     this.config = _.cloneDeep(this.initConfig)
     this.hierarchy = new DigraphInternal(this.config.hierarchy)
     if (debug) {
@@ -2292,8 +2289,8 @@ class Config {
       // const aw = (word, def) => this.addWord(word, def)
       // const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
       let config = km.config
-     
-      if (config.addedArgss) { 
+
+      if (config.addedArgss) {
         this.addedArgss = this.addedArgss.concat(config.addedArgss)
       }
 
@@ -2316,15 +2313,15 @@ class Config {
         return config
       }
       // const hierarchy = new DigraphInternal((config.config || {}).hierarchy)
-      const args = new Object(setupInitializerFNArgs(this, { 
-        isModule, 
-        hierarchy: this.hierarchy, 
+      const args = new Object(setupInitializerFNArgs(this, {
+        isModule,
+        hierarchy: this.hierarchy,
         testConfig: config,
-        currentConfig: config, 
-        uuid: config._uuid, 
-        objects: namespacedObjects, 
-        namespace, 
-        api: config.api,
+        currentConfig: config,
+        uuid: config._uuid,
+        objects: namespacedObjects,
+        namespace,
+        api: config.api
       }))
 
       const currentConfig = args.currentConfig
@@ -2341,12 +2338,12 @@ class Config {
       // debugger
       // greg55
       config.initializerFn(args, { dontCallFn: true })
-        initAfterApis.unshift({ config, args })
+      initAfterApis.unshift({ config, args })
       if (config._api) {
         if (config._api.initialize) {
           // reverse the list
           // TODO sync up the args with initialize of config
-          inits.unshift( () => config._api.initialize({ config: this, km: kmFn, ...args, api: config._api }) )
+          inits.unshift(() => config._api.initialize({ config: this, km: kmFn, ...args, api: config._api }))
           // config._api.initialize({ config, api: config._api })
         } else {
           inits.unshift(null)
@@ -2388,13 +2385,13 @@ class Config {
       this.config.priorities = []
       this.config.associations = { positive: [], negative: [] }
       this.config.words = {}
-      
+
       for (let i = 0; i < addInternals.length; ++i) {
-        let name;
+        let name
         if (addInternals[i]) {
           this.addInternalR(addInternals[i], true, false, false, true)
           name = addInternals[i].name
-        } else{
+        } else {
           // the ones defined in config must come after the ones in the templates
           this.config.generators = generators.concat(this.config.generators)
           this.config.semantics = semantics.concat(this.config.semantics)
@@ -2408,7 +2405,7 @@ class Config {
         }
         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) {
@@ -2423,9 +2420,10 @@ class Config {
     this.checkBridges()
   }
 
-  nameToUUID(name) {
+  nameToUUID (name) {
     return this.configs.find((km) => km._name == name)._uuid
   }
+
   // name: namespace name
   // others
   //    if undefined namespace applies to first loaded config
@@ -2602,7 +2600,7 @@ class Config {
           context: context.map((id) => {
             return [toNS(id[0]), id[1]]
           }),
-          choose,
+          choose
         }
         if (ordered) {
           priority.ordered = ordered
@@ -2627,7 +2625,7 @@ class Config {
     }
 
     const seen = {}
-    for (let operator of this.config.operators) {
+    for (const operator of this.config.operators) {
       if (seen[operator.pattern]) {
         const key = `${operator.pattern} (namespace: ${operator.uuid})`
         throw new Error(`Operator '${key}' is defined more than once in the operators`)
@@ -2700,10 +2698,10 @@ class Config {
       throw new Error(`Setting invalid property ${property}`)
     }
 
-    if ('words' == property) {
-      for (let word in value) {
-        for (let def of value[word]) {
-          if (!def['uuid']) {
+    if (property == 'words') {
+      for (const word in value) {
+        for (const def of value[word]) {
+          if (!def.uuid) {
             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}'`)
           }
         }
@@ -2711,8 +2709,8 @@ class Config {
     }
 
     if (['operators', 'bridges'].includes(property)) {
-      for (let def of value) {
-        if (!def['uuid']) {
+      for (const def of value) {
+        if (!def.uuid) {
           throw new Error(`All definitions for '${property}' must have the uuid property set (config.uuid). uuid is missing from ${JSON.stringify(def)}`)
         }
       }
@@ -2792,9 +2790,9 @@ class Config {
     this.configs.forEach((km) => {
       this.instances = (km._config.instances || this.initInstances.slice()).concat(this.instances)
     })
-    let noDups = []
-    for (let instance of this.instances) {
-      if (!noDups.find( (existing) => existing.name == instance.name )) {
+    const noDups = []
+    for (const instance of this.instances) {
+      if (!noDups.find((existing) => existing.name == instance.name)) {
         noDups.push(instance)
       }
     }
@@ -2806,7 +2804,7 @@ class Config {
   }
 
   // TODO get rid of useOldVersion arg
-  addInternal (more, { uuid, addFirst = false, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false, handleCalculatedProps : hcps = false } = {}) {
+  addInternal (more, { uuid, addFirst = false, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false, handleCalculatedProps: hcps = false } = {}) {
     validConfigProps(more)
     if (more instanceof Config) {
       more.initialize({ force: false })
@@ -2888,12 +2886,12 @@ class Config {
           const isDup = (op1, op2) => op1.pattern == op2.pattern
           for (const newOne of more[key]) {
             for (let iOldOne = 0; iOldOne < this.config[key].length; ++iOldOne) {
-              const oldOne = this.config[key][iOldOne];
+              const oldOne = this.config[key][iOldOne]
               if (isDup(newOne, oldOne)) {
                 if (oldOne.allowDups) {
                   // the old one takes precedence to match what would happen during the original load
                   this.config[key].splice(iOldOne, 1)
-                  break;
+                  break
                 }
               }
             }
@@ -2904,14 +2902,14 @@ class Config {
           const idDup = (b1, b2) => b1.id == b2.id && b1.level == b2.level && b1.bridge == b2.bridge
           for (const newOne of more[key]) {
             for (let iOldOne = 0; iOldOne < this.config[key].length; ++iOldOne) {
-              const oldOne = this.config[key][iOldOne];
+              const oldOne = this.config[key][iOldOne]
               if (newOne.id == oldOne.id) {
                 if (oldOne.allowDups) {
                   // the old one takes precedence to match what would happen during the original load
                   this.config[key].splice(iOldOne, 1)
-                  break;
+                  break
                 }
-              } 
+              }
             }
           }
         }
@@ -3009,12 +3007,12 @@ class Config {
           const isDup = (op1, op2) => op1.pattern == op2.pattern
           for (const newOne of more[key]) {
             for (let iOldOne = 0; iOldOne < this.config[key].length; ++iOldOne) {
-              const oldOne = this.config[key][iOldOne];
+              const oldOne = this.config[key][iOldOne]
               if (isDup(newOne, oldOne)) {
                 if (oldOne.allowDups) {
                   // the old one takes precedence to match what would happen during the original load
                   this.config[key].splice(iOldOne, 1)
-                  break;
+                  break
                 }
               }
             }
@@ -3025,12 +3023,12 @@ class Config {
           const idDup = (b1, b2) => b1.id == b2.id && b1.level == b2.level && b1.bridge == b2.bridge
           for (const newOne of more[key]) {
             for (let iOldOne = 0; iOldOne < this.config[key].length; ++iOldOne) {
-              const oldOne = this.config[key][iOldOne];
+              const oldOne = this.config[key][iOldOne]
               if (newOne.id == oldOne.id) {
                 if (oldOne.allowDups) {
                   // the old one takes precedence to match what would happen during the original load
                   this.config[key].splice(iOldOne, 1)
-                  break;
+                  break
                 }
               }
             }
@@ -3056,5 +3054,5 @@ module.exports = {
   Config,
   config_toServer,
   operatorKey_valid,
-  handleBridgeProps,
+  handleBridgeProps
 }