theprogrammablemind_4wp 9.5.1-beta.9 → 9.6.0

package/client.js

@@ -12,10 +12,9 @@ const _ = require('lodash')
 const stringify = require('json-stable-stringify')
 const Lines = require('./lines')
 const flattens = require('./src/flatten')
-const { appendNoDups, updateQueries, safeNoDups, stableId, where, suggestAssociationsFix, suggestAssociationsFixFromSummaries, validProps } = require('./src/helpers')
+const { sortJson, appendNoDups, updateQueries, safeNoDups, stableId, where, suggestAssociationsFix, suggestAssociationsFixFromSummaries, validProps } = require('./src/helpers')
 const runtime = require('./runtime')
-const sortJson = runtime.sortJson
-const debug = require('./src/debug')
+const db = require('./src/debug')
 
 const getConfig_getObjectsCheck = (config, testConfig) => {
   let testConfigName = config.name
@@ -46,33 +45,33 @@ const getSuggestionMessage = (suggestion) => {
   return `Try adding this to the associations: { context: ${JSON.stringify(getSuggestion(suggestion))}, choose: <indexOfMainElement> },\n If that does not work look at the logs and check when the operators become wrong during an interation. Deduce the change based on the previous iteration and what operator was applied.`
 }
 
-const getConfig_getContextCheck = (testConfig) => {
-  return (testConfig.checks && testConfig.checks.context) || []
-}
-
 const pickContext = (contextChecks) => (context) => {
   return project2(context, contextChecks)
 }
 
 const pickObjects = (config, testConfig, getObjects) => {
-  /*
-  let testConfigName = config.name
-  if (testConfig.testModuleName) {
-    objects = getObjects(config.config.objects)(config.getConfigs()[testConfig.testModuleName].uuid)
-    testConfigName = testConfig.testModuleName
-  }
-  */
   const checks = getConfig_getObjectsCheck(config, testConfig)
+  const contextChecks = config.getContextChecks()
   const projection = {}
   for (const km in checks) {
     const objects = getObjects(km)
     if (!objects) {
       throw new Error(`In the checks for ${config.name} the KM ${km} does not exist`)
     }
-    if (checks[km] && checks[km].find((check) => check.match && check.apply)) {
-      projection[km] = project2(objects, checks[km])
+
+    if (false) {
+      if (checks[km] && checks[km].find((check) => check.match && check.apply)) {
+        projection[km] = project2(objects, checks[km])
+      } else {
+        projection[km] = project(objects, checks[km])
+      }
     } else {
-      projection[km] = project(objects, checks[km])
+      const lastIndex = contextChecks.length - 1
+      const last = contextChecks[lastIndex]
+      contextChecks[lastIndex] = { match: last.match, apply: () => [...new Set([...(checks[km] || []), ...last.apply()])] }
+
+      // projection[km] = project2(objects, [...checks[km], ...contextChecks])
+      projection[km] = project2(objects, contextChecks)
     }
   }
   return projection
@@ -237,9 +236,10 @@ const doWithRetries = async (n, url, queryParams, data) => {
       body: JSON.stringify(data),
       timeout: 1000 * 60 * 5, // it does not respect this timeout so that's why I have the retries
       headers: {
-        mode: 'no-cors',
+        // mode: 'no-cors',
         'Content-Type': 'application/json'
-      }
+      },
+      credentials: 'same-origin',
     })
     if (result.ok) {
       return JSON.parse(JSON.stringify(await result.json()))
@@ -841,7 +841,7 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
   }
   console.log(responses.trace)
 
-  if (true) {
+  if (false) {
     if (global.beforeObjects) {
       console.log('objects', runtime.jsonDiff.diffString(global.beforeObjects, config.get('objects')))
     } else {
@@ -916,7 +916,7 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
   console.log('')
   const screen_width = process.stdout.columns
   // || 0 for when running without a console
-  const widths = [70, 10, Math.max(80, screen_width - 71 || 0)]
+  const widths = Lines.addRemainder([70, 10])
   const lines = new Lines(widths)
   lines.setElement(0, 0, '--- The paraphrases are ----------')
   lines.setElement(0, 2, '--- The response strings are ----------')
@@ -973,7 +973,7 @@ const rebuildTemplate = async ({ config, instance, target, previousResultss, reb
     if (instance.fragments) {
       pr = instance.fragments[index]
     }
-    return Object.assign({}, toProperties(query), { property: 'fragments', previousResults: pr, skipSemantics: false })
+    return Object.assign({}, toProperties(query), { property: 'fragments', previousResults: pr, skipSemantics: true })
   }
 
   const looper = async (configs) => {
@@ -1327,13 +1327,32 @@ const knowledgeModuleImpl = async ({
       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', '--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('-f', '--filter', { help: 'for -pd only the data for the knowledge modules that start with this string will be shown' })
       parser.add_argument('-ip ', '--server', { help: 'Server to run against' })
       parser.add_argument('-qp ', '--queryParams', { help: 'Query params for the server call' })
       parser.add_argument('-dt', '--deleteTest', { help: 'Delete the specified query from the tests file.' })
       parser.add_argument('--parenthesized', { action: 'store_true', help: 'Show the generated phrases with parenthesis.' })
       parser.add_argument('-c', '--clean', { help: 'Remove data from the test files. a === association' })
       parser.add_argument('-od', '--objectDiff', { action: 'store_true', help: 'When showing the objects use a colour diff' })
-      parser.add_argument('-p', '--print', { help: 'Print the specified elements c === config, w === words, b === bridges, o === operators d === objects (d for data), h === hierarchy, ha === hierarchy ancestors g === generators, s === semantics, l === load t=tests ordering p === priorities a === associations j === JSON sent to server. for example --print wb' })
+      parser.add_argument('-p', '--print', { help: 
+`Print the specified elements 
+    a === associations 
+    b === bridges, 
+    c === config,
+    cc === test checks,
+    d === objects (d for data), 
+    g === generators, 
+    h === hierarchy, 
+    ha === hierarchy ancestors,
+    j === JSON sent to server, 
+    l === load ordering,
+    o === operators,
+    p === priorities,
+    s === semantics, 
+    t === tests ordering,
+    w === words, 
+ for example --print wb' })
+` })
       parser.add_argument('-s', '--save', { action: 'store_true', help: 'When running with the --query flag this will save the current run to the test file. When running without the --query flag all tests will be run and resaved.' })
       parser.add_argument('-fr', '--failRebuild', { action: 'store_true', help: 'If a rebuild is required fail out.' })
       parser.add_argument('-sd', '--saveDeveloper', { action: 'store_true', help: 'Same as -s but the query will not show up in the info command.' })
@@ -1494,6 +1513,12 @@ const knowledgeModuleImpl = async ({
               counter += 1
             }
           }
+          if (hasArg('cc')) {
+            for (const cc of config.getContextChecks()) {
+              const printable = { ...cc, match: cc.match.toString(), apply: cc.apply.toString() }
+              console.log(JSON.stringify(printable, null, 2))
+            }
+          }
           if (hasArg('c')) {
             const { data } = setupProcessB({ config })
             console.log('Config as sent to server')
@@ -1557,8 +1582,19 @@ const knowledgeModuleImpl = async ({
           }
 
           if (hasArg('d')) {
-            console.log('objects (data) ================')
-            console.log(JSON.stringify(config.config.objects, null, 2))
+            if (args.filter) {
+              console.log(`objects (data) filtered by ${args.filter} ================`)
+              const projection = { namespaced: {} }
+              for (const key of Object.keys(config.config.objects.namespaced)) {
+                if (key.startsWith(args.filter)) {
+                  projection.namespaced[key] = config.config.objects.namespaced[key]
+                }
+              }
+              console.log(JSON.stringify(projection, null, 2))
+            } else {
+              console.log('objects (data) ================')
+              console.log(JSON.stringify(config.config.objects, null, 2))
+            }
           }
 
           if (hasArg('p')) {
@@ -2011,9 +2047,15 @@ const ensureTestFile = (module, name, type) => {
 }
 
 const knowledgeModule = async (...args) => {
-  await knowledgeModuleImpl(...args).catch((e) => {
+  await knowledgeModuleImpl(...args).catch(async (e) => {
     console.error(e)
-    process.exit(-1)
+    function sleep(ms) {
+      return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+      });
+    }
+    await sleep(1) // get the stderr to flush
+    await process.exit(-1);   // tiny trick: empty write forces flush of console.error buffer
   })
 }
 
@@ -2038,5 +2080,6 @@ module.exports = {
   gs,
   flattens,
   writeTest,
-  getConfigForTest
+  getConfigForTest,
+  debug: db,
 }

package/lines.js

@@ -5,7 +5,7 @@ class Lines {
     this.rows = []
   }
 
-  static SCREEN_WIDTH = 132
+  static SCREEN_WIDTH = 164
 
   static addRemainder(widths) {
     const sum = widths.reduce((a, b) => a + b)

package/package.json

@@ -70,9 +70,8 @@
     "node-fetch": "^2.6.1",
     "readline": "^1.3.0",
     "scriptjs": "^2.5.9",
-    "sort-json": "^2.0.0",
     "uuid": "^8.3.2"
   },
-  "version": "9.5.1-beta.9",
+  "version": "9.6.0",
   "license": "UNLICENSED"
 }

package/runtime.js

@@ -12,7 +12,6 @@ module.exports = {
   ArgumentParser: 'Should not be called in the browser',
   readline: 'Should not be called in the browser',
   jsonDiff: 'Should not be called in the browser',
-  sortJson: 'Should not be called in the browser',
   util: 'Should not be called in the browser',
   performance: 'Should not be called in the browser'
 }

package/src/config.js

@@ -10,7 +10,7 @@ const { ecatch } = require('./helpers')
 const runtime = require('../runtime')
 const _ = require('lodash')
 const db = require('./debug')
-const { fragmentInstantiator } = require('./fragments')
+const { fragmentInstantiator, fragmentMapperInstantiator } = require('./fragments')
 
 const debugBreak = () => {
   // debugger
@@ -21,8 +21,6 @@ const bags = [
   'semantics'
 ]
 
-global.GORDO = true
-
 const indent = (string, indent) => {
   return string.replace(/^/gm, ' '.repeat(indent))
 }
@@ -337,6 +335,8 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
           config.addPriority({ context: [[bridge.id, bridge.level], after], choose: [0] })
         }
       }
+
+      // done in setTestConfig
       if (bridge.check) {
         if (!config.testConfig) {
           config.testConfig = {}
@@ -347,12 +347,15 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
         if (!config.testConfig?.checks?.context) {
           config.testConfig.checks.context = []
         }
-        config.testConfig.checks.context.push({
+        config.contextChecksFromBridges.push({
+          'bridge.id': bridge.id,
+          'bridge.check': bridge.check,
           match: ({context}) => context.marker == bridge.id,
           exported: true,
           apply: ({context}) => bridge.check,
         })
       }
+
       if (bridge.after) {
         for (let before of bridge.after) {
           if (typeof before === 'string') {
@@ -402,11 +405,15 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
       if (bridge.generatorp) {
         const match = bridge.generatorp.match || (() => true)
         const apply = typeof bridge.generatorp === 'function' ? bridge.generatorp : bridge.generatorp.apply || bridge.generatorp
-        const level = bridge.generatorp.level >= 0 ? bridge.generatorp.level : bridge.level + 1
+        let level = bridge.generatorp.level >= 0 ? bridge.generatorp.level : bridge.level + 1
+        if (!bridge.bridge) {
+          level = 0
+        }
 
         const generator = {
           where: bridge.generatorp.where || bridge.where || helpers.where(4),
-          match: async (args) => bridge.id === args.context.marker && args.context.level === level && args.context.paraphrase && await match(args),
+          // match: async (args) => bridge.id === args.context.marker && args.context.level === level && args.context.paraphrase && await match(args),
+          match: async (args) => args.isA(args.context.marker, bridge.id) && args.context.level === level && args.context.paraphrase && await match(args),
           apply: (args) => apply(args),
           applyWrapped: apply,
           property: 'generatorp'
@@ -423,7 +430,8 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
         const level = bridge.generatorr.level >= 0 ? bridge.generatorr.level : bridge.level + 1
         const generator = {
           where: bridge.generatorr.where || bridge.where || helpers.where(4),
-          match: async (args) => bridge.id === args.context.marker && args.context.level === level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && await match(args),
+          // match: async (args) => bridge.id === args.context.marker && args.context.level === level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && await match(args),
+          match: async (args) => args.isA(args.context.marker, bridge.id) && args.context.level === level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && await match(args),
           apply: (args) => apply(args),
           applyWrapped: apply,
           property: 'generatorr'
@@ -510,8 +518,43 @@ const handleCalculatedProps = (baseConfig, moreConfig, { addFirst, uuid } = {})
   if (moreConfig.bridges) {
     moreConfig.bridges = moreConfig.bridges.map((bridge) => {
       bridge = { ...bridge }
-      const valid = ['after', 'conditional', 'associations', 'before', 'bridge', 'check', 'disabled', 'scope', 'skipable', 'return_type_selector', 'evaluator', 'evaluators', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'operator', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
-        'level', 'optional', 'selector', 'separators', 'semantic', 'semantics', 'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where', 'uuid']
+      const valid = [
+        'after', 
+        'associations', 
+        'before', 
+        'bridge', 
+        'check', 
+        'children', 
+        'conditional', 
+        'convolution', 
+        'disabled', 
+        'enhanced_associations', 
+        'evaluator', 
+        'evaluators', 
+        'generatorp', 
+        'generatorpr', 
+        'generatorr', 
+        'generators', 
+        'id', 
+        'inverted', 
+        'isA', 
+        'level', 
+        'levelSpecificHierarchy', 
+        'localHierarchy', 
+        'operator', 
+        'optional', 
+        'parents',
+        'return_type_selector', 
+        'scope', 
+        'selector', 
+        'semantic', 
+        'semantics', 
+        'separators', 
+        'skipable', 
+        'uuid',
+        'where', 
+        'words', /Bridge$/, 
+      ]
       helpers.validProps(valid, bridge, 'bridge')
       handleBridgeProps(baseConfig, bridge, { addFirst, uuid })
       return bridge
@@ -674,7 +717,7 @@ function setWordsUUIDs (words, uuid) {
   for (const key in literals) {
     literals[key] = literals[key].map((o) => Object.assign(o, { uuid }))
   }
-  const patterns = words.patterns
+  const patterns = words.patterns || []
   for (const pattern of patterns) {
     pattern.defs.map((def) => Object.assign(def, { uuid }))
   }
@@ -903,6 +946,10 @@ class Config {
     return config_toServer(config)
   }
 
+  async run(handler) {
+    return configHelpers.run(this, handler)
+  }
+
   async fixtures () {
     if (this.testConfig?.fixtures) {
       const args = {}
@@ -936,6 +983,7 @@ class Config {
 
   getPseudoConfig (uuid, config) {
     return {
+      pseudo: true,
       description: 'this is a pseudo config that has limited functionality due to being available in the initializer and fixtures function context',
       addAssociation: (...args) => this.addAssociation(...args),
       addAssociations: (...args) => this.addAssociations(...args),
@@ -949,6 +997,22 @@ class Config {
       removeSemantic: (...args) => this.removeSemantic(...args, uuid, config.name),
       addWord: (...args) => this.addWord(...args, uuid),
       addPattern: (...args) => this.addPattern(...args, uuid),
+      updateBridge: (...args) => this.updateBridge(...args),
+      processContext: (...args) => this.processContext(...args),
+
+      semantics: () => this.config.semantics,
+      getConfigs: () => this.configs,
+      getTestConfig: () => this.getTestConfig(),
+      getTests: () => this.getTests(),
+      getName: () => this.getName(),
+      getDescription: () => this.getDescription(),
+      getDebug: () => this.getDebug(),
+      getDebugLoops: () => this.getDebugLoops(),
+      getMaxDepth: () => this.getMaxDepth(),
+      getAPIs: (...args) => this.getAPIs(...args),
+      getAPI: (...args) => this.getAPI(...args),
+      getUUID: (...args) => this.getUUID(...args),
+      nsToString: (...args) => this.nsToString(...args),
 
       getHierarchy: (...args) => this.config.hierarchy,
       getBridges: (...args) => this.config.bridges,
@@ -958,10 +1022,53 @@ class Config {
       fragment: (...args) => this.fragment(...args),
       server: (...args) => this.server(...args),
       exists: (...args) => this.exists(...args),
-      addAPI: (...args) => this.addAPI(...args)
+      addAPI: (...args) => this.addAPI(...args),
+
+      getParenthesized: () => this.getParenthesized(),
+      setParenthesized: (...args) => this.setParenthesized(...args),
     }
   }
 
+  getUUID() {
+    return this.uuid
+  }
+
+  getTestConfig() {
+    return this.testConfig
+  }
+
+  getMaxDepth() {
+    return this.config.maxDepth
+  }
+
+  getDebug() {
+    return this.config.debug
+  }
+
+  getDebugLoops() {
+    return this.config.debugLoops
+  }
+
+  getName() {
+    return this.name
+  }
+
+  getDescription() {
+    return this.description
+  }
+
+  getTests() {
+    return this.tests
+  }
+
+  getParenthesized(value) {
+    return this.parenthesized
+  }
+
+  setParenthesized(value) {
+    this.parenthesized = value
+  }
+
   inDevelopmentMode (call) {
     config.developmentModeOn += 1
     try {
@@ -978,7 +1085,27 @@ class Config {
   }
 
   setTestConfig (testConfig) {
-    this.testConfig = testConfig
+    this.testConfig = { ...testConfig }
+    if (!this.testConfig.checks) {
+      this.testConfig.checks = {}
+    }
+    if (!this.testConfig?.checks?.context) {
+      this.testConfig.checks.context = []
+    }
+    this.testConfig.checks.context = this.contextChecksFromBridges.concat(this.testConfig.checks.context)
+    /*
+    const currentTestConfig = testConfig // add bridge has added check.context's
+
+    if (!this.testConfig.checks) {
+      debugger
+      // this.testConfig.checks = 
+    }
+
+    // set during bridge setup
+    if (currentTestConfig.checks?.context) {
+      this.testConfig.checks.context = currentTestConfig.checks.context.concat(this.testConfig.checks.context)
+    }
+    */
   }
 
   getTestConfig () {
@@ -1108,26 +1235,52 @@ class Config {
     return instance
   }
 
-  fragment (args, query) {
+  getFragment(query) {
     for (const instance of (this.instances || [])) {
       for (const fragment of (instance.fragments || [])) {
         if (fragment.query === query) {
-          return fragmentInstantiator(args, fragment.contexts)
+          return fragment
         }
       }
       for (const fragment of (instance.resultss || [])) {
         if (fragment.isFragment && fragment.query === query) {
-          return fragmentInstantiator(args, fragment.contexts)
+          return fragment
         }
       }
       for (const fragment of (this.fragmentsBeingBuilt || [])) {
         if (fragment.query === query) {
-          return fragmentInstantiator(args, fragment.contexts)
+          return fragment
         }
       }
     }
   }
 
+  // mappings are optional
+  async fragment (args, query, mappings) {
+    const fragment = this.getFragment(query)
+    if (fragment) {
+      let fi = fragmentInstantiator(args, fragment.contexts)
+      if (mappings) {
+        fi = await fi
+        return fi.instantiate([{
+          match: ({context}) => !!mappings[context.value], // is the value in the mappings
+          apply: ({context}) => Object.assign(context, mappings[context.value]),
+        }])
+      } else {
+        return fi
+      }
+    }
+  }
+
+  fragmentMapper (args, values, fromModelQuery, toModelQuery) {
+    const fromModelFragment = this.getFragment(fromModelQuery)
+    console.dir(fromModelFragment)
+    const toModelFragment = this.getFragment(toModelQuery)
+    console.dir(toModelFragment)
+    const mapper = fragmentMapperInstantiator(values, fromModelFragment.contexts, toModelFragment.contexts)
+    return mapper
+  }
+
   // { rebuild: false, isModule: false }
   needsRebuild (template, instance, options) {
     if (options.rebuild) {
@@ -1486,6 +1639,11 @@ class Config {
     }
   }
 
+  updateBridge(id, updater) {
+    const bridge = this.config.bridges.find((b) => b.id === id)
+    updater({ config: this, bridge })
+  }
+
   addBridge (bridge, uuid) {
     if (!this.config.bridges) {
       this.config.bridges = []
@@ -1670,7 +1828,9 @@ class Config {
 
   getAPIs (uuid) {
     let config
-    if (this._uuid === uuid) {
+    if (!uuid) {
+      config = this
+    } else if (this._uuid === uuid) {
       config = this
     } else {
       for (const km of this.configs) {
@@ -1685,6 +1845,14 @@ class Config {
     }
   }
 
+  /*
+  getAPIs (config) {
+    if (config && config._api && config._api.multiApi) {
+      return config._api.apis
+    }
+  }
+  */
+
   getServer () {
     return this._server
   }
@@ -1787,7 +1955,7 @@ class Config {
 
   // set the args in the api's
   setArgs (args) {
-    const setArgs = (config) => {
+    const setConfigArgs = (config) => {
       if (!config._api) {
         return
       }
@@ -1800,10 +1968,10 @@ class Config {
       }
     }
 
-    setArgs(this)
+    setConfigArgs(this)
     for (const config of this.configs) {
       if (config.config instanceof Config) {
-        setArgs(config.config)
+        setConfigArgs(config.config)
       }
     }
   }
@@ -1832,6 +2000,16 @@ class Config {
     }
   }
 
+  getObjects () {
+    const configs = {}
+    const ns = this.config.objects.namespaced
+    configs[this.name] = this
+    for (const config of this.configs) {
+      configs[config._name] = ns[config._uuid]
+    }
+    return configs
+  }
+
   getConfig (name) {
     if (this.name === name) {
       return this
@@ -1879,14 +2057,6 @@ class Config {
       } else if (this.scope == 'development') {
         new_result = !(element.scope === 'testing')
       }
-      /*
-      if (global.GORDO && old_result !== new_result) {
-        global.GORDO = false
-        console.log("THERE WAS A DIFFERENCE ------------------------------------------------")
-        debugger // greg23old
-      }
-      */
-      // return old_result
       return new_result
     }
 
@@ -1992,6 +2162,8 @@ class Config {
       config.priorities = config.priorities || []
     }
 
+    this.contextChecksFromBridges = []
+
     this._enable = []
     this._apiKMs = apiKMs
 
@@ -2051,7 +2223,7 @@ class Config {
 
     // set the default server so stuff just works
     // this.server('https://184.67.27.82:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
-    this.server('https://thinktelligence.com:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
+    this.server('https://thinktelligence.com/entodicton', '6804954f-e56d-471f-bbb8-08e3c54d9321')
 
     this.defaultConfig()
     this.initializerFn = ({ currentConfig }) => {
@@ -2318,6 +2490,7 @@ class Config {
     // update uuid here set the uuid in the objects and add error checking
     cp.initializerFn = this.initializerFn
     cp.terminatorFn = this.terminatorFn
+    cp.contextChecksFromBridges = this.contextChecksFromBridges
     cp._apiKMs = this._apiKMs
     cp._apiConstructor = this._apiConstructor
     if (cp._apiConstructor) {
@@ -2678,19 +2851,37 @@ class Config {
 
   getContextChecks() {
     const allChecks = []
-    for (const name of this.loadOrdering) {
-      const checks = this.kms[name].testConfig?.checks?.context || []
-      for (const check of checks) {
-        if (check.exported) {
-          allChecks.push(check)
+    let defaults = () => []
+    if (this.loadOrdering) {
+      for (const name of this.loadOrdering) {
+        const checks = this.kms[name].testConfig?.checks?.context || []
+        const oldDefaults = defaults
+        for (const check of checks) {
+          if (!check.match) {
+            const oldDefaults = defaults
+            defaults = () => helpers.safeNoDups([...check.apply(), ...oldDefaults()])
+            continue
+          }
+          if (check.exported) {
+            allChecks.push(check)
+          }
         }
       }
     }
     for (const check of this.testConfig?.checks?.context || []) {
+      if (!check.match) {
+        const oldDefaults = defaults
+        defaults = () => [...new Set([...check.apply(), ...oldDefaults()])]
+        continue
+      }
       if (!check.exported) {
         allChecks.push(check)
       }
     }
+    allChecks.push({
+      match: () => true,
+      apply: defaults
+    })
     return allChecks
   }
 

package/src/configHelpers.js

@@ -97,11 +97,11 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   if (args.uuid) {
     args.objects = args.getObjects(args.uuid)
   }
-  if (!hierarchy) {
-    hierarchy = config.hierarchy
+  if (!hierarchy && config.getHierarchy) {
+    hierarchy = config.getHierarchy()
   }
   // callId
-  args.calls = new InitCalls(args.isInstance ? `${args.isInstance}#${config.name}` : config.name)
+  args.calls = new InitCalls(args.isInstance ? `${args.isInstance}#${config.getName()}` : config.getName())
   if (global.theprogrammablemind && global.theprogrammablemind.loadForTesting) {
     args.calls = new InitCalls(Object.keys(global.theprogrammablemind.loadForTesting)[0])
   }
@@ -112,14 +112,18 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
     throw new ErrorReason(context)
   }
   args.kms = config.getConfigs()
-  args.config = config
+  args.config = config.getPseudoConfig(uuidForScoping, config)
   args.hierarchy = hierarchy
   args.isA = isA(hierarchy)
   // args.listable = listable(hierarchy)
   // args.asList = asList
   args.retry = () => { throw new RetryError() }
-  args.fragments = (query) => {
-    return config.fragment(args, query)
+  // mappings are optional
+  args.fragments = (query, mappings) => {
+    return config.fragment(args, query, mappings)
+  }
+  args.fragmentMapper = (values, fromModelQuery, toModelQuery) => {
+    return config.fragmentMapper(args, values, fromModelQuery, toModelQuery)
   }
   args.breakOnSemantics = false
   args.theDebugger = {
@@ -133,23 +137,35 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   args.addPattern = (pattern, def) => config.addPattern(pattern, args.uuid)
   args.addGenerator = (generator) => config.addGenerator(generator, args.uuid, config.name)
 
-  if (config.testConfig?.testModuleName) {
-    args.testModuleName = config.testConfig.testModuleName
+  if (config.getTestConfig()?.testModuleName) {
+    args.testModuleName = config.getTestConfig().testModuleName
   }
   args.addAssumedScoped = (args, assumed) => {
     const addAssumed = (args, ...moreAssumed) => {
       return { ...args, assumed: Object.assign({}, assumed, (args.assumed || {}), ...moreAssumed) }
     }
 
-    args.s = (c) => config.getSemantics(logs).apply(args, c)
-    args.g = (c, a = {}) => {
-      return config.getGenerators(logs).apply(addAssumed(args, a), c, a)
+    args.s = (c, options = {}) => config.getSemantics(logs).apply(args, c, options)
+    args.g = (c, rest = {}) => {
+      // if (JSON.stringify(rest) !== '{}' && !(rest.assumed || rest.options)) {
+      //   debugger
+      // }
+      const { assumed = {}, options = {} } = rest
+      return config.getGenerators(logs).apply(addAssumed(args, assumed), c, assumed, options)
     }
-    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.gp = (c, rest = {}) => {
+      // if (JSON.stringify(rest) !== '{}' && !(rest.assumed || rest.options)) {
+      //   debugger
+      // }
+      const { assumed = {}, options = {} } = rest
+      return config.getGenerators(logs).apply(addAssumed(args, assumed, { paraphrase: true, isResponse: false, response: false }), c, { paraphrase: true, isResponse: false, response: false }, options)
     }
-    args.gr = (c, a = {}) => {
-      return config.getGenerators(logs).apply(addAssumed(args, a, { paraphrase: false, isResponse: true }), { ...c, paraphrase: false, isResponse: true })
+    args.gr = (c, rest  = {}) => {
+      // if (JSON.stringify(rest) !== '{}' && !(rest.assumed || rest.options)) {
+      //   debugger
+      // }
+      const { assumed = {}, options = {} } = rest
+      return config.getGenerators(logs).apply(addAssumed(args, assumed, { paraphrase: false, isResponse: true }), { ...c, paraphrase: false, isResponse: true }, options)
     }
     args.e = (c) => {
       if (!c) {
@@ -182,14 +198,8 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   }
   config.getAddedArgs(args)
 
-  Object.assign(args, args.getUUIDScoped(uuidForScoping || config.uuid))
+  Object.assign(args, args.getUUIDScoped(uuidForScoping || config.getUUID()))
   args.apis = args.apis || ((name) => config.getConfig(name).api)
-  /*
-  if (uuidForScoping) {
-    Object.assign(args, args.getUUIDScoped(uuidForScoping))
-  }
-  */
-  // sets args for all the API. that make a copy so the args must be fully setup by here except for scoped
   config.setArgs(args)
 }
 
@@ -202,6 +212,22 @@ const getObjects = (objects) => {
   }
 }
 
+const run = async (config, handler) => {
+  // map to hash
+  config = config || {}
+  if (config.config) {
+    config = config
+  }
+
+  const hierarchy = new DigraphInternal((config.config || {}).hierarchy || [])
+
+  const objects = config.config.objects.namespaced[config.uuid]
+  const logs = []
+  const args = {}
+  setupArgs(args, config, logs, hierarchy)
+  return handler(args)
+}
+
 const processContext = async (context, { objects = {}, config, logs = [] }) => {
   const generators = config.getGenerators(logs)
   const semantics = config.getSemantics(logs)
@@ -373,21 +399,21 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
         const generated = contextPrime.isResponse ? await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
         let generatedParenthesized = []
         if (generateParenthesized) {
-          config.parenthesized = true
+          config.setParenthesized(true)
           generatedParenthesized = contextPrime.isResponse ? await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
-          config.parenthesized = false
+          config.setParenthesized(false)
         }
         // assumed = { paraphrase: true, response: false };
         assumed = { paraphrase: true, isResponse: false, response: false }
         if (generateParenthesized) {
-          config.parenthesized = false
+          config.setParenthesized(false)
         }
         const paraphrases = await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
         let paraphrasesParenthesized = []
         if (generateParenthesized) {
-          config.parenthesized = true
+          config.setParenthesized(true)
           paraphrasesParenthesized = await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
-          config.parenthesized = false
+          config.setParenthesized(false)
         }
         contextsPrime.push(contextPrime)
         generatedPrime.push(generated)
@@ -434,11 +460,6 @@ const loadInstance = async (config, instance) => {
   const transitoryMode = global.transitoryMode
   global.transitoryMode = false
 
-  /*
-  if (config.name == 'people' && instance.name == 'people') {
-    debugger
-  }
-  */
   const rl = instance.resultss.length
   if (rl > 0) {
     config.addAssociations(instance.resultss[instance.resultss.length - 1].rtf_associations || [])
@@ -516,6 +537,7 @@ module.exports = {
   // listable,
   setupArgs,
   processContext,
+  run,
   getObjects,
   gs,
   processContextsB,

package/src/fragments.js

@@ -1,85 +1,42 @@
 const _ = require('lodash')
 const helpers = require('./helpers')
 
-function fragmentInstantiator(args, contexts) {
-  return new Object({
-    contexts: () => contexts,
-
+function fragmentInstantiator (args, contexts) {
+  return new Object({ 
+    contexts: () => {
+      return _.cloneDeep(contexts)
+    },
     instantiate: async (mappings) => {
-      const root = _.cloneDeep(contexts);
-
-      // To prevent infinite loops on circular references
-      const visited = new WeakSet();
-
-      // Stack item: { node, path }
-      // path is an array like: [], ['user'], ['users', 0], ['users', 0, 'address']
-      const todo = [{ node: root, path: [] }];
-
-      args = { ...args };
-
+      const instantiated = _.cloneDeep(contexts)
+      const todo = [{ context: instantiated, path: [] }]
+      args = { ...args }
       while (todo.length > 0) {
-        const { node, path } = todo.pop();
-
-        // Skip non-compound values early
-        if (!helpers.isCompound(node)) continue;
-
-        // Prevent reprocessing (including circular refs)
-        if (visited.has(node)) continue;
-        visited.add(node);
-
-        // Attach clean, frozen path array (non-enumerable)
-        Object.defineProperty(node, '__path', {
-          value: Object.freeze(path.slice()), // immutable copy
-          writable: false,
-          enumerable: false,
-          configurable: false
-        });
-
-        // Helpful string version
-        Object.defineProperty(node, '__pathString', {
-          value: path.map(p => String(p)).join('.'),
-          enumerable: false
-        });
-
-        // Pass rich context to mappings
-        args.context = node;
-        args.path = path;                    // e.g. ['users', 0, 'profile']
-        args.pathString = path.map(p => String(p)).join('.'); // "users.0.profile"
-
-        // Apply mappings
+        const { context, path } = todo.pop()
+        args.context = context
+        args.path = path
         for (const mapping of mappings) {
           if (await mapping.match(args)) {
-            await mapping.apply(args);
+            await mapping.apply(args)
           }
         }
-
-        // Traverse children — build path correctly for objects AND arrays
-        if (Array.isArray(node)) {
-          node.forEach((child, index) => {
-            if (helpers.isCompound(child)) {
-              todo.push({
-                node: child,
-                path: [...path, index]  // index as number!
-              });
-            }
-          });
-        } else {
-          // Plain object
-          for (const key of Object.keys(node)) {
-            const child = node[key];
-            if (helpers.isCompound(child)) {
-              todo.push({
-                node: child,
-                path: [...path, key]  // key as string
-              });
-            }
+        for (const key of Object.keys(context)) {
+          // if (['number', 'string', 'boolean'].includes(typeof (context[key]))) {
+          if (!helpers.isCompound(context[key])) {
+            continue
           }
+          if (context[key].instantiated) {
+            continue
+          }
+          todo.push({ context: context[key], path: [...path, key] })
         }
       }
-
-      return root;
+      if (contexts.length == 1 && instantiated.length == 1) {
+        return instantiated[0]
+      } else {
+        return instantiated
+      }
     }
-  });
+  })
 }
 
 async function fragmentMapperInstantiator(values, modelFrom, modelTo) {

package/src/generators.js

@@ -1,4 +1,3 @@
-const { stringify } = require('flatted');
 const { args: contextArgs, normalizeGenerator } = require('./helpers')
 const Lines = require('../lines')
 const helpers = require('./helpers')
@@ -27,11 +26,13 @@ class Generator {
     }
   }
 
+  /*
   getAPIs (config) {
     if (config && config._api && config._api.multiApi) {
       return config._api.apis
     }
   }
+  */
 
   toLabel () {
     const where = this.where ? `where: "${this.where}"` : ''
@@ -60,7 +61,7 @@ class Generator {
       context,
       callId,
       api: this.getAPI(config),
-      apis: this.getAPIs(config)
+      apis: config.getAPIs(),
     }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
     // return this.match(args)
@@ -79,11 +80,11 @@ class Generator {
     if (!log) {
       throw new Error('generators.apply argument log is required')
     }
-    if (baseArgs.call && config && baseArgs.calls.stack.length > config.maxDepth) {
-      throw new Error(`Max depth of ${config.maxDepth} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
+    if (baseArgs.call && config && baseArgs.calls.stack.length > config.getMaxDepth()) {
+      throw new Error(`Max depth of ${config.getMaxDepth()} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
     }
 
-    if (config && config.debugLoops) {
+    if (config && config.getDebugLoops()) {
       console.log('apply', this.toLabel())
     }
     // this.getAPI(config)
@@ -114,7 +115,7 @@ class Generator {
       config,
       response,
       api: this.getAPI(config),
-      apis: this.getAPIs(config)
+      apis: config.getAPIs()
     }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
     if (this.property === 'generatorp') {
@@ -186,7 +187,7 @@ class Generators {
         // this.logs.push(`Generators: applied ${generator.toString()}\n to\n ${stringify(context)}`)
         let errorMessage = 'The apply function did not return a value'
         try {
-          generated = await generator.apply(args, objects, context, hierarchy, config, response, log)
+          generated = await generator.apply(args, objects, context, hierarchy, config, response, log, options)
         } catch (e) {
           // the next if handle this
           generated = null
@@ -213,7 +214,7 @@ class Generators {
           lines.newRow()
           lines.setElement(0, 1, 'TO')
           lines.setElement(0, 2, `context_id: ${context.context_id}`)
-          lines.setElement(1, 2, stringify(helpers.sortJson(context, { depth: 10 }), null, 2))
+          lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 10 }), null, 2))
           lines.newRow()
           lines.setElement(0, 1, 'STACK')
           lines.setElement(0, 2, stack)
@@ -224,13 +225,13 @@ class Generators {
           lines.setElement(0, 1, 'ERROR')
           lines.setElement(0, 2, errorMessage)
           this.logs.push(lines.toString())
-          const message = `ERROR while applying (${source}) ${generator.toLabel()}\n to\n ${stringify(context, null, 2)}.\n${errorMessage}'`
+          const message = `ERROR while applying (${source}) ${generator.toLabel()}\n to\n ${JSON.stringify(context, null, 2)}.\n${errorMessage}'`
           // this.logs.push(message)
           // return [message]
           args.calls.pop()
           throw { error: [message], logs: this.logs }
         }
-        if (((config || {}).config || {}).debug) {
+        if (config.getDebug()) {
           const widths = Lines.addRemainder([10, 10])
           const lines = new Lines(widths)
           lines.setElement(0, 0, 'Generator')
@@ -255,7 +256,7 @@ class Generators {
           lines.newRow()
           lines.setElement(0, 1, 'TO')
           lines.setElement(0, 2, `context_id: ${context.context_id}`)
-          lines.setElement(1, 2, stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
+          lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
           this.logs.push(lines.toString())
         }
         applied = true
@@ -263,7 +264,7 @@ class Generators {
       }
     }
     args.calls.pop()
-    if (!applied && ((config || {}).config || {}).debug) {
+    if (!applied && config.getDebug()) {
       const widths = Lines.addRemainder([10, 10])
       const lines = new Lines(widths)
       lines.setElement(0, 0, 'Generator')
@@ -273,10 +274,14 @@ class Generators {
       lines.setElement(0, 2, stack)
       lines.newRow()
       lines.setElement(0, 1, 'TO')
-      lines.setElement(0, 2, stringify(context, null, 2))
+      lines.setElement(0, 2, JSON.stringify(context, null, 2))
       this.logs.push(lines.toString())
     }
-    return ((config || {}).parenthesized ? '(' + generated + ')' : generated)
+    let parenthesized = false
+    if (config && config.getParenthesized()) {
+      parenthesized = true
+    }
+    return parenthesized ? '(' + generated + ')' : generated
   }
 }
 

package/src/helpers.js

@@ -292,8 +292,53 @@ const hashCode = (str) => {
   return hash
 }
 
-const sortJson = (json) => {
-  return json
+/**
+ * Recursively sorts object keys alphabetically.
+ * Fully handles arrays (including objects inside arrays) and preserves Date/other non-plain objects.
+ *
+ * @param {any} input - The value to sort (object, array, primitive, etc.)
+ * @param {Object} [options]
+ *   - ignoreCase: boolean (default false) – case-insensitive sort
+ *   - reverse: boolean (default false) – reverse alphabetical order
+ * @returns {any} New sorted value
+ */
+function sortJson(input, options = {}) {
+  const { ignoreCase = false, reverse = false } = options;
+
+  // Helper: is this a plain object {} (not Array, Date, Map, null, etc.)
+  function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && value.constructor === Object;
+  }
+
+  // Handle arrays: map over elements and recurse
+  if (Array.isArray(input)) {
+    return input.map(item => sortJson(item, options));
+  }
+
+  // If not a plain object, return unchanged (preserves Date, Map, Set, primitives, etc.)
+  if (!isPlainObject(input)) {
+    return input;
+  }
+
+  // Sorter for keys
+  const sorter = (a, b) => {
+    const A = ignoreCase ? a.toLowerCase() : a;
+    const B = ignoreCase ? b.toLowerCase() : b;
+    return reverse ? B.localeCompare(A) : A.localeCompare(B);
+  };
+
+  // Build new sorted object
+  const sorted = {};
+
+  Object.keys(input)
+    .sort(sorter)
+    .forEach(key => {
+      const value = input[key];
+      // Always recurse: handles nested objects and arrays properly
+      sorted[key] = sortJson(value, options);
+    });
+
+  return sorted;
 }
 
 const validProps = (valids, object, type) => {

package/src/project2.js

@@ -1,7 +1,32 @@
-function project(source, filters) {
+function areFirstNEqual(arr1, arr2, n) {
+  if (n <= 0) return true;
+  if (arr1.length < n || arr2.length < n) return false;
+
+  for (let i = 0; i < n; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function project(source, filters, path=[]) {
   if (['string', 'number'].includes(typeof source)) {
     return source
   }
+  if (Array.isArray(source)) {
+    const result = []
+    for (const value of source) {
+      result.push(project(value, filters, [...path, '*']))
+    }
+    return result
+  }
+  function isPlainObject(obj) {
+    return Object.prototype.toString.call(obj) === '[object Object]';
+  }
+  if (!isPlainObject(source) && !Array.isArray(source)) {
+    return source
+  }
 
   if (Object.keys(source).length === 0 && filters.length === 0) {
     return {};
@@ -11,7 +36,7 @@ function project(source, filters) {
   const filter = filters.find(f => f.match({ context: source }));
   if (!filter) {
     if (Array.isArray(source)) {
-      return source.map((element) => project(element, filters))
+      return source.map((element) => project(element, filters, [...path, '*']))
     }
     return {};
   }
@@ -22,6 +47,7 @@ function project(source, filters) {
   // update 
   const updatedProperties = []
   for (const property of properties) {
+    // property that contains a list of properties to be checked
     if (property.properties) {
       for (const moreProperty of source[property.properties] || []) {
         updatedProperties.push(moreProperty)
@@ -35,10 +61,34 @@ function project(source, filters) {
   // Build the result object
   const result = {};
   properties.forEach(prop => {
-    if (source.hasOwnProperty(prop)) {
+    if (prop.path && (prop.path.length === path.length + 1) && areFirstNEqual(path, prop.path, path.length) && source.hasOwnProperty(prop.path[path.length])) {
+      const endProp = prop.path[path.length]
+      if (Array.isArray(source[endProp])) {
+        result[endProp] = []
+        for (const key in source[endProp]) {
+          result[endProp].push(project(source[endProp][key], filters, [...path, endProp, key]))
+        }
+      } else {
+        result[endProp] = {}
+        for (const key in source[endProp]) {
+          result[endProp][key] = project(source[endProp][key], filters, [...path, endProp, key])
+        }
+      }
+    } else if (source.hasOwnProperty(prop)) {
       // If the property is an object and not null, recursively project it
       if (typeof source[prop] === 'object' && source[prop] !== null) {
-        result[prop] = project(source[prop], filters);
+        result[prop] = project(source[prop], filters, [...path, prop]);
+      } else {
+        // Copy primitive or null properties directly
+        result[prop] = source[prop];
+      }
+    } else if (prop.property && source.hasOwnProperty(prop.property)) {
+      // If the property is an object and not null, recursively project it
+      if (typeof source[prop.property] === 'object' && source[prop.property] !== null) {
+        result[prop.property] = {}
+        for (const key of prop.check) {
+          result[prop.property][key] = project(source[prop.property][key], filters, [...path, prop.property, key]);
+        }
       } else {
         // Copy primitive or null properties directly
         result[prop] = source[prop];

package/src/semantics.js

@@ -1,6 +1,7 @@
 const { args: contextArgs, normalizeGenerator, normalizeSemantic } = require('./helpers')
 const Lines = require('../lines')
 const helpers = require('./helpers')
+const debug = require('./debug')
 
 class Semantic {
   // constructor ({match, apply, uuid, index, km, notes}) {
@@ -43,11 +44,13 @@ class Semantic {
     }
   }
 
+  /*
   getAPIs (config) {
     if (config && config._api && config._api.multiApi) {
       return config._api.apis
     }
   }
+  */
 
   fixUpArgs (args, context) {
     args.uuid = this.uuid
@@ -57,7 +60,7 @@ class Semantic {
     args.global = objects
     const config = args.config
     args.api = this.getAPI(config)
-    args.apis = this.getAPIs(config)
+    args.apis = config.getAPIs()
     args.args = contextArgs(context, args.hierarchy)
     args.context = context
     let n = (id) => id
@@ -70,6 +73,7 @@ class Semantic {
   }
 
   async matches (args, context, options = {}) {
+    args = {...args}
     this.fixUpArgs(args, context)
     const matches = await this.matcher(args)
     if (matches && (options.debug || {}).match || args.callId === this.callId) {
@@ -81,12 +85,13 @@ class Semantic {
   }
 
   async apply (args, context, s, options = {}) {
+    args = {...args}
     const { config } = args
-    if (config && config.debugLoops) {
+    if (config && config.getDebugLoops()) {
       console.log('apply', this.toLabel())
     }
-    if (args.calls && config && args.calls.stack.length > config.maxDepth) {
-      throw new Error(`Max depth of ${config.maxDepth} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
+    if (args.calls && config && args.calls.stack.length > config.getMaxDepth()) {
+      throw new Error(`Max depth of ${config.getMaxDepth()} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
     }
 
     const contextPrime = Object.assign({}, context)
@@ -157,6 +162,7 @@ class Semantics {
     }
     args = { ...args }
     const config = args.config
+    const debug = config.getDebug()
     let contextPrime = Object.assign({}, context)
     const s = (context, options) => this.apply(args, context, options)
     let applied = false
@@ -197,7 +203,6 @@ class Semantics {
             continue
           }
           if (!contextPrime.controlKeepMotivation && semantic.oneShot) {
-            // semantic.tied_ids.forEach((tied_id) => args.config.removeSemantic(tied_id))
             args.config.removeSemantic(semantic)
           }
           for (const { listener } of deferred) {
@@ -247,7 +252,7 @@ class Semantics {
         }
         args.calls.touch(contextPrime)
         // this.logs.push(`Semantics: applied ${semantic.toString()}\n to\n ${JSON.stringify(context)}\n the result was ${JSON.stringify(contextPrime)}\n`)
-        if (((config || {}).config || {}).debug) {
+        if (config.getDebug()) {
           const widths = Lines.addRemainder([10, 10])
           const lines = new Lines(widths)
           lines.setElement(0, 0, 'Semantic')
@@ -294,7 +299,7 @@ class Semantics {
       counter += 1
     }
     args.calls.pop()
-    if (!applied && ((config || {}).config || {}).debug) {
+    if (!applied && debug) {
       const widths = Lines.addRemainder([10, 10])
       const lines = new Lines(widths)
       lines.setElement(0, 0, 'Semantic')