tpmkms_4wp 8.0.0-beta.20 → 8.0.0-beta.22

package/common/fastfood.js

@@ -216,7 +216,7 @@ const template = {
         {
           where: where(),
           match: ({context}) => false && context.marker == 'combo' && context.comboNumber,
-          apply: ({context, g}) => g(context.comboNumber),
+          apply: async ({context, g}) => await g(context.comboNumber),
         }
       ],
       bridges: [
@@ -225,7 +225,7 @@ const template = {
           id: 'withModification',
           level: 0,
           before: ['preposition'],
-          generatorp: ({context, gp}) => `with ${gp(context.modifications)}`,
+          generatorp: async ({context, gp}) => `with ${await gp(context.modifications)}`,
           bridge: "{ ...next(operator), modifications: after[0], flatten: false }",
         },
         { 
@@ -287,18 +287,16 @@ const template = {
         {
           // split "sprite and fanta" into separate things so the ask will pick them up
           match: ({context}) => context.marker == 'list' && context.topLevel && !context.flatten,
-          apply: ({context, s}) => {
-            s({...context, flatten: true})
-          }
+          apply: async ({context, s}) => await s({...context, flatten: true}),
         },
         {
           where: where(),
           match: ({context, api}) => context.marker == 'controlEnd' && api.hasAskedForButNotAvailable(),
-          apply: ({context, api, gp, toContext, verbatim}) => {
+          apply: async ({context, api, gp, toContext, verbatim}) => {
             const naArray = api.getAskedForButNotAvailable()
             naArray.forEach((f) => f.paraphrase = true)
             const naContext = toContext(naArray)
-            verbatim(`The following are not menu items: ${gp(naContext)}`)
+            verbatim(`The following are not menu items: ${await gp(naContext)}`)
             // allow other motivation to run
             context.cascade = true
           }
@@ -306,11 +304,13 @@ const template = {
         {
           where: where(),
           match: ({context, api}) => context.marker == 'controlEnd' && api.hasAskedForButNotAvailableModification(),
-          apply: ({context, api, gp, toContext, verbatim}) => {
-            const naArray = api.getAskedForButNotAvailableModification().map(({ item, modification }) => {
+          apply: async ({context, api, gp, toContext, verbatim}) => {
+            const naArray = []
+            for (const args of api.getAskedForButNotAvailableModification()) {
+              const args = { item, modification }
               // return `${gp(item)} can not be modified with ${gp(modification)}.`
-              return `XXX can not be modified with ${gp(modification)}.`
-            })
+              naArray.push(`XXX can not be modified with ${await gp(modification)}.`)
+            }
             verbatim(naArray.join(' '))
             // allow other motivation to run
             context.cascade = true
@@ -413,11 +413,11 @@ const template = {
           id: "change",
           isA: ['verby'],
           localHierarchy: [ ['thisitthat', 'meal'] ],
-          generatorp: ({context, gp}) => `change ${gp(context.from)} to ${gp(context.to)}`,
+          generatorp: async ({context, gp}) => `change ${await gp(context.from)} to ${await gp(context.to)}`,
           bridge: "{ ...next(operator), from: after[0], to: after[1].toObject }",
-          semantic: ({context, api, e}) => {
+          semantic: async ({context, api, e}) => {
             const state = api.state
-            const eFrom = e(context.from).evalue
+            const eFrom = (await e(context.from)).evalue
             const from = state.getIdCombo(eFrom.fromSTM ? eFrom : context.from)
             const to = state.getIdCombo(context.to)
             for (const item of api.items()) {
@@ -887,8 +887,8 @@ class State {
                 {
                   where: where(),
                   match: ({context, isA}) => isA(context.marker, 'number') && !context.evaluate,
-                  apply: ({context, e}) => {
-                    food.comboNumber = { value: e(context).value }
+                  apply: async ({context, e}) => {
+                    food.comboNumber = { value: (await e(context)).value }
                     this.add(Object.assign(food, context))
                   }
                 },
@@ -935,7 +935,7 @@ class State {
   }
 }
 
-const createConfig = (additionalConfig) => {
+const createConfig = async (additionalConfig) => {
   const config = new Config({ 
     name: 'fastfood',
     operators: [
@@ -949,10 +949,10 @@ const createConfig = (additionalConfig) => {
         where: where(),
         priority: -10,
         match: ({context}) => context.marker == 'compound_operator',
-        apply: ({context, s}) => {
+        apply: async ({context, s}) => {
           context.marker = 'list'
           context.flatten = true
-          s(context)
+          await s(context)
         }
       },
       {
@@ -979,7 +979,7 @@ const createConfig = (additionalConfig) => {
         id: 'showOrder',
         parents: ['verby'],
         bridge: "{ ...next(operator), order: after[0] }",
-        generatorp: ({context, g}) => `show ${g(context.order)}`,
+        generatorp: async ({context, g}) => `show ${await g(context.order)}`,
         semantic: ({api}) => {
           api.state.show()
         },
@@ -987,15 +987,15 @@ const createConfig = (additionalConfig) => {
     ],
   }, module)
   config.stop_auto_rebuild()
-  config.add(edible(), countable(), events(), sizeable())
-  config.api = api
-  config.initializer( ({api}) => {
+  await config.add(edible, countable, events, sizeable)
+  await config.setApi(api)
+  await config.initializer( ({api}) => {
     api.state = new State(api)
   })
   if (additionalConfig) {
     additionalConfig(config)
   }
-  config.restart_auto_rebuild()
+  await config.restart_auto_rebuild()
   return config
 }
 

package/common/formulas.instance.json

@@ -31,7 +31,7 @@
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/formulas.js:109",
           "match": "({context, api}) => context.evaluate && api.get(context)",
-          "apply": "({context, api, e}) => {\n        const { formula } = api.get(context)\n        // console.log('greg24 -----------', JSON.stringify(formula, null, 2))\n        context.evalue = e(formula) \n      }"
+          "apply": "async ({context, api, e}) => {\n        const { formula } = api.get(context)\n        // console.log('greg24 -----------', JSON.stringify(formula, null, 2))\n        context.evalue = await e(formula) \n      }"
         }
       ],
       "bridges": [
@@ -44,14 +44,14 @@
           ],
           "convolution": true,
           "bridge": "{ number: before[0].number, ...next(operator), what: before[0], equality: after[0], variable: after[1] }",
-          "generatorp": "({context, g}) => `${g(context.what)} ${g(context.equality)} ${g(context.variable)}`",
+          "generatorp": "async ({context, g}) => `${await g(context.what)} ${await g(context.equality)} ${await g(context.variable)}`",
           "evaluator": "({context, api, objects}) => {\n        const formulas = api.gets(context.variable).map((f) => { return { ...f.equality, paraphrase: true } })\n        context.evalue = { marker: 'list', value: formulas }\n      }"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/formulas.js:132",
           "id": "solve",
           "bridge": "{ ...next(operator), equality: after[0], variable: after[2] }",
-          "generatorp": "({context, gp}) => `${context.word} ${gp(context.equality)} for ${gp(context.variable)}`",
+          "generatorp": "async ({context, gp}) => `${context.word} ${await gp(context.equality)} for ${await gp(context.variable)}`",
           "semantic": "({context}) => {\n        context.response = solveFor(context.equality, context.variable)\n        context.isResponse = true\n        context.value = null\n        if (!context.response) {\n          // TODO some KM for talking to the user wrt brief+avatar\n          context.verbatim = `Solving failed`\n        }\n      }"
         },
         {
@@ -80,14 +80,14 @@
             "verby"
           ],
           "bridge": "{ ...next(operator), expression: after[0] }",
-          "generatorp": "({context, g}) => `${context.word} ${g(context.expression)}`",
+          "generatorp": "async ({context, g}) => `${context.word} ${await g(context.expression)}`",
           "localHierarchy": [
             [
               "unknown",
               "expression"
             ]
           ],
-          "semantic": "({context, e}) => {\n        context.evalue = e(context.expression)\n        context.isResponse = true\n      }"
+          "semantic": "async ({context, e}) => {\n        context.evalue = await e(context.expression)\n        context.isResponse = true\n      }"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/formulas.js:171",
@@ -105,7 +105,7 @@
               "expression"
             ]
           ],
-          "generatorp": "({context, gp}) => `${gp(context.left)} ${context.word} ${gp(context.right)}`",
+          "generatorp": "async ({context, gp}) => `${await gp(context.left)} ${context.word} ${await gp(context.right)}`",
           "semantic": "({context, api}) => {\n        // TODO make sure left is a single name\n        // TODO calculate invertable formulas?\n        api.add(context.left, context.right, context)\n      }"
         }
       ]

package/common/formulas.js

@@ -108,10 +108,10 @@ let configStruct = {
     {
       where: where(),
       match: ({context, api}) => context.evaluate && api.get(context),
-      apply: ({context, api, e}) => {
+      apply: async ({context, api, e}) => {
         const { formula } = api.get(context)
         // console.log('greg24 -----------', JSON.stringify(formula, null, 2))
-        context.evalue = e(formula) 
+        context.evalue = await e(formula) 
       }    
     },
   ],
@@ -122,7 +122,7 @@ let configStruct = {
       isA: ['preposition', 'queryable'],
       convolution: true,
       bridge: "{ number: before[0].number, ...next(operator), what: before[0], equality: after[0], variable: after[1] }",
-      generatorp: ({context, g}) => `${g(context.what)} ${g(context.equality)} ${g(context.variable)}`,
+      generatorp: async ({context, g}) => `${await g(context.what)} ${await g(context.equality)} ${await g(context.variable)}`,
       evaluator: ({context, api, objects}) => {
         const formulas = api.gets(context.variable).map((f) => { return { ...f.equality, paraphrase: true } })
         context.evalue = { marker: 'list', value: formulas }
@@ -132,7 +132,7 @@ let configStruct = {
       where: where(),
       id: 'solve', 
       bridge: "{ ...next(operator), equality: after[0], variable: after[2] }",
-      generatorp: ({context, gp}) => `${context.word} ${gp(context.equality)} for ${gp(context.variable)}`,
+      generatorp: async ({context, gp}) => `${context.word} ${await gp(context.equality)} for ${await gp(context.variable)}`,
       semantic: ({context}) => {
         context.response = solveFor(context.equality, context.variable)
         context.isResponse = true
@@ -160,10 +160,10 @@ let configStruct = {
       id: 'calculate',
       isA: ['verby'],
       bridge: "{ ...next(operator), expression: after[0] }",
-      generatorp: ({context, g}) => `${context.word} ${g(context.expression)}`,
+      generatorp: async ({context, g}) => `${context.word} ${await g(context.expression)}`,
       localHierarchy: [ ['unknown', 'expression'] ],
-      semantic: ({context, e}) => {
-        context.evalue = e(context.expression)
+      semantic: async ({context, e}) => {
+        context.evalue = await e(context.expression)
         context.isResponse = true
       } 
     },
@@ -175,7 +175,7 @@ let configStruct = {
       after: ['mathematical_operator'],
       // TODO have this be per argument then 'is' can map to equals where this only applied to before[0] and not after[0]
       localHierarchy: [ ['unknown', 'expression'] ],
-      generatorp: ({context, gp}) => `${gp(context.left)} ${context.word} ${gp(context.right)}`,
+      generatorp: async ({context, gp}) => `${await gp(context.left)} ${context.word} ${await gp(context.right)}`,
       semantic: ({context, api}) => {
         // TODO make sure left is a single name
         // TODO calculate invertable formulas?
@@ -192,13 +192,13 @@ const template = {
   ]
 }
 
-const createConfig = () => {
+const createConfig = async () => {
   const api = new API()
   config = new Config({ name: 'formulas' }, module)
   config.stop_auto_rebuild()
-  config.add(dialogues(), pos(), math(), hierarchy(), comparable(), countable())
-  config.api = api
-  config.restart_auto_rebuild()
+  await config.add(dialogues, pos, math, hierarchy, comparable, countable)
+  await config.setApi(api)
+  await config.restart_auto_rebuild()
   return config
 }
 

package/common/gdefaults.js

@@ -28,15 +28,15 @@ let configStruct = {
       //({context}) => context.paraphrase && context.modifiers,
       // match: ({context}) => context.paraphrase && (context.modifiers || context.postModifiers),
       match: ({context}) => (context.modifiers || context.postModifiers),
-      apply: ({context, g, gs, callId}) => {
+      apply: async ({context, g, callId}) => {
         const text = []
         for (modifier of (context.modifiers || [])) {
           if (Array.isArray(context[modifier])) {
             for (let m of context[modifier]) {
-              text.push(g(m))
+              text.push(await g(m))
             }
           } else {
-            text.push(g(context[modifier], { isModifier: true }))
+            text.push(await g(context[modifier], { isModifier: true }))
           }
         }
         // text.push(context.word)
@@ -47,15 +47,15 @@ let configStruct = {
           number = isMany(context) ? 'many' : 'one'
         }
         if (context.postModifiers) {
-          text.push(g({...context, number: 'one', postModifiers: undefined, modifiers: undefined}))
+          text.push(await g({...context, number: 'one', postModifiers: undefined, modifiers: undefined}))
         } else {
-          text.push(g({...context, number, postModifiers: undefined, modifiers: undefined}))
+          text.push(await g({...context, number, postModifiers: undefined, modifiers: undefined}))
         }
         for ([index, modifier] of (context.postModifiers || []).entries()) {
           if (index == context.postModifiers.length - 1) {
-            text.push(g({...context[modifier], number}))
+            text.push(await g({...context[modifier], number}))
           } else {
-            text.push(g(context[modifier]))
+            text.push(await g(context[modifier]))
           }
         }
         return text.join(' ')
@@ -134,19 +134,19 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.evalue,
-      apply: ({context, g}) => g(context.evalue)
+      apply: async ({context, g}) => await g(context.evalue)
     },
 
     {
       where: where(),
       match: ({context}) => context.value && Array.isArray(context.value),
-      apply: ({context, gs}) => gs(context.value)
+      apply: async ({context, gs}) => await gs(context.value)
     },
 
     {
       where: where(),
       match: ({context}) => context.value,
-      apply: ({context, g}) => g(context.value)
+      apply: async ({context, g}) => await g(context.value)
     },
 
     {
@@ -181,10 +181,10 @@ let configStruct = {
   ],
 };
 
-const createConfig = () => {
+const createConfig = async () => {
   const config = new Config(configStruct, module)
-  config.add(tokenize())
-  config.initializer( ({config}) => {
+  await config.add(tokenize)
+  await config.initializer( ({config}) => {
     config.addArgs((args) => {
       return {
         number: (context) => isMany(context) ? "many" : "one",

package/common/help.js

@@ -82,12 +82,12 @@ const configStruct = {
   },
 };
 
-const createConfig = () => {
+const createConfig = async () => {
   const config = new Config(configStruct, module)
   config.stop_auto_rebuild()
-  config.add(dialogues())
+  await config.add(dialogues)
 
-  config.initializer( ({ config, addWord, kms }) => {
+  await config.initializer( ({ config, addWord, kms }) => {
     const names = new Set()
     for (let name in kms) {
       names.add(name);
@@ -96,7 +96,7 @@ const createConfig = () => {
       addWord(name, {id: "km", initial: `{ value: '${name}', word: '${name}' }`})
     }
   })
-  config.restart_auto_rebuild()
+  await config.restart_auto_rebuild()
   return config
 }
 

package/common/helpers/concept.js

@@ -86,7 +86,6 @@ class API {
     })
     // modifierds.forEach((modifierId) => config.addWord(modifierId, { id: modifierId, initial: `{ value: '${modifierId}' }`}))
 
-    debugger
     modifierIds.forEach((modifierId) => config.addBridge({ id: modifierId, level: 0, bridge: `{ ...next(operator), value: '${modifierId}' }`,  allowDups: true }))
     config.addBridge({ id: objectId, level: 0, bridge: `{ ...next(operator), value: '${objectId}' }`,  allowDups: true })
     // config.addBridge({ id: modifierObjectId, level: 0, bridge: `{ ...next(operator), value: '${modifierObjectId}' }`, allowDups: true })

package/common/helpers/dialogues.js

@@ -50,10 +50,9 @@ class API {
     return this._objects.brief
   }
 
-  evaluateToConcept(value, context, log, s) {
+  async evaluateToConcept(value, context, log, s) {
     value.evaluate = { toConcept: true }
-    // const concept = s(value, { debug: { apply: true } }) 
-    const concept = s(value)
+    const concept = await s(value)
     if (!concept.evalue && !concept.verbatim) {
       this.warningNotEvaluated(log, value);
       concept.evalue = concept.value

package/common/helpers/properties.js

@@ -136,7 +136,7 @@ class API {
       notes: 'semantic for setting value with constraint',
       match: ({context, isA}) => isA(context.marker, after[0].tag) && context.evaluate && context.constraints,
       // match: ({context, isA}) => context.marker == after[0].tag && context.evaluate,
-      apply: ({km, context, e, log, isA, s}) => {
+      apply: async ({km, context, e, log, isA}) => {
         const constraint = context.constraints[0];
         const value = constraint.constraint;
         let property = constraint.property;
@@ -151,7 +151,7 @@ class API {
         // value.greg = true
         // value.ownee.query = true
         value.query = true
-        let instance = e(value)
+        let instance = await e(value)
         if (instance.verbatim) {
           context.evalue = { verbatim: instance.verbatim }
           return
@@ -168,13 +168,13 @@ class API {
     config.addGenerator({
       notes: 'generator for constraint',
       match: ({context}) => context.marker == edAble.operator && context.paraphrase && context.constrained,
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         if (context[before[0].tag].marker == 'by') {
           // the cat wendy owned
-          return `${g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${g({...context[before[0].tag], paraphrase: true})}`
+          return `${await g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${await g({...context[before[0].tag], paraphrase: true})}`
         } else {
           // the cat owned by wendy
-          return `${g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${['by', g({...context[before[0].tag], paraphrase: true})].filter((t) => t).join(' ')}`
+          return `${await g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${['by', await g({...context[before[0].tag], paraphrase: true})].filter((t) => t).join(' ')}`
         }
       },
     })
@@ -194,19 +194,19 @@ class API {
 
         return false;
       },
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         const chosen = chooseNumber(context, word.singular, word.plural)
-        return `${g(context[before[0].tag])} ${chosen} ${g(context[after[0].tag])}`
+        return `${await g(context[before[0].tag])} ${chosen} ${await g(context[after[0].tag])}`
       }
     })
     config.addGenerator({
       match: ({context}) => context.marker == edAble.operator && context.isEd,
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         const chosen = chooseNumber(context[after[0].tag], 'is', 'are')
         if (context[before[0].tag].evalue && context[before[0].tag].evalue.marker == 'answerNotKnown') {
-          return g(context[before[0].tag])
+          return await g(context[before[0].tag])
         }
-        return `${g(context[after[0].tag])} ${chosen} ${edAble.word} by ${g(context[before[0].tag])}`
+        return `${await g(context[after[0].tag])} ${chosen} ${edAble.word} by ${await g(context[before[0].tag])}`
       }
     })
     /*
@@ -250,7 +250,7 @@ class API {
         notes: `generator for who/what is X owned by`,
         // match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.one && context.one.marker == 'ownee' && context.one.constraints && context.one.constraints[0] && context.one.constraints[0].constraint.marker == 'owned' && context.one.constraints[0].constraint.owner.implicit,
         match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.one && context.one.marker == after[0].tag && context.one.constraints && context.one.constraints[0] && context.one.constraints[0].constraint.marker == edAble.operator && context.one.constraints[0].constraint[before[0].tag].implicit,
-        apply: ({context, g, gs, callId}) => {
+        apply: async ({context, g, gs, callId}) => {
           const isToFromM = [{"from":["one"],"to":["two"]},{"from":["two"],"to":["one"]}]
           const fromF = config.fragment(whoIsWhatVerbedBy).contexts()[0]
           // const fromF = config.fragment[before[0].tag]"ownerVar is owneeVar owned by").contexts()[0]
@@ -269,11 +269,11 @@ class API {
           // const from = context.one.constraints[0].constraint
           const from = context
           const im = translationMappingToInstantiatorMappings(tmPrime, from, to)
-          const translation = toF.instantiate(im)
+          const translation = await toF.instantiate(im)
           if (Array.isArray(translation)) {
-            return gs(translation)
+            return await gs(translation)
           } else {
-            return g(translation)
+            return await g(translation)
           }
         }
       }
@@ -383,11 +383,16 @@ class API {
     config.addGenerator({
       notes: 'ordering generator for paraphrase',
       match: ({context}) => context.marker == operator && context.paraphrase && !context.query,
-      apply: ({context, gp, g}) => {
-        const beforeGenerator = before.map( (arg) => g(context[arg.tag]) )
-        const afterGenerator = after.map( (arg) => gp(context[arg.tag]) )
+      apply: async ({context, gp, g}) => {
+        const beforeGenerator = []
+        for (const arg of before) {
+          beforeGenerator.push(await g(context[arg.tag]))
+        }
+        const afterGenerator = []
+        for (const arg of after) {
+          afterGenerator.push(await gp(context[arg.tag]))
+        }
         const word = context.word
-        // return beforeGenerator.concat([`${context.word}`]).concat(afterGenerator).join(' ')
         const sub = []
         if (context.subphrase) {
           sub.push(['that'])
@@ -399,7 +404,7 @@ class API {
     config.addGenerator({
       notes: 'ordering generator for response',
       match: ({context}) => context.marker == operator && context.evalue && context.isResponse,
-      apply: ({context, g, km}) => {
+      apply: async ({context, g, km}) => {
         const brief = km("dialogues").api.getBrief()
 
         const { evalue } = context 
@@ -414,7 +419,7 @@ class API {
         if (evalue.truthValueOnly || brief) {
           return `${yesno}`
         } else {
-          return `${yesno} ${g(Object.assign({}, evalue, { paraphrase: true }))}`
+          return `${yesno} ${await g(Object.assign({}, evalue, { paraphrase: true }))}`
         }
       }
     })
@@ -628,8 +633,8 @@ class API {
         setValue: ([object, property], value, has) => {
           return this.setProperty(object, property, value, has, true)
         },
-        getValue: ([object, property]) => {
-          return this.getPropertyDirectly(object, property)
+        getValue: async ([object, property]) => {
+          return await this.getPropertyDirectly(object, property)
         },
       })
     }
@@ -645,16 +650,18 @@ class API {
         error.code = 'ReadOnly'
         throw error
       },
-      getValue: ([object, property]) => {
-        return this.getPropertyDirectly(object, property)
+      getValue: async ([object, property]) => {
+        return await this.getPropertyDirectly(object, property)
       },
     })
     this.propertiesFH.setHandler(path, handler)
   }
 
-  getObject(object) {
+  /*
+  async getObject(object) {
     return this.propertiesFH.getValue([object])
   }
+  */
 
   getHandler(object, property) {
     return this.propertiesFH.getHandler([object, property])
@@ -671,34 +678,33 @@ class API {
     // return context.value
   }
 
-  getProperty(object, property, g) {
+  async getProperty(object, property, g) {
     object = this.toValue(object)
     property = this.toValue(property)
     const handler = this.propertiesFH.getHandler([object, property])
     if (handler) {
-      return handler.getValue([object, property])
+      return await handler.getValue([object, property])
     }
-    return this.getPropertyDirectly(object, property, g)
+    return await this.getPropertyDirectly(object, property, g)
   }
 
-  getPropertyDirectly(object, property, g) {
+  async getPropertyDirectly(object, property, g) {
     if (property == 'property') {
-      const objectProps = this.propertiesFH.getValue([object])
+      const objectProps = await this.propertiesFH.getValue([object])
       const values = []
       for (let key of Object.keys(objectProps)) {
         if (objectProps[key].has) {
-          // values.push(`${g(key)}: ${g({ ...objectProps[key].value, evaluate: true })}`)
-          values.push(`${g(key)}: ${g({ ...objectProps[key].value, paraphrase: true })}`)
+          values.push(`${await g(key)}: ${await g({ ...objectProps[key].value, paraphrase: true })}`)
         }
       }
       return { marker: 'list', value: values }
     } else {
-      return this.propertiesFH.getValue([object, property]).value
+      return (await this.propertiesFH.getValue([object, property])).value
     }
   }
 
-  hasProperty(object, property, has) {
-    return this.propertiesFH.getValue([object, property]).has
+  async hasProperty(object, property, has) {
+    return (await this.propertiesFH.getValue([object, property])).has
   }
 
   setProperty(object, property, value, has, skipHandler) {
@@ -726,7 +732,7 @@ class API {
     }
   }
 
-  knownObject(object) {
+  async knownObject(object) {
     if (object == 'property') {
       return object
     }
@@ -735,10 +741,10 @@ class API {
     }
     const path = [object]
     // return this.knownPropertyNew(path)
-    return this.propertiesFH.knownProperty(path)
+    return await this.propertiesFH.knownProperty(path)
   }
 
-  hasProperty(object, property) {
+  async hasProperty(object, property) {
     if (property == 'property') {
       return true;
     }
@@ -748,7 +754,7 @@ class API {
     const seen = [object];
     while (todo.length > 0) {
       const next = todo.pop();
-      if ((this.propertiesFH.getValue([next, property], false) || {}).has) {
+      if ((await this.propertiesFH.getValue([next, property], false) || {}).has) {
         return true
       }
       const parents = this._objects.parents[next] || [];
@@ -763,11 +769,11 @@ class API {
   }
 
   // NOT DONE
-  knownProperty(object, property) {
+  async knownProperty(object, property) {
     object = this.toValue(object)
     property = this.toValue(property)
     if (property == 'property') {
-      const objectProps = this.propertiesFH.getValue([object])
+      const objectProps = await this.propertiesFH.getValue([object])
       return !_.isEmpty(objectProps)
     }
 
@@ -776,7 +782,7 @@ class API {
     const seen = [object];
     while (todo.length > 0) {
       const next = todo.pop();
-      if ((this.propertiesFH.getValue([next, property], false) || {}).has) {
+      if ((await this.propertiesFH.getValue([next, property], false) || {}).has) {
         return true
       }
       const parents = this._objects.parents[next] || [];
@@ -911,22 +917,6 @@ class API {
 
   set config(config) {
     this._config = config
-    /*
-    const toJSON = (h) => {
-      if (h.child && h.parent) {
-        return h
-      } else {
-        return { child: h[0], parent: h[1] }
-      }
-    }
-    for (const tuple of [...config().config.hierarchy]) {
-      const h = toJSON(tuple);
-      // TODO should this notice development flag?
-      if (this.isOperator(h.child) && this.isOperator(h.parent)) {
-        this.rememberIsA(h.child, h.parent)
-      }
-    }
-    */
   }
 
   get config() {