diff --git a/.gitmodules b/.gitmodules
index d159c254..6179065b 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,7 +1,3 @@
-[submodule "support/schematron"]
-	path = support/schematron
-	url = https://github.com/usnistgov/schematron.git
-	branch = master
 [submodule "support/xspec"]
 	path = support/xspec
 	url = https://github.com/AirQuick/xspec.git
@@ -10,3 +6,6 @@
 	path = support/metaschema
 	url = https://github.com/nikitawootten-nist/metaschema.git
 	fetchRecurseSubmodules = false
+[submodule "support/schxslt"]
+	path = support/schxslt
+	url = https://github.com/schxslt/schxslt.git
diff --git a/bin/metaschema-xslt b/bin/metaschema-xslt
index 06e3689b..0ac0be42 100755
--- a/bin/metaschema-xslt
+++ b/bin/metaschema-xslt
@@ -19,6 +19,8 @@ Subcommands:
     Generate JSON and XML schemas for a given metaschema
 - converter-gen METASCHEMA_XML OUTPUT_DIR SCHEMA_NAME [ADDITIONAL_ARGS]
     Generate converter transformations (XSLT) between JSON and XML for a given metaschema
+- composition-validate METASCHEMA_XML [ADDITIONAL_ARGS]
+    Test metaschema composition (assembling modules and linking definitions) and report issues
 EOF
 }
 
@@ -55,6 +57,9 @@ case "$SUBCOMMAND" in
     converter-gen)
         "$SRC_DIR"/converter-gen/mvn-converters-xpl.sh "$@"
         ;;
+    composition-validate)
+        "$SRC_DIR"/validate/mvn-composition-validate-xpl.sh "$@"
+        ;; 
     ?)
         msg "Unknown subcommand: $SUBCOMMAND"
         exit 1
diff --git a/src/README.md b/src/README.md
index e1ff5efa..4948fc1c 100644
--- a/src/README.md
+++ b/src/README.md
@@ -1,121 +1,64 @@
-# XSLT-M4
+# XSLT-M4 `src`
 
