diff --git a/schematron.rnc b/schematron.rnc
index b1c784b..67c3fb8 100644
--- a/schematron.rnc
+++ b/schematron.rnc
@@ -1,4 +1,4 @@
-# Copyright © ISO/IEC 2017
+# Copyright © ISO/IEC 2024
 # The following permission notice and disclaimer shall be included in all 
 # copies of this XML schema ("the Schema"), and derivations of the Schema: 
 
@@ -26,7 +26,7 @@
 namespace local = ""
 default namespace sch = "http://purl.oclc.org/dsdl/schematron"
 
-start = schema
+start = schema | library
 
 # Element declarations 
 schema =
@@ -34,11 +34,12 @@ schema =
         attribute id { xsd:ID }?,
         rich,
         attribute schemaVersion { non-empty-string }?,
+        attribute schematronEdition { non-empty-string }?,
         attribute defaultPhase { xsd:IDREF }?,
         attribute queryBinding { non-empty-string }?,
         (foreign
-         & inclusion*
-         & (title?, ns*, p*, let*, phase*, pattern+, p*, diagnostics?, properties?))
+         & (inclusion | extends)*
+         & (title?, ns*, p*, param*, let*, phase*, abstract-rules*, (rule-set|pattern)+, p*, diagnostics?, properties?))
     }
 active =
     element active {
@@ -54,22 +55,23 @@ assert =
         attribute properties { xsd:IDREFS }?,
         rich,
         linkable,
-        (foreign & (text | name | value-of | emph | dir | span)*)
+        severity,
+        message
     }
 diagnostic =
     element diagnostic {
         attribute id { xsd:ID },
         attribute role { roleValue }?,
         rich,
-        (foreign & (text | value-of | emph | dir | span)*)
+        message
     }
 diagnostics = element diagnostics { foreign & inclusion* & diagnostic* }
 dir =
     element dir {
         attribute value { "ltr" | "rtl" }?,
-        (foreign & text)
+        (foreign & (text | dynamic)*)
     }
