theprogrammablemind 7.6.0 → 7.7.0

package/client.js

@@ -173,22 +173,32 @@ const setupArgs = (args, config, logs, hierarchy) => {
   args.theDebugger = {
     breakOnSemantics: (value) => args.breakOnSemantics = value
   }
-  args.s = (c) => config.getSemantics(logs).apply(args, c)
-  args.g = (c) => config.getGenerators(logs).apply(args, c)
-  args.gp = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: true, isResponse: false, response: false})
-  args.gr = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: false, isResponse: true })
   if (!logs) {
     debugger
   }
-  args.e = (c) => config.getEvaluator(args.s, args.calls, logs, c)
   args.log = (message) => logs.push(message)
-  args.gs = gs(args.g)
-  args.gsp = gs(args.gp)
-  args.gsr = gs(args.gr)
+
+  args.addAssumedScoped = (args, assumed) => {
+    args.s = (c) => config.getSemantics(logs).apply(args, c)
+    args.g = (c) => config.getGenerators(logs).apply(args, c)
+    args.gp = (c) => config.getGenerators(logs).apply({...args, assumed: {paraphrase: true, isResponse: false, response: false}}, c, {paraphrase: true, isResponse: false, response: false})
+    args.gr = (c) => config.getGenerators(logs).apply({...args, assumed: {paraphrase: false, isResponse: true}}, { ...c, paraphrase: false, isResponse: true })
+    args.e = (c) => config.getEvaluator(args.s, args.calls, logs, c)
+    args.gs = gs(args.g)
+    args.gsp = gs(args.gp)
+    args.gsr = gs(args.gr)
+  }
+  // for semantics
+  args.addAssumedScoped(args, {})
   config.getAddedArgs(args)
 }
 
 const gs = (g) => (contexts, separator, lastSeparator) => {
+  if (!Array.isArray(contexts)) {
+    debugger
+    throw new Error("Expected a list")
+  }
+
   let s = ''
   if (!separator) {
     separator = ' '
@@ -276,8 +286,9 @@ const processContext = (context, { objects = {}, config, logs = [] }) => {
   setupArgs(args, config, logs, hierarchy)
 
   context = semantics.apply(args, context)
-  const generated = generators.apply(args, context)[0]
-  const paraphrases = generators.apply(args, context, { paraphrase: true, response: false, isResponse: false })[0]
+  const generated = generators.apply(args, context)
+  const assumed = { paraphrase: true, response: false, isResponse: false }
+  const paraphrases = generators.apply({...args, assumed}, context, { paraphrase: true, response: false, isResponse: false })
   let responses = []
   if (context.isResponse) {
     responses = generated
@@ -447,37 +458,29 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
         continue
       }
       let assumed = { isResponse: true };
-      const generated = contextPrime.isResponse ? config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0] : ''
+      const generated = contextPrime.isResponse ? config.getGenerators(json.logs).apply({...args, assumed}, contextPrime, assumed) : ''
       let generatedParenthesized = []
       if (generateParenthesized) {
         config.parenthesized = true
-        generatedParenthesized = contextPrime.isResponse ? config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0] : ''
+        generatedParenthesized = contextPrime.isResponse ? config.getGenerators(json.logs).apply({...args, assumed}, contextPrime, assumed) : ''
         config.parenthesized = false
       }
       // assumed = { paraphrase: true, response: false };
-      assumed = { paraphrase: true };
-      args.g = (c) => config.getGenerators(json.logs).apply(args, c, assumed)
-      args.gp = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: true, isResponse: false, response: false }, assumed)
-      args.gr = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: false }, assumed)
-      args.gs = gs(args.g)
-      args.gsp = gs(args.gsp)
-      args.gsr = gs(args.gr)
+      assumed = { paraphrase: true, isResponse: false, response: false };
+      // args.g = (c) => config.getGenerators(json.logs).apply({...args, assumed}, c, assumed)
+      // args.gs = gs(args.g)
       if (generateParenthesized) {
         config.parenthesized = false
       }
