theprogrammablemind 8.0.0 → 8.1.0-beta.0

package/src/config.js

@@ -2,9 +2,10 @@
 const { Semantics, normalizeGenerator } = require('./semantics')
 const { Generators } = require('./generators')
 const { v4: uuidv4 } = require('uuid')
-const client = require('../client')
+const configHelpers = require('./configHelpers')
 const DigraphInternal = require('./digraph_internal')
 const helpers = require('./helpers')
+const { InitCalls } = require('./helpers')
 const { ecatch } = require('./helpers')
 const runtime = require('../runtime')
 const _ = require('lodash')
@@ -40,6 +41,9 @@ const initWords = (words) => {
 }
 
 const debugPriority = (priority) => {
+  if (global.pauseDebugging) {
+    return
+  }
   if (global.entodictonDebugPriority) {
     if (helpers.subPriority(entodictonDebugPriority, priority)) {
       debugger // debug hierarchy hit
@@ -48,6 +52,9 @@ const debugPriority = (priority) => {
 }
 
 const debugAssociation = (association) => {
+  if (global.pauseDebugging) {
+    return
+  }
   if (global.entodictonDebugAssociation) {
     if (helpers.safeEquals(global.entodictonDebugAssociation, association)) {
       debugger // debug association hit
@@ -55,7 +62,21 @@ const debugAssociation = (association) => {
   }
 }
 
+const debugWord = (word) => {
+  if (global.pauseDebugging) {
+    return
+  }
+  if (global.entodictonDebugWord) {
+    if (helpers.safeEquals(global.entodictonDebugWord, word)) {
+      debugger // debug word hit
+    }
+  }
+}
+
 const debugHierarchy = (pair) => {
+  if (global.pauseDebugging) {
+    return
+  }
   if (global.entodictonDebugHierarchy) {
     if (helpers.safeEquals(global.entodictonDebugHierarchy, pair)) {
       debugger // debug hierarchy hit
@@ -64,14 +85,20 @@ const debugHierarchy = (pair) => {
 }
 
 const debugBridge = (bridge) => {
+  if (global.pauseDebugging) {
+    return
+  }
   if (global.entodictonDebugBridge) {
-    if (global.entodictonDebugBridge[0] == bridge.id && global.entodictonDebugBridge[1] == bridge.level) {
+    if (global.entodictonDebugBridge == bridge.id) {
       debugger // debug hierarchy hit
     }
   }
 }
 
 const debugOperator = (operator) => {
+  if (global.pauseDebugging) {
+    return
+  }
   if (global.entodictonDebugOperator) {
     if ((operator.pattern || operator) === global.entodictonDebugOperator) {
       debugger // debug operator hit
@@ -80,18 +107,29 @@ const debugOperator = (operator) => {
 }
 
 const debugConfigProps = (config) => {
+  if (global.pauseDebugging) {
+    return
+  }
   if (!config) {
     return
   }
   const checkProps = [
     { property: 'priorities', check: (v) => debugPriority(v) },
     { property: 'association', check: (v) => debugAssociation(v) },
+    { property: 'words', check: (v) => debugAssociation(v) },
     { property: 'hierarchy', check: (v) => debugHierarchy(v) },
     { property: 'operators', check: (v) => debugOperator(v) },
     { property: 'bridges', check: (v) => debugBridge(v) }
   ]
   for (const { property, check } of checkProps) {
-    if (config[property]) {
+    if (property == 'words') {
+      if (config[property]) {
+        for (const value in config[property].literals) {
+          check(value)
+        }
+      }
+    }
+    else if (config[property]) {
       for (const value of config[property]) {
         check(value)
       }
@@ -217,6 +255,9 @@ const priority_valid = (cp) => {
 const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
   ecatch(`While processing the bridge for ${bridge.id}#${bridge.level}`,
     () => {
+      if (bridge.development && config.isModule) {
+        return
+      }
       if (!bridge.bridge) {
         bridge.bridge = '{ ...next(operator) }'
       }
@@ -225,7 +266,12 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
       }
       if (bridge.children) {
         for (const child of bridge.children) {
-          config.addHierarchy(child, bridge.id)
+          // config.addHierarchy(child, bridge.id)
+          if (child.child) {
+            config.addHierarchy(child.child, bridge.id, child.instance)
+          } else {
+            config.addHierarchy(child, bridge.id)
+          }
         }
       }
       if (bridge.operator) {
@@ -233,12 +279,20 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
       }
       if (bridge.parents) {
         for (const parent of bridge.parents) {
-          config.addHierarchy(bridge.id, parent)
+          if (parent.parent) {
+            config.addHierarchy(bridge.id, parent.parent, parent.instance)
+          } else {
+            config.addHierarchy(bridge.id, parent)
+          }
         }
       }
       if (bridge.isA) {
         for (const parent of bridge.isA) {
-          config.addHierarchy(bridge.id, parent)
+          if (parent.parent) {
+            config.addHierarchy(bridge.id, parent.parent, parent.instance)
+          } else {
+            config.addHierarchy(bridge.id, parent)
+          }
         }
       }
       if (bridge.before) {
@@ -260,7 +314,7 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
       if (bridge.words) {
         for (let def of bridge.words) {
           if (typeof def === 'string') {
-            config.addWordInternal(def, { id: bridge.id, initial: `{ value: "${def}"}` })
+            config.addWordInternal(def, { id: bridge.id, initial: `{ value: "${bridge.id}"}` })
           } else {
             const word = def.word
             def = { initial: JSON.stringify(def), id: bridge.id, word }
@@ -301,8 +355,8 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
         const level = bridge.generatorp.level >= 0 ? bridge.generatorp.level : bridge.level + 1
 
         const generator = {
-          where: bridge.generatorp.where || bridge.where || client.where(4),
-          match: (args) => bridge.id == args.context.marker && args.context.level == level && args.context.paraphrase && match(args),
+          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),
           apply: (args) => apply(args),
           applyWrapped: apply,
           property: 'generatorp'
@@ -318,8 +372,8 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
         const apply = typeof bridge.generatorr === 'function' ? bridge.generatorr : bridge.generatorr.apply || bridge.generatorr
         const level = bridge.generatorr.level >= 0 ? bridge.generatorr.level : bridge.level + 1
         const generator = {
-          where: bridge.generatorr.where || bridge.where || client.where(4),
-          match: (args) => bridge.id == args.context.marker && args.context.level == level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && match(args),
+          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),
           apply: (args) => apply(args),
           applyWrapped: apply,
           property: 'generatorr'
@@ -332,7 +386,7 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
       }
       if (bridge.evaluator) {
         const semantic = {
-          where: bridge.evaluator.where || bridge.where || client.where(3),
+          where: bridge.evaluator.where || bridge.where || helpers.where(3),
           match: ({ context }) => bridge.id == context.marker && context.evaluate,
           apply: (args) => bridge.evaluator(args),
           applyWrapped: bridge.evaluator,
@@ -346,7 +400,7 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
       }
       if (bridge.semantic) {
         const semantic = {
-          where: bridge.semantic.where || bridge.where || client.where(3),
+          where: bridge.semantic.where || bridge.where || helpers.where(3),
           match: ({ context }) => bridge.id == context.marker && !context.evaluate,
           apply: (args) => bridge.semantic(args),
           applyWrapped: bridge.semantic,
@@ -404,13 +458,13 @@ if (runtime.process.env.DEBUG_ASSOCIATION) {
   global.entodictonDebugAssociation = JSON.parse(runtime.process.env.DEBUG_ASSOCIATION)
 }
 
+if (runtime.process.env.DEBUG_WORD) {
+  global.entodictonDebugWord = runtime.process.env.DEBUG_WORD
+}
+
 if (runtime.process.env.DEBUG_BRIDGE) {
-  // id/level
-  global.entodictonDebugBridge = runtime.process.env.DEBUG_BRIDGE.split('/')
-  if (global.entodictonDebugBridge.length !== 2) {
-    console.log('Expected DEBUG_BRIDGE to be of the form "id/level"')
-    process.exit(-1)
-  }
+  // id
+  global.entodictonDebugBridge = runtime.process.env.DEBUG_BRIDGE
   global.entodictonDebugBridge[1] = parseInt(global.entodictonDebugBridge[1])
 }
 
@@ -514,7 +568,7 @@ function isLetter (char) {
 }
 */
 
-function configDup (config, options) {
+async function configDup (config, options) {
   if (config instanceof Config) {
     return config.copy(options)
   }
@@ -654,9 +708,9 @@ class KM {
     return true
   }
 
-  copy2 (options) {
+  async copy2 (options) {
     // greg -> add a flag to say don't init the api's
-    const config = configDup(this._config, options)
+    const config = await configDup(this._config, options)
     const km = new KM({
       config,
       getCounter: options.getCounter,
@@ -668,10 +722,10 @@ class KM {
     return km // copy2()
   }
 
-  copy () {
+  async copy () {
     const km = new KM({
       name: this._name,
-      config: configDup(this._config),
+      config: await configDup(this._config),
       // _uuid: uuidv4(),
       _uuid: this._config.getCounter(this._config._name),
       getCounter: (name) => this._config.getCounter(name),
@@ -723,12 +777,11 @@ const multiApiImpl = (initializer) => {
     multiApi: true,
 
     // multi functions
-    add: (config, multiApi, api) => {
+    add: async (config, multiApi, api, apiConstructor) => {
       initializer(config, api)
       const name = api.getName()
       multiApi.apis[name] = api
-      // api.objects = config.get('objects')
-      // api.config = () => config
+      multiApi.apiConstructors[name] = apiConstructor
       multiApi.current = name
     },
 
@@ -751,6 +804,9 @@ const multiApiImpl = (initializer) => {
     apis: {
     },
 
+    apiConstructors: {
+    },
+
     // api functions
     api: (multiApi) => multiApi.apis[multiApi.current]
   })
@@ -761,17 +817,6 @@ class Config {
     return config_toServer(config)
   }
 
-  base () {
-    const base = new Config()
-    for (const km of this.configs.reverse()) {
-      if (km.isSelf) {
-        continue
-      }
-      base.add(km.config)
-    }
-    return base
-  }
-
   getInfo () {
     const name = this.name
     const includes = this.configs.slice(1).map((km) => km.config.name)
@@ -815,6 +860,7 @@ class Config {
       addArgs: (...args) => this.addArgs(...args),
       getBridge: (...args) => this.getBridge(...args),
       fragment: (...args) => this.fragment(...args),
+      server: (...args) => this.server(...args),
       exists: (...args) => this.exists(...args),
       addAPI: (...args) => this.addAPI(...args)
     }
@@ -951,23 +997,8 @@ class Config {
 
   // value is in response field
   // TODO maybe generalize out query+evaluate along the lines of set value and set reference
-  /*
-  getEvaluator (s, log, context) {
-    const instance = s({ ...context, evaluate: true })
-    if (!instance.evalue && !instance.verbatim && !instance.value) {
-      this.warningNotEvaluated(log, context);
-    }
-    if (!instance.evalue) {
-      instance.evalue = instance.value
-      instance.edefault = true
-    }
-    delete instance.evaluate
-    instance.instance = true;
-    return instance
-  }
-  */
-  getEvaluator (s, calls, log, context) {
-    const instance = s({ ...context, evaluate: true })
+  async getEvaluator (s, calls, log, context) {
+    const instance = await s({ ...context, evaluate: true })
     calls.touch(instance)
     if (!instance.evalue && !instance.verbatim && !instance.value) {
       this.warningNotEvaluated(log, context)
@@ -981,19 +1012,21 @@ class Config {
     return instance
   }
 
-  fragmentInstantiator (contexts) {
+  fragmentInstantiator (args, contexts) {
     return new Object({
       contexts: () => contexts,
-      instantiate: (mappings) => {
+      instantiate: async (mappings) => {
         const instantiated = _.cloneDeep(contexts)
         // const todo = [...instantiated]
         // const todo = [...instantiated]
         const todo = _.clone(instantiated)
+        args = {...args}
         while (todo.length > 0) {
           const context = todo.pop()
+          args.context = context
           for (const mapping of mappings) {
-            if (mapping.match({ context })) {
-              mapping.apply({ context })
+            if (await mapping.match(args)) {
+              await mapping.apply(args)
             }
           }
           for (const key of Object.keys(context)) {
@@ -1012,11 +1045,21 @@ class Config {
     })
   }
 
-  fragment (query) {
+  fragment (args, query) {
     for (const instance of (this.instances || [])) {
       for (const fragment of (instance.fragments || [])) {
         if (fragment.query === query) {
-          return this.fragmentInstantiator(fragment.contexts)
+          return this.fragmentInstantiator(args, fragment.contexts)
+        }
+      }
+      for (const fragment of (instance.resultss || [])) {
+        if (fragment.isFragment && fragment.query === query) {
+          return this.fragmentInstantiator(args, fragment.contexts)
+        }
+      }
+      for (const fragment of (this.fragmentsBeingBuilt || [])) {
+        if (fragment.query === query) {
+          return this.fragmentInstantiator(args, fragment.contexts)
         }
       }
     }
@@ -1056,6 +1099,27 @@ class Config {
       } else {
         const config = { ...queryOrConfig }
         delete config.where
+
+        if (config.words && config.words.hierarchy) {
+          config.words.hierarchy = config.words.hierarchy.map( (value) => {
+            value = {...value}
+            delete value.uuid
+            return value
+          })
+        }
+
+        if (config.words && config.words.patterns) {
+          config.words.patterns = config.words.patterns.map( (value) => {
+            value = {...value}
+            value.defs = value.defs.map( (value) => {
+              value = {...value}
+              delete value.uuid
+              return value
+            })
+            return value
+          })
+        }
+
         config.operators = (config.operators || []).map((operator) => {
           if (typeof operator === 'string') {
             return { pattern: operator }
@@ -1083,6 +1147,9 @@ class Config {
             delete bridge.generatorpr
             delete bridge.evaluator
             delete bridge.semantic
+            if (!bridge.bridge) {
+              bridge.bridge = "{ ...next(operator) }"
+            }
             return bridge
           })
         } else {
@@ -1134,8 +1201,24 @@ class Config {
     let startOfChanges
     for (let iq = 0; iq < templateQueries.length; ++iq) {
       if (!helpers.safeEquals(templateQueries[iq], instanceQueries[iq])) {
-        sameQueries = false
-        startOfChanges = iq
+        // if the current and rest are not queries or fragments then treat as not needing rebuild
+        if (templateQueries.length != instanceQueries.length) {
+          sameQueries = false
+          startOfChanges = iq
+        } else {
+          let hasQueryOrFragment = false
+          for (let rest = iq; rest < templateQueries.length; ++rest) {
+            const value = templateQueries[rest]
+            if (typeof value == 'string' || (value.query && value.isFragment)) {
+              hasQueryOrFragment = true
+              break
+            }
+          }
+          if (hasQueryOrFragment) {
+            sameQueries = false
+            startOfChanges = iq
+          }
+        }
         break;
       }
     }
@@ -1160,7 +1243,9 @@ class Config {
         // console.log("instanceFragments", instanceFragments)
       }
     }
-    if (startOfChanges || instance.resultss) {
+    if (startOfChanges) {
+      return { needsRebuild: true, startOfChanges, previousResultss: instance.resultss }
+    } else if (startOfChanges || instance.resultss) {
       return { needsRebuild: !(instance && sameQueries && sameFragments), startOfChanges, previousResultss: instance.resultss }
     } else {
       return { needsRebuild: !(instance && sameQueries && sameFragments) }
@@ -1185,7 +1270,7 @@ class Config {
   }
 
   // loadTemplate
-  load (template, instance, options = { rebuild: false, previousResultss: undefined, startOfChanges: undefined }) {
+  async load (rebuildTemplate, template, instance, options = { rebuild: false, previousResultss: undefined, startOfChanges: undefined }) {
     this.validifyTemplate(template)
     instance.template = template
     this.logs.push(`loading template for ${this.name}`)
@@ -1193,7 +1278,7 @@ class Config {
       // TODO fix beforeQuery
       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 })
+      await rebuildTemplate({ config: this, target: this.name, previousResultss: options.previousResultss, startOfChanges: options.startOfChanges, beforeQuery: () => {}, template, ...options })
     } else {
       // no change
       // this.initInstances.push({ ...instance, name: config.name })
@@ -1218,7 +1303,7 @@ class Config {
         instance.name = this.name
         this.initInstances.push(instance)
         this.instances.push(instance)
-        client.loadInstance(this, instance)
+        await configHelpers.loadInstance(this, instance)
       }
     }
   }
@@ -1272,9 +1357,9 @@ class Config {
     }
   }
 
-  addHierarchy (child, parent) {
+  addHierarchy (child, parent, instance) {
     if (child && parent || !child || Array.isArray(child) || (typeof child === 'string' && !parent)) {
-      this.addHierarchyChildParent(child, parent)
+      this.addHierarchyChildParent(child, parent, instance)
       // this.addHierarchyProperties ({ child, parent })
     } else {
       this.addHierarchyProperties(child)
@@ -1282,26 +1367,32 @@ class Config {
   }
 
   addHierarchyProperties (edge) {
-    const { child, parent } = edge
+    const { child, parent, instance } = edge
     if (typeof child !== 'string') {
       throw new Error(`addHierarchy expected child property to be a string. got ${JSON.stringify(child)}`)
     }
     if (typeof parent !== 'string') {
       throw new Error(`addHierarchy expected parent property to be a string. got ${JSON.stringify(parent)}`)
     }
+    if (instance && typeof instance !== 'boolean') {
+      throw new Error(`addHierarchy expected instance property to be a boolean or undefined. got ${JSON.stringify(instance)}`)
+    }
     debugHierarchy([child, parent])
     this.config.hierarchy.push(edge)
     // TODO greg11 this.hierarchy.addEdge(edge)
-    this._delta.json.hierarchy.push([child, parent])
+    this._delta.json.hierarchy.push([child, parent, instance || false])
   }
 
-  addHierarchyChildParent (child, parent) {
+  addHierarchyChildParent (child, parent, instance) {
     if (typeof child !== 'string') {
       throw new Error(`addHierarchy expected child to be a string. got ${JSON.stringify(child)}`)
     }
     if (typeof parent !== 'string') {
       throw new Error(`addHierarchy expected parent to be a string. got ${JSON.stringify(parent)}`)
     }
+    if (instance && typeof instance !== 'boolean') {
+      throw new Error(`addHierarchy expected instance property to be a boolean or undefined. got ${JSON.stringify(instance)}`)
+    }
     debugHierarchy([child, parent])
     if (this.config.hierarchy.find((element) => {
       const hc = hierarchyCanonical(element)
@@ -1312,9 +1403,9 @@ class Config {
       return
     }
 
-    this.config.hierarchy.push([child, parent])
+    this.config.hierarchy.push([child, parent, instance || false])
     // this.hierarchy.addEdge([child, parent])
-    this._delta.json.hierarchy.push([child, parent])
+    this._delta.json.hierarchy.push([child, parent, instance || false])
   }
 
   getBridge (id, level) {
@@ -1361,7 +1452,7 @@ class Config {
     }
 
     if (!generator.where) {
-      generator.where = client.where(3)
+      generator.where = helpers.where(3)
     }
 
     const generators = this.config.generators
@@ -1384,7 +1475,7 @@ class Config {
     }
 
     if (!semantic.where) {
-      semantic.where = client.where(3)
+      semantic.where = helpers.where(3)
     }
 
     const semantics = this.config.semantics
@@ -1458,6 +1549,7 @@ class Config {
         hierarchy: [],
       }
     }
+    debugWord(word)
 
     const literals = this.config.words.literals
     def = Object.assign({}, def, { uuid: uuid || this._uuid })
@@ -1570,16 +1662,20 @@ class Config {
     return params
   }
 
-  processContexts (contexts, params) {
-    client.processContexts(contexts, this.getParams())
+  async processContext (context) {
+    return await configHelpers.processContext(context, this.getParams())
   }
 
-  processContext (context) {
-    return client.processContext(context, this.getParams())
+  process (query, options) {
+    return this.clientProcess(this, query, options)
   }
 
-  process (query, options) {
-    return client.process(this, query, options)
+  query (query, options) {
+    return this.process(query, options)
+  }
+
+  processQuery (query, options) {
+    return this.process(query, options)
   }
 
   initDefaults () {
@@ -1711,8 +1807,25 @@ class Config {
     config.words.hierarchy = hierarchyPrime
   }
 
+  terminate() {
+    this.configs.forEach((km) => {
+      const config = km.config
+      if (!config.terminatorFn) {
+        this.terminatorFn(this)
+      } else {
+        config.terminatorFn(this)
+      }
+    })
+  }
+
+  setTerminator(terminatorFn) {
+    if (terminatorFn) {
+      this.terminatorFn = terminatorFn
+    }
+  }
+
   // configs = [ { config, namespace } ... ]
-  constructor (config, module) {
+  constructor (config, module, clientProcess) {
     if (config instanceof Config) {
       throw new Error('Excepted the config argument to be a hash not a Config object')
     }
@@ -1730,6 +1843,7 @@ class Config {
       config.priorities = config.priorities || []
     }
 
+    this.clientProcess = clientProcess
     this.maxDepth = 20 // for generators and semantics
     this.debugLoops = false // for generators and semantics
 
@@ -1755,24 +1869,6 @@ class Config {
     // 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
-    if (config && config.bridges) {
-      let duplicated = new Set()
-      const seen = new Set()
-      for (const bridge of config.bridges) {
-        const id = `${bridge.id}/${bridge.level}`
-        if (seen.has(id)) {
-          duplicated.add(id)
-        } else {
-          seen.add(id)
-        }
-      }
-      duplicated = Array.from(duplicated)
-      if (duplicated.length > 0) {
-        throw new Error(`In the KM ${config.name}, the following operators are duplicated in the bridges: ${duplicated}`)
-      }
-    }
-
     if (config && config.words) {
       initWords(config.words)
       isValidWordDef(config.words)
@@ -1794,6 +1890,7 @@ class Config {
         currentConfig.wasInitialized = true
       }
     }
+    this.terminatorFn = () => {}
     if (config) {
       this.name = config.name
     }
@@ -1821,6 +1918,7 @@ class Config {
     }
     this.get('objects').namespaced[this._uuid] = {}
     this.valid()
+    this.checks()
     debugConfigProps(this.config)
   }
 
@@ -1832,9 +1930,9 @@ class Config {
     this._stop_auto_rebuild = true
   }
 
-  restart_auto_rebuild() {
+  async restart_auto_rebuild() {
     this._stop_auto_rebuild = false
-    this.rebuild()
+    await this.rebuild()
   }
 
   getAddedArgs (args) {
@@ -1853,8 +1951,8 @@ class Config {
     }
   }
 
-  set multiApi (initializer) {
-    this.api = multiApiImpl(initializer)
+  async setMultiApi (initializer) {
+    await this.setApi(() => multiApiImpl(initializer))
   }
 
   get multiApi () {
@@ -1902,31 +2000,38 @@ class Config {
     }
   }
 
-  addAPI (api) {
+  async addAPI (api) {
+    // console.trace()
+    // throw "addAPI"
     if (this._api && this._api.multiApi) {
-      this._api.add(this, this._api, api)
+      await this._api.add(this, this._api, api)
     } else {
       throw new Error('Can only add apis to a multi-api')
     }
   }
 
-  set api (value) {
+  async setApi (constructor) {
+    if (typeof constructor !== 'function') {
+      throw new Error(`Expected the argument to be an API constructor for ${this.name}.`)
+    }
+    const value = constructor()
     if (!value.initialize) {
       throw new Error(`Expected the API to have an initialize function for ${this.name}.`)
     }
 
     if (this._api && this._api.multiApi) {
-      this._api.add(this, this._api, value)
-    } else {
-      this._api = _.cloneDeep(value)
-      /*
-      if (this._api) {
-        // this._api.objects = this.config.objects
-        // this._api.config = () => this
-        // this._api.uuid = this._uuid
+      await this._api.add(this, this._api, value, constructor)
+      const previousApiConstructor = this._apiConstructor
+      this._apiConstructor = (config) => {
+        const api = previousApiConstructor(config)
+        // does this need await?
+        api.add(config, api, constructor(config), constructor)
+        return api
       }
-      */
-      this.rebuild()
+    } else {
+      this._api = value
+      this._apiConstructor = constructor
+      await this.rebuild()
     }
   }
 
@@ -1946,7 +2051,7 @@ class Config {
   }
 
   // remove all added modules and initialize with the init config
-  resetToOne () {
+  async resetToOne () {
     /*
     this.config = _.cloneDeep(this.initConfig)
     this.configs = [this.configs[0]]
@@ -1955,11 +2060,8 @@ class Config {
     */
     this.configs = [this.configs[0]]
     this.defaultConfig()
-    if (!this.initializeFn) {
-      // TODO move this to the default initializer
-      Object.assign(this.config.objects, _.cloneDeep(this.initConfig.objects || {}))
-    }
-    this.initializeConfigFromConfigs({ others: [], objects: this.config.objects.namespaced, moreNames: [], callInitializers: false })
+    Object.assign(this.config.objects, _.cloneDeep(this.initConfig.objects || {}))
+    await this.initializeConfigFromConfigs({ others: [], objects: this.config.objects.namespaced, moreNames: [], callInitializers: false })
     const map = {}
     for (let i = 0; i < this.configs.length; ++i) {
       map[this.configs[i].uuid] = this.configs[i].uuid
@@ -1981,21 +2083,27 @@ class Config {
     runtime.fs.writeFileSync(fn, JSON.stringify(this.config, 0, 2))
   }
 
-  copy (options = { callInitializers: true }) {
-  }
-
-  copy (options = { callInitializers: true }) {
+  async copy (options = { callInitializers: true }) {
     this.valid()
     const cp = new Config()
     cp.logs = []
     cp.maxDepth = this.maxDepth
     cp.debugLoops = this.debugLoops
     cp.transitoryMode = this.transitoryMode
-    cp.configs = this.configs.map((km) => km.copy2(Object.assign({}, options, { getCounter: (name) => cp.getCounter(name), callInitializers: false })))
+    // cp.configs = this.configs.map((km) => await km.copy2(Object.assign({}, options, { getCounter: (name) => cp.getCounter(name), callInitializers: false })))
+    cp.configs = []
+    for (const km of this.configs) {
+      cp.configs.push(await km.copy2(Object.assign({}, options, { getCounter: (name) => cp.getCounter(name), callInitializers: false })))
+    }
     cp._uuid = cp.configs[0]._uuid
     // update uuid here set the uuid in the objects and add error checking
     cp.initializerFn = this.initializerFn
-    cp._api = _.cloneDeep(this._api)
+    cp.terminatorFn = this.terminatorFn
+    // cp._api = _.cloneDeep(this._api)
+    if (this._apiConstructor) {
+      cp._api = this._apiConstructor(cp)
+      cp._apiConstructor = this._apiConstructor
+    }
     cp._namespace = this._namespace
     cp._eqClasses = this._eqClasses
     cp.name = this.name
@@ -2007,18 +2115,14 @@ class Config {
     cp.instances = this.instances.slice()
     cp.configCounter = this.configCounter
     cp.testConfig = this.testConfig
+    cp._server = this._server
 
     cp.initConfig = _.cloneDeep(this.initConfig)
     cp.defaultConfig()
     // cp.wasInitialized = false;  // since default config GREG
     cp.resetWasInitialized()
-    if (!this.initializeFn) {
-      // TODO move this to the default initializer
-      Object.assign(cp.config.objects, _.cloneDeep(this.initConfig.objects || {}))
-    }
-    // cp.initializeConfigFromConfigs({ others: [], objects: cp.config.objects.namespaced, moreNames: [], ...options })
-    // cp.initializeConfigFromConfigs(Object.assign({ others: [], objects: cp.config.objects.namespaced, moreNames: [] }, { callInitializers: false }))
-    cp.initializeConfigFromConfigs(Object.assign({ others: [], objects: cp.config.objects.namespaced, moreNames: [] }, options))
+    Object.assign(cp.config.objects, _.cloneDeep(this.initConfig.objects || {}))
+    await cp.initializeConfigFromConfigs(Object.assign({ others: [], objects: cp.config.objects.namespaced, moreNames: [] }, options))
     const map = {}
     for (let i = 0; i < this.configs.length; ++i) {
       map[this.configs[i].uuid] = cp.configs[i].uuid
@@ -2029,33 +2133,16 @@ class Config {
       // debugger
     }
     if (options.callInitializers) {
-      cp.rebuild(options)
+      await cp.rebuild(options) // in copy
     } else {
-      // this mess is for duplicate into a KM after resetToOne was called
-      /*
-      if (cp._api) {
-        // cp._api.objects = cp.config.objects
-        // cp._api.config = () => (cp instanceof Config) ? cp : cp.config
-        // cp._api.uuid = cp._uuid
-      }
-      */
-
       if (!cp.config.objects) {
         cp.config.objects = { namespaced: {} }
       } else if (!cp.config.objects.namespaced) {
         cp.config.objects.namespaced = {}
       }
       cp.configs.forEach((km) => {
-        // const namespace = km.namespace
         cp.config.objects.namespaced[km._uuid] = {}
       })
-      /*
-      if (cp._uuid == 'concept2') {
-        if (!cp.api.objects.defaultTypesForHierarchy) {
-          debugger
-        }
-      }
-    */
     }
     cp.valid()
     return cp
@@ -2179,41 +2266,7 @@ class Config {
     }
   }
 
-  initializeFromConfigs () {
-    // [...this.configs].reverse().forEach(({ config, namespace, uuid }) => {
-    [...this.configs].reverse().forEach(({ config, namespace, uuid }) => {
-      /*
-      let objects = this.get('objects')
-      if (namespace) {
-        objects = {}
-        this.get('objects')['namespaced'][namespace] = objects
-      }
-      */
-      const objects = {}
-      if (config instanceof Config) {
-        this.get('objects').namespaced[config._uuid] = objects
-        /*
-        if (config._api) {
-          // config._api.objects = objects
-          // config._api.config = () => this
-        }
-        */
-        config.initializerFn(setupInitializerFNArgs(this, { testConfig: config, currentConfig: config, objects, namespace, uuid }))
-      } else {
-        this.get('objects').namespaced[this._uuid] = objects
-        /*
-        if (config._api) {
-          // config._api.objects = objects
-          // config._api.config = () => this
-        }
-        */
-        this.initializerFn(setupInitializerFNArgs(this, { testConfig: this, currentConfig: this, objects, namespace, uuid }))
-      }
-    })
-    this.instances.forEach((instance) => client.loadInstance(this, instance))
-  }
-
-  initialize ({ force = true } = {}) {
+  initialize23 ({ force = true } = {}) {
     if (force || !this.wasInitialized) {
       const objects = this.config.objects.namespaced[this._uuid]
       this.initializerFn(setupInitializerFNArgs(this, { testConfig: this, currentConfig: this, objects, uuid: this._uuid, namespace: '' }))
@@ -2221,7 +2274,7 @@ class Config {
     }
   }
 
-  initializer (fn, options = {}) {
+  async initializer (fn, options = {}) {
     if (options) {
       for (const option of Object.keys(options)) {
         const validOptions = []
@@ -2243,8 +2296,7 @@ class Config {
       currentConfig.wasInitialized = true
       global.transitoryMode = transitoryMode
     }
-    // this.initializeFromConfigs()
-    this.rebuild()
+    await this.rebuild()
   }
 
   nsToString (id) {
@@ -2390,7 +2442,7 @@ class Config {
   }
 
   // rebuild ({ isModule: mainIsModule = false } = {}) {
-  rebuild ({ isModule: mainIsModule } = {}) {
+  async rebuild ({ isModule: mainIsModule } = {}) {
     if (this._stop_auto_rebuild) {
       return
     }
@@ -2558,7 +2610,7 @@ class Config {
         }
         const instance = this.instances.find((instance) => instance.name == name)
         if (instance) {
-          client.loadInstance(this, instance)
+          await configHelpers.loadInstance(this, instance)
         }
         this.hierarchy.edges = this.config.hierarchy
       }
@@ -2566,7 +2618,7 @@ class Config {
 
     this.hierarchy.edges = this.config.hierarchy
     this.valid()
-    this.checkBridges()
+    this.checks()
   }
 
   nameToUUID (name) {
@@ -2578,6 +2630,7 @@ class Config {
   //    if undefined namespace applies to first loaded config
   //    if list of name then namespace applied only to those configs
   //    if true then namespace applies to all loaded configs
+  /*
   namespace (moreNames, others) {
     const config = this.copy()
     if (!Array.isArray(moreNames)) {
@@ -2613,6 +2666,7 @@ class Config {
     config.rebuild()
     return config
   }
+  */
 
   setupNamespace (km) {
     let config = km.config
@@ -2631,7 +2685,7 @@ class Config {
 
   // config.initializerFn({ config: this, objects, namespace })
   // this goes through all the configs and sets up this.config
-  initializeConfigFromConfigs ({ others, objects, moreNames, callInitializers = true }) {
+  async initializeConfigFromConfigs ({ others, objects, moreNames, callInitializers = true }) {
     // setup the namespace in the configs
     let first = true
     this.configs.forEach((km) => {
@@ -2780,6 +2834,11 @@ class Config {
     }
   }
 
+  checks () {
+    this.checkOperators()
+    this.checkBridges()
+  }
+
   checkOperators () {
     if (!this.config.operators) {
       return
@@ -2800,53 +2859,19 @@ class Config {
       return
     }
 
-    /*
-      "namespaces": {
-        "634a678b-8d92-4464-bf65-943a82f404d8": {
-          "ids": [ "tankConcept" ],
-          "namespace": [ "ns1" ]
-        },
-       console.log('before check', JSON.stringify(this._eqClasses, null, 2))
-    */
-
-    const errors = []
-    /*
-    const namespaces = this.config.namespaces
-    const nsToIds = {}
-    for (const uuid in namespaces) {
-      const namespace = namespaces[uuid].namespace
-      const ns = namespace.join('#')
-      if (!nsToIds[ns]) {
-        nsToIds[ns] = new Set()
-      }
-      const ids = nsToIds[ns]
-      for (const id of namespaces[uuid].ids) {
-        if (ids.has(id)) {
-          if (ns === '') {
-            const dups = this.config.bridges.filter( (bridge) => bridge.id == id )
-            errors.push(`Id '${id}' is defined more than once in the bridges of the base namespace of the KM ${this.name}, Dups are ${JSON.stringify(dups)}`)
-          } else {
-            errors.push(`Id '${id}' is defined more than once in the bridges of the ${ns} namespace of the KM ${this.name}`)
-          }
-        } else {
-          ids.add(id)
-        }
-      }
-    }
-    */
-
-    const keyIsPresent = {}
+    let duplicated = new Set()
+    const seen = new Set()
     for (const bridge of this.config.bridges) {
-      const key = `${bridge.id}/${bridge.level} (namespace: ${bridge.uuid})`
-      if (keyIsPresent[key]) {
-        errors.push(new Error(`Id '${key}' is defined more than once in bridges of the base namespace of the KM ${this.name}`))
+      const id = `${bridge.id}/${bridge.level} (namespace: ${bridge.uuid || this.uuid})`
+      if (seen.has(id)) {
+        duplicated.add(id)
       } else {
-        keyIsPresent[key] = key
+        seen.add(id)
       }
     }
-
-    if (errors.length > 0) {
-      throw errors
+    duplicated = Array.from(duplicated)
+    if (duplicated.length > 0) {
+      throw new Error(`In the KM ${this.name}, the following operators are duplicated in the bridges: ${duplicated}`)
     }
   };
 
@@ -2903,25 +2928,29 @@ class Config {
     }
   }
 
-  add (...mores) {
-    mores.forEach((km) => {
-      if (km === this) {
-        throw new Error('Cannot add an object to itself.')
+  async add (...createConfigs) {
+    createConfigs.forEach((createConfig, index) => {
+      if (typeof createConfig !== 'function') {
+        throw new Error(`Expected add argument number ${index+1} to be a function that constructs the config.`)
       }
     })
 
-    mores = mores.map((km) => {
-      if (!(km instanceof Config)) {
-        km = new Config(km)
+    const mores = []
+    for (const createConfig of createConfigs) {
+      const more = await createConfig()
+      if (this.name && this.name == more.name) {
+        throw new Error('Cannot add an object to itself for argument number ${index+1}.')
       }
-      return km
-    })
-
-    mores.forEach((more) => {
+      if (this === more) {
+        throw new Error('Cannot add an object to itself.')
+      }
+      mores.push(more)
+    }
+    for (let more of mores) {
       this.valid()
       more.valid()
       // copy so i don't have to copy later
-      more = more.copy()
+      more = await more.copy()
       more.server(this._server, this._key, this._queryParams)
 
       const moreConfigs = more.configs.map((km) => km.name || km.uuid)
@@ -2936,9 +2965,6 @@ class Config {
       const moreKMs1 = [new KM({ config: more, getCounter: (name) => this.getCounter(name), uuid: more.uuid, namespace })]
       const moreKMs2 = more.configs.slice(1).map((km) => {
         return km
-        // const cp = km.copy()
-        // cp.namespace = namespace
-        // return cp;
       })
       const moreKMs = moreKMs1.concat(moreKMs2)
       const eqClass = moreKMs.map((km) => km.uuid)
@@ -2952,7 +2978,7 @@ class Config {
           this.configs.push(moreKM)
         }
       }
-      more.resetToOne()
+      await more.resetToOne()
       this.config.eqClasses = this._eqClasses
       // greg
       // setup instances
@@ -2967,8 +2993,8 @@ class Config {
         }
       }
       this.instances = noDups
-    })
-    this.rebuild()
+    }
+    await this.rebuild() // in add(
     this.valid()
     return this
   }
@@ -3124,7 +3150,7 @@ class Config {
   // assumes this is called in reverse order
   addInternalR (more, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false) {
     if (more instanceof Config) {
-      more.initialize({ force: false })
+      more.initialize23({ force: false })
       if (useOldVersion) {
         more = more.config
       } else {