-An XSLT implementation of the metaschema toolchain for generating schemas, converters, and model documentation.
+An XSLT implementation of the [Metaschema](https://pages.nist.gov/metaschema) toolchain for generating schemas, converters, and model documentation.
 
 Typically any of these operations will combine several lower-level operations in a defined sequence.
 
 More details (produced by surveying the files) can be seen in [file-manifest.md](file-manifest.md). Note however that this file is not reliable if it is not more recent than the files described.
 
-In addition to this readme, this folder contains XSLT transformations (`*.xsl`), and XProc pipelines (`xpr`). The XSLT provides stable runtimes to the supported operations as described below. The XProc  The XProc is provided for convenience in development and debugging, and can be expected to change (develop/proliferate) somewhat more freely. These are currently XProc 1.0 pending further development.
+In addition to this readme, this folder contains XSLT transformations (`*.xsl`), and XProc pipelines (`xpl`). The XSLT provides stable runtimes to the supported operations as described below. The XProc provides optimized runtimes when producing multiple outputs (results) from single inputs.
 
-Routines described below provide the XSLT entry point for the service. In general, any service consumes a metaschema input and produces one or more outputs, publishable as artifacts. For any XSLT, an analogous XProc is usually discernable from a file name (for example, `make-metaschema-xsd.xpr` instantiates the same pipeline as `nist-metaschema-MAKE-XSD.xsl`). For documentation production, only XProc is given.
+See each subdirectory README for more instructions.
 
-## Generate schemas
 
-### Generate XML Schema (XSD)
+## common
 
-source: metaschema (main module)
+XSLT and logic used as common modules by other utilities.
 
-XSLT: `nist-metaschema-MAKE-XSD.xsl`
+Moving or removing this directory will often break things.
 
-result: XSD (suffix `*.xsd`)
+## compose
 
-parameters: none
+Implements a metaschema composition pipeline - producing a unified single metaschema from a metaschema top-level module, by performing imports and linking references.
 
-The output is an XSD (XML Schema Definition) that can be used to provide structural and datatype validation over XML data instances, testing conformance to models defined by the metaschema.
+This subroutine is a dependency for most other metaschema processes, so like `common` this directory should be kept in place.
 
-### Generate JSON Schema
+## converter-gen
 
-source: metaschema (main module)
+Logic to generate converter transformations (XSLT) capable of producing JSON from XML or XML from JSON, according to mappings defined by appropriate metaschema definitions, defining schemas to which the respective data sets are valid.
 
-XSLT: `nist-metaschema-MAKE-JSON-SCHEMA.xsl`
+## document
 
-result: JSON Schema (suffix `*.json`)
+Logic to create HTML-based web-ready documentation of XML and JSON schemas based on a metaschema.
 
-parameters: none
+## metapath
 
-The output is a JSON Schema (v 7) that can be used to provide structural and lexical validation over JSON (and YAML) data instances, testing conformance to models defined by the metaschema.
+Provides support for parsing and mapping Metapath, the metaschema path language.
 
-## Generate converters
+This directory is a dependency for logic in converter generation, which uses it to match JSON in conversion into XML, and schema generation, which uses it to implement path traversal in constraints definition and implementation. 
 
-### XML to JSON converter
+## schema-gen
 
-source: metaschema (main module)
+Logic to provide schemas for validating XML or JSON according to definitions provided in a metaschema.
 
-XSLT: `nist-metaschema-MAKE-XML-TO-JSON-CONVERTER.xsl`
+Generators for XSD and JSON Schema v7 are provided.
 
-result: XSLT (suffix `*.xsl`)
+Additionally, a partial implementation of Metaschema constraints via a Schematron cast is offered, as a basis for future work.
 
-An XML instance valid to a given metaschema-defined model can be converted by the XSLT produced by this XSLT (operating on the metaschema), into an information-identical JSON representation, losslessly, valid to the analogous JSON Schema.
+## testing
 
-### JSON to XML converter
+Some testing artifacts.
 
-source: metaschema (main module)
+Also find testing within each subdirectory, appropriate to its functionalities.
 
-XSLT: `nist-metaschema-MAKE-JSON-TO-XML-CONVERTER.xsl`
+## util
 
-result: XSLT (suffix `*.xsl`)
+Miscellaneous utilities. Due for cleanup.
 
-A JSON serialization (string) valid to a given metaschema-defined model can be converted by the XSLT produced by this XSLT (operating on the metaschema), into an information-identical XML representation, losslessly, valid to the analogous XML Schema (XSD).
+## validate
 
-## Generate Metatron / Metaschema-based constraints validation
+Provides support for *extra-schema validation* of Metaschema instances against constraints implicit in Metaschema semantics.
 
-source: metaschema (main module)
+Note that validation provided here via Schematron applies *additionally* to regular structural schema validation of a metaschema, using its XSD.
 
-XSLT: `nist-metaschema-MAKE-XML-METATRON.xsl`
-
-result: Schematron (suffix `*.sch`)
-
-tbd: Schematron that operates on JSON inputs (JSONatron)
-
-## Generate documentation
-
-For any metaschema a range of documentation artifacts are produced for consumption by Hugo (ingest into a static published documentation repository / web sites).
-
-Accordingly see these XProc pipelines for details:
-
-`make-metaschema-standalone-docs.xpl` a generic pipeline producing standalone documentation (by passing Hugo ingest files through a normalizer/stabilizer).
-
-Use with a debugging pipeline that binds the output ports for inspection.
-
-`write-hugo-metaschema-docs.xpl` producing the same set of docs, except writing them to the file system ready for Hugo. Note that this pipeline writes files to the system.
-
-Produced by both these pipelines (which should be work-alikes):
-  - XML and JSON-oriented model documents with cross-links
-    - Both instance- and model-oriented
-  - XML and JSON model maps / synopsis
-  - Indexes
-
-## Extras
-
-The XSLT `nist-metaschema-metaprocess.xsl` is a utility XSLT providing a unified interface for orchestrating the order and application of subordinate transformations, via configurations.
-
-### Metaschema schemas / `validate` folder
-
-Any metaschema, metaschema module, or composed metaschema, should be valid to the Metaschema XSD `../support/metaschema/schema/xml/metaschema.xsd` and to the `validate/metaschema-check.sch` Schematron.
-
-A composed metaschema is essentially what a metaschema will look like with all imports resolved (last appearing definition prevailing, imports read before main definitions); so a metaschema with no imports maps directly to its own composed expression. In composition, pointers are also written into the metaschema representation to provide useful information for downstream processing in resolving referential ambiguities (resulting from unintended or intended import clashes).
-
-The Schematron currently runs the composition step irrespectively. We should perhaps factor out Schematron checks that are dependent on Metaschema composition, from those that should apply to any metaschema (composed, standalone) or module.
-
-### Compose metaschema
-
-Schema composition is essentially import resolution, wherein overriding imports are resolved. Semantics of metaschema composition essentially follow Metaschema specifications for resolution of *metaschema modules* in importing.
-
-The result is a single normalized and annotated Metaschema module instance with all defaults explicit and disambiguated, or error reports.
-
-source: metaschema (main module)
-
-XSLT: `nist-metaschema-MAKE-JSON-MAP.xsl`
-
-result: XML conformant to Metaschema XSD/Schematron
-
-A composition step is provided internally by other processes, but it can also be run independently.
-
-### XProc
-
-As noted above, everything can also be done under XProc 1.0 (`*.xpl` files) for debugging.
-
-For a view of any XProc, try the [XProc Visualizer](https://pages.nist.gov/xslt-blender/xproc-visualizer/).
-
-Porting to XProc 3.0 and/or to other pipelining approaches is on the further horizon.
+[end]
diff --git a/src/common/nist-metaschema-metaprocess.xsl b/src/common/nist-metaschema-metaprocess.xsl
index 7d7cdce4..a00d8461 100644
--- a/src/common/nist-metaschema-metaprocess.xsl
+++ b/src/common/nist-metaschema-metaprocess.xsl
@@ -18,7 +18,7 @@
     
     <xsl:variable name="transformation-sequence" select="()"/>
     
-    <xsl:variable name="xslt-base" select="document('')/document-uri()"/>
+    <xsl:variable name="xslt-base" select="document('')/base-uri()"/>
     
     <!--<xsl:variable name="transformation-sequence">
         <nm:transform version="3.0">compose/metaschema-collect.xsl</nm:transform>
@@ -27,14 +27,14 @@
         <nm:transform version="3.0">compose/metaschema-digest.xsl</nm:transform>
     </xsl:variable>-->
     
-    <xsl:template match="/" name="nm:process-pipeline">
+    <xsl:template match="/" name="nm:process-pipeline" priority="-0.6">
         <xsl:param name="source"   as="document-node()"  select="/"/>
         <xsl:param name="sequence" as="document-node()?" select="$transformation-sequence"/>
         <!-- Each element inside $transformation-sequence is processed in turn.
              Each represents a stage in processing.
              The result of each processing step is passed to the next step as its input, until no steps are left. -->
         <xsl:call-template name="alert">
-            <xsl:with-param name="msg" expand-text="yes"> COMPOSING METASCHEMA { document-uri($source) } </xsl:with-param>
+            <xsl:with-param name="msg" expand-text="yes"> COMPOSING METASCHEMA { base-uri($source) } </xsl:with-param>
         </xsl:call-template>
         <xsl:iterate select="$sequence/*">
             <xsl:param name="doc" select="$source" as="document-node()"/>
@@ -48,7 +48,7 @@
             </xsl:next-iteration>
         </xsl:iterate>
     </xsl:template>
-
+    
     <!-- for nm:transformation, the semantics are "apply this XSLT" -->
     <xsl:template mode="nm:execute" match="nm:transform">
         <xsl:param name="sourcedoc" as="document-node()"/>
@@ -68,7 +68,7 @@
                 <xsl:map-entry key="'stylesheet-params'"   select="$runtime-params"/>
             </xsl:map>
         </xsl:variable>
-
+       
         <!-- The function returns a map; primary results are under 'output'
              unless a base output URI is given
              https://www.w3.org/TR/xpath-functions-31/#func-transform -->
diff --git a/src/converter-gen/mvn-jsonxml-converter-xsl.sh b/src/converter-gen/mvn-jsonxml-converter-xsl.sh
old mode 100644
new mode 100755
diff --git a/src/converter-gen/mvn-xmljson-converter-xsl.sh b/src/converter-gen/mvn-xmljson-converter-xsl.sh
old mode 100644
new mode 100755
diff --git a/src/document/mvn-schemadocs-debug-xpl.sh b/src/document/mvn-schemadocs-debug-xpl.sh
old mode 100644
new mode 100755
diff --git a/src/document/mvn-schemadocs-html-xpl.sh b/src/document/mvn-schemadocs-html-xpl.sh
old mode 100644
new mode 100755
diff --git a/src/schema-gen/mvn-xsd-schema-xsl.sh b/src/schema-gen/mvn-xsd-schema-xsl.sh
old mode 100644
new mode 100755
diff --git a/src/testing/models_metaschema.xml b/src/testing/models_metaschema.xml
index 7ed56698..e46580ba 100644
--- a/src/testing/models_metaschema.xml
+++ b/src/testing/models_metaschema.xml
@@ -25,24 +25,24 @@
 
     <define-flag name="id">
         <formal-name>ID</formal-name>
-        <description>flag id</description>
+        <description>flag id.</description>
     </define-flag>
     
     <define-flag name="simple-flag">
         <formal-name>Simple Flag</formal-name>
-        <description>some string</description>
+        <description>some string.</description>
     </define-flag>
     
     <define-flag name="integer-flag" as-type="integer" >
         <formal-name>Integer Flag</formal-name>
-        <description>an integer</description>
+        <description>an integer.</description>
         <remarks><p>Things to know about integers</p></remarks>
     </define-flag>
     
     <!-- -->
     <define-assembly name="everything">
         <formal-name>EVERYTHING</formal-name>
-        <description>assembly everything</description>
+        <description>assembly everything.</description>
         <root-name>EVERYTHING</root-name>
         <flag ref="id"/>
         <model>
@@ -103,7 +103,7 @@
 
     <define-field name="overloaded">
         <formal-name>OVERLOADED</formal-name>
-        <description>Overloaded field</description>
+        <description>Overloaded field.</description>
         <flag ref="simple-flag"/>
         <flag ref="integer-flag">
             <remarks>
@@ -114,89 +114,89 @@
     
     <define-field name="field-1only">
         <formal-name>FIELD-1ONLY</formal-name>
-        <description>field field-1only</description>
+        <description>field field-1only.</description>
         <flag ref="simple-flag"/>
         <flag ref="integer-flag"/>
     </define-field>
     
-    <define-field name="field-base64" as-type="base64Binary">
+    <define-field name="field-base64" as-type="base64">
         <formal-name>FIELD-BASE64</formal-name>
-        <description>field field-base64</description>
+        <description>field field-base64.</description>
     </define-field>
     
     <define-field name="field-boolean" as-type="boolean">
         <formal-name>FIELD-BOOLEAN</formal-name>
-        <description>field field-boolean</description>
+        <description>field field-boolean.</description>
     </define-field>
     
     <define-field name="field-simple-groupable">
         <formal-name>FIELD-SIMPLE-GROUPABLE</formal-name>
-        <description>simple field, groupable</description>
+        <description>simple field, groupable.</description>
         <flag ref="simple-flag"/>
         <flag ref="integer-flag"/>
     </define-field>
     
     <define-field name="field-flagged-groupable">
         <formal-name>FIELD-FLAGGED-GROUPABLE</formal-name>
-        <description>field field-groupable</description>
+        <description>field field-groupable.</description>
         <define-flag name="flagged-date" as-type="date">
             <formal-name>Date flag</formal-name>
-            <description>A flag for a date</description>
+            <description>A flag for a date.</description>
         </define-flag>
         <define-flag name="flagged-decimal" as-type="decimal">
             <formal-name>Decimal flag</formal-name>
-            <description>A flag with a decimal value</description>
+            <description>A flag with a decimal value.</description>
         </define-flag>
     </define-field>
     
     <define-field name="field-wrappable">
         <formal-name>FIELD-WRAPPABLE</formal-name>
-        <description>field field-wrappable</description>
+        <description>field field-wrappable.</description>
     </define-field>
     
     <define-field name="field-by-key">
         <formal-name>FIELD-BY-KEY</formal-name>
-        <description>field field-by-key</description>
+        <description>field field-by-key.</description>
         <json-key flag-ref="id"/>
         <flag ref="id" required="yes"/>
     </define-field>
     
     <define-field name="field-named-value">
         <formal-name>FIELD-NAMED-VALUE</formal-name>
-        <description>field field-named-value</description>
+        <description>field field-named-value.</description>
         <json-value-key>CUSTOM-VALUE-KEY</json-value-key>
         <flag ref="id" required="yes"/>
     </define-field>
     
     <define-field name="field-dynamic-value-key">
         <formal-name>FIELD-DYNAMIC-VALUE-KEY</formal-name>
-        <description>field field-dynamic-value-key</description>
+        <description>field field-dynamic-value-key.</description>
         <json-value-key-flag flag-ref="id"/>
         <flag ref="id" required="yes"/>
         <define-flag name="color">
             <formal-name>COLOR</formal-name>
-            <description>flag color</description>    
+            <description>flag color.</description>    
         </define-flag>
     </define-field>
 
     <define-field name="markup-line" as-type="markup-line">
         <formal-name>MARKUP-LINE</formal-name>
-        <description>field markup-line</description>
+        <description>field markup-line.</description>
     </define-field>
     
     <define-field name="wrapped-prose" as-type="markup-multiline">
         <formal-name>WRAPPED-PROSE</formal-name>
-        <description>field wrapped-prose</description>
+        <description>field wrapped-prose.</description>
     </define-field>
     
     <define-field name="loose-prose" as-type="markup-multiline">
         <formal-name>LOOSE-PROSE</formal-name>
-        <description>field loose-prose</description>
+        <description>field loose-prose.</description>
     </define-field>
     
     <define-assembly name="branch1">
         <formal-name>branch 1 for OVERLOAD1</formal-name>
-        <description>A discrete containter for objects with overloaded names.</description>
+        <description>A discrete containter for objects with overloaded names..</description>
         <model>
             <assembly ref="overload1" max-occurs="unbounded">
                 <use-name>OVERLOAD</use-name>
@@ -207,7 +207,7 @@
     
     <define-assembly name="branch2">
         <formal-name>branch 2 for OVERLOAD2</formal-name>
-        <description>A discrete containter for objects with overloaded names.</description>
+        <description>A discrete containter for objects with overloaded names..</description>
         <model>
             <assembly ref="overload2" max-occurs="unbounded">
                 <use-name>OVERLOAD</use-name>
@@ -218,11 +218,11 @@
     
     <define-assembly name="overload1">
         <formal-name>Overloaded name 1</formal-name>
-        <description>The first object with an overloaded name</description>
+        <description>The first object with an overloaded name.</description>
         <use-name>OVERLOAD</use-name>
         <define-flag name="a">
             <formal-name>An OVERLOAD/@a</formal-name>
-            <description>A flag on an assembly called 'OVERLOAD'</description>
+            <description>A flag on an assembly called 'OVERLOAD'.</description>
         </define-flag>
         <model>
             <assembly ref="overload1" max-occurs="unbounded">
@@ -234,11 +234,11 @@
     
     <define-assembly name="overload2">
         <formal-name>Overloaded name 2</formal-name>
-        <description>The second object with an overloaded name</description>
+        <description>The second object with an overloaded name.</description>
         <use-name>OVERLOAD</use-name>
         <define-flag name="z">
             <formal-name>An OVERLOAD/@z</formal-name>
-            <description>A flag on an assembly called 'OVERLOAD'</description>
+            <description>A flag on an assembly called 'OVERLOAD'.</description>
         </define-flag>
         <model>
             <assembly ref="overload2" max-occurs="unbounded">
@@ -250,19 +250,19 @@
     
     <define-assembly name="assembly-empty">
         <formal-name>ASSEMBLY-EMPTY</formal-name>
-        <description>assembly assembly-empty</description>
+        <description>assembly assembly-empty.</description>
         <flag ref="id" required="yes"/>
     </define-assembly>
     
     <define-assembly name="assembly-empty-grouped">
         <formal-name>ASSEMBLY-EMPTY-GROUPED</formal-name>
-        <description>assembly assembly-empty-grouped</description>
+        <description>assembly assembly-empty-grouped.</description>
         <flag ref="id" required="yes"/>
     </define-assembly>
     
     <define-assembly name="assembly-1only">
         <formal-name>ASSEMBLY-1ONLY</formal-name>
-        <description>assembly assembly-1only</description>
+        <description>assembly assembly-1only.</description>
         <root-name>ASSEMBLY-1ONLY</root-name>
         <model>
             <field ref="field-1only"/>
@@ -272,7 +272,7 @@
     
     <define-assembly name="assembly-alias1">
         <formal-name>ASSEMBLY-ALIASED 1</formal-name>
-        <description>first aliased assembly (has a name conflict)</description>
+        <description>first aliased assembly (has a name conflict).</description>
         <model>
             <field ref="field-1only"/>
             <assembly ref="assembly-1only"/>
@@ -284,7 +284,7 @@
     
     <define-assembly name="assembly-alias2">
         <formal-name>ASSEMBLY-ALIASED 2</formal-name>
-        <description>second aliased assembly (has a name conflict)</description>
+        <description>second aliased assembly (has a name conflict).</description>
         <model>
             <assembly ref="assembly-1only"/>
             <field ref="field-1only"/>
@@ -293,7 +293,7 @@
     
     <define-assembly name="assembly-groupable">
         <formal-name>ASSEMBLY-GROUPABLE</formal-name>
-        <description>assembly assembly-groupable</description>
+        <description>assembly assembly-groupable.</description>
         <model>
             <field ref="field-simple-groupable" max-occurs="unbounded">
                 <group-as name="groupable-simple-fields"/>
@@ -306,7 +306,7 @@
     
     <define-assembly name="assembly-wrappable">
         <formal-name>ASSEMBLY-WRAPPABLE</formal-name>
-        <description>assembly assembly-wrappable</description>
+        <description>assembly assembly-wrappable.</description>
         <model>
             <field ref="field-wrappable" max-occurs="unbounded">
                 <group-as name="wrapped-fields" in-xml="GROUPED" in-json="ARRAY"/>
@@ -320,7 +320,7 @@
     
     <define-assembly name="assembly-by-key">
         <formal-name>ASSEMBLY-BY-KEY</formal-name>
-        <description>assembly assembly-by-key</description>
+        <description>assembly assembly-by-key.</description>
         <json-key flag-ref="id"/>
         <flag ref="id" required="yes"/>
         
diff --git a/src/validate/METASCHEMA-SCHXSLT-VALIDATE.xpl b/src/validate/METASCHEMA-SCHXSLT-VALIDATE.xpl
new file mode 100644
index 00000000..53ce2154
--- /dev/null
+++ b/src/validate/METASCHEMA-SCHXSLT-VALIDATE.xpl
@@ -0,0 +1,51 @@
+<?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:schxslt="https://doi.org/10.5281/zenodo.1495494"
+  type="metaschema:METASCHEMA-ALL-SCHEMAS" name="METASCHEMA-ALL-SCHEMAS">
+  
+  <p:import href="../../support/schxslt/core/src/main/resources/xproc/1.0/validate-with-schematron.xpl"/>
+  
+  <!-- &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& -->
+  <!-- Ports -->
+  
+  <p:input port="METASCHEMA" primary="true"/>
+  <p:input port="parameters" kind="parameter"/>
+  
+  <p:serialization port="INT_0_echo-input" indent="true"  method="xml"/>
+  <p:output port="INT_0_echo-input" primary="false">
+    <p:pipe port="result" step="echo-input"/>
+  </p:output>
+  
+  <p:serialization port="OUT_report-SVRL" indent="true"  method="xml"/>
+  <p:output port="OUT_report-SVRL" primary="false">
+    <p:pipe port="report" step="schematron-check"/>
+  </p:output>
+  
+  <p:serialization port="OUT_report-plaintext" indent="true"  method="text"/>
+  <p:output port="OUT_report-plaintext" primary="false">
+    <p:pipe port="result" step="plaintext-report"/>
+  </p:output>
+  
+  <p:identity name="echo-input"/>
+
+  <schxslt:validate-with-schematron name="schematron-check">
+    <p:input port="schema">
+      <p:document href="metaschema-composition-check.sch"/>
+    </p:input>
+  </schxslt:validate-with-schematron>
+  
+  <!-- primary result is the document again, which we are done with -->
+  <p:sink/>
+  
+  <p:xslt name="plaintext-report">
+    <p:input port="source">
+      <p:pipe port="report" step="schematron-check"/>
+    </p:input>
+    <p:input port="stylesheet">
+      <p:document href="svrl-reduce.xsl"/>
+    </p:input>
+  </p:xslt>
+  
+</p:declare-step>
\ No newline at end of file
diff --git a/src/validate/METASCHEMA-VALIDATE.xpl b/src/validate/METASCHEMA-VALIDATE.xpl
new file mode 100644
index 00000000..c0668bb2
--- /dev/null
+++ b/src/validate/METASCHEMA-VALIDATE.xpl
@@ -0,0 +1,52 @@
+<?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"
+  type="metaschema:METASCHEMA-VALIDATE" name="METASCHEMA-VALIDATE">
+  
+  <!--For validating using the Schematron Skeleton - if we can get 'allow-foreign' working -->
+  <!-- &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& &&& -->
+  <!-- Ports -->
+  
+  <p:input port="METASCHEMA" primary="true"/>
+  <p:input port="parameters" kind="parameter"/>
+  
+  <p:serialization port="INT_0_echo-input" indent="true"  method="xml"/>
+  <p:output port="INT_0_echo-input" primary="false">
+    <p:pipe port="result" step="echo-input"/>
+  </p:output>
+  
+  <p:serialization port="OUT_report-SVRL" indent="true"  method="xml"/>
+  <p:output port="OUT_report-SVRL" primary="false">
+    <p:pipe port="report" step="schematron-check"/>
+  </p:output>
+  
+  <!-- <p:serialization port="OUT_report-plaintext" indent="true"  method="text"/>
+  <p:output port="OUT_report-plaintext" primary="false">
+    <p:pipe port="result" step="plaintext-report"/>
+  </p:output>-->
+  
+  <p:identity name="echo-input"/>
+  
+  <p:validate-with-schematron name="schematron-check" assert-valid="false">
+    <p:input port="schema">
+      <p:document href="metaschema-composition-check.sch"/>
+    </p:input>
+    <p:with-param name="allow-foreign" select="true()"/>
+  </p:validate-with-schematron>
+  
+  <!-- primary result is the document again, which we are done with -->
+  <p:sink/>
+  
+  <!--<p:identity name="plaintext-report"/>-->
+  
+  <!--<p:xslt name="plaintext-report">
+    <p:input port="source">
+      <p:pipe port="report" step="schematron-check"/>
+    </p:input>
+    <p:input port="stylesheet">
+      <p:document href="svrl-reduce.xsl"/>
+    </p:input>
+  </p:xslt>-->
+  
+</p:declare-step>
\ No newline at end of file
diff --git a/src/validate/Makefile b/src/validate/Makefile
new file mode 100644
index 00000000..665c7ee4
--- /dev/null
+++ b/src/validate/Makefile
@@ -0,0 +1,11 @@
+include ../testing/make_common.mk
+
+# XML Calabash prefers absolute paths
+test_metaschema:=../testing/models_metaschema.xml
+
+.PHONY: test
+test: smoke-test ## Run all tests
+
+.PHONY: smoke-test
+smoke-test: ## Run all smoke-tests
+	./mvn-composition-validate-xpl.sh "$(test_metaschema)"
diff --git a/src/validate/metaschema-composition-check.sch b/src/validate/metaschema-composition-check.sch
index 45a6333a..63a472af 100644
--- a/src/validate/metaschema-composition-check.sch
+++ b/src/validate/metaschema-composition-check.sch
@@ -3,8 +3,7 @@
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
     xmlns:m="http://csrc.nist.gov/ns/oscal/metaschema/1.0"
     xmlns:nm="http://csrc.nist.gov/ns/metaschema"
-    xmlns:sqf="http://www.schematron-quickfix.com/validator/process"
-    xmlns:oscal="http://csrc.nist.gov/ns/oscal/1.0">
+    xmlns:sqf="http://www.schematron-quickfix.com/validator/process">
 
 <!-- Extra-XSD validation for NIST Metaschema format 
 
@@ -15,16 +14,15 @@
     <sch:ns uri="http://csrc.nist.gov/ns/oscal/metaschema/1.0" prefix="m"/>
     <sch:ns uri="http://csrc.nist.gov/ns/metaschema" prefix="nm"/>
     
-    <xsl:import href="metaschema-validation-support.xsl"/>
+    <xsl:include href="metaschema-validation-support.xsl"/>
     
     <!--<xsl:import href="oscal-datatypes-check.xsl"/>-->
     
-    
     <xsl:import href="oscal-datatypes-check.xsl"/>
     
-    <xsl:param    name="global-context" select="/"/>
+    <!--<xsl:param    name="global-context" select="/"/>-->
+    
     
-    <xsl:variable name="composed-metaschema" select="nm:compose-metaschema($global-context)"/>
  
     <!--<sch:let name="metaschema-is-abstract" value="/m:METASCHEMA/@abstract='yes'"/>-->
     
@@ -61,12 +59,14 @@
             <sch:report role="information" test="true()">Defs ID: <xsl:value-of select="nm:composed-definition-identifier(nm:as-composed(.))"/></sch:report>
             <sch:report role="information" test="true()">Defs: '<xsl:value-of select="nm:definitions-for-reference(nm:as-composed(.))/serialize(.)" separator=", "/>'</sch:report>
 -->            
-            <xsl:variable name="as-composed" as="element()?" select="nm:as-composed(.)"/>
-            <xsl:variable name="is-multiple"  select="count($as-composed) gt 1"/>
-            <xsl:variable name="defs-for-reference" as="element()*" select="$as-composed/nm:definitions-for-reference(.)"/>
+            <sch:let name="as-composed" value="nm:as-composed(.)"/>
+            <sch:let name="is-multiple" value="count($as-composed) gt 1"/>
+            <sch:let name="defs-for-reference" value="$as-composed/nm:definitions-for-reference(.)"/>
 
+<!-- emit some diagnostics to determine whazzup -->
             <sch:assert id="require-a-reference-in-composition" test="count($defs-for-reference) gt 0" >No <sch:name/> appears named "<sch:value-of select="@ref"/>" ... please check</sch:assert>
-            <sch:assert id="require-unambiguous-reference-in-composition" test="count($defs-for-reference) le 1" >Ambiguous reference to '<sch:value-of select="@ref"/>' found in <sch:name/>. The reference resolved to define-<sch:name/> <sch:value-of select="if (count($defs-for-reference) gt 1) then ' definitions' else 'definition'"/> with the name '<sch:value-of select="@ref"/>' in: <xsl:value-of select="$defs-for-reference/@_base-uri" separator=", "/>. Is this due to a duplicated METASCHEMA/short-name in a module?</sch:assert>
+            
+            <sch:assert id="require-unambiguous-reference-in-composition" test="count($defs-for-reference) le 1" >Ambiguous reference to '<sch:value-of select="@ref"/>' found in <sch:name/>. The reference resolved to define-<sch:name/> <sch:value-of select="if (count($defs-for-reference) gt 1) then ' definitions' else 'definition'"/> with the name '<sch:value-of select="@ref"/>' in: <sch:value-of select="$defs-for-reference/@_base-uri => string-join(', ')"/>. Is this due to a duplicated METASCHEMA/short-name in a module?</sch:assert>
             
             <sch:let name="my-xml-name"  value="$as-composed/@_in-xml-name"/>
             <sch:let name="my-json-name" value="$as-composed/@_in-json-name"/>
@@ -86,26 +86,26 @@
             <sch:assert id="require-unique-xml-sibling-names" test="empty($as-composed) or $is-multiple or count($named-like-me-in-xml) = 1">Name clash among sibling elements or attributes with XML name '<sch:value-of select="$my-xml-name"/>'.</sch:assert>
         </sch:rule>
         
-        <sch:rule id="rule-name-clash-definitions" context="m:define-flag | m:define-field | m:define-assembly"><xsl:variable name="as-composed" as="element()*" select="nm:as-composed(.)"/>
-            <xsl:variable name="is-multiple"  select="count($as-composed) gt 1"/>
+        <sch:rule id="rule-name-clash-definitions" context="m:define-flag | m:define-field | m:define-assembly"><sch:let name="as-composed" value="nm:as-composed(.)"/>
+            <sch:let name="is-multiple" value="count($as-composed) gt 1"/>
 
-            <sch:assert id="require-unambiguous-definitions" test="not($is-multiple)">Duplicate name found for <sch:name/> '<sch:value-of select="@name"/>' in: <xsl:value-of select="$as-composed/@_base-uri" separator=", "/>. Is this due to a duplicated METASCHEMA/short-name in a module?</sch:assert>
+            <sch:assert id="require-unambiguous-definitions" test="not($is-multiple)">Duplicate name found for <sch:name/> '<sch:value-of select="@name"/>' in: <sch:value-of select="$as-composed/@_base-uri => string-join(', ')"/>. Is this due to a duplicated METASCHEMA/short-name in a module?</sch:assert>
             
         </sch:rule>
     </sch:pattern>
     
     <sch:pattern id="pattern-definition-shadowing">
         <sch:rule id="rule-definition-shadowing" context="/m:METASCHEMA/m:define-assembly | /m:METASCHEMA/m:define-field | /m:METASCHEMA/m:define-flag">
-            <xsl:variable name="as-composed" as="element()*" select="nm:as-composed(.)"/>
+            <sch:let name="as-composed" value="nm:as-composed(.)"/>
             <!-- filter out current node from defs. This allows a non-match to pass the following assertion, which can happen if the target definition was found to be unused. -->
             <sch:let name="extra-definitions" value="nm:composed-top-level-definitions-matching(.) except $as-composed"/>
-            <sch:assert test="empty($extra-definitions)" id="detect-shadowed-definitions" role="warning">Definition shadows another definition in this (composed) metaschema: see <sch:name/> <xsl:value-of select="$extra-definitions/concat(@module,':',@name)" separator=", "/> (<xsl:value-of select="$extra-definitions/@_base-uri" separator=", "/>)</sch:assert>
+            <sch:assert test="empty($extra-definitions)" id="detect-shadowed-definitions" role="warning">Definition shadows another definition in this (composed) metaschema: see <sch:name/> <sch:value-of select="$extra-definitions/concat(@module,':',@name) => string-join(', ')"/> (<sch:value-of select="$extra-definitions/@_base-uri => string-join(', ')"/>)</sch:assert>
         </sch:rule>
     </sch:pattern>
 
     <sch:pattern id="group-as">
         <sch:rule context="m:assembly | m:field | m:model/m:define-assembly | m:model/m:define-field">
-            <xsl:variable name="as-composed" as="element()*" select="nm:as-composed(.)"/>
+            <sch:let name="as-composed" value="nm:as-composed(.)"/>
 
             <sch:assert test="not(exists($as-composed)) or number($as-composed/@max-occurs)=1 or exists($as-composed/m:group-as/@name)" id="expect-group-as-with-maxoccurs-gt-1">Unless @max-occurs is 1, a group-as name must be given within an instance or a local definition.</sch:assert>
         </sch:rule>
@@ -116,11 +116,11 @@
 
 <!--            <sch:report test="true()">Parent ID: <xsl:value-of select="nm:metaschema-module-node-identifier(parent::*)"/></sch:report>-->
             
-            <xsl:variable name="parent-as-composed" as="element()*" select="nm:as-composed(parent::*)"/>
+            <sch:let name="parent-as-composed" value="nm:as-composed(parent::*)"/>
 
 <!--            <sch:report test="true()">Parent Composed: '<xsl:value-of select="$parent-as-composed/serialize(.)"/>'</sch:report>-->
 
-            <xsl:variable name="def-as-composed" as="element()*" select="nm:definitions-for-reference($parent-as-composed)"/>
+            <sch:let name="def-as-composed" value="$parent-as-composed/nm:definitions-for-reference(.)"/>
 
 <!--            <sch:report test="true()">Definition: '<xsl:value-of select="nm:definition-for-reference($parent-as-composed)/serialize(.)"/>'</sch:report>
 -->            
@@ -165,8 +165,8 @@
         <!--field references and inline definitions -->
         <sch:rule context="m:field | m:model//m:define-field">
             <!-- constraints on markup-multiline **XXX** TEST ME -->
-            <!--<xsl:variable name="as-composed" as="element()*" select="key('composed-node-by-identifier',nm:metaschema-module-node-identifier(.),$composed-metaschema)"/>-->
-            <xsl:variable name="as-composed" as="element()*" select="nm:as-composed(.)"/>
+            <!--<sch:let name="as-composed" as="element()*" select="key('composed-node-by-identifier',nm:metaschema-module-node-identifier(.),$composed-metaschema)"/>-->
+            <sch:let name="as-composed" value="nm:as-composed(.)"/>
             <sch:assert id="permit-a-single-unwrapped-markupmultiline" test="empty($as-composed) or not($as-composed/@in-xml='UNWRAPPED') or not($as-composed/@as-type='markup-multiline') or not(preceding-sibling::*[$as-composed/@in-xml='UNWRAPPED']/@as-type='markup-multiline')">Only one field may be marked as 'markup-multiline' (without xml wrapping) within a model.</sch:assert>
             <sch:report id="forbid-multiple-unwrapped-fields" test="($as-composed/@in-xml='UNWRAPPED') and (@max-occurs!='1')">An 'unwrapped' field must have a max occurrence of 1</sch:report>
             <sch:assert id="forbid-unwrapped-xml-except-markupmultiline" test="$as-composed/key('composed-definition-by-key-name',nm:composed-definition-identifier(.),$composed-metaschema)/@as-type='markup-multiline' or not(@in-xml='UNWRAPPED')">Only 'markup-multiline' fields may be unwrapped in XML. SEEING '<sch:value-of select="nm:composed-definition-identifier(.)"/>'</sch:assert>
@@ -182,7 +182,10 @@
         <sch:rule context="m:json-key">
             <sch:let name="json-key-flag-name" value="@flag-ref"/>
             <sch:let name="json-key-flag" value="../m:flag[@ref=$json-key-flag-name] |../m:define-flag[@name=$json-key-flag-name]"/>
-            <sch:assert test="exists($json-key-flag)" id="require-json-key-flag-is-a-flag">JSON key indicates no flag on this <sch:value-of select="substring-after(local-name(..),'define-')"/> <xsl:if test="exists(../m:flag | ../m:define-flag)"> - @flag-ref should be (one of) <xsl:value-of select="../m:flag/@ref | ../m:define-flag/@name" separator=", "/></xsl:if></sch:assert>
+            <sch:let name="parent-flag-names" value="../m:flag/@ref | ../m:define-flag/@name"/>
+            <sch:assert test="exists($json-key-flag)" id="require-json-key-flag-is-a-flag">JSON key indicates no flag on this <sch:value-of select="substring-after(local-name(..),'define-')"/> 
+                <sch:value-of select=".[exists($parent-flag-names)]/(' - @flag-ref should be (one of) ' || $parent-flag-names => string-join(', '))"/>
+            </sch:assert>
         </sch:rule>
         
         <sch:rule context="m:json-value-key-flag">
@@ -207,8 +210,6 @@
         </sch:rule>
     </sch:pattern>
     
-    <xsl:key name="index-by-name" match="m:index | m:is-unique" use="@name"/>
-    
     <sch:pattern id="schema-docs">
         <sch:rule context="m:define-assembly | m:define-field | m:define-flag">
             <sch:assert role="warning" test="exists(m:formal-name)" id="expect-formal-name">Formal name missing from <sch:name/> named '<sch:value-of select="@name"/>'</sch:assert>
@@ -226,108 +227,5 @@
     </sch:pattern>
     
     
-    <!-- 0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|-->
-    
-    <!--<xsl:function name="nm:has-a-distinct-name" as="xs:boolean">
-        <!-\- checks a field or assembly as referenced in a modeled (i.e. references and inline definitions)
-             and returns if they have distinct names -\->
-    </xsl:function>-->
-    
-    <!-- =========================== -->
-    <!-- = Composed node retrieval = -->
-    <!-- =========================== -->
-    <xsl:function name="nm:as-composed" as="element()*">
-        <!-- Used to get the composed node for the provided uncomposed node -->
-        <xsl:param name="who" as="element()"/>
-        <!-- Typically, this will return:
-            1) the composed if found with no exceptions,
-            2) multiple nodes if there is a naming clash among siblings, or
-            3) an empty sequence if there was no matching node. -->
-        <xsl:sequence select="key('composed-node-by-identifier',nm:metaschema-module-node-identifier($who),$composed-metaschema)[empty(m:EXCEPTION)]"/>
-    </xsl:function>
-
-    <xsl:key name="composed-node-by-identifier"
-        match="m:define-assembly | m:define-field | m:define-flag
-        | m:flag | m:field | m:assembly" use="nm:composed-node-id(.)"/>
-    
-    <xsl:function name="nm:composed-node-id" as="xs:string">
-        <!-- Used to get the key of a composed definition or instance for use with key('composed-node-by-identifier') -->
-        <xsl:param name="who" as="element()"/>
-        <xsl:variable name="top-level-definition" select="$who/ancestor-or-self::m:define-assembly[parent::m:METASCHEMA] |
-            $who/ancestor-or-self::m:define-field[parent::m:METASCHEMA] | 
-            $who/ancestor-or-self::m:define-flag[parent::m:METASCHEMA]"/>
-        <xsl:variable name="module-defined" select="$top-level-definition/@module"/>
-        <xsl:value-of
-            select="($module-defined,
-            $who/ancestor-or-self::*/(@name | @ref),
-            name($who), $who/m:use-name) => string-join('#')"/>
-    </xsl:function>
-    
-    <xsl:function name="nm:metaschema-module-node-identifier" as="xs:string">
-        <!-- Used to get the key of an uncomposed definition or instance for use with key('composed-node-by-identifier') -->
-        <xsl:param name="who" as="element()"/>
-        <xsl:value-of
-            select="($who/root()/*/m:short-name,
-            $who/ancestor-or-self::*/(@name | @ref),
-            name($who), $who/m:use-name) => string-join('#')"/>
-    </xsl:function>
-
-
-    <!-- ===================================== -->
-    <!-- = Definition retrieval for instance = -->
-    <!-- ===================================== -->
-    <xsl:function name="nm:definitions-for-reference" as="element()*">
-        <!-- Used to get the composed definition for the provided composed instance. If the composed instance is a local definition, the same instance will be returned. -->
-        <!-- If two definitions have the same @_key-name, perhaps due to a short-name clash, multiple definitions might be returned. -->
-        <xsl:param name="who" as="element()"/>
-        <xsl:choose>
-            <xsl:when test="$who/(self::m:define-assembly | self::m:define-field | self::m:define-flag)">
-                <xsl:sequence select="$who"/>
-            </xsl:when>
-            <xsl:otherwise>
-                <xsl:sequence select="key('composed-definition-by-key-name',nm:composed-definition-identifier($who),$composed-metaschema)"/>
-            </xsl:otherwise>
-        </xsl:choose>
-    </xsl:function>
-    
-    <xsl:key name="composed-definition-by-key-name"
-        match="m:define-assembly | m:define-field | m:define-flag" use="nm:composed-definition-identifier(.)"/>
-
-    <xsl:function name="nm:composed-definition-identifier" as="xs:string">
-        <!-- Used to get the key of a composed definition or instance for use with key('composed-definition-by-key-name') -->
-        <xsl:param name="who" as="element()"/>
-        <xsl:choose>
-            <xsl:when test="$who/(self::m:define-assembly | self::m:define-field | self::m:define-flag)">
-                <xsl:value-of select="(name($who), $who/(@_key-name)) => string-join('#')"/>
-            </xsl:when>
-            <xsl:otherwise>
-                <xsl:value-of select="(concat('define-',name($who)), $who/(@_key-ref)) => string-join('#')"/>
-            </xsl:otherwise>
-        </xsl:choose>
-    </xsl:function>
-
-    <!-- ====================================== -->
-    <!-- = Get top-level definition with name = -->
-    <!-- ====================================== -->
-    <xsl:function name="nm:composed-top-level-definitions-matching" as="element()*">
-        <!-- Used to get the matching top-level definition(s) for the provided uncomposed node -->
-        <xsl:param name="who" as="element()"/>
-        <!-- Typically, this will return:
-            1) the composed definition if found,
-            2) multiple composed definitions if there is a naming clash or shadowing among global definitions, or
-            3) an empty sequence if there was no matching definition. -->
-        <xsl:sequence select="key('top-level-definition-by-name',nm:metaschema-definition-identifier($who),$composed-metaschema)"/>
-    </xsl:function>
-
-    <xsl:key name="top-level-definition-by-name" use="nm:metaschema-definition-identifier(.)"
-        match="m:METASCHEMA/m:define-assembly[not(@scope='local')] |
-        m:METASCHEMA/m:define-field[not(@scope='local')] |
-        m:METASCHEMA/m:define-flag[not(@scope='local')]"/>
-
-    <xsl:function name="nm:metaschema-definition-identifier" as="xs:string">
-        <xsl:param name="who" as="element()"/>
-        <xsl:value-of
-            select="(name($who),$who/(@name | @ref)) => string-join('#')"/>
-    </xsl:function>
     
 </sch:schema>
