From 6bb023b5310685be5c3eb89fe49fe6df05feae1f Mon Sep 17 00:00:00 2001
From: Wendell Piez <wendell.piez@nist.gov>
Date: Tue, 14 Jul 2020 17:21:04 -0400
Subject: [PATCH] Implementing shell logic for producing standalone converter
 XSLTs from metaschema source. Many bug repairs and extensions. #53.

---
 .../MAKE-JSON-TO-XML-CONVERTER.xsl            | 128 -----
 .../MAKE-XML-TO-JSON-CONVERTER.xsl            |  61 ---
 .../markdown-to-supermodel-xml-converter.xsl  |   8 +-
 .../converter-gen/produce-json-converter.xsl  |  14 +-
 .../converter-gen/produce-xml-converter.xsl   |  40 +-
 .../converter-gen/supermodel-to-json.xsl      | 235 +++++++--
 .../converter-gen/supermodel-to-xml.xsl       |  18 +-
 .../xslt-M4/make-metaschema-converters.xpl    | 129 +++++
 ...make-metaschema-xml-to-supermodel-xslt.xpl |   2 +
 ...-metaschema-MAKE-JSON-TO-XML-CONVERTER.xsl | 202 ++++++++
 ...-metaschema-MAKE-XML-TO-JSON-CONVERTER.xsl | 182 +++++++
 .../xslt-M4/testing/test-xml-conversions.xpl  |   9 +-
 .../testing/test-xml-json-roundtrip.xpl       |  21 +-
 .../xslt-M4/testing/testdata-supermodel.xml   | 459 ++++++------------
 14 files changed, 937 insertions(+), 571 deletions(-)
 delete mode 100644 toolchains/xslt-M4/converter-gen/MAKE-JSON-TO-XML-CONVERTER.xsl
 delete mode 100644 toolchains/xslt-M4/converter-gen/MAKE-XML-TO-JSON-CONVERTER.xsl
 create mode 100644 toolchains/xslt-M4/make-metaschema-converters.xpl
 create mode 100644 toolchains/xslt-M4/nist-metaschema-MAKE-JSON-TO-XML-CONVERTER.xsl
 create mode 100644 toolchains/xslt-M4/nist-metaschema-MAKE-XML-TO-JSON-CONVERTER.xsl

diff --git a/toolchains/xslt-M4/converter-gen/MAKE-JSON-TO-XML-CONVERTER.xsl b/toolchains/xslt-M4/converter-gen/MAKE-JSON-TO-XML-CONVERTER.xsl
deleted file mode 100644
index c953f695d..000000000
--- a/toolchains/xslt-M4/converter-gen/MAKE-JSON-TO-XML-CONVERTER.xsl
+++ /dev/null
@@ -1,128 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-  xmlns:xs="http://www.w3.org/2001/XMLSchema"
-  xmlns:nm="http://csrc.nist.gov/ns/metaschema"
-  
-  xmlns:XSLT="http://csrc.nist.gov/ns/oscal/metaschema/xslt-alias"
-    exclude-result-prefixes="#all"
-    version="3.0">
-
-
-    <xsl:output indent="yes"/>
-
-  <xsl:namespace-alias stylesheet-prefix="XSLT" result-prefix="xsl"/>
-<!-- 
-    From a metaschema
-    Produces a single XSLT with simple interfaces
-      named shortname=json-to-xml-converter.xsl
-      -it initial-template 'from-json' or 'from-xdm-json-xml'
-      -'file' parameter indicates file name f source data
-      -produce=xml is default
-      -produce=supermodel produces supermodel (intermediate)
-
-    stylesheet sequence
-    
-    source: metaschema
-      pipeline through external calls to
-        compose
-        produce definition map
-        produce JSON converter
-      result is JSON converter: stitch that into a result XSLT
-        i:'from-json'
-          JSON parsing 'file'
-        i:'from=xdm-json-xml'
-          reading XML source directly
-        JSON converter +
-        post-process supermodel results with XML serializer code
-      
-      output XSLT performs a three step:
-        convert (or read) JSON in
-        convert to supermodel
-        convert to XML
-    -->
-  
-  <xsl:output method="xml" indent="yes"/>
-  
-  <!-- Turning $trace to 'on' will
-         - emit runtime messages with each transformation, and
-         - retain nm:ERROR and nm:WARNING messages in results. -->
-  
-  <xsl:mode name="package-converter" on-no-match="shallow-copy"/>
-  
-  <xsl:param name="trace" as="xs:string">off</xsl:param>
-  <xsl:variable name="louder" select="$trace = 'on'"/>
-  
-  <xsl:variable name="xslt-base" select="document('')/document-uri()"/>
-  
-  <xsl:import href="../lib/metaschema-metaprocess.xsl"/>
-  
-  <!-- The $transformation-sequence declares transformations to be applied in order. -->
-  <xsl:variable name="produce-json-converter">
-    <!-- first compose the metaschema -->
-    <nm:transform version="3.0">../compose/metaschema-collect.xsl</nm:transform>
-    <nm:transform version="3.0">../compose/metaschema-reduce1.xsl</nm:transform>
-    <nm:transform version="3.0">../compose/metaschema-reduce2.xsl</nm:transform>
-    <nm:transform version="3.0">../compose/metaschema-digest.xsl</nm:transform>
-    
-    <!-- next produce definition map -->
-    <nm:transform version="3.0">../compose/make-model-map.xsl</nm:transform>
-    <nm:transform version="3.0">../compose/unfold-model-map.xsl</nm:transform>
-    <nm:transform version="3.0">../compose/reduce-map.xsl</nm:transform>
-    
-    <nm:transform version="3.0">produce-json-converter.xsl</nm:transform>
-    <!--<nm:transform version="3.0">package-json-converter.xsl</nm:transform>-->
-  </xsl:variable>
-  
-  <xsl:template match="/">
-    <xsl:variable name="json-converter">
-      <xsl:call-template name="nm:process-pipeline">
-        <xsl:with-param name="sequence" select="$produce-json-converter"/>
-      </xsl:call-template>
-    </xsl:variable>
-    <xsl:apply-templates select="$json-converter" mode="package-converter"/>
-  </xsl:template>
-  
-  <xsl:template match="xsl:stylesheet | xsl:transform" mode="package-converter">
-    <xsl:copy>
-      <xsl:copy-of select="@*"/>
-      <xsl:text>&#xA;</xsl:text>
-      <xsl:copy-of select="$transformation-architecture"/>
-      <xsl:text>&#xA;</xsl:text>
-      <xsl:apply-templates mode="#current"/>
-    </xsl:copy>
-  </xsl:template>
- 
- 
-  <xsl:variable name="transformation-architecture">
-    <xsl:text>&#xA;</xsl:text>
-    <xsl:comment> Processing architecture </xsl:comment>
-    <XSLT:param name="file" as="xs:string"/>
-    <XSLT:param name="produce" as="xs:string">xml</XSLT:param><!-- set to 'supermodel' to produce supermodel intermediate -->
-    
-    <XSLT:template name="from-json">
-      <XSLT:if test="not(unparsed-text-available($file))">
-        <nm:ERROR>No file found at { $file }</nm:ERROR>
-      </XSLT:if>
-    </XSLT:template>
-    
-    <XSLT:template match="/" name="from-xdm-json-xml">
-      <!-- Take source to be JSON in XPath 3.1 (XDM) representation -->
-      <XSLT:param name="source" select="/"/>
-      <XSLT:variable name="converted-rawmd">
-        <XSLT:apply-templates select="$source"/>
-      </XSLT:variable>
-      <XSLT:variable name="supermodel">
-        <XSLT:apply-templates select="$converted-rawmd" mode="convert-markdown"/>
-      </XSLT:variable>
-      <XSLT:choose>
-        <XSLT:when test="$produce = 'supermodel'">
-          <XSLT:sequence select="$supermodel"/>
-        </XSLT:when>
-        <XSLT:otherwise>
-          <XSLT:apply-templates select="$supermodel" mode="make-xml"/>
-        </XSLT:otherwise>
-      </XSLT:choose>   
-    </XSLT:template>
-  </xsl:variable>
-  
-</xsl:stylesheet>
\ No newline at end of file
diff --git a/toolchains/xslt-M4/converter-gen/MAKE-XML-TO-JSON-CONVERTER.xsl b/toolchains/xslt-M4/converter-gen/MAKE-XML-TO-JSON-CONVERTER.xsl
deleted file mode 100644
index 9cb382c21..000000000
--- a/toolchains/xslt-M4/converter-gen/MAKE-XML-TO-JSON-CONVERTER.xsl
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-  xmlns:xs="http://www.w3.org/2001/XMLSchema"
-  xmlns:nm="http://csrc.nist.gov/ns/metaschema"
-  exclude-result-prefixes="#all"
-  version="3.0">
-  
-  <xsl:output indent="yes"/>
-  
-    <xsl:output indent="yes"/>
-
-<!-- 
-    From a metaschema
-    Produces a single XSLT with simple interfaces
-      named shortname=xml-to-json-converter.xsl
-      -source - XML to be converted to JSON
-      produce='json' (default) emit serialized JSON
-      produce='supermodel' emit supermodel notation
-      produce='xdm-json-xml' emit XPath XML notation JSON
-    
-      
-    stylesheet sequence
-    
-    source: metaschema
-      pipeline through external calls to
-        compose
-        produce definition map
-        produce XML converter
-      result is XML converter: stitch that into a result XSLT
-        XML converter + supermodel JSON serializer
-          producing optional intermediate results
-      
-    -->
-  
-  
-  <xsl:output method="xml" indent="yes"/>
-  
-  <!-- Turning $trace to 'on' will
-         - emit runtime messages with each transformation, and
-         - retain nm:ERROR and nm:WARNING messages in results. -->
-  
-  <xsl:param name="trace" as="xs:string">off</xsl:param>
-  <xsl:variable name="louder" select="$trace = 'on'"/>
-  
-  <xsl:variable name="xslt-base" select="document('')/document-uri()"/>
-  
-  <xsl:import href="../lib/metaschema-metaprocess.xsl"/>
-  
-  <!-- The $transformation-sequence declares transformations to be applied in order. -->
-  <xsl:variable name="transformation-sequence">
-    <nm:transform version="3.0">../compose/metaschema-collect.xsl</nm:transform>
-    <nm:transform version="3.0">../compose/metaschema-reduce1.xsl</nm:transform>
-    <nm:transform version="3.0">../compose/metaschema-reduce2.xsl</nm:transform>
-    <nm:transform version="3.0">../compose/metaschema-digest.xsl</nm:transform>
-    <!-- composed metaschema -->
-    
-    <!-- definition map -->
-    <!--<nm:transform version="3.0">produce-xml-converter.xsl</nm:transform>-->
-    <!--<nm:transform version="3.0">package-xml-converter.xsl</nm:transform>-->
-  </xsl:variable>
-</xsl:stylesheet>
\ No newline at end of file
diff --git a/toolchains/xslt-M4/converter-gen/markdown-to-supermodel-xml-converter.xsl b/toolchains/xslt-M4/converter-gen/markdown-to-supermodel-xml-converter.xsl
index 5c1a922a0..8b106c1dd 100644
--- a/toolchains/xslt-M4/converter-gen/markdown-to-supermodel-xml-converter.xsl
+++ b/toolchains/xslt-M4/converter-gen/markdown-to-supermodel-xml-converter.xsl
@@ -13,15 +13,15 @@
     <xsl:mode on-no-match="shallow-copy"/>
     
     <xsl:template match="value[@as-type=('markup-line','markup-multiline')]">
