theprogrammablemind 7.12.8-beta.5 → 7.12.8-beta.6

package/client.js

@@ -646,17 +646,15 @@ const loadInstance = (config, instance) => {
     const results = instance.resultss[i]
     if (results.extraConfig) {
       // config.addInternal(results, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false)
-      // config.addInternal(config.template.queries[i], { handleCalculatedProps: true } )
       const uuid = config.nameToUUID(instance.name)
       // used to do a CLONE
-      // config.addInternal(_.cloneDeep(instance.template.queries[i]), { uuid, addFirst: true, handleCalculatedProps: true })
-      config.addInternal(instance.template.queries[i], { uuid, addFirst: true, handleCalculatedProps: true })
+      config.addInternal(instance.template.configs[i], { uuid, addFirst: true, handleCalculatedProps: true })
     } else if (results.apply) {
       const objects = config.get('objects')
       const args = { objects, getObjects: getObjects(objects) }
-      if (instance.queries) {
+      if (instance.configs) {
         args.isInstance = `instance${i}`
-        args.instance = instance.queries[i]
+        args.instance = instance.configs[i]
       }
 
       const uuid = config.nameToUUID(instance.name)
@@ -824,15 +822,27 @@ const getConfigForTest = (config, testConfig) => {
     // configForTest[key] = config.config[key]
     if (key === 'words') {
       const words = config.config.words
-      configForTest.words = {}
-      for (const key of Object.keys(words)) {
+      configForTest.words = {
+        literals: {},
+        patterns: [],
+        hierarchy: [],
+      }
+
+      const literals = config.config.words.literals
+      for (const key in literals) {
         const defs = []
-        for (const def of words[key]) {
+        for (const def of literals[key]) {
           // TODO handle thie uuids the right way
           defs.push(Object.assign({}, def, { uuid: undefined }))
         }
-        configForTest.words[key] = defs
+        configForTest.words.literals[key] = defs
       }
+
+      const patterns = config.config.words.patterns
+      configForTest.words.patterns = patterns.map((pattern) => Object.assign({}, pattern, { uuid: undefined }))
+
+      const hierarchy = config.config.words.hierarchy
+      configForTest.words.hierarchy = hierarchy.map((hierarchy) => Object.assign({}, hierarchy, { uuid: undefined }))
     } else if (key === 'operators') {
       configForTest.operators = config.config.operators.map((operator) => Object.assign({}, operator, { uuid: undefined }))
     } else if (key === 'bridges') {
@@ -1305,12 +1315,12 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
     associations: [],
     learned_contextual_priorities: []
   }
-  const looper = async (queries) => {
-    if (queries.length === 0) {
+  const looper = async (configs) => {
+    if (configs.length === 0) {
       finish()
       return
     }
-    const { property, hierarchy, query: queryOrExtraConfig, previousResults, initializer, skipSemantics } = queries.shift()
+    const { property, hierarchy, query: queryOrExtraConfig, previousResults, initializer, skipSemantics } = configs.shift()
     // queries are strings or { query: "blah", development: true/false }
     if (typeof queryOrExtraConfig === 'string' || queryOrExtraConfig.query) {
       let query = queryOrExtraConfig
@@ -1362,7 +1372,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
         accumulators[property].push(results)
         accumulators.associations = accumulators.associations.concat(results.associations)
         accumulators.learned_contextual_priorities = accumulators.learned_contextual_priorities.concat(results.learned_contextual_priorities)
-        await looper(queries)
+        await looper(configs)
       } catch (e) {
         const error = { errors: [e], query: query.query }
         config.config.skipSemantics = null
@@ -1376,7 +1386,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
       setupArgs(args, config, config.logs, hierarchy)
       initFunction(args)
       accumulators[property].push({ apply: queryOrExtraConfig })
-      await looper(queries)
+      await looper(configs)
     } else {
       // extra config is def from a time like operators or bridges or words etc
       // it will just get added to the config
@@ -1392,7 +1402,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
           throw new Error(`Error processing extra config${where}: ${e.stack}}`)
         }
         accumulators[property].push({ extraConfig: true, ...extraConfig })
-        await looper(queries)
+        await looper(configs)
       }
     }
   }
@@ -1432,7 +1442,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
       return template
     }
     stabilizeOutput(accumulators)
-    runtime.fs.writeFileSync(instanceName, JSON.stringify(Object.assign({ queries: template.queries.map(updateQueries) }, accumulators), 0, 2))
+    runtime.fs.writeFileSync(instanceName, JSON.stringify(Object.assign({ configs: template.configs.map(updateQueries) }, accumulators), 0, 2))
 
     // km tests file
     const testsName = `./${target}.test.json`
@@ -1451,7 +1461,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
   }
   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, index) => {
+  todo = todo.concat((template.configs || []).map((query, index) => {
     let pr
     if (index < startOfChanges) {
       pr = previousResultss[index]
@@ -1501,19 +1511,6 @@ const knowledgeModuleImpl = async ({
   acceptsAdditionalConfig = false,
   ...rest
 } = {}) => {
-  /*
-  if (description == 'fastfood related concepts') {
-    debugger
-    global.old = template.template.queries[91].bridges[0]
-  }
-  let old
-  if (template && template.template && template.template.queries) {
-    old = template.template.queries
-    template.template.queries = _.cloneDeep(template.template.queries)
-    template.wasCopied = true
-  }
-  */
-
   const unknownArgs = Object.keys(rest)
   if (unknownArgs.length > 0) {
     throw new Error(`Unknown arguments to knowledgeModule: ${unknownArgs.join()}`)

package/package.json

@@ -65,6 +65,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.12.8-beta.5",
+  "version": "7.12.8-beta.6",
   "license": "UNLICENSED"
 }

package/src/config.js

@@ -26,6 +26,19 @@ const config_toServer = (config) => {
   // cant change things because copy breaks something
 }
 
+const initWords = (words) => {
+  if (!words.literals) {
+    words.literals = {}
+  }
+  if (!words.patterns) {
+    words.patterns = []
+  }
+  if (!words.hierarchy) {
+    words.hierarchy = []
+  }
+  return words
+}
+
 const debugPriority = (priority) => {
   if (global.entodictonDebugPriority) {
     if (helpers.subPriority(entodictonDebugPriority, priority)) {
@@ -92,6 +105,7 @@ const validConfigProps = (config) => {
     'objects',
     'bridges',
     'operators',
+    'trie',
     'words',
     'priorities',
     'associations',
@@ -123,6 +137,7 @@ const validConfigProps = (config) => {
 
 const setupInitializerFNArgs = (config, args) => {
   const aw = (word, def) => config.addWord(word, def, args.uuid)
+  const ap = (pattern, def) => config.addPattern(pattern, def, args.uuid)
   const ag = (generator) => config.addGenerator(generator, args.uuid, config.name)
   const km = (name) => config.getConfig(name)
   const apis = (name) => config.getConfig(name).api
@@ -130,6 +145,7 @@ const setupInitializerFNArgs = (config, args) => {
   return {
     ...args,
     addWord: aw,
+    addPattern: ap,
     addGenerator: ag,
     config: config.getPseudoConfig(args.uuid, args.currentConfig),
     km,
@@ -412,10 +428,13 @@ const hierarchyCanonical = (element) => {
   }
 }
 
-const isValidDef = (word, def, config) => {
+const isValidWordDef = (word, def, config) => {
+  // TODO trie
+  /*
   if (!def.id) {
     throw new Error(`In the KM "${config.name}", for the word ${word} the following definition is missing the "id" property: ${JSON.stringify(def)}`)
   }
+  */
   /*
   if (!def.initial) {
     throw `In the KM "${config.name}", for the word ${word} the following definition is missing the "initial" property: ${JSON.stringify(def)}`
@@ -423,6 +442,10 @@ const isValidDef = (word, def, config) => {
   */
 }
 
+const isValidTrie = (trie) => {
+  return true
+}
+
 const hierarchyToCanonical = (edge) => {
   if (Array.isArray(edge)) {
     return { child: edge[0], parent: edge[1] }
@@ -430,18 +453,33 @@ const hierarchyToCanonical = (edge) => {
   return edge
 }
 
+// for trie defs
+
+const addPattern = (config, uuid) => ({ pattern, defs }) => {
+  if (!config.trie) {
+    config.trie = []
+  }
+  const trie = config.trie
+  const def = { id, initial, uuid }
+  trie.unshift({ pattern, defs })
+}
+
 const addWord = (config, uuid) => ({ word, id, initial }) => {
   if (!config.words) {
-    config.words = {}
+    config.words = {
+      literals: {},
+      patterns: [],
+      hierarchy: [],
+    }
   }
-  const words = config.words
+  const literals = config.words.literals
   const def = { id, initial, uuid }
-  if (words[word]) {
-    if (!words[word].some((e) => helpers.safeEquals(e, def))) {
-      words[word].unshift(def)
+  if (literals[word]) {
+    if (!literals[word].some((e) => helpers.safeEquals(e, def))) {
+      literals[word].unshift(def)
     }
   } else {
-    words[word] = [def]
+    literals[word] = [def]
   }
 }
 
@@ -500,8 +538,23 @@ function configDup (config, options) {
 }
 
 function setWordsUUIDs (words, uuid) {
-  for (const key in words) {
-    words[key] = words[key].map((o) => Object.assign(o, { uuid }))
+  const literals = words.literals
+  for (const key in literals) {
+    literals[key] = literals[key].map((o) => Object.assign(o, { uuid }))
+  }
+  const patterns = words.patterns
+  for (const pattern of patterns) {
+    pattern.defs.map((def) => Object.assign(def, { uuid }))
+  }
+  const hierarchy = words.hierarchy
+  for (const pair of hierarchy) {
+    pair.uuid = uuid 
+  }
+}
+
+function setTrieUUIDs (patterns, uuid) {
+  for (const pattern of patterns) {
+    pattern.defs.map((def) => Object.assign(def, { uuid }))
   }
 }
 
@@ -535,6 +588,9 @@ function applyUUID (config, uuid) {
   if (config.words) {
     setWordsUUIDs(config.words, uuid)
   }
+  if (config.trie) {
+    setTrieUUIDs(config.trie, uuid)
+  }
   for (const property of bags) {
     if (config[property]) {
       config[property].forEach((bag) => { bag.uuid = uuid })
@@ -752,7 +808,7 @@ class Config {
     }
     const templateQueries = []
     if (this.instances && this.instances.length > 0) {
-      for (const query of this.instances.slice(-1)[0].queries) {
+      for (const query of this.instances.slice(-1)[0].configs) {
         if (typeof query === 'string') {
           templateQueries.push(query)
         }
@@ -776,6 +832,7 @@ class Config {
       addSemantic: (...args) => this.addSemantic(...args, uuid, config.name),
       removeSemantic: (...args) => this.removeSemantic(...args, uuid, config.name),
       addWord: (...args) => this.addWord(...args, uuid),
+      addPattern: (...args) => this.addPattern(...args, uuid),
 
       getHierarchy: (...args) => this.config.hierarchy,
       getBridges: (...args) => this.config.bridges,
@@ -797,28 +854,6 @@ class Config {
     }
   }
 
-  // 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 (const word in this.config.words) {
-      const defs = this.config.words[word].filter((def) => def.uuid !== this.uuid)
-      if (defs.length > 0) {
-        words[word] = defs
-      }
-    }
-    return {
-      operators,
-      bridges,
-      words
-    }
-  }
-
   getCounter (maybeName = '') {
     const counter = this.configCounter
     this.configCounter += 1
@@ -855,7 +890,12 @@ class Config {
         namespaced: {}
       },
       description: '',
-      words: {}, // Done
+      trie: [],
+      words: {
+        literals: {},
+        patterns: [],
+        hierarchy: [],
+      }, // Done
       floaters: [],
       implicits: [],
       flatten: [],
@@ -883,6 +923,7 @@ class Config {
       'eqClasses',
       'priorities',
       'associations',
+      'trie',
       'words',
       'floaters',
       'implicits',
@@ -1114,8 +1155,8 @@ class Config {
       return elements.map(toCanonicalQuery)
     }
 
-    const templateQueries = toCanonicalQueries(template.queries || []).map(helpers.updateQueries)
-    const instanceQueries = toCanonicalQueries(instance.queries || [])
+    const templateQueries = toCanonicalQueries(template.configs || []).map(helpers.updateQueries)
+    const instanceQueries = toCanonicalQueries(instance.configs || [])
     let sameQueries = true
     let startOfChanges
     for (let iq = 0; iq < templateQueries.length; ++iq) {
@@ -1136,7 +1177,6 @@ class Config {
     if (templateQueries.length < instanceQueries.length) {
       startOfChanges = instanceQueries.length
     }
-    // const sameQueries = helpers.safeEquals(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), toCanonicalQueries(instance.queries || []))
 
     if (debug) {
       if (!(instance && sameQueries && sameFragments)) {
@@ -1145,8 +1185,6 @@ class Config {
         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))
       }
     }
     if (startOfChanges || instance.resultss) {
@@ -1157,13 +1195,13 @@ class Config {
   }
 
   validifyTemplate (template) {
-    if (!template.queries && !template.fragments) {
-      throw new Error(`Expected the template for ${this.name} to be an object that can have the properties: queries and fragments`)
+    if (!template.configs && !template.fragments) {
+      throw new Error(`Expected the template for ${this.name} to be an object that can have the properties: configs and fragments`)
     }
-    for (const query of template.queries || []) {
+    for (const query of template.configs || []) {
       if (typeof query === 'string') {
       } else if (query instanceof Config) {
-        throw new Error(`For the template for ${this.name}, each element in queries should be either a string or a structure with a config (not a Config object).`)
+        throw new Error(`For the template for ${this.name}, each element in configs should be either a string or a structure with a config (not a Config object).`)
       }
     }
   }
@@ -1180,7 +1218,7 @@ class Config {
     this.logs.push(`loading template for ${this.name}`)
     if (options.rebuild) {
       // TODO fix beforeQuery
-      template = { fragments: [], queries: [], ...template }
+      template = { fragments: [], configs: [], ...template }
       template.fragments = template.fragments.concat(this.dynamicFragments)
       client.rebuildTemplate({ config: this, target: this.name, previousResultss: options.previousResultss, startOfChanges: options.startOfChanges, beforeQuery: () => {}, template, ...options })
     } else {
@@ -1188,7 +1226,7 @@ class Config {
       // this.initInstances.push({ ...instance, name: config.name })
       const isEmpty = (instance) => {
         const properties = [
-          'queries',
+          'configs',
           'resultss',
           'fragments',
           'semantics',
@@ -1201,7 +1239,7 @@ class Config {
         for (let i = 0; i < instance.resultss.length; ++i) {
           const result = instance.resultss[i]
           if (result.apply) {
-            result.apply = template.queries[i]
+            result.apply = template.configs[i]
           }
         }
         instance.name = this.name
@@ -1435,27 +1473,59 @@ class Config {
     this._delta.json.operators.push({ action: 'add', operator })
   }
 
+  /*
+  addPattern (pattern, def, uuid) {
+    if (!this.config.trie) {
+      this.config.trie = []
+    }
+    const patterns = this.config.trie
+    def = Object.assign({}, def, { uuid: uuid || this._uuid })
+    patterns.unshift({ pattern, def })
+    this._delta.json.trie.push({ action: 'add', pattern, def })
+  }
+  */
+
   addWord (word, def, uuid) {
     this.addWordInternal(word, def, uuid)
   }
 
   addWordInternal (word, def, uuid) {
     if (!this.config.words) {
-      this.config.words = {}
+      this.config.words = {
+        literals: {},
+        patterns: [],
+        hierarchy: [],
+      }
     }
-    const words = this.config.words
+
+    const literals = this.config.words.literals
     def = Object.assign({}, def, { uuid: uuid || this._uuid })
-    if (words[word]) {
-      if (!words[word].some((e) => helpers.safeEquals(e, def))) {
-        words[word].unshift(def)
+    if (literals[word]) {
+      if (!literals[word].some((e) => helpers.safeEquals(e, def))) {
+        literals[word].unshift(def)
       }
     } else {
-      words[word] = [def]
+      literals[word] = [def]
     }
 
     this._delta.json.words.push({ action: 'add', word, def })
   }
 
+  addPattern (pattern, def, uuid) {
+    if (!this.config.words) {
+      this.config.words = {
+        literals: {},
+        patterns: [],
+        hierarchy: [],
+      }
+    }
+
+    const patterns = this.config.words.patterns
+    def = Object.assign({}, def, { uuid: uuid || this._uuid })
+    patterns.unshift({ pattern, defs: [def] })
+    this._delta.json.words.push({ action: 'add', pattern, defs: [def] })
+  }
+
   getAPI (uuid) {
     if (this._uuid === uuid) {
       return this.api
@@ -1649,13 +1719,47 @@ class Config {
     config.generators = config.generators.filter((element) => !element.development)
     config.semantics = config.semantics.filter((element) => !element.development)
     config.hierarchy = (config.hierarchy).filter((element) => !element.development)
-    for (const word in config.words) {
-      const defs = config.words[word] || []
-      config.words[word] = defs.filter((def) => !def.development)
-      if (config.words[word].length == 0) {
-        delete config.words[word]
+
+    const literals = config.words.literals
+    for (const word in literals) {
+      const defs = literals[word] || []
+      literals[word] = defs.filter((def) => !def.development)
+      if (literals[word].length == 0) {
+        delete literals[word]
+      }
+    }
+
+    const patterns = config.words.patterns || []
+    const patternsPrime = []
+    for (const pattern of patterns) {
+      let defs = pattern.defs || []
+      defs = defs.filter((def) => !def.development)
+      if (defs.length !== 0) {
+        patternsPrime.push({...pattern, defs})
       }
     }
+    config.words.patterns = patternsPrime
+
+    const hierarchy = config.words.hierarchy || []
+    const hierarchyPrime = []
+    for (const pair of hierarchy) {
+      if (!pair.development) {
+        hierarchyPrime.push(pair)
+      }
+    }
+    config.words.hierarchy = hierarchyPrime
+
+    const toDelete = []
+    for (const [index, pattern] of config.trie.entries()) {
+      const defs = pattern.defs
+      pattern.defs = defs.filter((def) => !def.development)
+      if (pattern.defs.length == 0) {
+        toDelete.unshift(index)
+      }
+    }
+    for (const index of toDelete) {
+      config.patterns.split(index, 1)
+    }
   }
 
   // configs = [ { config, namespace } ... ]
@@ -1669,7 +1773,8 @@ class Config {
 
       config.operators = config.operators || []
       config.bridges = config.bridges || []
-      config.words = config.words || {}
+      config.trie = config.trie || []
+      config.words = config.words || { literals: {}, patterns: [], hierarchy: [] }
       config.generators = config.generators || []
       config.semantics = config.semantics || []
       config.hierarchy = config.hierarchy || []
@@ -1699,7 +1804,7 @@ class Config {
     this.instances = []
     this.logs = []
     this.dynamicFragments = []
-    // when running queries any bridges added are marked as transitory so that the associated will ignore those op's
+    // when running configs any bridges added are marked as transitory so that the associated will ignore those op's
     this.transitoryMode = false
 
     // check for duplicate bridges
@@ -1721,11 +1826,12 @@ class Config {
     }
 
     if (config && config.words) {
-      for (const word of Object.keys(config.words)) {
-        for (const def of config.words[word]) {
-          isValidDef(word, def, config)
-        }
-      }
+      initWords(config.words)
+      isValidWordDef(config.words)
+    }
+
+    if (config && config.trie) {
+      isValidTrie(config.trie)
     }
 
     if (config && config.priorities) {
@@ -1830,6 +1936,7 @@ class Config {
     this._delta = {
       cacheKey,
       json: {
+        trie: [],
         words: [],
         operators: [],
         bridges: [],
@@ -2014,6 +2121,7 @@ class Config {
   setUUIDs () {
     this.config.bridges && this.config.bridges.forEach((bridge) => { bridge.uuid = this._uuid })
     this.config.words && setWordsUUIDs(this.config.words, this._uuid)
+    this.config.trie && setTrieUUIDs(this.config.trie, this._uuid)
     this.config.operators && this.config.operators.forEach((operator) => { operator.uuid = this._uuid })
     const ids = Array.from(new Set(this.config.bridges.map((bridge) => bridge.id)))
     ids.sort()
@@ -2041,10 +2149,28 @@ class Config {
       this.config.namespaces = ns
     }
 
-    if (this.config.words) {
-      const words = this.config.words
-      for (const key in words) {
-        words[key].forEach((o) => {
+    if (!this.config.words) {
+      this.config.words = {}
+    }
+
+    if (this.config.words.literals) {
+      const literals = this.config.words.literals
+      for (const key in literals) {
+        literals[key].forEach((o) => {
+          if (o.uuid) {
+            if (map[o.uuid]) {
+              o.uuid = map[o.uuid]
+            }
+          } else {
+            o.uuid = this._uuid
+          }
+        })
+      }
+    }
+
+    const mapDefList = (list) => {
+      for (const element of list) {
+        element.defs.forEach((o) => {
           if (o.uuid) {
             if (map[o.uuid]) {
               o.uuid = map[o.uuid]
@@ -2056,6 +2182,26 @@ class Config {
       }
     }
 
+    if (this.config.words.patterns) {
+      mapDefList(this.config.words.patterns)
+    }
+
+    if (this.config.words.hierarchy) {
+      for (const o of this.config.words.hierarchy) {
+        if (o.uuid) {
+          if (map[o.uuid]) {
+            o.uuid = map[o.uuid]
+          }
+        } else {
+          o.uuid = this._uuid
+        }
+      }
+    }
+
+    if (this.config.trie) {
+      mapDefList(this.config.trie)
+    }
+
     if (this.config.bridges) {
       this.config.bridges.forEach((bridge) => {
         if (bridge.uuid) {
@@ -2228,14 +2374,20 @@ class Config {
     }
     */
 
-    for (const key in this.config.words) {
-      const values = this.config.words[key]
-      if (values.some((word) => (Object.keys(word).includes('uuid') && !word.uuid))) {
-        debugBreak()
-        return false
+    const literals = this.config.words.literals
+    if (literals) {
+      for (const key in literals) {
+        const values = literals[key]
+        if (values.some((word) => (Object.keys(word).includes('uuid') && !word.uuid))) {
+          debugBreak()
+          return false
+        }
       }
     }
 
+    // TODO trie
+    isValidTrie(this.config.trie)
+
     const kmsUuids = this.configs.map((km) => km.uuid)
     const bridgesUuids = this.config.bridges.map((bridge) => bridge.uuid).filter((uuid) => uuid)
     let result = true
@@ -2438,6 +2590,7 @@ class Config {
         hierarchy: this.config.hierarchy,
         priorities: this.config.priorities,
         associations: this.config.associations,
+        trie: this.config.trie,
         words: this.config.words
       }
 
@@ -2446,7 +2599,9 @@ class Config {
       this.config.hierarchy = []
       this.config.priorities = []
       this.config.associations = { positive: [], negative: [] }
-      this.config.words = {}
+      this.config.words = initWords({})
+
+      this.config.trie = []
 
       for (let i = 0; i < addInternals.length; ++i) {
         let name
@@ -2633,6 +2788,30 @@ class Config {
     }
 
     if (config.words) {
+      const literals = {}
+      for (const word in config.words.literals) {
+        literals[word] = config.words.literals[word].map((word) => {
+          return Object.assign({}, word, { id: toNS(word.id), uuid })
+        })
+      }
+      config.words.literals = literals
+
+      for (const pattern of config.words.patterns) {
+        pattern.defs.forEach((def) => {
+          def.id = toNS(def.id)
+          def.uuid = uuid
+        })
+      }
+
+      for (const pair of config.words.hierarchy) {
+        pair.child = toNS(pair.child)
+        pair.parent = toNS(pair.parent)
+      }
+    }
+
+    if (config.trie) {
+      // TODO not currently used
+      /*
       const words = {}
       for (const word in config.words) {
         words[word] = config.words[word].map((word) => {
@@ -2640,6 +2819,7 @@ class Config {
         })
       }
       config.words = words
+      */
     }
 
     if (config.hierarchy) {
@@ -2760,7 +2940,9 @@ class Config {
       throw new Error(`Setting invalid property ${property}`)
     }
 
+    // TODO trie
     if (property == 'words') {
+      throw "you need to fix this"
       for (const word in value) {
         for (const def of value[word]) {
           if (!def.uuid) {
@@ -2770,6 +2952,10 @@ class Config {
       }
     }
 
+    if (property == 'trie') {
+      isValidTrie(value)
+    }
+
     if (['operators', 'bridges'].includes(property)) {
       for (const def of value) {
         if (!def.uuid) {
@@ -2906,17 +3092,47 @@ class Config {
         this.config[key] = value
         continue
       }
-      if (key === 'words') {
-        const configWords = this.config.words
-        const moreWords = more.words
-        for (const word of Object.keys(moreWords)) {
-          if (!configWords[word]) {
-            configWords[word] = []
+      if (key === 'trie') {
+        const configTrie = this.config.trie
+        const morePatterns = more.trie
+        for (const pattern of morePatterns) {
+          if (addFirst) {
+            configTrie.unshift(pattern)
+          } else {
+            configTrie.push(pattern)
+          }
+        }
+      } else if (key === 'words') {
+        if (more.words.literals) {
+          const literals = this.config.words.literals
+          const moreLiterals = more.words.literals
+          for (const word of Object.keys(moreLiterals)) {
+            if (!literals[word]) {
+              literals[word] = []
+            }
+            if (addFirst) {
+              literals[word] = moreLiterals[word].concat(literals[word])
+            } else {
+              literals[word] = literals[word].concat(moreLiterals[word])
+            }
           }
+        }
+        if (more.words.patterns) {
+          const patterns = this.config.words.patterns
+          const morePatterns = more.words.patterns
           if (addFirst) {
-            configWords[word] = moreWords[word].concat(configWords[word])
+            this.config.words.patterns = morePatterns.concat(patterns)
           } else {
-            configWords[word] = configWords[word].concat(moreWords[word])
+            this.config.words.patterns = patterns.concat(morePatterns)
+          }
+        }
+        if (more.words.hierarchy) {
+          const hierarchy = this.config.words.hierarchy
+          const moreHierarchy = more.words.hierarchy
+          if (addFirst) {
+            this.config.words.hierarchy = moreHierarchy.concat(hierarchy)
+          } else {
+            this.config.words.hierarchy = hierarchy.concat(moreHierarchy)
           }
         }
       } else if (key === 'name') {
@@ -3027,15 +3243,30 @@ class Config {
         this.config[key] = value
         continue
       }
-      if (key === 'words') {
-        const configWords = this.config.words
-        const moreWords = more.words
-        for (const word of Object.keys(moreWords)) {
-          if (!configWords[word]) {
-            configWords[word] = []
+      if (key === 'trie') {
+        for (const pattern of more.trie) {
+          this.config.trie.unshift(pattern)
+        }
+      } else if (key === 'words') {
+        if (this.config.words.literals) {
+          const literals = this.config.words.literals
+          const moreLiterals = more.words.literals
+          for (const word of Object.keys(moreLiterals)) {
+            if (!literals[word]) {
+              literals[word] = []
+            }
+            literals[word] = moreLiterals[word].concat(literals[word])
           }
-          // configWords[word] = configWords[word].concat(moreWords[word])
-          configWords[word] = moreWords[word].concat(configWords[word])
+        }
+        if (this.config.words.patterns) {
+          const patterns = this.config.words.patterns
+          const morePatterns = more.words.patterns
+          this.config.words.patterns = morePatterns.concat(patterns)
+        }
+        if (this.config.words.hierarchy) {
+          const hierarchy = this.config.words.hierarchy
+          const moreHierarchy = more.words.hierarchy
+          this.config.words.hierarchy = moreHierarchy.concat(hierarchy)
         }
       } else if (key === 'name') {
         /*