\ No newline at end of file
diff --git a/src/validate/metaschema-validation-support.xsl b/src/validate/metaschema-validation-support.xsl
index e818ed65..0bcfec9d 100644
--- a/src/validate/metaschema-validation-support.xsl
+++ b/src/validate/metaschema-validation-support.xsl
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <xsl:stylesheet version="3.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
     xmlns:nm="http://csrc.nist.gov/ns/metaschema"
+    xmlns:m="http://csrc.nist.gov/ns/oscal/metaschema/1.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:xs="http://www.w3.org/2001/XMLSchema"
     xpath-default-namespace="http://csrc.nist.gov/ns/oscal/metaschema/1.0"
@@ -18,12 +19,18 @@
     -->
 
     <xsl:variable name="home" select="/"/>
-    <xsl:variable name="xslt-base" select="document('')/document-uri()"/>
+    
 
-    <xsl:import href="../common/nist-metaschema-metaprocess.xsl"/>
+    <xsl:include href="../common/nist-metaschema-metaprocess.xsl"/>
+    
+    <xsl:variable name="composed-metaschema" select="nm:compose-metaschema(/)"/>
+    
+    <xsl:key name="index-by-name" match="m:index | m:is-unique" use="@name"/>
     
-    <!-- The $transformation-sequence declares transformations to be applied in order. -->
-    <xsl:variable name="transformation-sequence">
+    <!-- Defining transformations to be applied in order for composition. -->
+    <!-- todo: see if we can call ../compose/nist-metaschema-COMPOSE.xsl in place of (same) pipeline
+         then we can get rid of metaprocess here -->
+    <xsl:variable name="composition-sequence">
         <nm:transform version="3.0">../compose/metaschema-collect.xsl</nm:transform>
         <nm:transform version="3.0">../compose/metaschema-build-refs.xsl</nm:transform>
         <nm:transform version="3.0">../compose/metaschema-trim-extra-modules.xsl</nm:transform>