-        <xsl:call-template name="parse">
+        <xsl:call-template name="parse-markdown">
             <xsl:with-param name="markdown-str" select="string(.)"/>
         </xsl:call-template>
     </xsl:template>
     
-    <xsl:template name="run-tests" match="/">
+    <xsl:template name="run-tests">
         <!--<xsl:copy-of select="$tag-replacements"/>-->
         <!--<xsl:copy-of select="$examples"/>-->
-        <xsl:call-template name="parse">
+        <xsl:call-template name="parse-markdown">
             <xsl:with-param name="markdown-str" select="string($examples)"/>
         </xsl:call-template>
         <!--<xsl:for-each select="$line-example">
@@ -59,7 +59,7 @@
     (we can ignore quotes as long as our markup has no attributes only elements)
     -->
     
-    <xsl:template name="parse">
+    <xsl:template name="parse-markdown">
         
 <!-- First, group according to ``` delimiters btw codeblocks and not
         within codeblock, escape & and < (only)
diff --git a/toolchains/xslt-M4/converter-gen/produce-json-converter.xsl b/toolchains/xslt-M4/converter-gen/produce-json-converter.xsl
index eeaa4d8a8..03ac00718 100644
--- a/toolchains/xslt-M4/converter-gen/produce-json-converter.xsl
+++ b/toolchains/xslt-M4/converter-gen/produce-json-converter.xsl
@@ -80,8 +80,6 @@
         <xsl:apply-templates select="." mode="make-json-pull"/>
     </xsl:template>
     
-    
-    
     <xsl:template priority="2" match="value" mode="make-json-pull">
         <XSLT:apply-templates select="." mode="get-value-property"/>
     </xsl:template>
@@ -90,8 +88,10 @@
         <XSLT:apply-templates select="*[@key='{@key}']"/>
     </xsl:template>
     
-    
-    
+    <xsl:template match="group/*[empty(@key)]" mode="make-json-pull">
+        <XSLT:apply-templates select="*"/>
+    </xsl:template>
+
     <!-- overriding template in produce-xml-converter that suppresses template
          production for an element not present in the XML: this time we want the field
          (but must also hard-wire the match). -->
@@ -141,7 +141,7 @@
             <xsl:apply-templates select="." mode="make-match"/>
         </xsl:variable>
         <!-- now producing a template to produce a value node representing the value of the field-->
-        <XSLT:template match="{ $matching }" mode="get-value-property">
+        <XSLT:template match="{ $matching }" mode="get-value-property" priority="{count(ancestor-or-self::*)}">
             <value>
                 <xsl:copy-of select="value/(@key | @key-flag | @as-type)"/>
                 <xsl:apply-templates select="value/@as-type" mode="assign-json-type"/>
@@ -160,8 +160,8 @@
         <xsl:variable name="matching">
             <xsl:apply-templates select="." mode="make-match"/>
         </xsl:variable>
-        <XSLT:template match="{ $matching}" mode="keep-value-property">
-            <xsl:comment> Property is a flag; dropped when grabbing values</xsl:comment>
+        <XSLT:template match="{ $matching}" mode="keep-value-property" priority="{count(ancestor-or-self::*)}">
+            <xsl:comment> Not keeping the flag here. </xsl:comment>
         </XSLT:template>
     </xsl:template>
     
diff --git a/toolchains/xslt-M4/converter-gen/produce-xml-converter.xsl b/toolchains/xslt-M4/converter-gen/produce-xml-converter.xsl
index ac4c4cddd..bc31c2f53 100644
--- a/toolchains/xslt-M4/converter-gen/produce-xml-converter.xsl
+++ b/toolchains/xslt-M4/converter-gen/produce-xml-converter.xsl
@@ -1,12 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
     xmlns:xs="http://www.w3.org/2001/XMLSchema"
-    xmlns:math="http://www.w3.org/2005/xpath-functions/math"
     xmlns:m="http://csrc.nist.gov/ns/oscal/metaschema/1.0"
     xmlns:XSLT="http://csrc.nist.gov/ns/oscal/metaschema/xslt-alias"
     
     xpath-default-namespace="http://csrc.nist.gov/ns/oscal/metaschema/1.0"
-    exclude-result-prefixes="xs math"
     version="3.0"
     xmlns="http://csrc.nist.gov/ns/oscal/metaschema/1.0/supermodel">
     
@@ -54,8 +52,9 @@
                 <!-\-<XSLT:output-character character="&#xE0000;" string="\"/>-\->
             </XSLT:character-map>-->
 
-            <!-- first we produce templates for (each) of the global definitions.-->
-            <xsl:for-each-group select="//*[@scope = 'global'][not(@recursive='true')]"
+            <!-- first we produce templates for (each) of the global definitions
+                 and for any flags thereon.-->
+            <xsl:for-each-group select="//*[@scope = 'global'][not(@recursive='true')]/( . | child::flag )"
                 group-by="string-join((local-name(), @name), ':')">
                 <!-- These are all the same so we do only one, but we pass in the group to construct the match -->
                 <xsl:apply-templates select="current-group()[1]" mode="make-template">
@@ -110,12 +109,12 @@
         </xsl:if>
     </xsl:template>
     
-    <xsl:template match="*[@scope='global']" mode="make-template-for-local"/>
+    <xsl:template match="*[@scope='global']"      mode="make-template-for-local"/>
+    
+    <xsl:template priority="1" match="*[@scope='global']/flag" mode="make-template-for-local"/>
     
     <xsl:template match="*" mode="make-template-for-local">
-        <xsl:apply-templates select="." mode="make-template">
-            <xsl:with-param name="local" select="true()"/>
-        </xsl:apply-templates>
+        <xsl:apply-templates select="." mode="make-template"/>
     </xsl:template>
  
     <!-- no template for implicit wrappers on markup-multiline -->
@@ -129,7 +128,7 @@
         <xsl:variable name="json-key-flag-name" select="@json-key-flag"/>
         <XSLT:template match="{ $matching}">
             <xsl:if test="not(@scope='global')">
-                <xsl:attribute name="priority" select="10"/>
+                <xsl:attribute name="priority" select="count(ancestor-or-self::*)"/>
             </xsl:if>
             <!-- A parameter allows the call to drop the key, necessary for recursive
                 groups of elements also allowed at the root (at least) -->
@@ -163,7 +162,9 @@
             <xsl:apply-templates select="." mode="make-match"/>
         </xsl:variable>
         <XSLT:template match="{ $matching}">
-            <xsl:call-template name="comment-template"/>
+            <xsl:if test="not((.|..)/@scope='global')">
+                <xsl:attribute name="priority" select="count(ancestor-or-self::*)"/>
+            </xsl:if><xsl:call-template name="comment-template"/>
             <flag in-json="string">
                 <xsl:copy-of select="@* except @scope"/>
                 <!-- rewriting in-json where necessary -->
@@ -204,10 +205,13 @@
     
     <!-- Matches local declarations (only) -->
     <xsl:template match="*" mode="make-xml-match">
-        <xsl:for-each select="ancestor-or-self::*[@gi] except ancestor-or-self::*[@scope='global']/ancestor::*">
-            <xsl:if test="position() gt 1">/</xsl:if>
-            <xsl:apply-templates select="." mode="make-xml-step"/>
-        </xsl:for-each>
+        <xsl:value-of>
+            <xsl:for-each
+                select="ancestor-or-self::*[@gi]">
+                <xsl:if test="position() gt 1">/</xsl:if>
+                <xsl:apply-templates select="." mode="make-xml-step"/>
+            </xsl:for-each>
+        </xsl:value-of>
     </xsl:template>
 
     <!-- fallback should never match -->
@@ -217,6 +221,14 @@
         </pull>
     </xsl:template>
     
+    <xsl:template match="choice" mode="make-xml-pull make-json-pull">
+        <xsl:apply-templates mode="#current"/>
+    </xsl:template>
+    
+    <xsl:template match="constraint" mode="make-xml-pull make-json-pull">
+       <!--    <xsl:copy-of select="."/>-->
+    </xsl:template>
+    
     <xsl:variable name="prose-elements">p | ul | ol | pre | h1 | h2 | h3 | h4 | h5 | h6 | table</xsl:variable>
     
     <!-- A field without a GI is implicit in the XML; Metaschema prevents it from having flags -->
diff --git a/toolchains/xslt-M4/converter-gen/supermodel-to-json.xsl b/toolchains/xslt-M4/converter-gen/supermodel-to-json.xsl
index e5ed5c542..863424e73 100644
--- a/toolchains/xslt-M4/converter-gen/supermodel-to-json.xsl
+++ b/toolchains/xslt-M4/converter-gen/supermodel-to-json.xsl
@@ -5,6 +5,7 @@
     xpath-default-namespace="http://csrc.nist.gov/ns/oscal/metaschema/1.0/supermodel"
     xmlns="http://www.w3.org/2005/xpath-functions"
     exclude-result-prefixes="xs math"
+    default-mode="write-json"
     version="3.0">
     
 <!-- XXX TO DO XXX
@@ -16,36 +17,36 @@
     -->
     
     <xsl:output indent="true"/>
-    <xsl:strip-space elements="*"/>
-    <xsl:preserve-space elements="flag value"/>
+    
+    <xsl:strip-space elements="model assembly"/>
     
     <xsl:variable name="ns" select="/*/@namespace"/>
     
     <!--group assembly field flag value-->
     
-    <xsl:template match="group">
+    <xsl:template match="group" mode="write-json">
         <array>
             <xsl:copy-of select="@key"/>
-            <xsl:apply-templates/>
+            <xsl:apply-templates mode="#current"/>
         </array>
     </xsl:template>
     
-    <xsl:template match="group[@in-json='BY_KEY']">
+    <xsl:template match="group[@in-json='BY_KEY']" mode="write-json">
         <map>
             <xsl:copy-of select="@key"/>
-            <xsl:apply-templates/>
+            <xsl:apply-templates mode="#current"/>
         </map>
     </xsl:template>
     
-    <xsl:template match="flag[@key=../@json-key-flag]"/>
+    <xsl:template match="flag[@key=../@json-key-flag]" mode="write-json"/>
     
-    <xsl:template match="group[@in-json='SINGLETON_OR_ARRAY'][count(*)=1]">
-        <xsl:apply-templates>
+    <xsl:template match="group[@in-json='SINGLETON_OR_ARRAY'][count(*)=1]" mode="write-json">
+        <xsl:apply-templates mode="write-json">
             <xsl:with-param name="group-key" select="@key"/>
         </xsl:apply-templates>
     </xsl:template>
     
-    <xsl:template priority="2" match="group/assembly | group/field">
+    <xsl:template priority="2" match="group/assembly | group/field" mode="write-json">
         <!-- $group-key is only provided when group/@in-json="SINGLETON_OR_ASSEMBLY" and there is one member of the group -->
         <xsl:param name="group-key" select="()"/>
         <!--@json-key-flag is only available when group/@in-json="BY_KEY"-->
@@ -56,40 +57,40 @@
             <xsl:for-each select="flag[@key=$json-key-flag-name]">
                 <xsl:attribute name="key" select="."/>
             </xsl:for-each>
-            <xsl:apply-templates/>
+            <xsl:apply-templates mode="#current"/>
         </map>
     </xsl:template>
     
-    <xsl:template priority="3" match="group/field[@in-json='SCALAR']">
+    <xsl:template priority="3" match="group/field[@in-json='SCALAR']" mode="write-json">
         <xsl:param name="group-key" select="()"/>
         <xsl:variable name="json-key-flag-name" select="@json-key-flag"/>
         <!-- with no flags, this field has only its value -->
-        <xsl:apply-templates>
+        <xsl:apply-templates mode="write-json">
             <xsl:with-param name="use-key" select="flag[@key = $json-key-flag-name]"/>
         </xsl:apply-templates>
     </xsl:template>
     
     <!-- Extra object wrapper at the top   -->
-    <xsl:template match="/assembly">
+    <xsl:template match="/assembly" mode="write-json">
         <map>
             <xsl:next-match/>
         </map>
     </xsl:template>
     
-    <xsl:template match="assembly">
+    <xsl:template match="assembly" mode="write-json">
         <map key="{@key}">
-            <xsl:apply-templates/>
+            <xsl:apply-templates mode="#current"/>
         </map>
     </xsl:template>
     
-    <xsl:template match="field">
+    <xsl:template match="field" mode="write-json">
         <map key="{@key}">
-            <xsl:apply-templates/>
+            <xsl:apply-templates mode="#current"/>
         </map>
     </xsl:template>
     
-    <xsl:template match="field[@in-json='SCALAR']">
-        <xsl:apply-templates/>
+    <xsl:template match="field[@in-json='SCALAR']" mode="write-json">
+        <xsl:apply-templates mode="#current"/>
         <!--
         <!-\- when there are no flags, the field is a string whose value is the value -\->
         <string>
@@ -98,13 +99,13 @@
         </string> -->
     </xsl:template>
     
-    <xsl:template match="flag[@key=../value/@key-flag]"/>
+    <xsl:template match="flag[@key=../value/@key-flag]" mode="write-json"/>
     
-    <xsl:template match="flag">
+    <xsl:template match="flag" mode="write-json">
         <xsl:element name="{(@in-json[matches(.,'\S')],'string')[1]}"
             namespace="http://www.w3.org/2005/xpath-functions">
             <xsl:copy-of select="@key"/>
-            <xsl:apply-templates/>
+            <xsl:apply-templates mode="#current"/>
         </xsl:element>
     </xsl:template>
     
@@ -115,34 +116,206 @@
             otherwise if the field is a scalar, its key is used, with no key if it has none
             otherwise the nominated key is used --> 
     
-    <xsl:template priority="2" match="field[exists(@json-key-flag)]/value">
+    <xsl:template priority="2" match="field[exists(@json-key-flag)]/value" mode="write-json">
         <xsl:variable name="key-flag-name" select="../@json-key-flag"/>
         <xsl:element name="{@in-json}" namespace="http://www.w3.org/2005/xpath-functions">
             <xsl:attribute name="key" select="../flag[@key = $key-flag-name]"/>
-            <xsl:apply-templates/>
+            <xsl:apply-templates mode="#current"/>
         </xsl:element>
     </xsl:template>
     
-    <xsl:template match="field[@in-json='SCALAR'][empty(@key)]/value">
+    <xsl:template match="field[@in-json='SCALAR'][empty(@key)]/value" mode="write-json">
         <!-- A value given on a scalar field with no key gets no key either -->
         <xsl:element name="{@in-json}" namespace="http://www.w3.org/2005/xpath-functions">
-            <xsl:apply-templates/>
+            <xsl:apply-templates mode="#current"/>
         </xsl:element>
     </xsl:template>
     
-    <xsl:template match="value">
+    <xsl:template match="value" mode="write-json">
         <xsl:variable name="key-flag-name" select="@key-flag"/>
         <xsl:element name="{(@in-json[matches(.,'\S')],'string')[1]}"
             namespace="http://www.w3.org/2005/xpath-functions">
             <xsl:attribute name="key"
                 select="(../flag[@key=$key-flag-name],parent::field[@in-json = 'SCALAR']/@key, @key)[1]"/>
-            <xsl:apply-templates/>
+            <xsl:apply-templates select="." mode="cast-data"/>
         </xsl:element>
     </xsl:template>
     
-    <xsl:template match="p | ul | ol | pre | h1 | h2 | h3 | h4 | h5 | h6 | table">
-        <xsl:apply-templates select="." mode="make-markdown"/>
+    <xsl:template match="*" mode="cast-data">
+        <xsl:value-of select="."/>
+    </xsl:template>
+    
+    <xsl:template match="value[@as-type='markup-line']" mode="cast-data">
+        <xsl:apply-templates mode="md"/>
+    </xsl:template>
+    
+    <xsl:template match="value[@as-type='markup-multiline']" mode="cast-data">
+        <xsl:variable name="lines" as="element(string)*" xpath-default-namespace="http://www.w3.org/2005/xpath-functions">
+            <xsl:apply-templates select="*" mode="md"/>
+        </xsl:variable>
+        <xsl:value-of select="$lines" separator="&#xA;"/>
+    </xsl:template>
+    
+    <xsl:template name="conditional-lf">
+        <xsl:variable name="predecessor"
+            select="preceding-sibling::p | preceding-sibling::ul | preceding-sibling::ol | preceding-sibling::table | preceding-sibling::pre"/>
+        <xsl:if test="exists($predecessor)">
+            <string/>
+        </xsl:if>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="text()">
+        <!-- Escapes go here       -->
+        <!-- prefixes ` ~ ^ * with char E0000 from Unicode PUA -->
+        <!--<xsl:value-of select="replace(., '([`~\^\*''&quot;])', '&#xE0000;$1')"/>-->
+        <!-- prefixes ` ~ ^ * ' " with reverse solidus -->
+        <xsl:value-of select="replace(., '([`~\^\*&quot;])', '\\$1')"/>
+        <!--<xsl:value-of select="."/>-->
     </xsl:template>
     
     