-      const paraphrases = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
+      const paraphrases = config.getGenerators(json.logs).apply({...args, assumed}, contextPrime, assumed)
       let paraphrasesParenthesized = []
       if (generateParenthesized) {
         config.parenthesized = true
-        paraphrasesParenthesized = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
+        paraphrasesParenthesized = config.getGenerators(json.logs).apply({...args, assumed}, contextPrime, assumed)
         config.parenthesized = false
       }
-      args.g = (c) => config.getGenerators(json.logs).apply(args, c)
-      args.gp = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: true, isResponse: false, response: false })
-      args.gr = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: false })
-      args.gs = gs(args.g)
-      args.gsp = gs(args.gp)
-      args.gsr = gs(args.gr)
+      // args.g = (c) => config.getGenerators(json.logs).apply(args, c)
+      // args.gs = gs(args.g)
       contextsPrime.push(contextPrime)
       generatedPrime.push(generated)
       paraphrasesPrime.push(paraphrases)
@@ -660,6 +663,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         opChoices: []
       },
       times: 0.0,
+      clientSideTimes: 0.0,
       trace: '',
       contexts: [],
       generated: [],
@@ -701,8 +705,16 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
       if (json.status !== 200) {
         throw json
       } else {
+        let clientSideTime
+        if (isTest) {
+          start = runtime.performance.performance.now()
+        }
         const { contextsPrime, generatedPrime, paraphrasesPrime, paraphrasesParenthesizedPrime, generatedParenthesizedPrime, responsesPrime } =
                                   processContextsB({ isTest, config, hierarchy, json, commandLineArgs /*, generators, semantics */ })
+        if (isTest) {
+          end = runtime.performance.performance.now()
+          clientSideTime = end - start
+        }
         response.associations = json.associations
         response.learned_contextual_priorities = json.learned_contextual_priorities
         response.hierarchy = json.hierarchy
@@ -713,6 +725,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         // appendNoDups(response.metadata.priorities, json.metadata.priorities)
         appendNoDups(response.metadata.opChoices, json.metadata.opChoices)
         response.times += json.times
+        response.clientSideTimes += clientSideTime
         response.trace = response.trace.concat(json.trace)
         response.version = json.version
         response.explain_priorities = json.explain_priorities
@@ -778,10 +791,6 @@ const runTest = async (config, expected, { args, verbose, testConfig, debug }) =
   const test = expected.query
   // initialize in between test so state is not preserved since the test was adding without state
   config.rebuild()
-  if (!args.dontAddAssociations) {
-    config.addAssociationsFromTests(config.tests)
-  }
-  // config.addAssocationsFromTests(
   const errorHandler = (error) => {
     if (error.metadata) {
       const priorities = analyzeMetaData(expected.metadata, error.metadata)
@@ -806,10 +815,10 @@ const runTest = async (config, expected, { args, verbose, testConfig, debug }) =
         defaultInnerProcess(config, errorHandler, result)
       }
       if (verbose) {
-        const widths = [100, 20]
+        const widths = [100, 60]
         const lines = new Lines(widths)
         lines.setElement(0, 0, test)
-        lines.setElement(0, 1, `time on server ${result.times.toFixed(2)}`)
+        lines.setElement(0, 1, `time on server: ${result.times.toFixed(2)} client: ${(result.clientSideTimes/1000).toFixed(2)}`)
         lines.log()
       }
       const expected_objects = sortJson(convertToStable(expected.objects), { depth: 25 })
@@ -1327,6 +1336,7 @@ const rebuildTemplate = async ({ config, target, template, errorHandler = defaul
           } else {
             delete result.load_cache_time
             delete result.times
+            delete result.clientSideTimes
             delete result.memory_free_percent
             delete result.logs
             delete result.version
@@ -1366,6 +1376,28 @@ const rebuildTemplate = async ({ config, target, template, errorHandler = defaul
   await looper(Object.assign([], todo))
 }
 
+const checkTemplate = (template) => {
+  return
+  if (!template) {
+    return
+  }
+  if (template.checks) {
+    throw new Error("The 'checks' property should be in the 'test' property not the 'template' property")
+  }
+}
+
+const checkTest = (testConfig) => {
+  if (!testConfig) {
+    return
+  }
+  if (!testConfig.name) {
+    throw new Error("The 'test' property is missing the 'name' property that contains the name of the '<km>.test.json' file")
+  }
+  if (!testConfig.contents) {
+    throw new Error("The 'test' property is missing the 'contents' property that contains contents of the '<km>.test.json' file")
+  }
+}
+
 const knowledgeModule = async ({
   module: moduleFromJSFile,
   description,
@@ -1399,9 +1431,10 @@ const knowledgeModule = async ({
   if (!description) {
     throw new Error("'description' is a required parameter. The value should the description of the knowledge module.")
   }
-  if (!test) {
+  if (!testConfig) {
     throw new Error("'test' is a required parameter. The value should the path to the file used to store the tests of the knowledge module and the contents of the file in the form { name: <filePath>, contexts: <json> }.")
   }
+  checkTest(testConfig)
 
   const isProcess = require.main === moduleFromJSFile
 
@@ -1466,7 +1499,6 @@ const knowledgeModule = async ({
     parser.add_argument('--parenthesized', { action: 'store_true', help: 'Show the generated phrases with parenthesis.' })
     parser.add_argument('-c', '--clean', { help: 'Remove data from the test files. a === association' })
     parser.add_argument('-od', '--objectDiff', { action: 'store_true', help: 'When showing the objects use a colour diff' })
-    parser.add_argument('-daa', '--dontAddAssociations', { action: 'store_true', help: 'Do not add associations from the tests.' })
     parser.add_argument('-p', '--print', { help: 'Print the specified elements c === config, w === words, b === bridges, o === operators d === objects (d for data), h === hierarchy, g === generators, s === semantics, l === load t=tests ordering p === priorities a == associations j == JSON sent to server. for example --print wb' })
     parser.add_argument('-s', '--save', { action: 'store_true', help: 'When running with the --query flag this will save the current run to the test file. When running without the --query flag all tests will be run and resaved.' })
     parser.add_argument('-sd', '--saveDeveloper', { action: 'store_true', help: 'Same as -s but the query will not show up in the info command.' })
@@ -1671,6 +1703,8 @@ const knowledgeModule = async ({
       }
     }
 
+    checkTemplate(template)
+
     if (template) {
       const needsRebuild = config.needsRebuild(template.template, template.instance, options)
       if (needsRebuild) {
@@ -1679,16 +1713,14 @@ const knowledgeModule = async ({
         config.config.rebuild = true
       }
       config.load(template.template, template.instance, { rebuild: needsRebuild })
-      printConfig()
+      if (!args.query) {
+        printConfig()
+      }
       if (needsRebuild) {
         return
       }
     }
 
-    if (!args.save && !args.rebuildTemplate && !args.dontAddAssociations) {
-      config.addAssociationsFromTests(config.tests);
-    }
-
     if (args.retrain) {
       config.config.retrain = true
     }
@@ -1696,7 +1728,6 @@ const knowledgeModule = async ({
     if (args.test || args.testVerbose || args.testAllVerbose || args.save) {
       global.transitoryMode = true
     }
-
     if (!args.query && !args.test && !args.info && (args.save || args.saveDeveloper)) {
       global.transitoryMode = true
       saveTests(config, test, testConfig, args.saveDeveloper)
@@ -1718,7 +1749,6 @@ const knowledgeModule = async ({
             useTestConfig = config.getConfigs()[args.testModuleName].getTestConfig()
             useTestConfig.testModuleName = args.testModuleName
             test = useTestConfig.name
-
           }
           runTests(config, test, { args, debug: args.debug, testConfig: useTestConfig, verbose: args.testVerbose || args.testAllVerbose, stopAtFirstError: !args.testAllVerbose }).then((results) => {
             let newError = false
@@ -1767,12 +1797,16 @@ const knowledgeModule = async ({
                   show('paraphrases', result.expected.paraphrases, result.actual.paraphrases)
                   if (!args.testNoParenthesized) {
                     show('paraphrases parenthesized', result.expected.paraphrasesParenthesized, result.actual.paraphrasesParenthesized)
+                    if (args.vimdiff) {
+                      vimdiff(result.actual.paraphrasesParenthesized, result.expected.paraphrasesParenthesized)
+                    }
+                  }
+                  /*
                   }
                   show('responses', result.expected.responses, result.actual.responses)
                   if (!args.testNoParenthesized) {
                     show('responses parenthesized', result.expected.generatedParenthesized, result.actual.generatedParenthesized)
                   }
-                  /*
                   if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
                     if (!headerShown) {
                       console.log('  Failure')
@@ -1836,16 +1870,18 @@ const knowledgeModule = async ({
                   }
                 }
               }
-              if (!headerShown) {
+              if (hasError) {
+                if (!headerShown) {
+                  if (!(useTestConfig.check && useTestConfig.check.length > 0)) {
+                    console.log('There are failures due to things other than paraphrases, responses and checked properties being different. They are not shown because you ran -tv or -tva which only shows difference in paraphrase and results. Usually what I do is -s and do a diff to make sure there are no other problems. If the paraphrases or results were different they would have shown here.')
+                  }
+                }
                 if (!(useTestConfig.check && useTestConfig.check.length > 0)) {
-                  console.log('There are failures due to things other than paraphrases, responses and checked properties being different. They are not shown because you ran -tv or -tva which only shows difference in paraphrase and results. Usually what I do is -s and do a diff to make sure there are no other problems. If the paraphrases or results were different they would have shown here.')
+                  console.log('use -v arg to write files expected.json and actual.json in the current directory for detailed comparison. Or do -s and then git diff the changes.')
+                  // console.log(JSON.stringify(contexts))
+                  console.log('**************************** ERRORS ************************')
                 }
               }
-              if (!(useTestConfig.check && useTestConfig.check.length > 0)) {
-                console.log('use -v arg to write files expected.json and actual.json in the current directory for detailed comparison. Or do -s and then git diff the changes.')
-                // console.log(JSON.stringify(contexts))
-                console.log('**************************** ERRORS ************************')
-              }
             }
             // const contexts = { failures: results }
             l(n - 1, hasError || newError)
@@ -1939,8 +1975,6 @@ const knowledgeModule = async ({
           errorHandler(e)
         }
       }
-
-      config.addAssociationsFromTests(config.tests);
     }
 
     createConfigExport = () => {

package/package.json

@@ -64,6 +64,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.6.0",
+  "version": "7.7.0",
   "license": "ISC"
 }

package/runtime.js

@@ -15,4 +15,5 @@ module.exports = {
   jsonDiff: require('json-diff'),
   sortJson: require('sort-json'),
   util: require('util'),
+  performance: require('perf_hooks'),
 }

package/src/config.js

@@ -1137,12 +1137,6 @@ class Config {
     return this.config.objects.namespaced[this._uuid]
   }
 
-  addAssociationsFromTests(tests = []) {
-    for (let test of tests) {
-      this.addAssociations(test.associations || []);
-    }
-  }
-
   addAssociations (associations) {
     for (let association of associations) {
       this.addAssociation(association)

package/src/flatten.js

@@ -81,6 +81,9 @@ const flatten = (markers, value) => {
     return flattenListHelper(markers, value)
   }
 
+  if (value.flatten === false) {
+    return [[value], false]
+  }
   const marker = value.marker
   let properties = value
 

package/src/generators.js

@@ -73,7 +73,8 @@ class Generator {
     return matches
   }
 
-  apply (baseArgs, objects, g, gs, context, hierarchy, config, response, log, options = {}) {
+  // apply (baseArgs, objects, g, gs, context, hierarchy, config, response, log, options = {}) {
+  apply (baseArgs, objects, context, hierarchy, config, response, log, options = {}) {
     if (!log) {
       throw new Error('generators.apply argument log is required')
     }
@@ -103,12 +104,12 @@ class Generator {
             log, 
             global: 
             objects, 
-            g, 
+            // g, 
             n, 
             hierarchy, 
             context, 
             uuid: this.uuid, 
-            gs, 
+            // gs, 
             config, 
             response, 
             api: this.getAPI(config), 
@@ -165,136 +166,125 @@ class Generators {
     this.logs = logs
   };
 
-  // assumed - properties added to contexts before the generators are called. For setting paraphrase property
-  apply (args, contexts, assumed = {}, options = {}) {
+  // assumed - properties added to context before the generators are called. For setting paraphrase property
+  apply (args, context, assumed = {}, options = {}) {
+    if (Array.isArray(context)) {
+      return new Error("Expected a context not an array")
+    }
+    if (typeof context !== 'object') {
+      return String(context)
+    }
+
     const config = args.config
     const objects = args.objects
     const hierarchy = args.hierarchy
     const response = args.response
-    if (Array.isArray(contexts)) {
-      // no-op
-    } else if (typeof contexts === 'object') {
-      contexts = [contexts]
-    } else {
-      return String(contexts)
-    }
 
-    const contextsPrime = []
-    for (const icontext in contexts) {
-      let context = contexts[icontext]
-      context = Object.assign({}, context, assumed)
-      // let context_prime = JSON.stringify(context);
-      let generated = context
-      let applied = false
-      const stack = args.calls.push()
-      for (let igenerator = 0; igenerator < this.generators.length; ++igenerator) {
-        const generator = this.generators[igenerator]
-        if (generator.matches(args, objects, context, hierarchy, config, options)) {
-          const g = (context, options) => {
-            const r = this.apply(args, context, Object.assign({}, ((options||{}).assumed || {}), assumed), options)
-            if (Array.isArray(r)) {
-              return r.join(' ')
-            } else {
-              return r
-            }
-          }
-          const log = (message) => { this.logs.push(message) }
-          // this.logs.push(`Generators: applied ${generator.toString()}\n to\n ${JSON.stringify(context)}`)
-          let errorMessage = 'The apply function did not return a value'
-          try {
-            generated= generator.apply(args, objects, g, args.gs, context, hierarchy, config, response, log)
-          } catch( e ) {
-            // the next if handle this
-            generated = null
-            e.retryCall = () => generator.apply(args, objects, g, args.gs, context, hierarchy, config, response, log)
-            const help = 'The error has a retryCall property that will recall the function that failed.'
-            if (e.stack && e.message) {
-              const info = `${generator.notes ? generator.notes : ''}${generator.where ? generator.where : ''}`
-              errorMessage = `Error applying generator '${info}. Error is ${e.toString()} stack is ${e.stack}. Generator is ${generator.toString()}. ${help}`
-            } else if (e.error) {
-              const info = `${generator.notes ? generator.notes : ''}${generator.where ? generator.where : ''}`
-              errorMessage = `Error applying generator '${info}. Error is ${e.error.join()}. Generator is ${generator.toString()}. ${help}`
-            } else {
-							errorMessage = e.toString()
-						}
+    
+    // args = { ...args, ...args.getAssumedScoped(assumed) }
+    args.addAssumedScoped(args, assumed) 
+    context = Object.assign({}, context, args.assumed)
+    let generated = ''
+    let applied = false
+    const stack = args.calls.push()
+    for (let igenerator = 0; igenerator < this.generators.length; ++igenerator) {
+      const generator = this.generators[igenerator]
+      if (generator.matches(args, objects, context, hierarchy, config, options)) {
+        const log = (message) => { this.logs.push(message) }
+        // this.logs.push(`Generators: applied ${generator.toString()}\n to\n ${JSON.stringify(context)}`)
+        let errorMessage = 'The apply function did not return a value'
+        try {
+          generated= generator.apply(args, objects, context, hierarchy, config, response, log)
+        } catch( e ) {
+          // the next if handle this
+          generated = null
+          e.retryCall = () => generator.apply(args, objects, context, hierarchy, config, response, log)
+          const help = 'The error has a retryCall property that will recall the function that failed.'
+          if (e.stack && e.message) {
+            const info = `${generator.notes ? generator.notes : ''}${generator.where ? generator.where : ''}`
+            errorMessage = `Error applying generator '${info}. Error is ${e.toString()} stack is ${e.stack}. Generator is ${generator.toString()}. ${help}`
+          } else if (e.error) {
+            const info = `${generator.notes ? generator.notes : ''}${generator.where ? generator.where : ''}`
+            errorMessage = `Error applying generator '${info}. Error is ${e.error.join()}. Generator is ${generator.toString()}. ${help}`
+          } else {
+            errorMessage = e.toString()
           }
-          if (!generated && generated !== '') {
-            const widths = [10, 10, 90]
-            const lines = new Lines(widths)
-            lines.setElement(0, 0, 'Generator')
-            const source = `${generator.km}/#${generator.index}`
-            lines.setElement(0, 2, `ERROR while applying (${source}) ${generator.toLabel()}`)
-            lines.newRow()
-            lines.setElement(0, 2, generator.toString())
-            lines.newRow()
-            lines.setElement(0, 1, 'TO')
-            lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(helpers.sortJson(context, { depth: 25 })))})`)
-            lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
-            lines.newRow()
-            lines.setElement(0, 1, 'STACK')
-            lines.setElement(0, 2, stack)
-						lines.newRow()
-						lines.setElement(0, 1, 'DEBUG')
-						lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
-            lines.newRow()
-            lines.setElement(0, 1, 'ERROR')
-            lines.setElement(0, 2, errorMessage)
-            this.logs.push(lines.toString())
-            const message = `ERROR while applying (${source}) ${generator.toLabel()}\n to\n ${JSON.stringify(context, null, 2)}.\n${errorMessage}'`
-            // this.logs.push(message)
-            // return [message]
-            args.calls.pop()
-            throw { error: [message], logs: this.logs }
-          }
-          if (((config || {}).config || {}).debug) {
-            const widths = [10, 10, 90]
-            const lines = new Lines(widths)
-            lines.setElement(0, 0, 'Generator')
-            if (generator.index > -1 && generator.km) {
-              // lines.setElement(0, 2, `KM '${generator.km}' ordinal: ${generator.index}`)
-              lines.setElement(0, 2, generator.toLabel())
-            }
-            lines.newRow()
-            lines.setElement(0, 1, 'APPLIED')
+        }
+        if (!generated && generated !== '') {
+          const widths = [10, 10, 90]
+          const lines = new Lines(widths)
+          lines.setElement(0, 0, 'Generator')
+          const source = `${generator.km}/#${generator.index}`
+          lines.setElement(0, 2, `ERROR while applying (${source}) ${generator.toLabel()}`)
+          lines.newRow()
+          lines.setElement(0, 2, generator.toString())
+          lines.newRow()
+          lines.setElement(0, 1, 'TO')
+          lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(helpers.sortJson(context, { depth: 25 })))})`)
+          lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
+          lines.newRow()
+          lines.setElement(0, 1, 'STACK')
+          lines.setElement(0, 2, stack)
+          lines.newRow()
+          lines.setElement(0, 1, 'DEBUG')
+          lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
+          lines.newRow()
+          lines.setElement(0, 1, 'ERROR')
+          lines.setElement(0, 2, errorMessage)
+          this.logs.push(lines.toString())
+          const message = `ERROR while applying (${source}) ${generator.toLabel()}\n to\n ${JSON.stringify(context, null, 2)}.\n${errorMessage}'`
+          // this.logs.push(message)
+          // return [message]
+          args.calls.pop()
+          throw { error: [message], logs: this.logs }
+        }
+        if (((config || {}).config || {}).debug) {
+          const widths = [10, 10, 90]
+          const lines = new Lines(widths)
+          lines.setElement(0, 0, 'Generator')
+          if (generator.index > -1 && generator.km) {
+            // lines.setElement(0, 2, `KM '${generator.km}' ordinal: ${generator.index}`)
             lines.setElement(0, 2, generator.toLabel())
-            lines.newRow()
-            lines.setElement(0, 2, generator.toString())
-            lines.newRow()
-            lines.setElement(0, 1, 'RESULT')
-            lines.setElement(0, 2, generated)
-            lines.newRow()
-            lines.setElement(0, 1, 'STACK')
-            lines.setElement(0, 2, stack)
-						lines.newRow()
-						lines.setElement(0, 1, 'DEBUG')
-						lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
-						lines.newRow()
-            lines.setElement(0, 1, 'TO')
-            lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(helpers.sortJson(context, { depth: 25 })))})`)
-            lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
-            this.logs.push(lines.toString())
           }
-          applied = true
-          break
+          lines.newRow()
+          lines.setElement(0, 1, 'APPLIED')
+          lines.setElement(0, 2, generator.toLabel())
+          lines.newRow()
+          lines.setElement(0, 2, generator.toString())
+          lines.newRow()
+          lines.setElement(0, 1, 'RESULT')
+          lines.setElement(0, 2, generated)
+          lines.newRow()
+          lines.setElement(0, 1, 'STACK')
+          lines.setElement(0, 2, stack)
+          lines.newRow()
+          lines.setElement(0, 1, 'DEBUG')
+          lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
+          lines.newRow()
+          lines.setElement(0, 1, 'TO')
+          lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(helpers.sortJson(context, { depth: 25 })))})`)
+          lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
+          this.logs.push(lines.toString())
         }
+        applied = true
+        break
       }
-      args.calls.pop()
-      if (!applied && ((config || {}).config || {}).debug) {
-        const widths = [10, 10, 90]
-        const lines = new Lines(widths)
-        lines.setElement(0, 0, 'Generator')
-        lines.setElement(0, 2, 'No generator applied')
-        lines.newRow()
-        lines.setElement(0, 1, 'STACK')
-        lines.setElement(0, 2, stack)
-        lines.newRow()
-        lines.setElement(0, 1, 'TO')
-        lines.setElement(0, 2, JSON.stringify(context, null, 2))
-        this.logs.push(lines.toString())
-      }
-      contextsPrime.push((config || {}).parenthesized ? "(" + generated + ")" : generated)
     }
-    return contextsPrime
+    args.calls.pop()
+    if (!applied && ((config || {}).config || {}).debug) {
+      const widths = [10, 10, 90]
+      const lines = new Lines(widths)
+      lines.setElement(0, 0, 'Generator')
+      lines.setElement(0, 2, 'No generator applied')
+      lines.newRow()
+      lines.setElement(0, 1, 'STACK')
+      lines.setElement(0, 2, stack)
+      lines.newRow()
+      lines.setElement(0, 1, 'TO')
+      lines.setElement(0, 2, JSON.stringify(context, null, 2))
+      this.logs.push(lines.toString())
+    }
+    return ((config || {}).parenthesized ? "(" + generated + ")" : generated)
   }
 }
 

package/src/project.js

@@ -45,7 +45,6 @@ const project = (object, filter) => {
           if (properties.property) {
             const property = properties.property
             if (properties.isPropertyList) {
-              debugger
               if (!Array.isArray(object[property])) {
                 return projection
               }