@@ -37,10 +44,10 @@
     <xsl:function name="nm:compose-metaschema" as="document-node()?">
         <xsl:param name="doc" as="document-node()?"/>
         <xsl:choose>
-            <xsl:when test="empty($doc/*[2]) and ($doc/*[1] is $doc/METASCHEMA[1])">
+            <xsl:when test="empty($doc/*[2]) and ($doc/*[1] is $doc/m:METASCHEMA[1])">
                 <xsl:call-template name="nm:process-pipeline">
                     <xsl:with-param name="source"   select="$doc"/>
-                    <xsl:with-param name="sequence" select="$transformation-sequence"/>
+                    <xsl:with-param name="sequence" select="$composition-sequence"/>
                 </xsl:call-template>
             </xsl:when>
             <xsl:otherwise expand-text="true">
@@ -51,8 +58,113 @@
         </xsl:choose>
     </xsl:function>
 
-    <xsl:template match="/">
-        <xsl:sequence select="nm:compose-metaschema(/)"/>
-    </xsl:template>
+    <!-- 0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|0#0|-->
+    
+    <!--<xsl:function name="nm:has-a-distinct-name" as="xs:boolean">
+        <!-\- checks a field or assembly as referenced in a modeled (i.e. references and inline definitions)
+             and returns if they have distinct names -\->
+    </xsl:function>-->
+    
+    <!-- =========================== -->
+    <!-- = Composed node retrieval = -->
+    <!-- =========================== -->
+    <xsl:function name="nm:as-composed" as="element()*">
+        <!-- Used to get the composed node for the provided uncomposed node -->
+        <xsl:param name="who" as="element()"/>
+        <!-- Typically, this will return:
+            1) the composed if found with no exceptions,
+            2) multiple nodes if there is a naming clash among siblings, or
+            3) an empty sequence if there was no matching node. -->
+        <xsl:sequence select="key('composed-node-by-identifier',nm:metaschema-module-node-identifier($who),$composed-metaschema)[empty(m:EXCEPTION)]"/>
+    </xsl:function>
+    
+    <xsl:key name="composed-node-by-identifier"
+        match="m:define-assembly | m:define-field | m:define-flag
+        | m:flag | m:field | m:assembly" use="nm:composed-node-id(.)"/>
+    
+    <xsl:function name="nm:composed-node-id" as="xs:string">
+        <!-- Used to get the key of a composed definition or instance for use with key('composed-node-by-identifier') -->
+        <xsl:param name="who" as="element()"/>
+        <xsl:variable name="top-level-definition" select="$who/ancestor-or-self::m:define-assembly[parent::m:METASCHEMA] |             $who/ancestor-or-self::m:define-field[parent::m:METASCHEMA] |              $who/ancestor-or-self::m:define-flag[parent::m:METASCHEMA]"/>
+        <xsl:variable name="module-defined" select="$top-level-definition/@module"/>
+        <xsl:value-of
+            select="($module-defined,
+            $who/ancestor-or-self::*/(@name | @ref),
+            name($who), $who/m:use-name) => string-join('#')"/>
+    </xsl:function>
+    
+    <xsl:key name="composed-node-by-identifier"
+        match="m:define-assembly | m:define-field | m:define-flag
+        | m:flag | m:field | m:assembly" use="nm:composed-node-id(.)"/>
+    
+    
+    <xsl:function name="nm:metaschema-module-node-identifier" as="xs:string">
+        <!-- Used to get the key of an uncomposed definition or instance for use with key('composed-node-by-identifier') -->
+        <xsl:param name="who" as="element()"/>
+        <xsl:value-of
+            select="($who/root()/*/m:short-name,
+            $who/ancestor-or-self::*/(@name | @ref),
+            name($who), $who/m:use-name) => string-join('#')"/>
+    </xsl:function>
+    
+    
+    <!-- ===================================== -->
+    <!-- = Definition retrieval for instance = -->
+    <!-- ===================================== -->
+    <xsl:function name="nm:definitions-for-reference" as="element()*">
+        <!-- Used to get the composed definition for the provided composed instance. If the composed instance is a local definition, the same instance will be returned. -->
+        <!-- If two definitions have the same @_key-name, perhaps due to a short-name clash, multiple definitions might be returned. -->
+        <xsl:param name="who" as="element()"/>
+        <xsl:choose>
+            <xsl:when test="$who/(self::m:define-assembly | self::m:define-field | self::m:define-flag)">
+                <xsl:sequence select="$who"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:sequence select="key('composed-definition-by-key-name',nm:composed-definition-identifier($who),$composed-metaschema)"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+    
+    <xsl:key name="composed-definition-by-key-name"
+        match="m:define-assembly | m:define-field | m:define-flag" use="nm:composed-definition-identifier(.)"/>
+    
+    <xsl:function name="nm:composed-definition-identifier" as="xs:string">
+        <!-- Used to get the key of a composed definition or instance for use with key('composed-definition-by-key-name') -->
+        <xsl:param name="who" as="element()"/>
+        <xsl:choose>
+            <xsl:when test="$who/(self::m:define-assembly | self::m:define-field | self::m:define-flag)">
+                <xsl:value-of select="(name($who), $who/(@_key-name)) => string-join('#')"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:value-of select="(concat('define-',name($who)), $who/(@_key-ref)) => string-join('#')"/>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+    
+    <!-- ====================================== -->
+    <!-- = Get top-level definition with name = -->
+    <!-- ====================================== -->
+    <xsl:function name="nm:composed-top-level-definitions-matching" as="element()*">
+        <!-- Used to get the matching top-level definition(s) for the provided uncomposed node -->
+        <xsl:param name="who" as="element()"/>
+        <!-- Typically, this will return:
+            1) the composed definition if found,
+            2) multiple composed definitions if there is a naming clash or shadowing among global definitions, or
+            3) an empty sequence if there was no matching definition. -->
+        <xsl:sequence select="key('top-level-definition-by-name',nm:metaschema-definition-identifier($who),$composed-metaschema)"/>
+    </xsl:function>
+    
+    <xsl:key name="top-level-definition-by-name" use="nm:metaschema-definition-identifier(.)"
+        match="m:METASCHEMA/m:define-assembly[not(@scope='local')] |
+        m:METASCHEMA/m:define-field[not(@scope='local')] |
+        m:METASCHEMA/m:define-flag[not(@scope='local')]"/>
+    
+    <xsl:function name="nm:metaschema-definition-identifier" as="xs:string">
+        <xsl:param name="who" as="element()"/>
+        <xsl:value-of
+            select="(name($who),$who/(@name | @ref)) => string-join('#')"/>
+    </xsl:function>
+    
+    
     
 </xsl:stylesheet>