+    <xsl:template mode="md" match="p">
+        <xsl:call-template name="conditional-lf"/>
+        <string>
+            <xsl:apply-templates mode="md"/>
+        </string>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="h1 | h2 | h3 | h4 | h5 | h6">
+        <xsl:call-template name="conditional-lf"/>
+        <string>
+            <xsl:apply-templates select="." mode="mark"/>
+            <xsl:apply-templates mode="md"/>
+        </string>
+    </xsl:template>
+    
+    <xsl:template mode="mark" match="h1"># </xsl:template>
+    <xsl:template mode="mark" match="h2">## </xsl:template>
+    <xsl:template mode="mark" match="h3">### </xsl:template>
+    <xsl:template mode="mark" match="h4">#### </xsl:template>
+    <xsl:template mode="mark" match="h5">##### </xsl:template>
+    <xsl:template mode="mark" match="h6">###### </xsl:template>
+    
+    <xsl:template mode="md" match="table">
+        <xsl:call-template name="conditional-lf"/>
+        <xsl:apply-templates select="*" mode="md"/>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="tr">
+        <string>
+            <xsl:apply-templates select="*" mode="md"/>
+        </string>
+        <xsl:if test="empty(preceding-sibling::tr)">
+            <string>
+                <xsl:text>|</xsl:text>
+                <xsl:for-each select="th | td">
+                    <xsl:text> --- |</xsl:text>
+                </xsl:for-each>
+            </string>
+        </xsl:if>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="th | td">
+        <xsl:if test="empty(preceding-sibling::*)">|</xsl:if>
+        <xsl:text> </xsl:text>
+        <xsl:apply-templates mode="md"/>
+        <xsl:text> |</xsl:text>
+    </xsl:template>
+    
+    <xsl:template mode="md" priority="1" match="pre">
+        <xsl:call-template name="conditional-lf"/>
+        <string>```</string>
+        <string>
+            <xsl:apply-templates mode="md"/>
+        </string>
+        <string>```</string>
+    </xsl:template>
+    
+    <xsl:template mode="md" priority="1" match="ul | ol">
+        <xsl:call-template name="conditional-lf"/>
+        <xsl:apply-templates mode="md"/>
+        <string/>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="ul//ul | ol//ol | ol//ul | ul//ol">
+        <xsl:apply-templates mode="md"/>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="li">
+        <string>
+            <xsl:for-each select="../ancestor::ul">
+                <xsl:text>&#32;&#32;</xsl:text>
+            </xsl:for-each>
+            <xsl:text>* </xsl:text>
+            <xsl:apply-templates mode="md"/>
+        </string>
+    </xsl:template>
+    <!-- Since XProc doesn't support character maps we do this in XSLT -   -->
+    
+    <xsl:template mode="md" match="ol/li">
+        <string/>
+        <string>
+            <xsl:for-each select="../ancestor::ul">
+                <xsl:text xml:space="preserve">&#32;&#32;</xsl:text>
+            </xsl:for-each>
+            <xsl:text>1. </xsl:text>
+            <xsl:apply-templates mode="md"/>
+        </string>
+    </xsl:template>
+    <!-- Since XProc doesn't support character maps we do this in XSLT -   -->
+    
+    <xsl:template mode="md" match="code | span[contains(@class, 'code')]">
+        <xsl:text>`</xsl:text>
+        <xsl:apply-templates mode="md"/>
+        <xsl:text>`</xsl:text>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="em | i">
+        <xsl:text>*</xsl:text>
+        <xsl:apply-templates mode="md"/>
+        <xsl:text>*</xsl:text>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="strong | b">
+        <xsl:text>**</xsl:text>
+        <xsl:apply-templates mode="md"/>
+        <xsl:text>**</xsl:text>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="q">
+        <xsl:text>"</xsl:text>
+        <xsl:apply-templates mode="md"/>
+        <xsl:text>"</xsl:text>
+    </xsl:template>
+    
+    <!-- <insert param-id="ac-1_prm_1"/> -->
+    <xsl:template mode="md" match="insert">
+        <xsl:text>{{ </xsl:text>
+        <xsl:value-of select="@param-id"/>
+        <xsl:text> }}</xsl:text>
+    </xsl:template>
+    
+    <xsl:template mode="md" match="a">
+        <xsl:text>[</xsl:text>
+        <xsl:value-of select="."/>
+        <xsl:text>]</xsl:text>
+        <xsl:text>(</xsl:text>
+        <xsl:value-of select="@href"/>
+        <xsl:text>)</xsl:text>
+    </xsl:template>
+    <!--![alt](src.jpg "title")-->
+    
+    <xsl:template mode="md" match="img">
+        <xsl:text>![</xsl:text>
+        <xsl:value-of select="(@alt,@src)[1]"/>
+        <xsl:text>]</xsl:text>
+        <xsl:text>(</xsl:text>
+        <xsl:value-of select="@src"/>
+        <xsl:for-each select="@title">
+            <xsl:text expand-text="true"> "{.}"</xsl:text>
+        </xsl:for-each>
+        <xsl:text>)</xsl:text>
+    </xsl:template>
+    
+        
 </xsl:stylesheet>
