theprogrammablemind_4wp 7.7.0-beta.0 → 7.7.0-beta.10

package/client.js

@@ -32,16 +32,26 @@ const pickObjects = (testConfig, objects) => {
 
 const getAsk = (config) => (uuid) => (asks) => {
   for (let ask of asks) {
+    let oneShot = true // default
+    if (ask.oneShot === false) {
+      oneShot = false
+    }
     config.addSemantic({
       uuid,
-      oneShot: true,
+      oneShot,
       match: (args) => ask.matchr(args),
       apply: (args) => ask.applyr(args)
     })
   }
+  let oneShot = true
+  for (let ask of asks) {
+    if (ask.oneShot === false) {
+      oneShot = false
+    }
+  }
   config.addSemantic({
       uuid,
-      oneShot: true,
+      oneShot,
       match: ({context}) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
       apply: (args) => {
         for (let ask of asks) {
@@ -64,7 +74,7 @@ const getAsk = (config) => (uuid) => (asks) => {
             break
           }
         }
-     }
+      }
   })
 }
 
@@ -169,6 +179,7 @@ const setupArgs = (args, config, logs, hierarchy) => {
       apis: getAPIs(uuid)
     }
   }
+  Object.assign(args, args.getUUIDScoped(this.uuid))
   args.breakOnSemantics = false
   args.theDebugger = {
     breakOnSemantics: (value) => args.breakOnSemantics = value
@@ -179,11 +190,23 @@ const setupArgs = (args, config, logs, hierarchy) => {
   args.log = (message) => logs.push(message)
 
   args.addAssumedScoped = (args, assumed) => {
+    const addAssumed = (args, ...moreAssumed) => {
+      return { ...args, assumed: Object.assign({}, (args.assumed || {}), ...moreAssumed) }
+    }
+
     args.s = (c) => config.getSemantics(logs).apply(args, c)
-    args.g = (c) => config.getGenerators(logs).apply(args, c)
-    args.gp = (c) => config.getGenerators(logs).apply({...args, assumed: {paraphrase: true, isResponse: false, response: false}}, c, {paraphrase: true, isResponse: false, response: false})
-    args.gr = (c) => config.getGenerators(logs).apply({...args, assumed: {paraphrase: false, isResponse: true}}, { ...c, paraphrase: false, isResponse: true })
-    args.e = (c) => config.getEvaluator(args.s, args.calls, logs, c)
+    args.g = (c, a = {}) => {
+      return config.getGenerators(logs).apply(addAssumed(args, a), c, a)
+    }
+    args.gp = (c, a = {}) => {
+      return config.getGenerators(logs).apply(addAssumed(args, a, {paraphrase: true, isResponse: false, response: false}), c, {paraphrase: true, isResponse: false, response: false})
+    }
+    args.gr = (c, a = {}) => {
+      return config.getGenerators(logs).apply(addAssumed(args, a, {paraphrase: false, isResponse: true}), { ...c, paraphrase: false, isResponse: true })
+    }
+    args.e = (c) => {
+      return config.getEvaluator(args.s, args.calls, logs, c)
+    }
     args.gs = gs(args.g)
     args.gsp = gs(args.gp)
     args.gsr = gs(args.gr)
@@ -467,8 +490,6 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
       }
       // assumed = { paraphrase: true, response: false };
       assumed = { paraphrase: true, isResponse: false, response: false };
-      // args.g = (c) => config.getGenerators(json.logs).apply({...args, assumed}, c, assumed)
-      // args.gs = gs(args.g)
       if (generateParenthesized) {
         config.parenthesized = false
       }
@@ -479,8 +500,6 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
         paraphrasesParenthesized = config.getGenerators(json.logs).apply({...args, assumed}, contextPrime, assumed)
         config.parenthesized = false
       }
-      // args.g = (c) => config.getGenerators(json.logs).apply(args, c)
-      // args.gs = gs(args.g)
       contextsPrime.push(contextPrime)
       generatedPrime.push(generated)
       paraphrasesPrime.push(paraphrases)
@@ -613,11 +632,25 @@ const loadInstance = (config, instance) => {
       // config.addInternal(results, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false)
       // config.addInternal(config.template.queries[i], { handleCalculatedProps: true } )
       config.addInternal(instance.template.queries[i], { addFirst: true, handleCalculatedProps: true } )
+    } else if (results.apply) {
+      const objects = config.get('objects')
+      const args = { objects, getObjects: getObjects(objects) }
+      if (instance.queries) {
+        args.isInstance = `instance${i}`
+        args.instance = instance.queries[i]
+      }
+      setupArgs(args, config, config.logs, hierarchy)
+      results.apply(args)
     } else {
       if (results.skipSemantics) {
         config.config.skipSemantics = results.skipSemantics
       }
-      processContextsB({ config, hierarchy, json: results/*, generators, semantics */, commandLineArgs: {}, isInstance: `instance${i}`, instance: instance.queries[i] })
+      const args = { config, hierarchy, json: results, commandLineArgs: {} }
+      if (instance.queries) {
+        args.isInstance = `instance${i}`
+        args.instance = instance.queries[i]
+      }
+      processContextsB(args)
       if (results.skipSemantics) {
         config.config.skipSemantics = null
       }
@@ -1182,9 +1215,9 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
   }
 
   if (responses.explain_priorities) {
-    console.log("Explain Priorities (listed from lower priority to higher priority)")
-    for ([inputss, outpus, reason] of responses.explain_priorities) {
-      console.log(`    ${JSON.stringify(inputss)} reason: ${reason}`)
+    console.log("Explain Priorities")
+    for ([inputs, output, reason] of responses.explain_priorities) {
+      console.log(`    inputs: ${JSON.stringify(inputs)} output: ${JSON.stringify(output)}  reason: ${reason}`)
     }
   }
   const objects = config.get('objects').namespaced[config.uuid]
@@ -1241,7 +1274,7 @@ const defaultProcess = ({ config, errorHandler }) => async (promise) => {
 }
 
 // builtTemplate saveInstance
-const rebuildTemplate = async ({ config, target, template, errorHandler = defaultErrorHandler }) => {
+const rebuildTemplate = async ({ config, target, previousResultss, startOfChanges, template, errorHandler = defaultErrorHandler }) => {
   const accumulators = {
     resultss: [],
     fragments: [],
@@ -1254,7 +1287,7 @@ const rebuildTemplate = async ({ config, target, template, errorHandler = defaul
       finish()
       return
     }
-    const { property, hierarchy, query: queryOrExtraConfig, initializer, skipSemantics } = queries.shift()
+    const { property, hierarchy, query: queryOrExtraConfig, previousResults, initializer, skipSemantics } = queries.shift()
     // queries are strings or { query: "blah", development: true/false }
     if (typeof queryOrExtraConfig === 'string' || queryOrExtraConfig.query) {
       let query = queryOrExtraConfig;
@@ -1276,7 +1309,15 @@ const rebuildTemplate = async ({ config, target, template, errorHandler = defaul
         }
       }
       try {
-        const results = await _process(config, query.query, {initializer, rebuildingTemplate: true})
+        let results
+        let prMessage = ''
+        if (previousResults && previousResults.query == query.query) {
+          results = previousResults
+          prMessage = ' Using previous results. use -rtf for a hard rebuild of everything on the server side.'
+          loadInstance(config, { resultss: [results] })
+        } else {
+          results = await _process(config, query.query, {initializer, rebuildingTemplate: true})
+        }
         if (config.config.debug) {
           // TODO pass in the error handler like the other ones
           defaultInnerProcess(config, defaultErrorHandler, results)
@@ -1285,9 +1326,9 @@ const rebuildTemplate = async ({ config, target, template, errorHandler = defaul
           console.log(`query "${query.query}". There is ${results.contexts.length} contexts in the results. Make sure its producing the results that you expect.`)
           throw new Error(`query "${query.query}". There is ${results.contexts.length} contexts in the results. Make sure its producing the results that you expect.`)
         } else if (results.paraphrases[0] != query.query) {
-          console.log(`query "${query.query}". The paraphrase is different from the query "${results.paraphrases[0]}".`)
+          console.log(`query "${query.query}". The paraphrase is different from the query "${results.paraphrases[0]}".${prMessage}`)
         } else {
-          console.log(`query ${query.query}`)
+          console.log(`query "${query.query}".${prMessage}`)
         }
         global.transitoryMode = transitoryMode
         config.config.skipSemantics = null
@@ -1304,6 +1345,15 @@ const rebuildTemplate = async ({ config, target, template, errorHandler = defaul
         config.config.skipSemantics = null
         errorHandler(error)
       }
+    } else if (typeof queryOrExtraConfig == 'function') {
+      console.log('calling initialize function')
+      const initFunction = queryOrExtraConfig
+      const objects = config.get('objects')
+      const args = { objects, getObjects: getObjects(objects) }
+      setupArgs(args, config, config.logs, hierarchy)
+      initFunction(args)
+      accumulators[property].push({ apply: queryOrExtraConfig })
+      await looper(queries)
     } else {
       // extra config is def from a time like operators or bridges or words etc
       // it will just get added to the config
@@ -1336,8 +1386,11 @@ const rebuildTemplate = async ({ config, target, template, errorHandler = defaul
     const stabilizeOutput = (template) => {
       stabilizeAssociations(template.associations)
       const stabilize = (results) => {
-        for (let result of results) {
-          if (result.extraConfig) {
+        for (let i = 0; i < results.length; ++i) {
+          const result = results[i]
+          if (result.apply) {
+            result.apply = result.apply.toString()
+          } else if (result.extraConfig) {
           } else {
             delete result.load_cache_time
             delete result.times
@@ -1375,7 +1428,13 @@ const rebuildTemplate = async ({ config, target, template, errorHandler = defaul
   }
   let todo = []
   todo = todo.concat((template.initializers || []).map((query) => { return { initializer: true, property: 'resultss', query, skipSemantics: false || query.skipSemantics } }))
-  todo = todo.concat((template.queries || []).map((query) => { return { property: 'resultss', query, skipSemantics: false || query.skipSemantics} }))
+  todo = todo.concat((template.queries || []).map((query, index) => { 
+    let pr
+    if (index < startOfChanges) {
+      pr = previousResultss[index] 
+    }
+    return { property: 'resultss', query, previousResults: pr, skipSemantics: false || query.skipSemantics} 
+  }))
   todo = todo.concat((template.fragments || []).map((query) => { return Object.assign({}, toProperties(query), { property: 'fragments', skipSemantics: false }) }))
   todo = todo.concat((template.semantics || []).map((definition) => { return { property: 'semantics', query: `${definition.from}\n${definition.to}`, skipSemantics: true } }))
   await looper(Object.assign([], todo))
@@ -1490,13 +1549,14 @@ const knowledgeModuleImpl = async ({
     parser.add_argument('-tnp', '--testNoParenthesized', { action: 'store_true', help: 'Don\' check parenthesized differences for the tests' })
     parser.add_argument('-n', '--count', { help: 'Number of times to run the tests. Default is one. Use this to check for flakey test. If possible the system will print out a message with the word "hint" suggesting how to fix the problem' })
     // parser.add_argument('-b', '--build', { help: 'Specify the template file name of the form <kmName>. There should be a file called <baseKmName>.<kmName>.template.json with the queries to run. For example { queries: [...] }. The template file will be run and generate an instantiation called <baseKmName>.<kmName>.instance.json and a file called <kmName>.js that will load the template file (this is file generated only if not already existing) and a test file called <KmName>.tests.json. This can then be loaded into an instance of the current knowledge module to setup initial conditions.' })
-    parser.add_argument('-rt', '--rebuildTemplate', { action: 'store_true', help: 'Force a template rebuild' })
+    parser.add_argument('-rt', '--rebuildTemplate', { action: 'store_true', help: 'Force a template rebuild. Using optimization where if the query/config has not changed it will use the previous value. One there is a change all subsequence query/configs will be run.' })
+    parser.add_argument('-rtf', '--rebuildTemplateFull', { action: 'store_true', help: 'Force a template rebuild. Skip the optimization' })
     parser.add_argument('-l', '--loop', { action: 'store_true', help: 'Run a loop so that multiply queries may be run' })
     parser.add_argument('-i', '--info', { action: 'store_true', help: 'Print meta-data for the module' })
     parser.add_argument('-v', '--vimdiff', { action: 'store_true', help: 'For failures run vimdiff' })
     parser.add_argument('-g', '--greg', { action: 'store_true', help: 'Set the server to be localhost so I can debug stuff' })
     parser.add_argument('-cl', '--checkForLoop', { nargs: "?", help: 'Check for loops in the priorities, Optional argument is list of operator keys to consider. For example [["banana", 0], ["food", 1]]' })
-    parser.add_argument('-r', '--retrain', { action: 'store_true', help: 'Get the server to retrain the neural nets' })
+    parser.add_argument('-r', '--reset', { action: 'store_true', help: 'Get the server to bypass the cache and rebuild everything' })
     parser.add_argument('-q', '--query', { help: 'Run the specified query' })
     parser.add_argument('-ip ', '--server', { help: 'Server to run against' })
     parser.add_argument('-qp ', '--queryParams', { help: 'Query params for the server call' })
@@ -1521,6 +1581,10 @@ const knowledgeModuleImpl = async ({
     const args = parser.parse_args()
     args.count = args.count || 1
 
+    if (args.rebuildTemplateFull) {
+      args.rebuildTemplate = true
+    }
+
     if (args.parenthesized) {
       config.parenthesized = true
     }
@@ -1611,6 +1675,10 @@ const knowledgeModuleImpl = async ({
       config.config.debug = true
     }
 
+    if (args.reset) {
+      config.config.skip_cache = true
+    }
+
     if (args.explainPriorities) {
       config.config.explain_priorities = true
     }
@@ -1711,23 +1779,33 @@ const knowledgeModuleImpl = async ({
     checkTemplate(template)
 
     if (template) {
-      const needsRebuild = config.needsRebuild(template.template, template.instance, options)
-      if (needsRebuild) {
+      let needsRebuild
+      if (args.rebuildTemplate && !args.rebuildTemplateFull) {
+        // get the startOfChanges for the partial rebuild
+        needsRebuild = config.needsRebuild(template.template, template.instance, { ...options, rebuild: false })
+      } else {
+        // do a check or full rebuild
+        needsRebuild = config.needsRebuild(template.template, template.instance, options)
+      }
+
+      if (needsRebuild.needsRebuild) {
+        if (needsRebuild.previousResultss) {
+          console.log("Rebuild using the optimization to use previous results until a change is hit. For a full rebuild use -rtf")
+        }
         console.log(`This module "${config.name}" needs rebuilding all other arguments will be ignored. Try again after the template is rebuilt.`)
         options.rebuild = true
         config.config.rebuild = true
       }
       try {
-        config.load(template.template, template.instance, { rebuild: needsRebuild })
+        config.load(template.template, template.instance, { rebuild: needsRebuild.needsRebuild || options.rebuild, previousResultss: needsRebuild.previousResultss, startOfChanges: needsRebuild.startOfChanges })
       } catch( e ) {
-        debugger
-        console.error(`Error loading template for ${config.name}. ${e.error ? e.error : e}`)
+        console.error(`Error loading template for ${config.name}. ${e.error ? e.error : e}${e.stack ? e.stack : ''}`)
         runtime.process.exit(-1)
       }
       if (!args.query) {
         printConfig()
       }
-      if (needsRebuild) {
+      if (needsRebuild.needsRebuild) {
         return
       }
     }
@@ -1890,7 +1968,7 @@ const knowledgeModuleImpl = async ({
                 if (!(useTestConfig.check && useTestConfig.check.length > 0)) {
                   console.log('use -v arg to write files expected.json and actual.json in the current directory for detailed comparison. Or do -s and then git diff the changes.')
                   // console.log(JSON.stringify(contexts))
-                  console.log('**************************** ERRORS ************************')
+                  console.log('**************************** THERE WERE ERRORS ************************')
                 }
               }
             }
@@ -1976,7 +2054,7 @@ const knowledgeModuleImpl = async ({
       }
 
       if (template) {
-        if (config.needsRebuild(template.template, template.instance, { isModule: !isProcess })) {
+        if (config.needsRebuild(template.template, template.instance, { isModule: !isProcess }).needsRebuild) {
           const error = `This module "${config.name}" cannot be used because the instance file needs rebuilding. Run on the command line with no arguments or the -rt argument to rebuild.`
           throw new Error(error)
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "devDependencies": {
     "eslint-plugin-import": "^2.23.4",
-    "jest": "^26.6.3",
+    "jest": "^29.7.0",
     "@typescript-eslint/parser": "^4.28.4",
     "@typescript-eslint/eslint-plugin": "^4.28.4",
     "eslint-plugin-node": "^11.1.0",
@@ -12,6 +12,7 @@
   "scripts": {
     "to:debug": "node inspect node_modules/.bin/jest --runInBand -t NEO23",
     "test:debug": "node inspect node_modules/.bin/jest --runInBand --config ./jest.config.json",
+    "td": "node inspect node_modules/.bin/jest --runInBand --config ./jest.config.json",
     "tod": "node inspect node_modules/.bin/jest --runInBand -t NEO23",
     "lint:fix": "eslint \"**/*.js\" --fix",
     "lint": "eslint \"**/*.js\"",
@@ -64,6 +65,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.7.0-beta.0",
+  "version": "7.7.0-beta.10",
   "license": "ISC"
 }

package/src/config.js

@@ -965,7 +965,7 @@ class Config {
   }
 
   // { rebuild: false, isModule: false }
-  needsRebuild(template, instance, options) {
+  needsRebuild (template, instance, options) {
     if (options.rebuild) {
       return true
     }
@@ -983,6 +983,8 @@ class Config {
       if (typeof queryOrConfig == 'string') {
         const query = queryOrConfig
         return query
+      } else if (typeof queryOrConfig == 'function') {
+        return { apply: queryOrConfig.toString() }
       } else {
         const config = { ...queryOrConfig }
         delete config.where
@@ -1058,7 +1060,22 @@ class Config {
       return elements.map( toCanonicalQuery )
     }
 
-    const sameQueries = helpers.safeEquals(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), toCanonicalQueries(instance.queries || []))
+    const templateQueries = toCanonicalQueries(template.queries || []).map(helpers.updateQueries)
+    const instanceQueries = toCanonicalQueries(instance.queries || [])
+    let sameQueries = true
+    let startOfChanges;
+    for (let iq = 0; iq < templateQueries.length; ++iq) {
+      if (!helpers.safeEquals(templateQueries[iq], instanceQueries[iq])) {
+        sameQueries = false
+        startOfChanges = iq
+      }
+    }
+
+    // things were deleted case
+    if (templateQueries.length < instanceQueries.length) {
+      startOfChanges = instanceQueries.length
+    }
+    // const sameQueries = helpers.safeEquals(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), toCanonicalQueries(instance.queries || []))
 
     const debug = false
     if (debug) {
@@ -1067,16 +1084,20 @@ class Config {
           debugger
           debugger
         }
-        console.log("instance", instance)
+        // console.log("instance", instance)
         console.log("sameQueries", sameQueries)
         console.log("sameFragments", sameFragments)
-        console.log("templateFragments", templateFragments)
-        console.log("instanceFragments", instanceFragments)
-        console.log('template.queries', JSON.stringify(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), null, 2))
-        console.log("instance.queries", JSON.stringify(toCanonicalQueries(instance.queries || []), null, 2))
+        // console.log("templateFragments", templateFragments)
+        // console.log("instanceFragments", instanceFragments)
+        // console.log('template.queries', JSON.stringify(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), null, 2))
+        // console.log("instance.queries", JSON.stringify(toCanonicalQueries(instance.queries || []), null, 2))
       }
     }
-    return !(instance && sameQueries && sameFragments)
+    if (startOfChanges || instance.resultss) {
+      return { needsRebuild: !(instance && sameQueries && sameFragments), startOfChanges, previousResultss: instance.resultss }
+    } else {
+      return { needsRebuild: !(instance && sameQueries && sameFragments) }
+    }
   }
 
   validifyTemplate (template) {
@@ -1097,7 +1118,7 @@ class Config {
   }
 
   // loadTemplate
-  load (template, instance, options = { rebuild: false } ) {
+  load (template, instance, options = { rebuild: false, previousResultss: undefined, startOfChanges: undefined } ) {
     this.validifyTemplate(template)
     instance.template = template
     this.logs.push(`loading template for ${this.name}`)
@@ -1105,7 +1126,7 @@ class Config {
       // TODO fix beforeQuery
       template = { fragments: [], queries: [], ...template }
       template.fragments = template.fragments.concat(this.dynamicFragments)
-      client.rebuildTemplate({ config: this, target: this.name, beforeQuery: () => {}, template, ...options })
+      client.rebuildTemplate({ config: this, target: this.name, previousResultss: options.previousResultss, startOfChanges: options.startOfChanges, beforeQuery: () => {}, template, ...options })
     } else {
       // no change
       // this.initInstances.push({ ...instance, name: config.name })
@@ -1120,6 +1141,13 @@ class Config {
         return !properties.find( (property) => instance[property] && instance[property].length > 0 )
       }
       if (!isEmpty(instance)) {
+        // fix up apply functions
+        for (let i = 0; i < instance.resultss.length; ++i) {
+          const result = instance.resultss[i]
+          if (result.apply) {
+            result.apply = template.queries[i]
+          }
+        }
         instance.name = this.name
         this.initInstances.push(instance)
         this.instances.push(instance)
@@ -2219,8 +2247,6 @@ class Config {
     const addInternals = []
     const inits = []
     const initAfterApis = []
-    const reverseIt = true
-    const interleaved = true
     this.configs.forEach((km) => {
       const namespace = km.namespace
       this.config.objects.namespaced[km._uuid] = {}
@@ -2286,58 +2312,30 @@ class 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)
-          }
+          inits.unshift(null)
         }
         // config._api.objects = namespacedObjects
         // config._api.config = () => this
         // config._api.uuid = config._uuid
       } else {
-        if (interleaved) {
-          inits.unshift(null)
-        }
+        inits.unshift(null)
       }
       config.setUUIDs()
       config.applyNamespace(config.config, namespace, config.uuid)
       if (!isSelf) {
-        if (!reverseIt) {
-          addInternals.push(config)
-        } else {
-          addInternals.unshift(config)
-        }
+        addInternals.unshift(config)
       } else {
-        if (interleaved) {
-          addInternals.unshift(null)
-        }
+        addInternals.unshift(null)
       }
       km.valid()
     })
 
     const generators = this.config.generators
     const semantics = this.config.semantics
-    if (reverseIt) {
-      this.config.generators = []
-      this.config.semantics = []
-    }
+    this.config.generators = []
+    this.config.semantics = []
 
-    if (!interleaved) {
-      for (const config of addInternals) {
-        if (!reverseIt) {
-          this.addInternal(config, { includeNamespace: false, allowNameToBeNull: true })
-        } else {
-          this.addInternalR(config, true, false, false, true)
-        }
-      }
-      // console.log('inits from config', inits)
-      for (const init of inits) {
-        init()
-      }
-      for (let init of initAfterApis) {
-        init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi: true })
-      }
-      this.instances.forEach((instance) => client.loadInstance(this, instance))
-    } else {
+    {
       const base = {
         operators: this.config.operators,
         bridges: this.config.bridges,
@@ -2353,13 +2351,16 @@ class Config {
       this.config.priorities = []
       this.config.associations = { positive: [], negative: [] }
       this.config.words = {}
-
+      
       for (let i = 0; i < addInternals.length; ++i) {
         let name;
         if (addInternals[i]) {
           this.addInternalR(addInternals[i], true, false, false, true)
           name = addInternals[i].name
         } 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)
           this.addInternalR(base, true, false, false, true)
           name = this.name
         }
@@ -2380,10 +2381,6 @@ class Config {
       }
     }
 
-    if (reverseIt) {
-      this.config.generators = generators.concat(this.config.generators)
-      this.config.semantics = semantics.concat(this.config.semantics)
-    }
     this.hierarchy.edges = this.config.hierarchy
     this.valid()
     this.checkBridges()

package/src/generators.js

@@ -179,7 +179,6 @@ class Generators {
     const objects = args.objects
     const hierarchy = args.hierarchy
     const response = args.response
-
     
     // args = { ...args, ...args.getAssumedScoped(assumed) }
     args.addAssumedScoped(args, assumed) 

package/src/helpers.js

@@ -272,6 +272,8 @@ const mapInPlace = (list, fn) => {
 const updateQueries = (queryOrConfig) => {
   if (typeof queryOrConfig == 'string' || queryOrConfig.query) {
     return queryOrConfig
+  } else if (typeof queryOrConfig == 'function') {
+    return { apply: queryOrConfig.toString() }
   } else {
     const config = queryOrConfig
     return functionsToStrings(config)