\ No newline at end of file
diff --git a/src/validate/mvn-composition-validate-xpl.sh b/src/validate/mvn-composition-validate-xpl.sh
new file mode 100755
index 00000000..e5eee7a1
--- /dev/null
+++ b/src/validate/mvn-composition-validate-xpl.sh
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=../common/subcommand_common.bash
+source "$SCRIPT_DIR/../common/subcommand_common.bash"
+
+usage() {
+    cat <<EOF
+Usage: ${BASE_COMMAND:-$(basename "${BASH_SOURCE[0]}")} METASCHEMA_XML [ADDITIONAL_ARGS]
+
+Validates a metaschema (top-level) module by composing it and checking the composition
+EOF
+}
+
+[[ -z "${1-}" ]] && { echo "Error: METASCHEMA_XML not specified"; usage; exit 1; }
+METASCHEMA_XML=$1
+
+ADDITIONAL_ARGS=$(shift 1; echo "${*// /\\ }")
+
+PIPELINE="${SCRIPT_DIR}/METASCHEMA-SCHXSLT-VALIDATE.xpl"
+
+
+CALABASH_ARGS="-iMETASCHEMA=\"$METASCHEMA_XML\" \
+               -oINT_0_echo-input=/dev/null \
+               -oOUT_report-SVRL=/dev/null \
+               $ADDITIONAL_ARGS \"$PIPELINE\""
+
+invoke_calabash "${CALABASH_ARGS}"
diff --git a/src/validate/readme.md b/src/validate/readme.md
index 7bd4ea60..9a7b9d87 100644
--- a/src/validate/readme.md
+++ b/src/validate/readme.md
@@ -4,3 +4,17 @@ Miscellaneous resources supporting validation of Metaschema and related formats.
 Of particular interest:
 
 - `metaschema-composition-check.sch` - some rules checking of a Metaschema module in reference to its composed rendition