\ No newline at end of file
diff --git a/toolchains/xslt-M4/converter-gen/supermodel-to-xml.xsl b/toolchains/xslt-M4/converter-gen/supermodel-to-xml.xsl
index d9f8db662..33687e29b 100644
--- a/toolchains/xslt-M4/converter-gen/supermodel-to-xml.xsl
+++ b/toolchains/xslt-M4/converter-gen/supermodel-to-xml.xsl
@@ -1,26 +1,24 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
     xmlns:xs="http://www.w3.org/2001/XMLSchema"
-    xmlns:math="http://www.w3.org/2005/xpath-functions/math"
     xmlns:s="http://csrc.nist.gov/ns/oscal/metaschema/1.0/supermodel"
-    exclude-result-prefixes="xs math"
-    default-mode="make-xml"
+    default-mode="write-xml"
     version="3.0">
     
     <xsl:output indent="true"/>
-    <xsl:strip-space elements="*"/>
-    <xsl:preserve-space elements="flag value"/>
+    <xsl:strip-space elements="s:*"/>
+    <xsl:preserve-space elements="s:flag s:value"/>
     
-    <xsl:mode name="make-xml"/>
+    <xsl:mode name="write-xml"/>
     
-    <xsl:template match="s:*[exists(@gi)]" mode="make-xml">
+    <xsl:template match="s:*[exists(@gi)]" mode="write-xml">
         <xsl:element name="{@gi}" namespace="{ /*/@namespace }">
             <!-- putting flags first in case of disarranged inputs -->
-            <xsl:apply-templates select="s:flag, (* except s:flag)" mode="make-xml"/>
+            <xsl:apply-templates select="s:flag, (* except s:flag)" mode="write-xml"/>
         </xsl:element>
     </xsl:template>
     
-    <xsl:template match="s:value[@as-type=('markup-line','markup-multiline')]" mode="make-xml">
+    <xsl:template match="s:value[@as-type=('markup-line','markup-multiline')]" mode="write-xml">
         <xsl:apply-templates mode="cast-prose"/>
     </xsl:template>
     
@@ -28,7 +26,7 @@
         <xsl:apply-templates select="." mode="cast-prose"/>
     </xsl:template>
     
-    <xsl:template priority="2" match="s:flag" mode="make-xml">
+    <xsl:template priority="2" match="s:flag" mode="write-xml">
         <xsl:attribute name="{@gi}">
             <xsl:value-of select="."/>
         </xsl:attribute>
diff --git a/toolchains/xslt-M4/make-metaschema-converters.xpl b/toolchains/xslt-M4/make-metaschema-converters.xpl
new file mode 100644
index 000000000..1d71cf781
--- /dev/null
+++ b/toolchains/xslt-M4/make-metaschema-converters.xpl
@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<p:declare-step xmlns:p="http://www.w3.org/ns/xproc"
+  xmlns:c="http://www.w3.org/ns/xproc-step" version="1.0"
+  xmlns:metaschema="http://csrc.nist.gov/ns/metaschema/1.0"
+  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  type="metaschema:make-xml-map" name="make-xml-map">
+  
+  <!-- &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& -->
+  <!-- Ports -->
+  
+  <p:input port="source" primary="true"/>
+  <p:input port="parameters" kind="parameter"/>
+  
+  <p:serialization port="a.echo-input" indent="true"/>
+  <p:output        port="a.echo-input" primary="false">
+    <p:pipe        port="result"       step="input"/>
+  </p:output>
+  
+  <p:serialization port="b.composed" indent="true"/>
+  <p:output        port="b.composed" primary="false">
+    <p:pipe        port="result"     step="composed"/>
+  </p:output>
+  
+  <p:serialization port="c.abstract-model-map" indent="true"/>
+  <p:output        port="c.abstract-model-map" primary="false">
+    <p:pipe        port="result"               step="make-model-map"/>
+  </p:output>
+  
+  <p:serialization port="d.unfolded-model-map" indent="true"/>
+  <p:output        port="d.unfolded-model-map" primary="false">
+    <p:pipe        port="result"               step="unfold-model-map"/>
+  </p:output>
+  
+  <p:serialization port="E.definition-map" indent="true"/>
+  <p:output        port="E.definition-map" primary="false">
+    <p:pipe        port="result"        step="definition-map"/>
+  </p:output>
+  
+  <p:serialization port="X1.xml-element-tree" indent="true"/>
+  <p:output        port="X1.xml-element-tree" primary="false">
+    <p:pipe        port="result"              step="make-xml-element-tree"/>
+  </p:output>
+  
+  <p:serialization port="X2.xml-model-html" indent="false" method="xml" omit-xml-declaration="false"/>
+  <p:output        port="X2.xml-model-html" primary="false">
+    <p:pipe        port="result"            step="render-xml-model-map"/>
+  </p:output>
+  
+  <p:serialization port="J1.json-object-tree" indent="true"/>
+  <p:output        port="J1.json-object-tree" primary="false">
+    <p:pipe        port="result"              step="make-json-object-tree"/>
+  </p:output>
+  
+  <p:serialization port="J2.json-model-html" indent="false" method="xml" omit-xml-declaration="false"/>
+  <p:output        port="J2.json-model-html" primary="false">
+    <p:pipe        port="result"             step="render-json-model-map"/>
+  </p:output>
+  
+  <!-- &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& -->
+  <!-- Import (subpipeline) -->
+  
+  <p:import href="metaschema-compose.xpl"/>
+  
+  <!-- &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& -->
+  <!-- Pipeline -->
+  
+  <p:identity name="input"/>
+  
+  <metaschema:metaschema-compose name="compose"/>
+  
+  <p:identity name="composed"/>
+  
+  <!--<p:identity  name="render-xml-model-map"/>-->
+  <p:xslt name="make-model-map">
+    <p:input port="source">
+      <p:pipe port="result" step="composed"/>
+    </p:input>
+    <p:input port="stylesheet">
+      <p:document href="compose/make-model-map.xsl"/>
+    </p:input>
+  </p:xslt>
+  
+  <p:xslt name="unfold-model-map">
+    <p:input port="stylesheet">
+      <p:document href="compose/unfold-model-map.xsl"/>
+    </p:input>
+  </p:xslt>
+  
+  <p:xslt name="definition-map">
+    <p:input port="source">
+      <p:pipe port="result" step="unfold-model-map"/>
+    </p:input>
+    <p:input port="stylesheet">
+      <p:document href="compose/reduce-map.xsl"/>
+    </p:input>
+  </p:xslt>
+  
+  <p:sink/>
+  
+  <p:xslt name="make-xml-converter">
+    <p:input port="source">
+      <p:pipe port="result" step="unfold-model-map"/>
+    </p:input>
+    <p:input port="stylesheet">
+      <p:document href="document/xml/element-tree.xsl"/>
+    </p:input>
+  </p:xslt>
+  
+  
+  
+  <p:sink/>
+  
+  <p:xslt name="make-json-object-tree">
+    <p:input port="source">
+      <p:pipe port="result" step="unfold-model-map"/>
+    </p:input>
+    <p:input port="stylesheet">
+      <p:document href="document/json/object-tree.xsl"/>
+    </p:input>
+  </p:xslt>
+  
+  <p:xslt name="render-json-model-map">
+    <p:with-option name="initial-mode" select="QName('','make-page')"/>    
+    <p:input port="stylesheet">
+      <p:document href="document/json/object-map-html.xsl"/>
+    </p:input>
+  </p:xslt>
+
+</p:declare-step>
\ No newline at end of file
diff --git a/toolchains/xslt-M4/make-metaschema-xml-to-supermodel-xslt.xpl b/toolchains/xslt-M4/make-metaschema-xml-to-supermodel-xslt.xpl
index 5477a3ee9..2e01a54aa 100644
--- a/toolchains/xslt-M4/make-metaschema-xml-to-supermodel-xslt.xpl
+++ b/toolchains/xslt-M4/make-metaschema-xml-to-supermodel-xslt.xpl
@@ -78,6 +78,8 @@
     </p:input>
   </p:xslt>
   
+  <!--<p:identity name="make-xml-converter"/>-->
+  
   <p:xslt name="make-xml-converter">
     <p:input port="stylesheet">
       <p:document href="converter-gen/produce-xml-converter.xsl"/>