-emph = element emph { text }
+emph = element emph { (foreign & (text | dynamic)*) }
 extends =
     element extends {
         (attribute rule { xsd:IDREF }
@@ -79,9 +81,18 @@ extends =
 let =
     element let {
         attribute name { nameValue },
+        attribute as { text }?,
         (attribute value { string }
          | foreign-element+)
     }
+library =
+    element library {
+        attribute id { xsd:ID }?,
+        rich,
+        (foreign
+         & (inclusion | extends)*
+         & (title?, p*, param*, let*, abstract-rules*, (rule-set|pattern)*, p*, diagnostics?, properties?))
+    }
 name =
     element name {
         attribute path { pathValue }?,
@@ -103,32 +114,18 @@ p =
 param =
     element param {
         attribute name { nameValue },
-        attribute value { non-empty-string }
+        attribute value { non-empty-string }?
     }
 
 pattern =
     element pattern {
-        attribute documents { pathValue }?,
-        rich,
-        (foreign
-         & inclusion*
-         & ((attribute abstract { "true" },
-             attribute id { xsd:ID },
-             title?,
-             (p*, let*, rule*))
-            | (attribute abstract { "false" }?,
-               attribute id { xsd:ID }?,
-               title?,
-               (p*, let*, rule*))
-            | (attribute abstract { "false" }?,
-               attribute is-a { xsd:IDREF },
-               attribute id { xsd:ID }?,
-               title?,
-               (p*, param*))))
+        rule-set-or-pattern
     }
 phase =
     element phase {
         attribute id { xsd:ID },
+        attribute from { pathValue }?,
+        attribute when { pathValue }?,
         rich,
         (foreign & inclusion* & (p*, let*, active*))
     }
@@ -138,7 +135,7 @@ property =
         attribute id { xsd:ID },
         attribute role { roleValue }?,
         attribute scheme { text }?,
-        (foreign & (text | name | value-of | emph | dir | span)*)
+        message
     }
 report =
     element report {
@@ -149,7 +146,8 @@ report =
         attribute properties { xsd:IDREFS }?,
         rich,
         linkable,
-        (foreign & (text | name | value-of | emph | dir | span)*)
+        severity,
+        message
     }
 rule =
     element rule {
@@ -158,20 +156,43 @@ rule =
         linkable,
         (foreign
          & inclusion*
-         & ((attribute abstract { "true" },
-             attribute id { xsd:ID },
-             let*,
-             (assert | report | extends | p)+)
-            | (attribute context { pathValue },
+         & ((attribute context { pathValue },
+               attribute visit-each { pathValue }?,
                attribute id { xsd:ID }?,
                attribute abstract { "false" }?,
+               title?,
                let*,
                (assert | report | extends | p)+)))
     }
+abstract-rule =
+    element rule {
+        attribute flag { flagValue }?,
+        rich,
+        linkable,
+        (foreign
+        & inclusion*
+        & (attribute abstract { "true" },
+            attribute id { xsd:ID },
+            title?,
+            let*,
+            (assert | report | extends | p)+))
+    }    
+abstract-rules =
+    element rules {
+        attribute id { xsd:ID }?,
+        rich,
+        title?,
+        p*,
+        abstract-rule+
+    }
+rule-set = 
+    element group {
+        rule-set-or-pattern    
+    }
 span =
     element span {
         attribute class { classValue },
-        (foreign & text)
+        (foreign & (text | dynamic)*)
     }
 title = element title { (text | dir)* }
 value-of =
@@ -205,6 +226,28 @@ foreign-element =
          | schema
          | text)*
     }
+rule-set-or-pattern =
+    attribute documents { pathValue }?,
+    attribute role { roleValue }?,
+    rich,
+    (foreign
+     & inclusion*
+     & ((attribute abstract { "true" },
+         attribute id { xsd:ID },
+         title?,
+         (p*, param*, let*, rule*))
+        | (attribute abstract { "false" }?,
+           attribute id { xsd:ID }?,
+           title?,
+           (p*, let*, rule*))
+        | (attribute abstract { "false" }?,
+           attribute is-a { xsd:IDREF },
+           attribute id { xsd:ID }?,
+           title?,
+           (p*, param*))))
+severity = attribute severity{ text }?           
+dynamic = value-of | name
+message = (foreign & (text | dynamic | emph | dir | span)*)
 
 # Data types 
 uriValue = xsd:anyURI
@@ -213,7 +256,7 @@ exprValue = string
 fpiValue = string
 langValue = xsd:language
 roleValue = string
-flagValue = string
+flagValue = list{ token+ }
 nameValue = string
 
 # In the default query language binding, xsd:NCNAME 
diff --git a/schematron.sch b/schematron.sch
index d31f5ab..7d3db6f 100644
--- a/schematron.sch
+++ b/schematron.sch
@@ -1,5 +1,5 @@
 <!--
-© ISO/IEC 2017
+© ISO/IEC 2024
 The following permission notice and disclaimer shall be included in all
 copies of this XML schema ("the Schema"), and derivations of the Schema:
 Permission is hereby granted, free of charge in perpetuity, to any
@@ -21,7 +21,9 @@ THIS SCHEMA HAS BEEN MODIFIED FROM THE SCHEMA DEFINED IN ISO/IEC 19757 3,
 AND SHOULD NOT BE INTERPRETED AS COMPLYING WITH THAT STANDARD."
 -->
 
-<sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron" xml:lang="en">
+<sch:schema xmlns:sch="http://purl.oclc.org/dsdl/schematron" xml:lang="en" queryBinding="xslt2"
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <xsl:key name='abstract-pattern' match='sch:pattern[@abstract="true"]' use='@id'/>
     <sch:title>Schema for Additional Constraints in Schematron</sch:title>
     <sch:ns prefix="sch" uri="http://purl.oclc.org/dsdl/schematron"/>
     <sch:p>This schema supplies some constraints in addition to those given in the
@@ -29,29 +31,46 @@ AND SHOULD NOT BE INTERPRETED AS COMPLYING WITH THAT STANDARD."
         (RELAX NG Compact Syntax) Schema for Schematron. </sch:p>
     <sch:pattern>
         <sch:rule context="sch:active">
-            <sch:assert test="//sch:pattern[@id=current()/@pattern]"> The pattern
+            <sch:assert test="//sch:pattern[@id=current()/@pattern]" id='active-patterns'> The pattern
                 attribute of the active element shall match the id
                 attribute of a pattern.</sch:assert>
         </sch:rule>
-        <sch:rule context="sch:pattern[@is-a]">
-            <sch:assert test="//sch:pattern[@abstract='true'][@id=current()/@is-a]"> The
-                is-a attribute of a pattern element shall match 
-                the id attribute of an abstract pattern.
-            </sch:assert>
-        </sch:rule>
         <sch:rule context="sch:extends">
-            <sch:assert test="//sch:rule[@abstract='true'][@id=current()/@rule]"> The rule
+            <sch:assert test="//sch:rule[@abstract='true'][@id=current()/@rule]" id="abstract-rules"> The rule
                 attribute of an extends element shall match the id
                 attribute of an abstract rule.
             </sch:assert>
         </sch:rule>
         <sch:rule context="sch:let">
-            <sch:assert
+            <sch:assert id="param-variable-clash"
                 test="not(//sch:pattern
                 [@abstract='true']/sch:param[@name=current()/@name])"
                 > A variable name and an abstract pattern parameter should not use the
                 same name.
             </sch:assert>
         </sch:rule>
+        <sch:rule context="sch:param">
+            <sch:assert test="not(../(sch:param except current())[@name=current()/@name])"
+                id="param-name">A parameter name should not use the same name as a parameter in the same scope.</sch:assert>
+        </sch:rule>
+    </sch:pattern>
+    <sch:pattern>
+        <sch:rule context="sch:pattern[@is-a]">
+            <sch:assert test="key('abstract-pattern', @is-a)" id="abstract-patterns"> The
+                is-a attribute of a pattern element shall match 
+                the id attribute of an abstract pattern.
+            </sch:assert>
+            <sch:assert test="every $name in current()/sch:param/@name
+                satisfies $name eq key('abstract-pattern', @is-a)/sch:param/@name" id="param-names-match"> The
+                name attribute of a pattern param element shall match 
+                the name attribute of an abstract pattern param element.
+            </sch:assert>
+        </sch:rule>
+        <sch:rule context="sch:pattern[@is-a]/sch:param">
+            <sch:assert test="@value or key('abstract-pattern', ../@is-a)/sch:param/@value" id="missing-param-value">A pattern parameter value shall be specified.</sch:assert>
+        </sch:rule>
+        <sch:rule context="sch:schema/sch:param">
+            <sch:assert test="@value" id="schema-param-value">A schema parameter value shall be specified.</sch:assert>
+        </sch:rule>
     </sch:pattern>
 </sch:schema>
diff --git a/schematron.xspec b/schematron.xspec
new file mode 100644
index 0000000..cceb6d3
--- /dev/null
+++ b/schematron.xspec
@@ -0,0 +1,162 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+        
+    XSpec tests for Schematron schema schema (Annex B of ISO standard).
+    Tested under XSpec v3.0
+    
+-->
+<x:description xmlns:x="http://www.jenitennison.com/xslt/xspec" xmlns:sch='http://purl.oclc.org/dsdl/schematron' schematron="schematron.sch">
+    <x:scenario label="demo-01">
+        <x:context><schema xmlns="http://purl.oclc.org/dsdl/schematron">
+            <param name="myParam"/>
+            <param name="myParam"/>
+            <phase id='faulty'>
+                <active pattern="p1"/>
+            </phase>
+            <phase id='fault-free'>
+                <active pattern="p2"/>
+            </phase>
+            <pattern id="p2"/>
+            <pattern id='p3' is-a='foo'/>
+            <pattern id='p4' is-a='bar'>
+                <param name="blort"/>
+                <param name="not-declared"/>
+            </pattern>
+            <pattern id='bar' abstract='true'>
+                <param name='blort'/>
+            </pattern>
+            <pattern id="p5">
+                <let name='blort'/>
+                <let name='wibble'/>
+                <rule abstract='true' id='r1'/>
+                <extends rule='r1'/>
+                <extends rule='r2'/>
+            </pattern>
+            <pattern id='p6' abstract='true'>
+                <param name="blort"/>
+                <param name="blort"/>
+            </pattern>
+            <pattern id='p7' is-a='bar'>
+                <param name="blort"/>
+            </pattern>
+            <pattern id='p8' abstract='true'>
+                <!-- abstract pattern param contains default value -->
+                <param name="jam" value='spam'/>
+            </pattern>
+            <pattern id='p9' is-a='p8'>
+                <!-- concrete pattern param missing; use default from abstract -->
+                <param name="jam"/>
+            </pattern>
+            <pattern id='p10' is-a='p8'>
+                <!-- concrete pattern param overrides default value -->
+                <param name="jam" value='clam'/>
+            </pattern>
+            <pattern id="p11" abstract='true'>
+                <!-- abstract pattern param has no default value -->
+                <param name="sham"/>
+            </pattern>
+            <pattern id='p12' is-a='p11'>
+                <!-- concrete pattern param specifies value -->
+                <param name="sham" value='shazam'/>
+            </pattern>
+        </schema></x:context>
+
+        <x:scenario label="active pattern references">
+            <x:expect-not-assert
+                label="active pattern referenced correctly" id="active-patterns"
+                location="/sch:schema/sch:phase[@id='fault-free']/sch:active"/>
+            <x:expect-assert label="active pattern missing"
+                id="active-patterns" location="/sch:schema/sch:phase[@id='faulty']/sch:active"/>
+        </x:scenario>
+        
+        <x:scenario label="abstract pattern references">
+            <x:expect-assert label="abstract pattern missing"
+                id="abstract-patterns"
+                location="/sch:schema[1]/sch:pattern[@id='p3']"/>
+            <x:expect-not-assert label="abstract pattern referenced correctly"
+                id="abstract-patterns"
+                location="/sch:schema[1]/sch:pattern[@id='p4']"/>
+        </x:scenario>
+        
+        <x:scenario label="abstract rule references">
+            <x:expect-assert label="abstract rule missing"
+            id="abstract-rules"
+            location="/sch:schema/sch:pattern[@id='p5']/sch:extends[@rule='r2']"/>
+            <x:expect-not-assert label="abstract rule referenced correctly"
+                id="abstract-rules"
+                location="/sch:schema/sch:pattern[@id='p5']/sch:extends[@rule='r1']"/>
+        </x:scenario>
+        
+        <x:scenario label="parameter variable name clash">
+            <x:expect-assert label="param variable name clash"
+                id="param-variable-clash"
+                location="/sch:schema/sch:pattern[@id='p5']/sch:let[@name='blort']"/>
+            <x:expect-not-assert label="param variable no name clash"
+                id="param-variable-clash"
+                location="/sch:schema/sch:pattern[@id='p5']/sch:let[@name='wibble']"/>
+        </x:scenario>
+        
+        <x:scenario label="schema param dupe name">
+            <x:expect-assert label="duplicate schema param"
+            id="param-name"
+            location="/sch:schema/sch:param[1]"/>
+            <x:expect-assert label="duplicate pattern param"
+                id="param-name"
+                location="/sch:schema/sch:pattern[@id='p6']/sch:param[1]"/>
+            <x:expect-not-assert label="distinct pattern param"
+                id="param-name"
+                location="/sch:schema/sch:pattern[@id='bar']/sch:param[1]"/>
+        </x:scenario>
+        
+        <!-- not-assert version of previous scenario, with no duplicate schema params -->
+        <x:scenario label="schema param dupe name">
+            <x:context><sch:schema>
+                <sch:param name='pram1'/>
+                <sch:param name='pram2'/>
+            </sch:schema></x:context>
+            <x:expect-not-assert label="distinct schema param"
+                id="param-name"
+                location="/sch:schema/sch:param[1]"/>
+        </x:scenario>
+        
+        <x:scenario label="concrete and abstract param names match">
+            <x:expect-assert label="param name not declared for abstract pattern"
+                id="param-names-match"
+                location="/sch:schema/sch:pattern[@id='p4']"/>
+            <x:expect-not-assert label="param name declared for abstract pattern"
+                id="param-names-match"
+                location="/sch:schema/sch:pattern[@id='p7']"/>
+        </x:scenario>
+        
+        <x:scenario label="pattern param value must be present">
+            <x:expect-assert label="param value not present on concrete or abstract pattern params"
+                id="missing-param-value"
+                location="/sch:schema/sch:pattern[@id='p7']/sch:param"/>
+            <x:expect-not-assert label="param value defaults to abstract pattern param"
+                id="missing-param-value"
+                location="/sch:schema/sch:pattern[@id='p9']/sch:param"/>
+            <x:expect-not-assert label="concrete pattern param value overrides abstract pattern default param value"
+                id="missing-param-value"
+                location="/sch:schema/sch:pattern[@id='p10']/sch:param"/>
+            <x:expect-not-assert label="concrete pattern param specifies value (no abstract pattern param default)"
+                id="missing-param-value"
+                location="/sch:schema/sch:pattern[@id='p12']/sch:param"/>
+        </x:scenario>
+        
+        <x:scenario label="schema param value must be present">
+            <x:expect-assert label="para value missing"
+                id="schema-param-value"
+                location="/sch:schema/sch:param[1]"/>
+        </x:scenario>
+        
+        <!-- not-assert version of previous scenario, with no missing schema param values -->
+        <x:scenario label="schema param value must be present">
+            <x:context><sch:schema>
+                <sch:param name='pram1' value='asldj'/>
+            </sch:schema></x:context>
+            <x:expect-not-assert label="schema param value present"
+                id="schema-param-value"
+                location="/sch:schema/sch:param[1]"/>
+        </x:scenario>
+    </x:scenario>
+</x:description>
diff --git a/svrl.rnc b/svrl.rnc
index 47ebd57..e182e78 100644
--- a/svrl.rnc
+++ b/svrl.rnc
@@ -1,4 +1,4 @@
-# Copyright © ISO/IEC 2019
+# Copyright © ISO/IEC 2024
 # 
 # The following permission notice and disclaimer shall be included in all 
 # copies of this XML schema ("the Schema"), and derivations of the Schema: 
@@ -32,10 +32,16 @@ schematron-output =
         attribute title { text }?,
         attribute phase { xsd:NMTOKEN }?,
         attribute schemaVersion { text }?,
-        human-text*,
-        ns-prefix-in-attribute-values*,
-        (active-pattern,
-         (fired-rule, (failed-assert | successful-report)*)*)+
+        attribute schematronEdition { text }?,
+        (
+            (error+, human-text*)
+            |
+            (error*,
+            human-text*,
+            ns-prefix-in-attribute-values*,
+            (active-pattern-rule-set,
+             (fired-rule, (failed-assert | successful-report)*)*)+)
+        )
     }
 # only namespaces from sch:ns need to be reported 
 ns-prefix-in-attribute-values =