+
+- METASCHEMA-SCHXSLT-VALIDATE.xpl
+
+  XProc applies the composition check to a metaschema (Metaschema instance) and reports results in minified plain text.
+
+  Invokes Schxslt
+
+- METASCHEMA-VALIDATE.xpl
+
+  *Should* do the same as above using the Skeleton implementation of Schematron (via XM Calabash), but not yet working or not yet under oXygen harness.
+
+  Note that the parameter `allow-foreign` is set to true. Also note the problem is in file traversals - this validator might run from the CL?
+
+
diff --git a/src/validate/svrl-reduce.xsl b/src/validate/svrl-reduce.xsl
new file mode 100644
index 00000000..3b707de3
--- /dev/null
+++ b/src/validate/svrl-reduce.xsl
@@ -0,0 +1,68 @@
+<?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:svrl="http://purl.oclc.org/dsdl/svrl"
+  xmlns:nm="http://csrc.nist.gov/ns/metaschema"
+  exclude-result-prefixes="#all" version="3.0">
+
+
+  <!-- Purpose: Rewrites SVRL coming back from SCHXSLT into quiet, legible plain text -->
+  
+  <xsl:output method="text" indent="no"/>
+  <!-- when embedded in XProc, serialize as plain text to
+       avoid XML markup in the results -->
+  
+  <xsl:variable name="incidents"
+    select="//svrl:failed-assert | //svrl:successful-report"/>
+
+  <xsl:variable name="home" select="/"/>
+  
+  <xsl:template match="/">
+    <report>
+      <xsl:if test="not($incidents)">You are good - well-formed, no reported errors</xsl:if>
+      <xsl:apply-templates select="$incidents"/>
+    </report>
+  </xsl:template>
+
+  <xsl:template match="svrl:failed-assert | svrl:successful-report">
+    <incident>
+      <xsl:variable name="code">
+        <xsl:value-of select="@role"/>
+        <xsl:if test="@role and @id">:</xsl:if>
+        <xsl:value-of select="@id"/>
+      </xsl:variable>
+      <xsl:if test="normalize-space($code)">
+        <xsl:text>[</xsl:text>
+        <xsl:value-of select="$code"/>
+        <xsl:text>] </xsl:text>
+      </xsl:if>
+      <xsl:text>- </xsl:text>
+      <xsl:value-of select="nm:path-ns-prefix(@location)"/>
+      <xsl:text> - </xsl:text>
+      <xsl:value-of select="normalize-space(.)"/>
+      <xsl:text>&#xA;</xsl:text>
+    </incident>
+  </xsl:template>
+
+  <xsl:function name="nm:path-ns-prefix" as="xs:string">
+    <xsl:param name="s"/>
+    <xsl:variable name="prefix-regex" as="xs:string">Q\{(.*?)\}</xsl:variable>
+    <xsl:value-of>
+    <xsl:analyze-string select="string($s)" regex="{$prefix-regex}">
+      <xsl:matching-substring>
+        <xsl:sequence select="nm:prefix-for-ns(regex-group(1))"/>
+        <xsl:text>:</xsl:text>
+      </xsl:matching-substring>
+      <xsl:non-matching-substring>
+        <xsl:sequence select="."/>
+      </xsl:non-matching-substring>
+    </xsl:analyze-string>
+    </xsl:value-of>
+  </xsl:function>
+  
+  <xsl:function name="nm:prefix-for-ns" as="xs:string?">
+    <xsl:param name="uri" as="xs:string"/>
+    <xsl:sequence select="$home/*/*[@uri=$uri]/@prefix/string()"/>
+  </xsl:function>
+  
+</xsl:stylesheet>
diff --git a/support/schematron b/support/schematron
deleted file mode 160000
index e16ecc49..00000000
--- a/support/schematron
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e16ecc490f9c6429f275ea268279787a71ff298f
diff --git a/support/schxslt b/support/schxslt
new file mode 160000
index 00000000..87cf981d
--- /dev/null
+++ b/support/schxslt
@@ -0,0 +1 @@
+Subproject commit 87cf981dcefd80247d2203fbdf63f5f15f212e1d