diff --git a/toolchains/xslt-M4/nist-metaschema-MAKE-JSON-TO-XML-CONVERTER.xsl b/toolchains/xslt-M4/nist-metaschema-MAKE-JSON-TO-XML-CONVERTER.xsl
new file mode 100644
index 000000000..443eaaae9
--- /dev/null
+++ b/toolchains/xslt-M4/nist-metaschema-MAKE-JSON-TO-XML-CONVERTER.xsl
@@ -0,0 +1,202 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  xmlns:nm="http://csrc.nist.gov/ns/metaschema"
+  xmlns="http://csrc.nist.gov/ns/oscal/metaschema/1.0/supermodel"
+  xpath-default-namespace="http://csrc.nist.gov/ns/oscal/metaschema/1.0/supermodel"
+  xmlns:XSLT="http://csrc.nist.gov/ns/oscal/metaschema/xslt-alias"
+  exclude-result-prefixes="#all"
+  version="3.0">
+
+
+    <xsl:output indent="yes"/>
+
+  <xsl:namespace-alias stylesheet-prefix="XSLT" result-prefix="xsl"/>
+<!-- 
+    From a metaschema
+    Produces a single XSLT with simple interfaces
+      named shortname=json-to-xml-converter.xsl
+      -it initial-template 'from-json' or 'from-xdm-json-xml'
+      -'file' parameter indicates file name f source data
+      -produce=xml is default
+      -produce=supermodel produces supermodel (intermediate)
+
+    stylesheet sequence
+    
+    source: metaschema
+      pipeline through external calls to
+        compose
+        produce definition map
+        produce JSON converter
+      result is JSON converter: stitch that into a result XSLT
+        i:'from-json'
+          JSON parsing 'file'
+        i:'from=xdm-json-xml'
+          reading XML source directly
+        JSON converter +
+        post-process supermodel results with XML serializer code
+      
+      output XSLT performs a three step:
+        convert (or read) JSON in
+        convert to supermodel
+        convert to XML
+    -->
+  
+  <xsl:output method="xml" indent="yes"/>
+  
+  <!-- Turning $trace to 'on' will
+         - emit runtime messages with each transformation, and
+         - retain nm:ERROR and nm:WARNING messages in results. -->
+  
+  <xsl:mode name="package-converter" on-no-match="shallow-copy"/>
+  
+  <xsl:param name="trace" as="xs:string">off</xsl:param>
+  <xsl:variable name="louder" select="$trace = 'on'"/>
+  
+  <xsl:variable name="xslt-base" select="document('')/document-uri()"/>
+  
+  <xsl:import href="lib/metaschema-metaprocess.xsl"/>
+  
+  <!-- The $transformation-sequence declares transformations to be applied in order. -->
+  <xsl:variable name="produce-json-converter">
+    <!-- first compose the metaschema -->
+    <nm:transform version="3.0">compose/metaschema-collect.xsl</nm:transform>
+    <nm:transform version="3.0">compose/metaschema-reduce1.xsl</nm:transform>
+    <nm:transform version="3.0">compose/metaschema-reduce2.xsl</nm:transform>
+    <nm:transform version="3.0">compose/metaschema-digest.xsl</nm:transform>
+    
+    <!-- next produce definition map -->
+    <nm:transform version="3.0">compose/make-model-map.xsl</nm:transform>
+    <nm:transform version="3.0">compose/unfold-model-map.xsl</nm:transform>
+    <nm:transform version="3.0">compose/reduce-map.xsl</nm:transform>
+    
+    <nm:transform version="3.0">converter-gen/produce-json-converter.xsl</nm:transform>
+    <!--<nm:transform version="3.0">package-json-converter.xsl</nm:transform>-->
+  </xsl:variable>
+  
+  <xsl:variable name="metaschema-source" select="/"/>
+  
+  <xsl:template match="/">
+    <xsl:variable name="json-converter">
+      <xsl:call-template name="nm:process-pipeline">
+        <xsl:with-param name="sequence" select="$produce-json-converter"/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:apply-templates select="$json-converter" mode="package-converter"/>
+  </xsl:template>
+  
+<!-- 'package-converter' enhances the code produced from the metaschema-json-converter pipeline:
+       adds interfaces for handling json inputs ($transformation-architecture)
+       provides pipeline infrastructure for supermodel production and serialization
+       provides templates from utility filters (Markdown to markup; XML writing)
+  -->
+
+  <!-- nb since by default the json converter passes markdown through, in mode 'package-converter'
+       we also rewrite its templates for producing contents of markup-line and markup-multiline,
+       hitting the 'parse-markdown' template from the markdown processor. -->
+  
+
+  <xsl:template match="xsl:stylesheet | xsl:transform" mode="package-converter">
+    <xsl:copy copy-namespaces="true">
+      <xsl:copy-of select="@*"/>
+      <xsl:text>&#xA;</xsl:text>
+      <xsl:comment> JSON to XML conversion: pipeline </xsl:comment>
+      <xsl:copy-of select="$transformation-architecture"/>
+      
+      <xsl:comment> JSON to XML conversion: object filters </xsl:comment>
+      
+      <xsl:text>&#xA;</xsl:text>
+      <xsl:apply-templates mode="#current"/>
+      
+      <!--  from the mardown to markup converter, we grab all the templates in all the modes;
+           but not unmoded templates (intended for pipeline use) or named templates apart from 'parse'-->
+      <xsl:text>&#xA;</xsl:text>
+      <xsl:comment> JSON to XML conversion: Markdown to markup inferencing </xsl:comment>
+      
+      <xsl:copy-of select="document('markdown-to-supermodel-xml-converter.xsl')/xsl:*/
+        ( xsl:call-template[@name='parse'] | xsl:*[@mode] | xsl:variable[not(matches(@name,'example'))] )"/>
+      
+      
+      <xsl:text>&#xA;</xsl:text>
+      <xsl:comment> JSON to XML conversion: Supermodel serialization as XML </xsl:comment>
+      <xsl:apply-templates mode="package-converter" select="document('supermodel-to-xml.xsl')/xsl:*/( xsl:* except xsl:output )"/>
+    </xsl:copy>
+  </xsl:template>
+ 
+  <xsl:template mode="package-converter"
+    match="xsl:template[value/@as-type=('markup-line','markup-multiline')][@mode='get-value-property']">
+    <xsl:message>boo!</xsl:message>
+    <XSLT:template match="{ @match }" mode="get-value-property">
+      <value as-type="markup-multiline" in-json="string">
+        <XSLT:call-template name="parse-markdown">
+          <XSLT:with-param name="markdown-str" select="string(.)"/>
+        </XSLT:call-template>
+      </value>
+    </XSLT:template>
+  </xsl:template>
+  
+  <xsl:template mode="package-converter"
+    match="xsl:template[@mode=('write-xml','cast-prose')]/xsl:element/@namespace">
+    <xsl:attribute name="namespace" select="$metaschema-source/*/namespace" xpath-default-namespace="http://csrc.nist.gov/ns/oscal/metaschema/1.0"/>
+  </xsl:template>
+  
+  
+  
+ <!--<xsl:template match=""-->
+  <xsl:variable name="transformation-architecture">
+    <xsl:text>&#xA;</xsl:text>
+    <xsl:comment> Processing architecture </xsl:comment>
+    <XSLT:param name="file" as="xs:string"/>
+    <XSLT:param name="produce" as="xs:string">xml</XSLT:param><!-- set to 'supermodel' to produce supermodel intermediate -->
+    
+    <XSLT:template name="from-json">
+      <XSLT:if test="not(unparsed-text-available($file))" expand-text="true">
+        <nm:ERROR>No file found at { $file }</nm:ERROR>
+      </XSLT:if>
+      <XSLT:call-template name="from-xdm-json-xml">
+        <XSLT:with-param name="source">
+          <XSLT:try select="unparsed-text($file) ! json-to-xml(.)" xmlns:err="http://www.w3.org/2005/xqt-errors">
+            <XSLT:catch>
+              <nm:ERROR code="{{ $err:code }}">{{ $err:description }}</nm:ERROR>
+            </XSLT:catch>
+          </XSLT:try>
+        </XSLT:with-param> 
+      </XSLT:call-template>
+    </XSLT:template>
+    
+    <XSLT:template match="/" name="from-xdm-json-xml" expand-text="true">
+      <!-- Take source to be JSON in XPath 3.1 (XDM) representation -->
+      <XSLT:param name="source">
+        <XSLT:choose>
+          <xsl:comment> evaluating { $file } as URI relative to nominal source directory</xsl:comment>
+          <XSLT:when test="exists($file)">
+            <XSLT:try select="$file ! document(.,/)" xmlns:err="http://www.w3.org/2005/xqt-errors">
+              <XSLT:catch>
+                <nm:ERROR code="{{ $err:code }}">{ $err:description }</nm:ERROR>
+              </XSLT:catch>
+            </XSLT:try>    
+          </XSLT:when>
+          <XSLT:otherwise>
+            <XSLT:sequence select="/"/>
+          </XSLT:otherwise>
+        </XSLT:choose>
+      </XSLT:param>
+      <XSLT:if test="$source/j:map" expand-text="true">
+        <nm:ERROR>No XPath (XML) JSON found at { $file } - syntax of http://www.w3.org/2005/xpath-functions</nm:ERROR>
+      </XSLT:if>
+      <!-- first step produces supermodel from input JSON including Markdown to markup conversion -->
+      <XSLT:variable name="supermodel">
+        <XSLT:apply-templates select="$source"/>
+      </XSLT:variable>
+      <XSLT:choose>
+        <XSLT:when test="$produce = 'supermodel'">
+          <XSLT:sequence select="$supermodel"/>
+        </XSLT:when>
+        <XSLT:otherwise>
+          <XSLT:apply-templates select="$supermodel" mode="write-xml"/>
+        </XSLT:otherwise>
+      </XSLT:choose>   
+    </XSLT:template>
+  </xsl:variable>
+  
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/toolchains/xslt-M4/nist-metaschema-MAKE-XML-TO-JSON-CONVERTER.xsl b/toolchains/xslt-M4/nist-metaschema-MAKE-XML-TO-JSON-CONVERTER.xsl
new file mode 100644
index 000000000..61b91d30d
--- /dev/null
+++ b/toolchains/xslt-M4/nist-metaschema-MAKE-XML-TO-JSON-CONVERTER.xsl
@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  xmlns:nm="http://csrc.nist.gov/ns/metaschema"
+  xmlns="http://csrc.nist.gov/ns/oscal/metaschema/1.0/supermodel"
+  xpath-default-namespace="http://csrc.nist.gov/ns/oscal/metaschema/1.0/supermodel"
+  xmlns:XSLT="http://csrc.nist.gov/ns/oscal/metaschema/xslt-alias"
+  exclude-result-prefixes="#all"
+  version="3.0">
+
+
+    <xsl:output indent="yes"/>
+
+  <xsl:namespace-alias stylesheet-prefix="XSLT" result-prefix="xsl"/>
+  
+  <!-- 
+    From a metaschema
+    Produces a single XSLT with simple interfaces
+      named shortname=xml-to-json-converter.xsl
+      -source - XML to be converted to JSON
+      produce='json' (default) emit serialized JSON
+      produce='supermodel' emit supermodel notation
+      produce='xdm-json-xml' emit XPath XML notation JSON
+    
+      
+    stylesheet sequence
+    
+    source: metaschema
+      pipeline through external calls to
+        compose
+        produce definition map
+        produce XML converter
+      result is XML converter: stitch that into a result XSLT
+        XML converter + supermodel JSON serializer
+          producing optional intermediate results
+      
+    -->
+  
+  
+  <xsl:output method="xml" indent="yes"/>
+  
+  <!-- Turning $trace to 'on' will
+         - emit runtime messages with each transformation, and
+         - retain nm:ERROR and nm:WARNING messages in results. -->
+  
+  <xsl:mode name="package-converter" on-no-match="shallow-copy"/>
+  
+  <xsl:param name="trace" as="xs:string">off</xsl:param>
+  <xsl:variable name="louder" select="$trace = 'on'"/>
+  
+  <xsl:variable name="xslt-base" select="document('')/document-uri()"/>
+  
+  <xsl:import href="lib/metaschema-metaprocess.xsl"/>
+  
+  <!-- The $transformation-sequence declares transformations to be applied in order. -->
+  <xsl:variable name="produce-xml-converter">
+    <!-- first compose the metaschema -->
+    <nm:transform version="3.0">compose/metaschema-collect.xsl</nm:transform>
+    <nm:transform version="3.0">compose/metaschema-reduce1.xsl</nm:transform>
+    <nm:transform version="3.0">compose/metaschema-reduce2.xsl</nm:transform>
+    <nm:transform version="3.0">compose/metaschema-digest.xsl</nm:transform>
+    
+    <!-- next produce definition map -->
+    <nm:transform version="3.0">compose/make-model-map.xsl</nm:transform>
+    <nm:transform version="3.0">compose/unfold-model-map.xsl</nm:transform>
+    <nm:transform version="3.0">compose/reduce-map.xsl</nm:transform>
+    
+    <!--<nm:transform version="3.0">produce-xml-converter.xsl</nm:transform>-->
+  </xsl:variable>
+  
+  <xsl:variable name="metaschema-source" select="/"/>
+  
+  <xsl:template match="/">
+    <xsl:variable name="converter">
+      <xsl:call-template name="nm:process-pipeline">
+        <xsl:with-param name="sequence" select="$produce-xml-converter"/>
+      </xsl:call-template>
+    </xsl:variable>
+    
+    <xsl:apply-templates select="$converter" mode="package-converter"/>
+  </xsl:template>
+  
+<!-- 'package-converter' enhances the code produced from the metaschema-json-converter pipeline:
+       adds interfaces for handling json inputs ($transformation-architecture)
+       provides pipeline infrastructure for supermodel production and serialization
+       provides templates from utility filters (Markdown to markup; XML writing)
+  -->
+
+  <!-- nb since by default the json converter passes markdown through, in mode 'package-converter'
+       we also rewrite its templates for producing contents of markup-line and markup-multiline,
+       hitting the 'parse-markdown' template from the markdown processor. -->
+  
+
+  <xsl:template match="xsl:stylesheet | xsl:transform" mode="package-converter">
+    <xsl:copy copy-namespaces="true">
+      <xsl:copy-of select="@*"/>
+      <xsl:text>&#xA;</xsl:text>
+      <xsl:comment> XML to JSON conversion: pipeline </xsl:comment>
+      <xsl:copy-of select="$transformation-architecture"/>
+      
+      <xsl:comment> XML to JSON conversion: object filters </xsl:comment>
+      
+      <xsl:text>&#xA;</xsl:text>
+      <xsl:apply-templates mode="#current"/>
+      
+      <xsl:text>&#xA;</xsl:text>
+      <xsl:comment> XML to JSON conversion: Supermodel serialization as JSON
+        including markdown production </xsl:comment>
+      <xsl:apply-templates mode="package-converter" select="document('supermodel-to-json.xsl')/xsl:*/( xsl:variable | xsl:template )"/>
+    </xsl:copy>
+  </xsl:template>
+ 
+  <xsl:variable name="transformation-architecture">
+    <xsl:text>&#xA;</xsl:text>
+    <xsl:comment> Supports either of two interfaces:
+      simply handle the XML as source (easier), producing the JSON as output, or
+      use arguments (equivalent to): -it from-xml produce=json file=[file] (mirrors the JSON converter interface) </xsl:comment>
+    <xsl:text>&#xA;</xsl:text>
+    <xsl:comment> Parameter 'produce' supports acquiring outputs other than JSON:
+      produce=xpath produces XPath JSON (an XML syntax)
+      produce=supermodel produces intermediate (internal) 'supermodel' format</xsl:comment>
+    <xsl:text>&#xA;</xsl:text>
+    <xsl:comment> Parameter setting 'json-indent=yes' produces JSON indented using the internal serializer</xsl:comment>
+    <XSLT:param name="file" as="xs:string"/>
+    <XSLT:param name="produce" as="xs:string">json</XSLT:param>
+    <!-- set to 'xdm-json-xml' or 'xpath' for XPath JSON XML
+                'supermodel' to produce supermodel intermediate -->
+    <XSLT:param name="json-indent" as="xs:string">no</XSLT:param>
+    
+    <XSLT:output omit-xml-declaration="true"/>
+    
+    <XSLT:variable name="write-options" as="map(*)">
+      <XSLT:map>
+        <XSLT:map-entry key="'indent'" expand-text="true">{ $json-indent='yes' }</XSLT:map-entry>
+      </XSLT:map>
+    </XSLT:variable>
+    
+    <XSLT:template match="/" name="from-xml">
+      <!-- Take source to be JSON in XPath 3.1 (XDM) representation -->
+      <XSLT:param name="source">
+        <XSLT:choose>
+          <xsl:comment> evaluating $file as URI relative to nominal source directory </xsl:comment>
+          <XSLT:when test="exists($file)">
+            <XSLT:try select="$file ! document(.,/)" xmlns:err="http://www.w3.org/2005/xqt-errors">
+              <XSLT:catch expand-text="true">
+                <nm:ERROR code="{{ $err:code }}">{ $err:description }</nm:ERROR>
+              </XSLT:catch>
+            </XSLT:try>    
+          </XSLT:when>
+          <XSLT:otherwise>
+            <XSLT:sequence select="/"/>
+          </XSLT:otherwise>
+        </XSLT:choose>
+      </XSLT:param>
+      <!-- first step produces supermodel from input XML -->
+      <XSLT:variable name="supermodel">
+        <XSLT:apply-templates select="$source"/>
+      </XSLT:variable>
+      <XSLT:choose>
+        <XSLT:when test="$produce = 'supermodel'">
+          <XSLT:sequence select="$supermodel"/>
+        </XSLT:when>
+        <XSLT:otherwise>
+          <XSLT:variable name="new-json-xml">
+            <XSLT:apply-templates select="$supermodel" mode="write-json"/>
+          </XSLT:variable>
+          <XSLT:when test="matches($produce,('xpath|xdm|xml')'">
+            <XSLT:sequence select="$new-json-xml"/>
+          </XSLT:when>
+          <XSLT:otherwise>
+            <XSLT:try select="xml-to-json($new-json-xml,$write-options)" xmlns:err="http://www.w3.org/2005/xqt-errors">
+              <XSLT:catch>
+                <nm:ERROR code="{{ $err:code }}">{ $err:description }</nm:ERROR>
+              </XSLT:catch>
+            </XSLT:try>  
+          </XSLT:otherwise>
+        </XSLT:otherwise>
+      </XSLT:choose>   
+    </XSLT:template>
+  </xsl:variable>
+  
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/toolchains/xslt-M4/testing/test-xml-conversions.xpl b/toolchains/xslt-M4/testing/test-xml-conversions.xpl
index 8ea24a6c9..ac1cd6ce7 100644
--- a/toolchains/xslt-M4/testing/test-xml-conversions.xpl
+++ b/toolchains/xslt-M4/testing/test-xml-conversions.xpl
@@ -114,6 +114,7 @@
     </p:input>
   </p:xslt>
   