@@ -44,23 +50,24 @@ ns-prefix-in-attribute-values =
         attribute uri { text },
         empty
     }
-# only active patterns are reported 
+# only active patterns and groups are reported 
 active-pattern =
     element active-pattern {
-        attribute id { xsd:NCName }?,
-        attribute documents { text }?,
-        attribute name { text }?,
-        attribute role { string }?,
-        empty
+        active
     }
+active-rule-set =
+    element active-group {
+        active
+    }    
 # only rules that are fired are reported, 
 fired-rule =
     element fired-rule {
         attribute id { xsd:NCName }?,
         attribute name { text }?,
         attribute context { text },
+        attribute visit-each { text }?,
         attribute role { string }?,
-        attribute flag { string }?,
+        attribute flag { list{ token+ } }?,
         attribute document { xsd:anyURI }?,
         empty
     }
@@ -68,17 +75,18 @@ fired-rule =
 diagnostic-reference =
     element diagnostic-reference {
         attribute diagnostic { xsd:NMTOKEN },
+        attribute role { text }?,
         human-text
     }
 # only failed assertions are reported 
 failed-assert =
     element failed-assert {
-        attlist.assert-and-report, diagnostic-reference*, property-reference*, human-text
+        assertion-message
     }
 # only successful asserts are reported 
 successful-report =
     element successful-report {
-        attlist.assert-and-report, diagnostic-reference*, property-reference*, human-text
+        assertion-message
     }
 # property-reference 
 property-reference =
