theprogrammablemind_4wp 7.5.4-beta.0 → 7.5.4-beta.10

package/client.js

@@ -8,7 +8,7 @@ const _ = require('lodash')
 const stringify = require('json-stable-stringify')
 const Lines = require('./lines')
 const flattens = require('./src/flatten')
-const { appendNoDups, InitCalls } = require('./src/helpers')
+const { appendNoDups, InitCalls, updateQueries } = require('./src/helpers')
 const runtime = require('./runtime')
 const sortJson = runtime.sortJson
 
@@ -478,7 +478,7 @@ const doWithRetries = async (n, url, queryParams, data) => {
   }
 }
 
-const setupProcessB = ({ config, allowDelta=false } = {}) => {
+const setupProcessB = ({ config, initializer, allowDelta=false } = {}) => {
   const key = config._key
 
   const data = Object.assign({ key, version: '3' }, { uuid: config._uuid })
@@ -515,10 +515,13 @@ const processInstance = (config, instance) => {
   const transitoryMode = global.transitoryMode
   global.transitoryMode = false
   const { /* data, generators, semantics, */ hierarchy } = setupProcessB({ config })
-  for (const results of (instance.resultss || [])) {
+  // for (const results of (instance.resultss || [])) {
+  for (const i in (instance.resultss || [])) {
+    const results = instance.resultss[i]
     if (results.extraConfig) {
       // config.addInternal(results, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false)
-      config.addInternal(results)
+      // config.addInternal(config.template.queries[i], { handleCalculatedProps: true } )
+      config.addInternal(instance.template.queries[i], { handleCalculatedProps: true } )
     } else {
       processContextsB({ config, hierarchy, json: results/*, generators, semantics */ })
     }
@@ -526,7 +529,7 @@ const processInstance = (config, instance) => {
   global.transitoryMode = transitoryMode
 }
 
-const _process = async (config, query, { commandLineArgs, credentials, writeTests, isTest, saveDeveloper, testConfig, testsFN, errorHandler = defaultErrorHandler } = {}) => {
+const _process = async (config, query, { initializer, commandLineArgs, credentials, writeTests, isTest, saveDeveloper, testConfig, testsFN, errorHandler = defaultErrorHandler } = {}) => {
   if (credentials) {
     config.server(credentials.server, credentials.key)
   }
@@ -546,7 +549,7 @@ const _process = async (config, query, { commandLineArgs, credentials, writeTest
     throw error
   }
 
-  let { data, /* generators, semantics, */ hierarchy } = setupProcessB({ config, allowDelta: true })
+  let { data, /* generators, semantics, */ hierarchy } = setupProcessB({ config, initializer, allowDelta: true })
   if (commandLineArgs && commandLineArgs.checkForLoop) {
     data.checkForLoop = true
   }
@@ -1057,7 +1060,7 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
       finish()
       return
     }
-    const { property, hierarchy, query: queryOrExtraConfig, skipSemantics } = queries.shift()
+    const { property, hierarchy, query: queryOrExtraConfig, initializer, skipSemantics } = queries.shift()
     // queries are strings or { query: "blah", development: true/false }
     if (typeof queryOrExtraConfig === 'string' || queryOrExtraConfig.query) {
       let query = queryOrExtraConfig;
@@ -1082,7 +1085,7 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
       }
 
       try {
-        const results = await _process(config, query.query, {})
+        const results = await _process(config, query.query, {initializer})
         if (config.config.debug) {
           // TODO pass in the error handler like the other ones
           defaultInnerProcess(config, defaultErrorHandler, results)
@@ -1143,7 +1146,7 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
       return template
     };
     stabilizeOutput(accumulators)
-    runtime.fs.writeFileSync(instanceName, JSON.stringify(Object.assign({ queries: template.queries }, accumulators), 0, 2))
+    runtime.fs.writeFileSync(instanceName, JSON.stringify(Object.assign({ queries: template.queries.map(updateQueries) }, accumulators), 0, 2))
 
     // km tests file
     const testsName = `./${target}.test.json`
@@ -1160,7 +1163,9 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
       return queryStringOrProperties
     }
   }
-  let todo = (template.queries || []).map((query) => { return { property: 'resultss', query, skipSemantics: false } })
+  let todo = []
+  todo = todo.concat((template.initializers || []).map((query) => { return { initializer: true, property: 'resultss', query, skipSemantics: false } }))
+  todo = todo.concat((template.queries || []).map((query) => { return { property: 'resultss', query, skipSemantics: false } }))
   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))
@@ -1265,7 +1270,6 @@ const knowledgeModule = async ({
       config.load(template.template, template.instance)
     }
   }
-
   if (isProcess) {
     // setup();
     const parser = new runtime.ArgumentParser({
@@ -1299,6 +1303,7 @@ const knowledgeModule = async ({
     parser.add_argument('-da', '--debugAssociation', { help: 'When running with the --debugAssociation flag the debugging will break when the specified association is added to the config' })
     parser.add_argument('-dh', '--debugHierarchy', { help: 'When running with the --debugHierarchy flag the debugging will break when the specified child-parent pair is added to the config for the main config. Set DEBUG_HIERARCHY to debug any config loaded. For example DEBUG_HIERARCHY=\'["cat", "mammel"]\'' })
     parser.add_argument('-db', '--debugBridge', { help: 'When running with the --debugBridge flag the debugging will break when the specified bridge is added to the config for the main config. Set DEBUG_BRIDGE to debug any config loaded. For example DEBUG_BRIDGE=\'id/level\'' })
+    parser.add_argument('-do', '--debugOperator', { help: 'When running with the --debugOperator flag the debugging will break when the specified operator is added to the config for the main config. Set DEBUG_OPERATOR to debug any config loaded. For example DEBUG_OPERATOR=\'([operator] ([arg]))\'' })
 
     const args = parser.parse_args()
     args.count = args.count || 1
@@ -1316,6 +1321,10 @@ const knowledgeModule = async ({
         console.log('Expected DEBUG_BRIDGE to be of the form "id/level"');
       }
     }
+    if (args.debugOperator) {
+        // id/level
+      global.entodictonDebugOperator = args.debugOperator
+    }
 
     if (args.clean) {
       const tests = JSON.parse(runtime.fs.readFileSync(testConfig.name))
@@ -1450,6 +1459,9 @@ const knowledgeModule = async ({
         for (const semantic of easyToRead) {
           semantic.match = semantic.match.toString()
           semantic.apply = semantic.apply.toString()
+          if (semantic.applyWrapped) {
+            semantic.applyWrapped = semantic.applyWrapped.toString()
+          }
         }
         console.dir(easyToRead)
       }
@@ -1656,7 +1668,14 @@ function where(goUp = 2) {
   const e = new Error();
   const regexForm1 = /\((.*):(\d+):(\d+)\)$/
   const regexForm2 = /at (.*):(\d+):(\d+)$/
-  const line = e.stack.split("\n")[goUp];
+  const lines = e.stack.split("\n")
+  let line
+  for (line of lines.slice(1)) {
+    if (!(line.includes("config.js:") || line.includes("client.js:"))) {
+      break;
+    }
+  }
+  // const line = e.stack.split("\n")[goUp];
   const match = regexForm1.exec(line) || regexForm2.exec(line);
   if (match) {
     return `${match[1]}:${match[2]}`

package/package.json

@@ -10,12 +10,13 @@
     "eslint": "^7.31.0"
   },
   "scripts": {
-    "to:debug": "node inspect node_modules/.bin/jest --runInBand -t ONE23",
+    "to:debug": "node inspect node_modules/.bin/jest --runInBand -t NEO23",
     "test:debug": "node inspect node_modules/.bin/jest --runInBand --config ./jest.config.json",
-    "tod": "node inspect node_modules/.bin/jest --runInBand -t ONE23",
+    "tod": "node inspect node_modules/.bin/jest --runInBand -t NEO23",
     "lint:fix": "eslint \"**/*.js\" --fix",
     "lint": "eslint \"**/*.js\"",
-    "to": "node node_modules/.bin/jest --runInBand -t ONE23",
+    "to": "node node_modules/.bin/jest --runInBand -t NEO23",
+    "tos": "node node_modules/.bin/jest --runInBand -t NEOS23",
     "test": "jest --config ./jest.config.json",
     "test:watch": "npm run test -- --watch"
   },
@@ -61,6 +62,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.5.4-beta.0",
+  "version": "7.5.4-beta.10",
   "license": "ISC"
 }

package/src/config.js

@@ -5,7 +5,6 @@ const { Generators } = require('./generators')
 const client = require('../client')
 const Digraph = require('./digraph')
 const helpers = require('./helpers')
-const deepEqual = require('deep-equal')
 const runtime = require('../runtime')
 const _ = require('lodash')
 
@@ -22,6 +21,114 @@ const indent = (string, indent) => {
     return string.replace(/^/gm, ' '.repeat(indent));
 }
 
+const handleBridgeProps = (config, bridge) => {
+  if (!bridge.bridge) {
+    bridge.bridge = "{ ...next(operator) }"
+  }
+  if (!bridge.level) {
+    bridge.level = 0
+  }
+  if (bridge.children) {
+    for (let child of bridge.children) {
+      config.addHierarchy(child, bridge.id)
+    }
+  }
+  if (bridge.parents) {
+    for (let parent of bridge.parents) {
+      config.addHierarchy(bridge.id, parent)
+    }
+  }
+  if (bridge.isA) {
+    for (let parent of bridge.isA) {
+      config.addHierarchy(bridge.id, parent)
+    }
+  }
+  if (bridge.before) {
+    for (let after of bridge.before) {
+      if (typeof after == 'string') {
+        after = [after, 0]
+      }
+      config.addPriorities([after, [bridge.id, bridge.level]])
+    }
+  }
+  if (bridge.words) {
+    for (let def of bridge.words) {
+      if (typeof def == 'string') {
+        config.addWordInternal(def, {"id": bridge.id, "initial": `{ value: "${def}"}` })
+      } else {
+        const word = def.word
+        def = { initial: JSON.stringify(def), id: bridge.id, word: undefined }
+        config.addWordInternal(word, def)
+      }
+    }
+  }
+  if (bridge.generator) {
+    config.config.generators.unshift(bridge.generator)
+  }
+  if (bridge.generators) {
+    const generators = [...bridge.generators]
+    generators.reverse()
+    for (let generator of generators) {
+      config.config.generators.unshift(generator)
+    }
+  }
+  if (bridge.generatorp) {
+    config.config.generators.unshift({ 
+      where: bridge.generatorp.where || bridge.where || client.where(4),
+      match: ({context}) => bridge.id == context.marker && context.paraphrase,
+      apply: (args) => bridge.generatorp(args),
+      applyWrapped: bridge.generatorp,
+      property: 'generatorp',
+    })
+  }
+  if (bridge.generatorr) {
+    config.config.generators.unshift({ 
+      // TODO merge response and isResponse
+      where: bridge.generatorr.where || bridge.where || client.where(3),
+      match: ({context}) => bridge.id == context.marker && !context.paraphrase && (context.response || context.isResponse),
+      apply: (args) => bridge.generatorr(args),
+      applyWrapped: bridge.generatorr,
+      property: 'generatorr',
+    })
+  }
+  if (bridge.evaluator) {
+    config.config.semantics.unshift({ 
+      where: bridge.evaluator.where || bridge.where || client.where(3),
+      match: ({context}) => bridge.id == context.marker && context.evaluate,
+      apply: (args) => bridge.evaluator(args),
+      applyWrapped: bridge.evaluator,
+      property: 'evaluator',
+    })
+  }
+  if (bridge.semantic) {
+    config.config.semantics.unshift({ 
+      where: bridge.semantic.where || bridge.where || client.where(3),
+      match: ({context}) => bridge.id == context.marker,
+      apply: (args) => bridge.semantic(args),
+      applyWrapped: bridge.semantic,
+      property: 'semantic',
+    })
+  }
+}
+
+const handleCalculatedProps = (baseConfig, moreConfig) => {
+  for (let bridge of moreConfig.bridges) {
+    const valid = [ 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generators', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
+                    'level', 'optional', 'selector', 'semantic',  'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where' ]
+    helpers.validProps(valid, bridge, 'bridge')
+    handleBridgeProps(baseConfig, bridge)
+  }
+  if (moreConfig.operators) {
+    moreConfig.operators = moreConfig.operators.map((operator) => {
+      if (typeof operator === 'string') {
+        return { pattern: operator }
+      } else {
+        return operator
+      }
+    })
+  }
+}
+
 if (runtime.process.env.DEBUG_HIERARCHY) {
   global.entodictonDebugHierarchy = JSON.parse(runtime.process.env.DEBUG_HIERARCHY)
 }
@@ -35,6 +142,11 @@ if (runtime.process.env.DEBUG_BRIDGE) {
   global.entodictonDebugBridge[1] = int(global.entodictonDebugBridge[1])
 }
 
+if (runtime.process.env.DEBUG_OPERATOR) {
+  // id/level
+  global.entodictonDebugOperator = runtime.process.env.DEBUG_OPERATOR
+}
+
 const hierarchyCanonical = (element) => {
     if (element.child && element.parent) {
       return element
@@ -86,6 +198,17 @@ const normalizeConfig = (config) => {
           config[bag][i].km = config.name
         }
       }
+      
+    }
+    if (config['bridges']) {
+      for (let bridge of config['bridges']) {
+        if (!bridge.level) {
+          bridge.level = 0
+        }
+        if (!bridge.bridge) {
+          bridge.bridge = "{ ...next(operator) }"
+        }
+      }
     }
   }
 }
@@ -324,6 +447,37 @@ const multiApiImpl = (initializer) => {
 
 class Config {
 
+  inDevelopmentMode (call) {
+    config.developmentModeOn += 1
+    try {
+      call()
+    } finally {
+      config.developmentModeOn -= 1
+    }
+  }
+
+  // return the config with just the elements from the included KM's
+  baseConfig() {
+    const operators = this.config.operators.filter((operator) => {
+      return operator.uuid !== this.uuid
+    })
+    const bridges = this.config.bridges.filter((bridge) => {
+      return bridge.uuid !== this.uuid
+    })
+    const words = {}
+    for (let word in this.config.words) {
+      const defs = this.config.words[word].filter( (def) => def.uuid !== this.uuid )
+      if (defs.length > 0) {
+        words[word] = defs
+      }
+    }
+    return {
+      operators,
+      bridges,
+      words
+    }
+  }
+
   getCounter (maybeName = '') {
     const counter = this.configCounter
     this.configCounter += 1
@@ -525,12 +679,13 @@ class Config {
     }
     const instanceFragments = (instance.fragments || []).map((fragment) => fragment.key || fragment.query).map( toCanonical )
     const templateFragments = (template.fragments || []).concat(this.dynamicFragments).map( toCanonical )
-    const sameFragments = deepEqual(templateFragments, instanceFragments)
-    const sameQueries = deepEqual((template.queries || []), (instance.queries || []))
+    const sameFragments = helpers.safeEquals(templateFragments, instanceFragments)
+    const sameQueries = helpers.safeEquals((template.queries || []).map(helpers.updateQueries), (instance.queries || []))
     return !(instance && sameQueries && sameFragments)
   }
 
   load (template, instance, options = { rebuild: false } ) {
+    instance.template = template
     this.logs.push(`loading template for ${this.name}`)
     if (instance && instance.associations && !options.rebuild) {
       this.addAssociations(instance.associations)
@@ -592,7 +747,7 @@ class Config {
       }
     }
     if (global.entodictonDebugAssociation) {
-      if (deepEqual(global.entodictonDebugAssociation, association)) {
+      if (helpers.safeEquals(global.entodictonDebugAssociation, association)) {
         debugger; // debug association hit
       }
     }
@@ -627,7 +782,7 @@ class Config {
       throw `addHierarchy expected parent property to be a string. got ${JSON.stringify(parent)}`
     }
     if (global.entodictonDebugHierarchy) {
-      if (deepEqual(global.entodictonDebugHierarchy, [child, parent])) {
+      if ((helpers.safeEquals.entodictonDebugHierarchy, [child, parent])) {
         debugger; // debug hierarchy hit
       }
     }
@@ -645,7 +800,7 @@ class Config {
     }
 
     if (global.entodictonDebugHierarchy) {
-      if (deepEqual(global.entodictonDebugHierarchy, [child, parent])) {
+      if (helpers.safeEquals(global.entodictonDebugHierarchy, [child, parent])) {
         debugger; // debug hierarchy hit
       }
     }
@@ -689,6 +844,7 @@ class Config {
     if (global.transitoryMode) {
       def.transitoryMode = true
     }
+    handleBridgeProps(this, def)
     bridges.push(def)
     this.checkBridges();
     this._delta.json.bridges.push({ action: 'add', bridge: def })
@@ -751,6 +907,7 @@ class Config {
     if (!this.config.operators) {
       this.config.operators = []
     }
+
     const operators = this.config.operators
 
     let operator;
@@ -760,6 +917,12 @@ class Config {
       operator = Object.assign({}, objectOrPattern, { uuid: this._uuid })
     }
 
+    if (global.entodictonDebugOperator) {
+      if (operator.pattern === global.entodictonDebugOperator) {
+        debugger; // debug operator hit
+      }
+    }
+
     if (operator.allowDups) {
       if (operators.find( (o) => o.pattern == operator.pattern )) {
         return;
@@ -1018,7 +1181,8 @@ class Config {
         'debug',
 
         // TODO Fix these from the test app
-        'implicit',
+        'implicits',
+        'convolution',
         'expected_generated',
         'expected_results',
         'skipSemantics',
@@ -1114,115 +1278,12 @@ class Config {
     if (config) {
       config = _.cloneDeep(config)
       this.config = config
-      for (let bridge of this.config.bridges) {
-        const valid = [ 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generators', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
-                        'level', 'optional', 'selector', 'semantic',  'words', /Bridge$/, 'localHierarchy' ]
-        helpers.validProps(valid, bridge, 'bridge')
-        /*
-        if (bridge.generator) {
-          this.config.generators.push({ 
-            match: ({context}) => bridge.id == context.marker,
-            apply: (args) => bridge.generator(args),
-          })
-        }
-        */
-        if (bridge.children) {
-          for (let child of bridge.children) {
-            this.addHierarchy(child, bridge.id)
-          }
-        }
-        if (bridge.parents) {
-          for (let parent of bridge.parents) {
-            this.addHierarchy(bridge.id, parent)
-          }
-        }
-        if (bridge.isA) {
-          for (let parent of bridge.isA) {
-            this.addHierarchy(bridge.id, parent)
-          }
-        }
-        if (bridge.before) {
-          for (let after of bridge.before) {
-            if (typeof after == 'string') {
-              after = [after, 0]
-            }
-            this.addPriorities([after, [bridge.id, bridge.level]])
-          }
-        }
-        if (bridge.words) {
-          for (let def of bridge.words) {
-            if (typeof def == 'string') {
-              this.addWordInternal(def, {"id": bridge.id, "initial": `{ value: "${def}"}` })
-            } else {
-              const word = def.word
-              def = { initial: JSON.stringify(def), id: bridge.id, word: undefined }
-              this.addWordInternal(word, def)
-            }
-          }
-        }
-        if (bridge.generator) {
-          this.config.generators.unshift(bridge.generator)
-        }
-        if (bridge.generators) {
-          const generators = [...bridge.generators]
-          generators.reverse()
-          for (let generator of generators) {
-            this.config.generators.unshift(generator)
-          }
-        }
-        if (bridge.generatorp) {
-          this.config.generators.unshift({ 
-            where: bridge.generatorp.where || client.where(3),
-            match: ({context}) => bridge.id == context.marker && context.paraphrase,
-            apply: (args) => bridge.generatorp(args),
-          })
-        }
-        if (bridge.generatorr) {
-          this.config.generators.unshift({ 
-            // TODO merge response and isResponse
-            where: bridge.generatorr.where || client.where(3),
-            match: ({context}) => bridge.id == context.marker && !context.paraphrase && (context.response || context.isResponse),
-            apply: (args) => bridge.generatorr(args),
-          })
-        }
-        if (bridge.evaluator) {
-          this.config.semantics.unshift({ 
-            where: bridge.evaluator.where || client.where(3),
-            match: ({context}) => bridge.id == context.marker && context.evaluate,
-            apply: (args) => bridge.evaluator(args),
-          })
-        }
-        if (bridge.semantic) {
-          this.config.semantics.unshift({ 
-            where: bridge.semantic.where || client.where(3),
-            match: ({context}) => bridge.id == context.marker,
-            apply: (args) => bridge.semantic(args),
-          })
-        }
-      }
-      if (config.operators) {
-        config.operators = config.operators.map((operator) => {
-          if (typeof operator === 'string') {
-            return { pattern: operator }
-          } else {
-            return operator
-          }
-        })
-      }
+      handleCalculatedProps(this, config)
     }
     this.hierarchy = new Digraph(this.config.hierarchy)
     this.initConfig = _.cloneDeep(this.config)
     this.configs.push(new KM({ config: this.config, getCounter: (name) => this.config.getCounter(name), uuid: this._uuid }))
 
-    /*
-    if (config) {
-      this.configs.push(new KM({config, isSelf: true}))
-      this.addInternal(Object.assign({}, config), false)
-    } else {
-      this.configs.push( new KM({config: this.config, isSelf: true}) )
-    }
-    */
-
     this.setUUIDs()
     this.initDefaults()
     if (!this.config.objects.namespaced) {
@@ -1311,6 +1372,7 @@ class Config {
         this._api.config = () => this
         this._api.uuid = this._uuid
       }
+      this.rebuild()
     }
   }
 
@@ -1613,7 +1675,8 @@ class Config {
 
       if (currentConfig.api) {
         currentConfig.api.objects = args.objects
-        currentConfig.api.config = () => this
+        // GREG42 currentConfig.api.config = () => this
+        currentConfig.api.config = () => args.baseConfig
         currentConfig.api.uuid = currentConfig._uuid
       }
       // this.instances.forEach( (instance) => client.processInstance(this, instance) )
@@ -1877,7 +1940,6 @@ class Config {
         } else {
           addInternals.unshift(config)
         }
-        // this.addInternal(config, true, false, false, true)
       } else {
         if (interleaved) {
           addInternals.unshift(null)
@@ -1886,10 +1948,6 @@ class Config {
       km.valid()
     })
 
-    if (addInternals.length !== inits.length || addInternals.length !== initAfterApis.length) {
-      debugger // bug
-    }
-
     const generators = this.config.generators
     const semantics = this.config.semantics
     if (reverseIt) {
@@ -1900,7 +1958,7 @@ class Config {
     if (!interleaved) {
       for (const config of addInternals) {
         if (!reverseIt) {
-          this.addInternal(config, true, false, false, true)
+          this.addInternal(config, { includeNamespace: false, allowNameToBeNull: true })
         } else {
           this.addInternalR(config, true, false, false, true)
         }
@@ -2052,7 +2110,7 @@ class Config {
 
       this.applyNamespace(configPrime, km.namespace, km.uuid)
       first = false
-      this.addInternal(configPrime, false, true)
+      this.addInternal(configPrime, { useOldVersion: false, skipObjects: true })
       applyUUID(configPrime, km.uuid)
     })
 
@@ -2342,7 +2400,7 @@ class Config {
   }
 
   // TODO get rid of useOldVersion arg
-  addInternal (more, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false) {
+  addInternal (more, { useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false, handleCalculatedProps : hcps = false } = {}) {
     if (more instanceof Config) {
       more.initialize({ force: false })
       if (useOldVersion) {
@@ -2352,6 +2410,10 @@ class Config {
         more = _.cloneDeep(more.initConfig)
       }
     }
+    if (hcps) {
+      handleCalculatedProps(this, more)
+      applyUUID(more, this._uuid)
+    }
     for (const key of Object.keys(more)) {
       const value = more[key]
       // TODO remove name and description on the config bag
@@ -2560,9 +2622,6 @@ class Config {
         // console.log('key', key, 'XXX')
         // console.log('more', JSON.stringify(more, null, 2))
         // this.config[key] = this.config[key].concat(more[key])
-        if (key == '2enerators') {
-          debugger
-        }
         // this.config[key] = this.config[key].concat(more[key])
         this.config[key] = more[key].concat(this.config[key])
       } else {

package/src/generators.js

@@ -6,9 +6,11 @@ class Generator {
   // constructor ({ match, apply, uuid, index, km, priority, notes }) {
   constructor (generator) {
     generator = normalizeGenerator(generator)
-    const { match, apply, uuid, index, km, priority, where, notes, debug } = generator
+    const { match, apply, uuid, index, km, priority, where, notes, debug, applyWrapped, property } = generator
     this.match = match
     this._apply = apply
+    this._applyWrapped = applyWrapped
+    this.property = property
     this.uuid = uuid
     this.index = index
     this.km = km
@@ -39,7 +41,7 @@ class Generator {
   }
 
   toString () {
-    return `Generator(${this.match}, ${this._apply})`
+    return `Generator(${this.match}, ${this._applyWrapped || this._apply})${this.property ? `\nsee the ${this.property} property` : ''}`
   }
 
   matches (baseArgs, objects, context, hierarchy, config, options = {}) {

package/src/helpers.js

@@ -44,10 +44,23 @@ const appendNoDups = (l1, l2) => {
 }
 
 const safeEquals = (v1, v2) => {
-  if (!deepEqual(stringify(v1), stringify(v2))) {
+  if (typeof v1 !== typeof v2) {
     return false
   }
-  return true
+
+  const type = typeof v1
+  if (type == 'number' || type == 'string') {
+    return v1 == v2
+  } else if (type == 'function') {
+    return v1.toString() == v2.toString()
+  } else {
+    for (let key in v1) {
+      if (!safeEquals(v1[key], v2[key])) {
+        return false
+      }
+    }
+    return true
+  }
 }
 
 /*
@@ -238,7 +251,66 @@ const mapInPlace = (list, fn) => {
   }
 }
 
+const updateQueries = (queryOrConfig) => {
+  if (typeof queryOrConfig == 'string' || queryOrConfig.query) {
+    return queryOrConfig
+  } else {
+    const config = queryOrConfig
+    return functionsToStrings(config)
+  }
+}
+
+const functionsToStrings = (config) => {
+  config = {...config}
+  const mapGenerator = (generator) => {
+      if (generator.apply) {
+        return { ...generator, match: generator.match.toString(), apply: generator.apply.toString() }
+      } else {
+        return [ generator[0].toString(), generator[1].toString() ]
+      }
+    }
+  if (config.generators) {
+    config.generators = config.generators.map( mapGenerator )
+  }
+  if (config.semantics) {
+    config.semantics = config.semantics.map( (semantic) => {
+      if (semantic.apply) {
+        return { ...semantic, match: semantic.match.toString(), apply: semantic.apply.toString() }
+      } else {
+        return [ semantic[0].toString(), semantic[1].toString() ]
+      }
+    })
+  }
+  if (config.bridges) {
+    config.bridges = config.bridges.map( (bridge) => {
+      bridge = {...bridge}
+      if (bridge.generator) {
+        bridge.generator = bridge.generator.toString()
+      }
+      if (bridge.generators) {
+        bridge.generators = bridge.generators.map( mapGenerator )
+      }
+      if (bridge.generatorp) {
+        bridge.generatorp = bridge.generatorp.toString()
+      }
+      if (bridge.generatorr) {
+        bridge.generatorr = bridge.generatorr.toString()
+      }
+      if (bridge.semantic) {
+        bridge.semantic = bridge.semantic.toString()
+      }
+      if (bridge.evaluator) {
+        bridge.evaluator = bridge.evaluator.toString()
+      }
+      return bridge
+    })
+  }
+  return config
+}
+
 module.exports = { 
+  functionsToStrings,
+  updateQueries,
   mapInPlace,
   validProps, 
   args, 

package/src/semantics.js

@@ -6,9 +6,11 @@ class Semantic {
   // constructor ({match, apply, uuid, index, km, notes}) {
   constructor (semantic) {
     semantic = normalizeSemantic(semantic)
-    const { match, apply, uuid, index, km, notes, priority, debug, where } = semantic
+    const { match, apply, uuid, index, km, notes, priority, debug, where, applyWrapped, property } = semantic
     this.matcher = match
     this._apply = apply
+    this._applyWrapped = applyWrapped
+    this.property = property
     this.uuid = uuid
     this.index = index
     this.km = km
@@ -27,7 +29,7 @@ class Semantic {
   }
 
   toString () {
-    return `Semantic(${this.matcher}, ${this._apply})`
+    return `Semantic(${this.matcher}, ${this._applyWrapped || this._apply})${this.property ? `\nsee the ${this.property} property` : ''}`
   }
 
   getAPI (config) {