+  <!--<p:identity name="convert-xml-testdata"/>-->
   <p:xslt name="convert-xml-testdata">
     <p:input port="source">
       <p:pipe port="testdata-xml" step="test-metaschema-conversions"/>
@@ -124,6 +125,7 @@
   </p:xslt>
   
   <!-- Now going back downhill to XML -->
+  <!--<p:identity name="convert-supermodel-to-xml"/>-->
   <p:xslt name="convert-supermodel-to-xml">
     <p:input port="stylesheet">
       <p:document href="../converter-gen/supermodel-to-xml.xsl"/>
@@ -140,13 +142,14 @@
   </p:identity>
   
   <!-- Back downhill to JSON -->
-  <!--<p:identity  name="convert-prose-to-markdown"/>-->
-  <p:xslt name="convert-prose-to-markdown">
+  <p:identity  name="convert-prose-to-markdown"/>
+  <!--<p:xslt name="convert-prose-to-markdown">
     <p:input port="stylesheet">
       <p:document href="../converter-gen/supermodel-to-markdown.xsl"/>
     </p:input>
-  </p:xslt>
+  </p:xslt>-->
   
+  <!--<p:identity name="convert-supermodel-to-json-xml"/>-->
   <p:xslt name="convert-supermodel-to-json-xml">
     <p:input port="stylesheet">
       <p:document href="../converter-gen/supermodel-to-json.xsl"/>
diff --git a/toolchains/xslt-M4/testing/test-xml-json-roundtrip.xpl b/toolchains/xslt-M4/testing/test-xml-json-roundtrip.xpl
index b00c3a0fd..a8ae2bb44 100644
--- a/toolchains/xslt-M4/testing/test-xml-json-roundtrip.xpl
+++ b/toolchains/xslt-M4/testing/test-xml-json-roundtrip.xpl
@@ -133,18 +133,12 @@
   
   <!-- Back downhill to JSON -->
   
-  <!-- First, we markdownify the prose in the supermodel -->
-  <p:xslt name="convert-prose-to-markdown">
-    <p:input port="source">
-      <p:pipe port="result" step="convert-xml-testdata"/>
-    </p:input>
-    <p:input port="stylesheet">
-      <p:document href="../converter-gen/supermodel-to-markdown.xsl"/>
-    </p:input>
-  </p:xslt>
   
   <!-- Now we map to XPath JSON -->
   <p:xslt name="convert-supermodel.1-to-json-xml">