@@ -88,6 +96,14 @@ property-reference =
         attribute scheme { text }?,
         human-text
     }
+# errors raised by the implementation
+error =
+    element error {
+        attribute document { xsd:anyURI },
+        attribute location { text },
+        attribute code { text }?,
+        rich-text
+    }
 # human text 
 human-text =
     element text {
@@ -133,5 +149,21 @@ attlist.assert-and-report =
     attribute location { text },
     attribute test { text },
     attribute role { string }?,
-    attribute flag { string }?
+    attribute flag { list{ token+ } }?,
+    attribute severity { string }?
+
+# active patterns and rule-sets
+active-pattern-rule-set =
+    active-pattern | active-rule-set
+active =
+    attribute id { xsd:NCName }?,
+    attribute documents { text }?,
+    attribute name { text }?,
+    attribute role { string }?,
+    error*
+    
+# assert and report message
+assertion-message = 
+    attlist.assert-and-report, diagnostic-reference*, property-reference*, human-text
+
 start = schematron-output
\ No newline at end of file
diff --git a/svrl.sch b/svrl.sch
index e7acb17..18e08aa 100644
--- a/svrl.sch
+++ b/svrl.sch
@@ -1,5 +1,5 @@
 <!--
-Copyright © ISO/IEC 2014
+Copyright © ISO/IEC 2024
 
 The following permission notice and disclaimer shall be included in all
 copies of this XML schema ("the Schema"), and derivations of the Schema:
@@ -54,7 +54,7 @@ AND SHOULD NOT BE INTERPRETED AS COMPLYING WITH THAT STANDARD."
             <sch:assert test="not(../*)"> The <sch:name/> element is the root element.
             </sch:assert>
             <sch:assert
-                test="count(svrl:text) + count(svrl:ns-prefix-in-attribute-values) +count(svrl:fired-rule) + count(svrl:failed-assert) +
+                test="count(svrl:text) + count(svrl:ns-prefix-in-attribute-values) + count(svrl:active-pattern) + count(svrl:fired-rule) + count(svrl:failed-assert) +
                 count(svrl:successful-report) = count(*)">
                 <sch:name/> may only contain the following elements: text,
                 ns-prefix-in-attribute-values, active-pattern, fired-rule, failed-assert and
@@ -89,7 +89,7 @@ AND SHOULD NOT BE INTERPRETED AS COMPLYING WITH THAT STANDARD."
             <sch:extends rule="second-level"/>
             <sch:extends rule="empty"/>
             <sch:assert
-                test="preceding-sibling::active-pattern |
+                test="preceding-sibling::svrl:active-pattern |
                 preceding-sibling::svrl:fired-rule |
                 preceding-sibling::svrl:failed-assert |
                 preceding-sibling::svrl:successful-report"
@@ -131,7 +131,7 @@ AND SHOULD NOT BE INTERPRETED AS COMPLYING WITH THAT STANDARD."
         <sch:title>Required Attributes</sch:title>
         <sch:rule context=" $context ">
             <sch:assert test="string-length( $attribute ) &gt; 0"> The <sch:name/> element
-                should have a <sch:value-of select="$attribute /name()"/> attribute.
+                should have a <sch:value-of select="name($attribute)"/> attribute.
             </sch:assert>
         </sch:rule>
     </sch:pattern>