+    <p:input port="source">
+      <p:pipe port="result" step="convert-xml-testdata"/>
+    </p:input>
     <p:input port="stylesheet">
       <p:document href="../converter-gen/supermodel-to-json.xsl"/>
     </p:input>
@@ -175,6 +169,11 @@
   <p:sink/>
   
   <!-- Applying the JSON converter, from the serialized JSON we produce the supermodel again -->
+  <!--<p:identity name="convert-jsonified-testdata">
+    <p:input port="source">
+      <p:pipe step="make-json-converter" port="result"/>
+    </p:input>
+  </p:identity>-->
   <p:xslt name="convert-jsonified-testdata">
     <p:input port="source">
       <p:pipe port="result" step="convert-supermodel.1-to-json-xml"/>
@@ -184,9 +183,7 @@
     </p:input>
   </p:xslt>
   
-  
-  <!-- Interpolating markup from the Markdown to produce a supermodel XML representation -->
-  <p:identity name="supermodel-markdown-to-markup"/>
+  <!--<p:identity name="convert-markdown-to-markup"/>-->
   <p:xslt name="convert-markdown-to-markup">
     <p:input port="stylesheet">
       <p:document href="../converter-gen/markdown-to-supermodel-xml-converter.xsl"/>
diff --git a/toolchains/xslt-M4/testing/testdata-supermodel.xml b/toolchains/xslt-M4/testing/testdata-supermodel.xml
index 7e60821ba..d2a8391dc 100644
--- a/toolchains/xslt-M4/testing/testdata-supermodel.xml
+++ b/toolchains/xslt-M4/testing/testdata-supermodel.xml
@@ -1,309 +1,166 @@
 <assembly xmlns="http://csrc.nist.gov/ns/oscal/metaschema/1.0/supermodel"
-          name="everything"
-          gi="EVERYTHING"
-          key="EVERYTHING"
-          namespace="http://csrc.nist.gov/metaschema/ns/everything">
-   <field name="field-1only" gi="field-1only" key="field-1only">
-      <value as-type="string" key="STRVALUE" in-json="string">FIELD-1-ONLY</value>
-   </field>
-   <field name="field-base64"
-          gi="field-base64"
-          in-json="SCALAR"
-          key="field-base64">
-      <value as-type="base64Binary" in-json="string">1234abcd</value>
-   </field>
-   <field name="field-boolean"
-          gi="field-boolean"
-          in-json="SCALAR"
-          key="field-boolean">
-      <value as-type="boolean" in-json="boolean">true</value>
-   </field>
-   <field name="field-named-value"
-          gi="field-named-value"
-          key="field-named-value">
-      <flag as-type="string" name="id" key="id" gi="id">fnv1</flag>
-      <value as-type="string" key="CUSTOM-VALUE-KEY" in-json="string">FIELD-NAMED-VALUE</value>
-   </field>
-   <field name="markup-line"
-          gi="markup-line"
-          in-json="SCALAR"
-          key="markup-line">
-      <value as-type="markup-line" in-json="string">Here's some <em>markup</em>: make of it <strong>what you will</strong>! Even if it has ... * funky characters ` ... and even an <img alt="some picture" src="img.jpg"/>
-      </value>
-   </field>
-   <group in-json="SINGLETON_OR_ARRAY" key="groupable-simple-fields">
-      <field name="field-simple-groupable" gi="field-simple-groupable">
-         <flag as-type="integer"
-               name="integer-flag"
-               key="integer-flag"
-               gi="integer-flag">1</flag>
-         <value as-type="string" key="STRVALUE" in-json="string">field-groupable 1</value>
-      </field>
-      <field name="field-simple-groupable" gi="field-simple-groupable">
-         <flag as-type="string"
-               name="simple-flag"
-               key="simple-flag"
-               gi="simple-flag">a</flag>
-         <value as-type="string" key="STRVALUE" in-json="string">field-groupable 2</value>
-      </field>
-      <field name="field-simple-groupable" gi="field-simple-groupable">
-         <flag as-type="integer"
-               name="integer-flag"
-               key="integer-flag"
-               gi="integer-flag">3</flag>
-         <value as-type="string" key="STRVALUE" in-json="string">field-groupable 3</value>
-      </field>
-   </group>
-   <group name="wrapped-fields"
-          gi="wrapped-fields"
-          group-json="ARRAY"
-          key="wrapped-fields">
-      <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-         <value as-type="string" in-json="string">field-wrappable 1</value>
-      </field>
-      <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-         <value as-type="string" in-json="string">field-wrappable 2</value>
-      </field>
-      <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-         <value as-type="string" in-json="string">field-wrappable 3</value>
-      </field>
-   </group>
-   <group in-json="BY_KEY" key="keyed-fields">
-      <field name="field-by-key"
-             gi="field-by-key"
-             json-key-flag="id"
-             in-json="SCALAR">
-         <flag as-type="string" name="id" key="id" gi="id">fbk1</flag>
-         <value as-type="string" key="STRVALUE" in-json="string">field-by-key 1</value>
-      </field>
-      <field name="field-by-key"
-             gi="field-by-key"
-             json-key-flag="id"
-             in-json="SCALAR">
-         <flag as-type="string" name="id" key="id" gi="id">fbk2</flag>
-         <value as-type="string" key="STRVALUE" in-json="string">field-by-key 2</value>
-      </field>
-      <field name="field-by-key"
-             gi="field-by-key"
-             json-key-flag="id"
-             in-json="SCALAR">
-         <flag as-type="string" name="id" key="id" gi="id">fbk3</flag>
-         <value as-type="string" key="STRVALUE" in-json="string">field-by-key 3</value>
-      </field>
-   </group>
-   <group in-json="SINGLETON_OR_ARRAY" key="dynamic-value-key-fields">
-      <field name="field-dynamic-value-key" gi="field-dynamic-value-key">
-         <flag as-type="string" name="id" key="id" gi="id">fdvk1</flag>
-         <value as-type="string" key-flag="id" in-json="string">field-dynamic-value-key 1</value>
-      </field>
-      <field name="field-dynamic-value-key" gi="field-dynamic-value-key">
-         <flag as-type="string" name="id" key="id" gi="id">fdvk2</flag>
-         <value as-type="string" key-flag="id" in-json="string">field-dynamic-value-key 2</value>
-      </field>
-      <field name="field-dynamic-value-key" gi="field-dynamic-value-key">
-         <flag as-type="string" name="id" key="id" gi="id">fdvk3</flag>
-         <value as-type="string" key-flag="id" in-json="string">field-dynamic-value-key 3</value>
-      </field>
-   </group>
-   <field name="wrapped-prose"
-          gi="wrapped-prose"
-          in-json="SCALAR"
-          key="wrapped-prose">
-      <value as-type="markup-multiline" in-json="string">
-         <h1>Wrapped up prose</h1>
-         <p>This is prose. All wrapped up.</p>
-      </value>
-   </field>
-   <field in-json="SCALAR" name="loose-prose" key="loose-prose">
-      <value in-json="string" as-type="markup-multiline">
-         <h1>Unwrapped prose</h1>
-         <p>Here we have unwrapped prose....</p>
-      </value>
-   </field>
-   <assembly name="assembly-1only" gi="ASSEMBLY-1ONLY" key="ASSEMBLY-1ONLY">
-      <field name="field-1only" gi="field-1only" key="field-1only">
-         <value as-type="string" key="STRVALUE" in-json="string">ASSEMBLY-1-ONLY / FIELD-1-ONLY</value>
+          name="anthology"
+          gi="ANTHOLOGY"
+          key="ANTHOLOGY"
+          namespace="http://csrc.nist.gov/metaschema/ns/anthology">
+   <assembly name="meta" gi="meta" key="meta">
+      <group in-json="SINGLETON_OR_ARRAY" key="creators">
+         <field name="creator" gi="creator">
+            <flag in-json="string"
+                  as-type="string"
+                  name="role"
+                  key="role"
+                  gi="role">editor</flag>
+            <value as-type="string" key="STRVALUE" in-json="string">Wendell Piez</value>
+         </field>
+      </group>
+      <group in-json="SINGLETON_OR_ARRAY" key="keywords">
+         <field name="keyword" gi="keyword" in-json="SCALAR">
+            <value as-type="string" in-json="string">poetry</value>
+         </field>
+         <field name="keyword" gi="keyword" in-json="SCALAR">
+            <value as-type="string" in-json="string">verse</value>
+         </field>
+      </group>
+      <field name="remarks" gi="remarks" in-json="SCALAR" key="remarks">
+         <value as-type="markup-multiline" in-json="string">
+            <h1>Demo anthology</h1>
+            <p>Compiled for purposes of testing and demonstrating validations against constraints
+                defined by NIST Metaschema.</p>
+         </value>
       </field>
    </assembly>
-   <group in-json="SINGLETON_OR_ARRAY" key="groupable-assemblies">
-      <assembly name="assembly-groupable" gi="assembly-groupable">
-         <group in-json="SINGLETON_OR_ARRAY" key="groupable-simple-fields">
-            <field name="field-simple-groupable" gi="field-simple-groupable">
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-groupable 1 / field-groupable 1</value>
-            </field>
-            <field name="field-simple-groupable" gi="field-simple-groupable">
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-groupable 1 / field-groupable 2</value>
-            </field>
-            <field name="field-simple-groupable" gi="field-simple-groupable">
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-groupable 1 / field-groupable 3</value>
-            </field>
-         </group>
-      </assembly>
-      <assembly name="assembly-groupable" gi="assembly-groupable">
-         <group in-json="SINGLETON_OR_ARRAY" key="groupable-simple-fields">
-            <field name="field-simple-groupable" gi="field-simple-groupable">
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-groupable 2 / field-groupable 1</value>
-            </field>
-            <field name="field-simple-groupable" gi="field-simple-groupable">
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-groupable 2 / field-groupable 2</value>
-            </field>
-            <field name="field-simple-groupable" gi="field-simple-groupable">
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-groupable 2 / field-groupable 3</value>
-            </field>
-         </group>
-      </assembly>
-      <assembly name="assembly-groupable" gi="assembly-groupable">
-         <group in-json="SINGLETON_OR_ARRAY" key="groupable-simple-fields">
-            <field name="field-simple-groupable" gi="field-simple-groupable">
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-groupable 3 / field-groupable 1</value>
-            </field>
-            <field name="field-simple-groupable" gi="field-simple-groupable">
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-groupable 3 / field-groupable 2</value>
-            </field>
-            <field name="field-simple-groupable" gi="field-simple-groupable">
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-groupable 3 / field-groupable 3</value>
-            </field>
-         </group>
+   <group in-json="SINGLETON_OR_ARRAY" key="pieces">
+      <assembly name="piece" gi="piece">
+         <assembly name="meta" gi="meta" key="meta">
+            <group in-json="SINGLETON_OR_ARRAY" key="creators">
+               <field name="creator" gi="creator">
+                  <flag in-json="string"
+                        as-type="string"
+                        name="role"
+                        key="role"
+                        gi="role">author</flag>
+                  <flag in-json="string"
+                        as-type="string"
+                        name="who"
+                        key="who"
+                        gi="who">#w.h.auden</flag>
+                  <value as-type="string" key="STRVALUE" in-json="string">W.H. Auden</value>
+               </field>
+            </group>
+            <field name="date" gi="date" key="date">
+               <value as-type="string" key="STRVALUE" in-json="string">1954</value>
+            </field>
+         </assembly>
+         <assembly name="verse" gi="verse" key="verse">
+            <flag in-json="string"
+                  as-type="string"
+                  name="type"
+                  key="type"
+                  gi="type">quatrain</flag>
+            <group in-json="SINGLETON_OR_ARRAY" key="lines">
+               <field name="line" gi="line">
+                  <flag in-json="number"
+                        as-type="integer"
+                        name="feet"
+                        key="feet"
+                        gi="feet">4</flag>
+                  <flag in-json="string"
+                        as-type="string"
+                        name="base"
+                        key="base"
+                        gi="base">trochee</flag>
+                  <value as-type="markup-line" key="RICHTEXT" in-json="string">Guard, Civility, with guns</value>
+               </field>
+               <field name="line" gi="line">
+                  <flag in-json="number"
+                        as-type="integer"
+                        name="feet"
+                        key="feet"
+                        gi="feet">4</flag>
+                  <flag in-json="string"
+                        as-type="string"
+                        name="base"
+                        key="base"
+                        gi="base">iamb</flag>
+                  <value as-type="markup-line" key="RICHTEXT" in-json="string">Your modes and your declensions:</value>
+               </field>
+               <field name="line" gi="line">
+                  <flag in-json="number"
+                        as-type="integer"
+                        name="feet"
+                        key="feet"
+                        gi="feet">4</flag>
+                  <flag in-json="string"
+                        as-type="string"
+                        name="base"
+                        key="base"
+                        gi="base">trochee</flag>
+                  <value as-type="markup-line" key="RICHTEXT" in-json="string">Any lout can spear with ease</value>
+               </field>
+               <field name="line" gi="line">
+                  <flag in-json="number"
+                        as-type="integer"
+                        name="feet"
+                        key="feet"
+                        gi="feet">4</flag>
+                  <flag in-json="string"
+                        as-type="string"
+                        name="base"
+                        key="base"
+                        gi="base">trochee</flag>
+                  <value as-type="markup-line" key="RICHTEXT" in-json="string">Singular Archimedes.</value>
+               </field>
+            </group>
+         </assembly>
       </assembly>
    </group>
-   <group name="wrapped-assemblies"
-          gi="wrapped-assemblies"
-          group-json="ARRAY"
-          key="wrapped-assemblies">
-      <assembly name="assembly-wrappable" gi="assembly-wrappable">
-         <group name="wrapped-fields"
-                gi="wrapped-fields"
-                group-json="ARRAY"
-                key="wrapped-fields">
-            <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-               <value as-type="string" in-json="string">assembly-wrappable 1 / field-wrappable 1</value>
-            </field>
-            <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-               <value as-type="string" in-json="string">assembly-wrappable 1 / field-wrappable 2</value>
-            </field>
-            <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-               <value as-type="string" in-json="string">assembly-wrappable 1 / field-wrappable 3</value>
-            </field>
+   <assembly name="back" gi="back" key="back">
+      <assembly name="author-index" gi="author-index" key="author-index">
+         <group in-json="BY_KEY" key="authors">
+            <assembly name="author" gi="author" json-key-flag="id">
+               <flag in-json="string"
+                     as-type="NCName"
+                     name="id"
+                     key="id"
+                     gi="id">w.h.auden</flag>
+               <field name="name" gi="name" in-json="SCALAR" key="name">
+                  <value as-type="string" in-json="string">Wystan Hugh Auden</value>
+               </field>
+               <field name="dates" gi="dates" key="dates">
+                  <flag in-json="string"
+                        as-type="date"
+                        name="birth"
+                        key="birth"
+                        gi="birth">1907-02-21</flag>
+                  <flag in-json="string"
+                        as-type="date"
+                        name="death"
+                        key="death"
+                        gi="death">1973-09-29</flag>
+                  <value as-type="empty" key="range" in-json="string"/>
+               </field>
+               <assembly name="bio" gi="bio" key="bio">
+                  <group in-json="SINGLETON_OR_ARRAY" key="fact-statements">
+                     <assembly name="facts" gi="facts">
+                        <field name="dates" gi="dates" key="dates">
+                           <flag in-json="string"
+                                 as-type="date"
+                                 name="birth"
+                                 key="birth"
+                                 gi="birth">1907-02-21</flag>
+                           <flag in-json="string"
+                                 as-type="date"
+                                 name="death"
+                                 key="death"
+                                 gi="death">1973-09-29</flag>
+                           <value as-type="empty" key="range" in-json="string"/>
+                        </field>
+                     </assembly>
+                  </group>
+               </assembly>
+            </assembly>
          </group>
       </assembly>
-      <assembly name="assembly-wrappable" gi="assembly-wrappable">
-         <group name="wrapped-fields"
-                gi="wrapped-fields"
-                group-json="ARRAY"
-                key="wrapped-fields">
-            <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-               <value as-type="string" in-json="string">assembly-wrappable 2 / field-wrappable 1</value>
-            </field>
-            <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-               <value as-type="string" in-json="string">assembly-wrappable 2 / field-wrappable 2</value>
-            </field>
-            <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-               <value as-type="string" in-json="string">assembly-wrappable 2 / field-wrappable 3</value>
-            </field>
-         </group>
-      </assembly>
-      <assembly name="assembly-wrappable" gi="assembly-wrappable">
-         <group name="wrapped-fields"
-                gi="wrapped-fields"
-                group-json="ARRAY"
-                key="wrapped-fields">
-            <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-               <value as-type="string" in-json="string">assembly-wrappable 3 / field-wrappable 1</value>
-            </field>
-            <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-               <value as-type="string" in-json="string">assembly-wrappable 3 / field-wrappable 2</value>
-            </field>
-            <field name="field-wrappable" gi="field-wrappable" in-json="SCALAR">
-               <value as-type="string" in-json="string">assembly-wrappable 3 / field-wrappable 3</value>
-            </field>
-         </group>
-      </assembly>
-   </group>
-   <group in-json="BY_KEY" key="keyed-assemblies">
-      <assembly name="assembly-by-key" gi="assembly-by-key" json-key-flag="id">
-         <flag as-type="string" name="id" key="id" gi="id">abk1</flag>
-         <group in-json="BY_KEY" key="keyed-fields">
-            <field name="field-by-key"
-                   gi="field-by-key"
-                   json-key-flag="id"
-                   in-json="SCALAR">
-               <flag as-type="string" name="id" key="id" gi="id">abk1.fbk1</flag>
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-by-key 1 / field-by-key 1</value>
-            </field>
-            <field name="field-by-key"
-                   gi="field-by-key"
-                   json-key-flag="id"
-                   in-json="SCALAR">
-               <flag as-type="string" name="id" key="id" gi="id">abk1.fbk2</flag>
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-by-key 1 / field-by-key 2</value>
-            </field>
-            <field name="field-by-key"
-                   gi="field-by-key"
-                   json-key-flag="id"
-                   in-json="SCALAR">
-               <flag as-type="string" name="id" key="id" gi="id">abk1.fbk3</flag>
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-by-key 1 / field-by-key 3</value>
-            </field>
-         </group>
-      </assembly>
-      <assembly name="assembly-by-key" gi="assembly-by-key" json-key-flag="id">
-         <flag as-type="string" name="id" key="id" gi="id">abk2</flag>
-         <group in-json="BY_KEY" key="keyed-fields">
-            <field name="field-by-key"
-                   gi="field-by-key"
-                   json-key-flag="id"
-                   in-json="SCALAR">
-               <flag as-type="string" name="id" key="id" gi="id">abk2.fbk1</flag>
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-by-key 1 / field-by-key 1</value>
-            </field>
-            <field name="field-by-key"
-                   gi="field-by-key"
-                   json-key-flag="id"
-                   in-json="SCALAR">
-               <flag as-type="string" name="id" key="id" gi="id">abk2.fbk2</flag>
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-by-key 1 / field-by-key 2</value>
-            </field>
-            <field name="field-by-key"
-                   gi="field-by-key"
-                   json-key-flag="id"
-                   in-json="SCALAR">
-               <flag as-type="string" name="id" key="id" gi="id">abk2.fbk3</flag>
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-by-key 1 / field-by-key 3</value>
-            </field>
-         </group>
-      </assembly>
-      <assembly name="assembly-by-key" gi="assembly-by-key" json-key-flag="id">
-         <flag as-type="string" name="id" key="id" gi="id">abk3</flag>
-         <group in-json="BY_KEY" key="keyed-fields">
-            <field name="field-by-key"
-                   gi="field-by-key"
-                   json-key-flag="id"
-                   in-json="SCALAR">
-               <flag as-type="string" name="id" key="id" gi="id">abk3.fbk1</flag>
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-by-key 1 / field-by-key 1</value>
-            </field>
-            <field name="field-by-key"
-                   gi="field-by-key"
-                   json-key-flag="id"
-                   in-json="SCALAR">
-               <flag as-type="string" name="id" key="id" gi="id">abk3.fbk2</flag>
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-by-key 1 / field-by-key 2</value>
-            </field>
-            <field name="field-by-key"
-                   gi="field-by-key"
-                   json-key-flag="id"
-                   in-json="SCALAR">
-               <flag as-type="string" name="id" key="id" gi="id">abk3.fbk3</flag>
-               <value as-type="string" key="STRVALUE" in-json="string">assembly-by-key 1 / field-by-key 3</value>
-            </field>
-         </group>
-      </assembly>
-   </group>
-   <group in-json="ARRAY" key="everything-recursive">
-      <assembly name="everything" gi="EVERYTHING">
-         <field name="field-1only" gi="field-1only" key="field-1only">
-            <value as-type="string" key="STRVALUE" in-json="string">nested FIELD-1-ONLY</value>
-         </field>
-      </assembly>
-   </group>
+   </assembly>
 </assembly>