diff --git a/projects/oscal-import/.gitignore b/projects/FM6-22-import/.gitignore
similarity index 100%
rename from projects/oscal-import/.gitignore
rename to projects/FM6-22-import/.gitignore
diff --git a/projects/oscal-import/GRAB-FM6-22.xpl b/projects/FM6-22-import/GRAB-FM6-22.xpl
similarity index 100%
rename from projects/oscal-import/GRAB-FM6-22.xpl
rename to projects/FM6-22-import/GRAB-FM6-22.xpl
diff --git a/projects/oscal-import/GRAB-NISO_STS-RNG.xpl b/projects/FM6-22-import/GRAB-NISO_STS-RNG.xpl
similarity index 100%
rename from projects/oscal-import/GRAB-NISO_STS-RNG.xpl
rename to projects/FM6-22-import/GRAB-NISO_STS-RNG.xpl
diff --git a/projects/oscal-import/GRAB-RESOURCES.xpl b/projects/FM6-22-import/GRAB-RESOURCES.xpl
similarity index 100%
rename from projects/oscal-import/GRAB-RESOURCES.xpl
rename to projects/FM6-22-import/GRAB-RESOURCES.xpl
diff --git a/projects/oscal-import/PRODUCE_FM6-22-chapter4.xpl b/projects/FM6-22-import/PRODUCE_FM6-22-chapter4.xpl
similarity index 100%
rename from projects/oscal-import/PRODUCE_FM6-22-chapter4.xpl
rename to projects/FM6-22-import/PRODUCE_FM6-22-chapter4.xpl
diff --git a/projects/oscal-import/TESTING.md b/projects/FM6-22-import/TESTING.md
similarity index 100%
rename from projects/oscal-import/TESTING.md
rename to projects/FM6-22-import/TESTING.md
diff --git a/projects/oscal-import/readme.md b/projects/FM6-22-import/readme.md
similarity index 100%
rename from projects/oscal-import/readme.md
rename to projects/FM6-22-import/readme.md
diff --git a/projects/oscal-import/source/export/fm6_22.html b/projects/FM6-22-import/source/export/fm6_22.html
similarity index 100%
rename from projects/oscal-import/source/export/fm6_22.html
rename to projects/FM6-22-import/source/export/fm6_22.html
diff --git a/projects/oscal-import/source/export/fm6_22_e.html b/projects/FM6-22-import/source/export/fm6_22_e.html
similarity index 100%
rename from projects/oscal-import/source/export/fm6_22_e.html
rename to projects/FM6-22-import/source/export/fm6_22_e.html
diff --git a/projects/oscal-import/src/fm22-6-html-to-sts.xsl b/projects/FM6-22-import/src/fm22-6-html-to-sts.xsl
similarity index 100%
rename from projects/oscal-import/src/fm22-6-html-to-sts.xsl
rename to projects/FM6-22-import/src/fm22-6-html-to-sts.xsl
diff --git a/projects/oscal-import/src/fm22-6_chapter4-sts.sch b/projects/FM6-22-import/src/fm22-6_chapter4-sts.sch
similarity index 100%
rename from projects/oscal-import/src/fm22-6_chapter4-sts.sch
rename to projects/FM6-22-import/src/fm22-6_chapter4-sts.sch
diff --git a/projects/oscal-import/src/fm22-6_restructure.xsl b/projects/FM6-22-import/src/fm22-6_restructure.xsl
similarity index 100%
rename from projects/oscal-import/src/fm22-6_restructure.xsl
rename to projects/FM6-22-import/src/fm22-6_restructure.xsl
diff --git a/projects/oscal-import/src/fm22-6_structure.xsl b/projects/FM6-22-import/src/fm22-6_structure.xsl
similarity index 100%
rename from projects/oscal-import/src/fm22-6_structure.xsl
rename to projects/FM6-22-import/src/fm22-6_structure.xsl
diff --git a/projects/oscal-import/src/fm22-6_sts-enhance1.xsl b/projects/FM6-22-import/src/fm22-6_sts-enhance1.xsl
similarity index 100%
rename from projects/oscal-import/src/fm22-6_sts-enhance1.xsl
rename to projects/FM6-22-import/src/fm22-6_sts-enhance1.xsl
diff --git a/projects/oscal-import/src/fm22-6_sts-enhance2.xsl b/projects/FM6-22-import/src/fm22-6_sts-enhance2.xsl
similarity index 100%
rename from projects/oscal-import/src/fm22-6_sts-enhance2.xsl
rename to projects/FM6-22-import/src/fm22-6_sts-enhance2.xsl
diff --git a/projects/oscal-import/src/fm22-6_sts-enhance3.xsl b/projects/FM6-22-import/src/fm22-6_sts-enhance3.xsl
similarity index 100%
rename from projects/oscal-import/src/fm22-6_sts-enhance3.xsl
rename to projects/FM6-22-import/src/fm22-6_sts-enhance3.xsl
diff --git a/projects/oscal-import/src/fm22-6_sts-to-oscal.xsl b/projects/FM6-22-import/src/fm22-6_sts-to-oscal.xsl
similarity index 100%
rename from projects/oscal-import/src/fm22-6_sts-to-oscal.xsl
rename to projects/FM6-22-import/src/fm22-6_sts-to-oscal.xsl
diff --git a/projects/oscal-import/src/oscal-check.sch b/projects/FM6-22-import/src/oscal-check.sch
similarity index 100%
rename from projects/oscal-import/src/oscal-check.sch
rename to projects/FM6-22-import/src/oscal-check.sch
diff --git a/projects/oscal-import/src/oscal-to-sts.xsl b/projects/FM6-22-import/src/oscal-to-sts.xsl
similarity index 100%
rename from projects/oscal-import/src/oscal-to-sts.xsl
rename to projects/FM6-22-import/src/oscal-to-sts.xsl
diff --git a/projects/oscal-import/src/sts-check.sch b/projects/FM6-22-import/src/sts-check.sch
similarity index 100%
rename from projects/oscal-import/src/sts-check.sch
rename to projects/FM6-22-import/src/sts-check.sch
diff --git a/projects/oscal-import/src/sts-reflow-ws.xsl b/projects/FM6-22-import/src/sts-reflow-ws.xsl
similarity index 100%
rename from projects/oscal-import/src/sts-reflow-ws.xsl
rename to projects/FM6-22-import/src/sts-reflow-ws.xsl
diff --git a/projects/oscal-import/src/validation-summaries.xpl b/projects/FM6-22-import/src/validation-summaries.xpl
similarity index 100%
rename from projects/oscal-import/src/validation-summaries.xpl
rename to projects/FM6-22-import/src/validation-summaries.xpl
diff --git a/projects/oscal-import/src/validation-summarize.xpl b/projects/FM6-22-import/src/validation-summarize.xpl
similarity index 100%
rename from projects/oscal-import/src/validation-summarize.xpl
rename to projects/FM6-22-import/src/validation-summarize.xpl
diff --git a/projects/oscal-import/src/www_fm22-6_fulltext.xsl b/projects/FM6-22-import/src/www_fm22-6_fulltext.xsl
similarity index 100%
rename from projects/oscal-import/src/www_fm22-6_fulltext.xsl
rename to projects/FM6-22-import/src/www_fm22-6_fulltext.xsl
diff --git a/projects/oscal-import/src/www_fm22-6_tables.xsl b/projects/FM6-22-import/src/www_fm22-6_tables.xsl
similarity index 100%
rename from projects/oscal-import/src/www_fm22-6_tables.xsl
rename to projects/FM6-22-import/src/www_fm22-6_tables.xsl
diff --git a/testing/xproc3-house-rules.sch b/testing/xproc3-house-rules.sch
index 96dad604..cf729920 100644
--- a/testing/xproc3-house-rules.sch
+++ b/testing/xproc3-house-rules.sch
@@ -87,6 +87,8 @@
    <sch:let name="resource-fileset-path" value="( (tokenize($fileset-relPath,'/')  [position() ne last()] ! '../') => string-join('') ) || $resource-repoPath"/>
    <sch:let name="fileset-resource-path" value="( (tokenize($resource-repoPath,'/')[position() ne last()] ! '../') => string-join('') ) || $fileset-relPath"/>
    
+   <sch:let name="okay-ns-prefixes" value="'','p','c','ox','xml','xsl','x','xs','html','svrl','xvrl','cprt'"/>
+   
    <sch:pattern>
       <sch:rule context="/*">
          <!--<sch:report test="false()">
@@ -100,7 +102,7 @@
          </sch:report>-->
          
          <sch:assert sqf:fix="sqf-exempt-from-houserules-check" role="warning" test="base-uri(.) = $listed-uris or exists(p:documentation[contains(.,'HALL PASS') and contains(.,'HOUSE RULES')])">file <sch:value-of select="$filename"/> isn't listed in validation set maintained in <sch:value-of select="$fileset-resource-path"/> - should it be?</sch:assert>
-         <sch:let name="unexpected-prefixes" value="in-scope-prefixes(.)[not(.=('','p','c','ox','xml','xsl','x','xs','html','svrl','xvrl'))]"/>
+         <sch:let name="unexpected-prefixes" value="in-scope-prefixes(.)[not(.=$okay-ns-prefixes)]"/>
          <sch:report test="$unexpected-prefixes => exists()">This repo is keeping a list of recognized namespace prefixes, which does not include <sch:value-of select="$unexpected-prefixes => string-join(', ')"/></sch:report>
          <sch:assert sqf:fix="sqf-make-version-3"   test="@version = '3.0'">Expecting XProc 3.0, not <sch:value-of select="@version"/></sch:assert>
       </sch:rule>
diff --git a/tutorial/source/oscal-convert/oscal-convert_350_src.html b/tutorial/source/oscal-convert/oscal-convert_350_src.html
index 5de1c760..f8778f82 100644
--- a/tutorial/source/oscal-convert/oscal-convert_350_src.html
+++ b/tutorial/source/oscal-convert/oscal-convert_350_src.html
@@ -50,5 +50,21 @@ <h2>Namespace fixup and namespace cleanup steps</h2>
             is a common remedy for <em>inflamed namespaces</em>, a condition that happens to XML that has been handled
             recklessly by too many handlers with too many namespaces. Also, <code>p:namespace-rename</code>.</p>
       </section>
+      <section>
+         <h2>Namespace tips and tricks XXX</h2>
+         <section>
+            <h3>Coining new namespaces</h3>
+         </section>
+         <section>
+            <h3>On-the-fly namespace declarations</h3>
+         </section>
+         <section>
+            <h3>Overloading prefixes</h3>
+         </section>
+         <section>
+            <h3>Matching with namespace wildcard</h3>
+            <p>For example, <code>match="*:p"</code> will match any <code>p</code> element in any namespace.</p>
+         </section>
+      </section>
    </body>
 </html>
\ No newline at end of file
diff --git a/tutorial/source/walkthrough/walkthrough_101_src.html b/tutorial/source/walkthrough/walkthrough_101_src.html
index dbe86fd7..a5c98966 100644
--- a/tutorial/source/walkthrough/walkthrough_101_src.html
+++ b/tutorial/source/walkthrough/walkthrough_101_src.html
@@ -85,7 +85,7 @@ <h2>A closer look</h2>
          <ul>
             <li><a href="../../../smoketest/TEST-XPROC3.xpl">smoketest/TEST-XPROC3.xpl</a> amounts to an XProc <q>Hello
                   World</q>. In that spirit, feel free to write your own version. (You get another chance to do this <a
-                  href="walkthrough_102_src.html">real soon now</a>.)</li>
+                  href="walkthrough_102_src.html" class="LessonUnit">real soon now</a>.)</li>
             <li><a href="../../../smoketest/TEST-XSLT.xpl">smoketest/TEST-XSLT.xpl</a> tests Saxon, an XSLT/XQuery
                transformation engine. XSLT and XQuery are related technologies (different languages, same data model)
                developed with XML processing in mind, but in recent years generalized to a wider range of data
@@ -151,7 +151,7 @@ <h3>TEST-XSLT</h3>
                results in the console. This time the result is not just the XML given in the pipeline, but that XML as
                modified by the transformation.</p>
             <p>If your pipeline execution can't process the XSLT (perhaps Saxon is not installed, or the XSLT itself has
-               a problem) you will get an error to say so.</p>
+               a problem) you will get an error saying so.</p>
             <p>Errors in XProc are reported by the Morgana engine using XML syntax. Among other things, this means they
                can be captured and processed in pipelines.</p>
          </section>
@@ -212,25 +212,28 @@ <h2>A not-so-simple pipeline</h2>
             predictable interface.</p>
          <p>Next, take a look at a more complex example, the prototype pipeline <a
                href="../../PRODUCE-PROJECTS-ELEMENTLIST.xpl">PRODUCE-PROJECTS-ELEMENTLIST.xpl</a>. Like the setup and
-            smoke-test pipelines, this is a standalone pipeline: when this plan (<q>step</q> or pipeline) is executed,
-            the processor will acquires inputs, produce results and write those results to the file system. The output
-            it generates is stored as <a href="../../sequence/element-directory.md">element-directory.md</a>, a Markdown
-            file (find the <code>p:store</code> step).</p>
-         <p>The result is a reference resource encoded in Markdown: an index of XProc elements used in pipelines
-            described in this tutorial, which can be reposted back into the repository or viewed with any Markdown
+            smoke-test pipelines, this is a standalone pipeline (requiring no runtime bindings or settings): when this
+            plan (<q>step</q> or pipeline) is executed, the processor will acquires inputs, produce results and write
+            those results to the file system. The output it generates is stored as <a
+               href="../../sequence/element-directory.md">element-directory.md</a>, a Markdown file (find the
+               <code>p:store</code> step).</p>
+         <p>The result is a reference resource encoded in Markdown: an index of XProc elements used in pipelines in this
+            repository. As Markdown, this result can be reposted back into the repository or viewed with any Markdown
             viewing application. The index lists XProc elements, that is the core of the XProc vocabulary: for any XProc
-            element used anywhere, the listing shows the pipelines where it appears. Following the index, the resource
-            also shows a list of (repository) project folders in an order corresponding to their treatment (if any) in
-            this tutorial, with their XProc files and whatever XProc elements appear <i>first</i> (within the entire
-            sequence up to to point) within that file. Among other uses this is helpful for assessing coverage of
-            lessons.</p>
+            element used anywhere among the projects listed, the listing shows the pipelines where it appears. Following
+            the index, the resource also shows a list of (repository) project folders in a prescribed order, with their
+            XProc files and whatever XProc elements appear <i>first</i> (within the entire sequence up to to point)
+            within that file. Among other uses this is helpful for assessing coverage of tutorial lessons as it offers a
+            (semi) <i>ordered</i> survey of the elements.</p>
          <p>For example, looking up <code>p:store</code> you can see all the pipelines that contain this common step. Or
-            looking at the <code>oscal-convert</code> listing you can see the XProc steps introduced in that lesson.</p>
-         <p>Delete or rename this result file and run the pipeline to confirm it functions properly.</p>
+            looking at the <code>oscal-convert</code> listing you can see the XProc steps appearing first in that
+            project folder.</p>
+         <p>To confirm proper functioning, run the pipeline again after deleting or renaming the Markdown result
+            file.</p>
          <p>Consider also what other kinds of indexing might be useful. When you modify XProc or add new XProc pipelines
             to the project folders, consider running this pipeline again to update the indexes.</p>
          <p>Open the file and inspect it to get a sense of how it works. The XML syntax is verbose, but not really all
-            that frightening. The pipeline is described in more detail in the <a href="walkthrough_102_src.html"
+            that frightening. Practice helps! The pipeline is also considered in the <a href="walkthrough_102_src.html"
                class="LessonUnit">102 Lesson unit</a> segment.</p>
          <section>
             <h3>PRODUCE-PROJECTS-ELEMENTLIST</h3>
@@ -248,11 +251,11 @@ <h3>PRODUCE-PROJECTS-ELEMENTLIST</h3>
                   produced in this second analytical phase, showing how once the files are surveyed, more than one
                   analysis is possible.</li>
                <li>In particular, the index to <q>first use</q> is not simple. A great deal of the complexity of
-                  detailed operations has been off loaded into XSLT transformation code, which in this pipeline can be
+                  detailed operations has been off-loaded into XSLT transformation code, which in this pipeline can be
                   seen embedded in the XProc, indeed occupying the greater part of the XML in the file. (About two
-                  thirds of the element count: you can usually recognize XSLT by the conventional <code>xsl:</code> or
-                     <code>xslt:</code> element prefix.) This pipeline also has an XSLT (at the end) called from an
-                  external file, toward the end. XProc can do it either way, and each has its advantages.</li>
+                  thirds of the element count: you can usually recognize XSLT by the conventional <code>xsl:</code>
+                  element prefix.) This pipeline also has an XSLT called from an external file (toward the end). XProc
+                  can provide XSLT either way, and each has its advantages.</li>
                <li>One good thing about seeing the XSLT here is you can get a good sense of what it looks like, whether
                   embedded or kept externally. XSLT is <a href="walkthrough_401_src.html" class="LessonUnit">not
                      essential to XProc</a>, but it very much expands its practical capabilities.</li>
diff --git a/tutorial/source/walkthrough/walkthrough_401_src.html b/tutorial/source/walkthrough/walkthrough_401_src.html
index c8b44ad6..d8e2c64e 100644
--- a/tutorial/source/walkthrough/walkthrough_401_src.html
+++ b/tutorial/source/walkthrough/walkthrough_401_src.html
@@ -53,33 +53,31 @@ <h2>XSLT: XSL (XML Stylesheet Language) Transformations</h2>
             model is both broadly applicable, and workable in a range of environments including client software or
             within encapsulated, secure software configurations and deployments.</p>
          <p>If your XSLT is strong enough, you don't need XProc, or not much. But as a functional language, XSLT is best
-            used in a functionally pure way that does not interact with the system: no <q>side effects</q>. This is
-            related to its definitions of conformant processing (X inputs produce Y outputs) and the determinism, based
-            in mathematical formalisms, that underlies this idea of conformance. However one cost of mathematical purity
-            is that operations that do interact with stateful externalities – things such as reading and writing files –
-            are not in XSLT's <q>comfort zone</q>. It easily defines what a new structure A' should look like for any
-            given structure A. But how A is first acquired or what we do once we have determined A', is less clear, and
-            left up to the processor to handle, as an interface, starting with an XSLT transformation's nominal
-               <em>source</em> and (primary) <em>result</em>. Often, this gap has been bridged by extended functionality
-            provided by leading processors. Does your processor read and parse XML files off the file system? Can it be
-            connected to upstream processes in different ways? Can it use HTTP <code>GET</code> and <code>PUT</code>?
-            The answer may be Yes to any or all of these. Throughout its history, XSLT in later versions was also
-            extended in this direction, with features such as the <code>collection()</code> function,
-               <code>xsl:result-document</code>, <code>doc-available()</code> and other features we don't need if we are
-            using XProc.</p>
-         <p>Then too, XSLT is commonly run from scripts, in web hosting environments, and indeed from XQuery. Or you
-            might be able to configure your desktop software (Editor or IDE) to run your XSLT, or indeed acquire
-            specialized software just for reading and filtering collections or managing sets of file outputs in
-            XSLT-based workflows.</p>
-         <p>It is difficult not to think, however, that a gentler approach is also possible to the range of problems
-            related to making XSLT accessible in any environment – one that offers the feature set and flexibility we
-            need, but with less overhead, especially with regard to routine chores like designating sets of inputs and
+            used in a functionally pure, <q>stateless</q> way that does not interact with the system: no <q>side
+               effects</q>. This is related to its definitions of conformant processing (X inputs produce Y outputs) and
+            the determinism, based in mathematical formalisms, that underlies its idea of conformance. However one cost
+            of mathematical purity is that operations that do interact with stateful externalities – things such as
+            reading and writing files – are not in XSLT's <q>comfort zone</q>. It easily defines what a new structure A'
+            should look like for any given structure A. But how A is first acquired or what we do once we have
+            determined A', is less clear, and left up to the processor to handle, as an interface, starting with an XSLT
+            transformation's nominal <em>source</em> and (primary) <em>result</em>. Often, this gap has been bridged by
+            extended functionality in processors. Does your processor read and parse XML files off the file system? Can
+            it be connected to upstream data producers in different ways? Can it use HTTP <code>GET</code> and
+               <code>PUT</code>? The answer may be Yes to any or all of these. Throughout its history, XSLT in later
+            versions was also extended in this direction, with features such as the <code>collection()</code> function,
+               <code>xsl:result-document</code>, <code>doc-available()</code> and other features we may not need if we
+            are using XProc.</p>
+         <p>XSLT is commonly run from scripts, in web hosting environments and XQuery databases. Or you might be able to
+            configure your desktop software (Editor or IDE) to run your XSLT, or acquire specialized software just for
+            reading and filtering collections or managing sets of file outputs in XSLT-based workflows.</p>
+         <p>Yet XProc may offer a gentler approach, while it enables XSLT on the one hand when needed, while on the
+            other enables us largely to do without it, offering both a useful feature set and the flexibility we need,
+            but with less overhead, especially with regard to routine chores like designating sets of inputs and
             outputs, or sequencing operations. The principle of Least Power may well apply here: it saves our present
             and our future selves effort if we can arrange and manage to do things less. XProc lets us do less.</p>
-         <p>XProc lets us use XSLT when we must, but also keeps routine and simple things both simple and consistent,
-            without requiring much overhead. But it adapts itself well to new requirements as they become more
-            complicated. Ultimately, it spares the XSLT developer the problem of having to design, build and test
-            something like XProc.</p>
+         <p>XProc lets us use XSLT when we must, but also keeps routine and simple things both simple and consistent.
+            And it adapts itself well to new requirements as they become more complicated. Ultimately, it spares the
+            XSLT developer the problem of having to design, build and test something like XProc.</p>
          <section>
             <h3>Running XSLT without XProc</h3>
             <p>As a standard and an externally-specified technology, XSLT can in principle be implemented on any
@@ -91,6 +89,21 @@ <h3>Running XSLT without XProc</h3>
             <p>Download and run Saxon to apply XSLT to XML and other inputs, without XProc.</p>
          </section>
       </section>
+      <section>
+         <h2>Using XSLT in XProc: avoiding annoyances XXX</h2>
+         <p>If you are an experienced XSLT user, congratulations! The power XProc puts into your hands is everything you
+            might think and hope.</p>
+         <p>There are a couple of small but potentially annoying considerations when embedding XSLT literals in your
+            XProc code. They do not apply when your XSLT is called from out of line, acquired by binding to an input
+            port or even <code>p:load</code>. If you acquire and even manipulate your XSLT without including literal
+            XSLT code in your XProc, that eliminates the syntax-level clashes at the roots of both these problems.</p>
+         <section>
+            <h3>Text and attribute value syntax in embedded XSLT</h3>
+         </section>
+         <section>
+            <h3>Namespaces in and for your XSLT</h3>
+         </section>
+      </section>
       <section>
          <h2>Learning XSLT the safer way</h2>
          <p>If setting out to learn XSLT, pause to read the following list of things to which you should give early
diff --git a/tutorial/tutorial-preview.html b/tutorial/tutorial-preview.html
index 6e848869..6c51c75d 100644
--- a/tutorial/tutorial-preview.html
+++ b/tutorial/tutorial-preview.html
@@ -109,7 +109,7 @@ <h2>Declarative markup in action</h2>
             <div class="unit observer"
                  id="toc-walkthrough_101"
                  data-track="observer">
-               <h1>101: Unpacking XProc 3.0<span class="wordcount over"> (~2669)</span>
+               <h1>101: Unpacking XProc 3.0<span class="wordcount over"> (~2680)</span>
                </h1>
                <div>
                   <h2>Goals</h2>
@@ -238,7 +238,7 @@ <h2>Exercise: Discussion board</h2>
             <div class="unit learner"
                  id="toc-walkthrough_401"
                  data-track="learner">
-               <h1>401 - XSLT Forward and Back<span class="wordcount okay"> (~1393)</span>
+               <h1>401 - XSLT Forward and Back<span class="wordcount okay"> (~1499)</span>
                </h1>
                <div>
                   <h2>Goals</h2>
@@ -264,6 +264,15 @@ <h2>XSLT: XSL (XML Stylesheet Language) Transformations</h2>
                      <h3>Running XSLT without XProc</h3>
                   </div>
                </div>
+               <div>
+                  <h2>Using XSLT in XProc: avoiding annoyances XXX</h2>
+                  <div>
+                     <h3>Text and attribute value syntax in embedded XSLT</h3>
+                  </div>
+                  <div>
+                     <h3>Namespaces in and for your XSLT</h3>
+                  </div>
+               </div>
                <div>
                   <h2>Learning XSLT the safer way</h2>
                </div>
@@ -462,7 +471,7 @@ <h2>for 599: round tripping as process test</h2>
             <div class="unit maker"
                  id="toc-oscal-convert_350"
                  data-track="maker">
-               <h1>350: Namespaces in XML and XProc<span class="wordcount okay"> (~371)</span>
+               <h1>350: Namespaces in XML and XProc<span class="wordcount okay"> (~399)</span>
                </h1>
                <div>
                   <h2>Goals</h2>
@@ -479,11 +488,26 @@ <h2>XML and namespaces</h2>
                <div>
                   <h2>Namespace fixup and namespace cleanup steps</h2>
                </div>
+               <div>
+                  <h2>Namespace tips and tricks XXX</h2>
+                  <div>
+                     <h3>Coining new namespaces</h3>
+                  </div>
+                  <div>
+                     <h3>On-the-fly namespace declarations</h3>
+                  </div>
+                  <div>
+                     <h3>Overloading prefixes</h3>
+                  </div>
+                  <div>
+                     <h3>Matching with namespace wildcard</h3>
+                  </div>
+               </div>
             </div>
             <div class="unit maker"
                  id="toc-oscal-convert_401"
                  data-track="maker">
-               <h1>401: XProc, XML, JSON and content types<span class="wordcount okay"> (~221)</span>
+               <h1>401: XProc, XML, JSON and content types<span class="wordcount okay"> (~296)</span>
                </h1>
                <div>
                   <h2>Goals</h2>
@@ -765,12 +789,12 @@ <h2>Goals</h2>
             </section>
             <section>
                <h2>Resources</h2>
-               <p>Same as <a href="setup_101_src.html"
+               <p>Same as <a href="acquire_101_src.html"
                      class="LessonUnit">Setup 101</a>.</p>
             </section>
             <section>
                <h2>Prerequisites</h2>
-               <p>Please complete the repository setup and smoke tests as described in the <a href="setup_101_src.html"
+               <p>Please complete the repository setup and smoke tests as described in the <a href="acquire_101_src.html"
                      class="LessonUnit">101 lesson</a>. In this lesson, we will run these pipelines with adjustments, or
             similar pipelines.</p>
                <p>This discussion assumes basic knowledge of coding, the Internet (including retrieving resources via
@@ -981,7 +1005,8 @@ <h2>A closer look</h2>
                <ul>
                   <li>
                      <a href="../../../smoketest/TEST-XPROC3.xpl">smoketest/TEST-XPROC3.xpl</a> amounts to an XProc <q>Hello
-                  World</q>. In that spirit, feel free to write your own version. (You get another chance to do this <a href="walkthrough_102_src.html">real soon now</a>.)</li>
+                  World</q>. In that spirit, feel free to write your own version. (You get another chance to do this <a href="walkthrough_102_src.html"
+                        class="LessonUnit">real soon now</a>.)</li>
                   <li>
                      <a href="../../../smoketest/TEST-XSLT.xpl">smoketest/TEST-XSLT.xpl</a> tests Saxon, an XSLT/XQuery
                transformation engine. XSLT and XQuery are related technologies (different languages, same data model)
@@ -1054,7 +1079,7 @@ <h3>TEST-XSLT</h3>
                results in the console. This time the result is not just the XML given in the pipeline, but that XML as
                modified by the transformation.</p>
                   <p>If your pipeline execution can't process the XSLT (perhaps Saxon is not installed, or the XSLT itself has
-               a problem) you will get an error to say so.</p>
+               a problem) you will get an error saying so.</p>
                   <p>Errors in XProc are reported by the Morgana engine using XML syntax. Among other things, this means they
                can be captured and processed in pipelines.</p>
                </section>
@@ -1124,25 +1149,27 @@ <h2>A not-so-simple pipeline</h2>
             managed and deployed just like a simple one, with its internal complexities masked by a simple and
             predictable interface.</p>
                <p>Next, take a look at a more complex example, the prototype pipeline <a href="../../PRODUCE-PROJECTS-ELEMENTLIST.xpl">PRODUCE-PROJECTS-ELEMENTLIST.xpl</a>. Like the setup and
-            smoke-test pipelines, this is a standalone pipeline: when this plan (<q>step</q> or pipeline) is executed,
-            the processor will acquires inputs, produce results and write those results to the file system. The output
-            it generates is stored as <a href="../../sequence/element-directory.md">element-directory.md</a>, a Markdown
-            file (find the <code>p:store</code> step).</p>
-               <p>The result is a reference resource encoded in Markdown: an index of XProc elements used in pipelines
-            described in this tutorial, which can be reposted back into the repository or viewed with any Markdown
+            smoke-test pipelines, this is a standalone pipeline (requiring no runtime bindings or settings): when this
+            plan (<q>step</q> or pipeline) is executed, the processor will acquires inputs, produce results and write
+            those results to the file system. The output it generates is stored as <a href="../../sequence/element-directory.md">element-directory.md</a>, a Markdown file (find the
+               <code>p:store</code> step).</p>
+               <p>The result is a reference resource encoded in Markdown: an index of XProc elements used in pipelines in this
+            repository. As Markdown, this result can be reposted back into the repository or viewed with any Markdown
             viewing application. The index lists XProc elements, that is the core of the XProc vocabulary: for any XProc
-            element used anywhere, the listing shows the pipelines where it appears. Following the index, the resource
-            also shows a list of (repository) project folders in an order corresponding to their treatment (if any) in
-            this tutorial, with their XProc files and whatever XProc elements appear <i>first</i> (within the entire
-            sequence up to to point) within that file. Among other uses this is helpful for assessing coverage of
-            lessons.</p>
+            element used anywhere among the projects listed, the listing shows the pipelines where it appears. Following
+            the index, the resource also shows a list of (repository) project folders in a prescribed order, with their
+            XProc files and whatever XProc elements appear <i>first</i> (within the entire sequence up to to point)
+            within that file. Among other uses this is helpful for assessing coverage of tutorial lessons as it offers a
+            (semi) <i>ordered</i> survey of the elements.</p>
                <p>For example, looking up <code>p:store</code> you can see all the pipelines that contain this common step. Or
-            looking at the <code>oscal-convert</code> listing you can see the XProc steps introduced in that lesson.</p>
-               <p>Delete or rename this result file and run the pipeline to confirm it functions properly.</p>
+            looking at the <code>oscal-convert</code> listing you can see the XProc steps appearing first in that
+            project folder.</p>
+               <p>To confirm proper functioning, run the pipeline again after deleting or renaming the Markdown result
+            file.</p>
                <p>Consider also what other kinds of indexing might be useful. When you modify XProc or add new XProc pipelines
             to the project folders, consider running this pipeline again to update the indexes.</p>
                <p>Open the file and inspect it to get a sense of how it works. The XML syntax is verbose, but not really all
-            that frightening. The pipeline is described in more detail in the <a href="walkthrough_102_src.html"
+            that frightening. Practice helps! The pipeline is also considered in the <a href="walkthrough_102_src.html"
                      class="LessonUnit">102 Lesson unit</a> segment.</p>
                <section>
                   <h3>PRODUCE-PROJECTS-ELEMENTLIST</h3>
@@ -1160,11 +1187,11 @@ <h3>PRODUCE-PROJECTS-ELEMENTLIST</h3>
                   produced in this second analytical phase, showing how once the files are surveyed, more than one
                   analysis is possible.</li>
                      <li>In particular, the index to <q>first use</q> is not simple. A great deal of the complexity of
-                  detailed operations has been off loaded into XSLT transformation code, which in this pipeline can be
+                  detailed operations has been off-loaded into XSLT transformation code, which in this pipeline can be
                   seen embedded in the XProc, indeed occupying the greater part of the XML in the file. (About two
-                  thirds of the element count: you can usually recognize XSLT by the conventional <code>xsl:</code> or
-                     <code>xslt:</code> element prefix.) This pipeline also has an XSLT (at the end) called from an
-                  external file, toward the end. XProc can do it either way, and each has its advantages.</li>
+                  thirds of the element count: you can usually recognize XSLT by the conventional <code>xsl:</code>
+                  element prefix.) This pipeline also has an XSLT called from an external file (toward the end). XProc
+                  can provide XSLT either way, and each has its advantages.</li>
                      <li>One good thing about seeing the XSLT here is you can get a good sense of what it looks like, whether
                   embedded or kept externally. XSLT is <a href="walkthrough_401_src.html"
                            class="LessonUnit">not
@@ -2047,33 +2074,31 @@ <h2>XSLT: XSL (XML Stylesheet Language) Transformations</h2>
             model is both broadly applicable, and workable in a range of environments including client software or
             within encapsulated, secure software configurations and deployments.</p>
                <p>If your XSLT is strong enough, you don't need XProc, or not much. But as a functional language, XSLT is best
-            used in a functionally pure way that does not interact with the system: no <q>side effects</q>. This is
-            related to its definitions of conformant processing (X inputs produce Y outputs) and the determinism, based
-            in mathematical formalisms, that underlies this idea of conformance. However one cost of mathematical purity
-            is that operations that do interact with stateful externalities – things such as reading and writing files –
-            are not in XSLT's <q>comfort zone</q>. It easily defines what a new structure A' should look like for any
-            given structure A. But how A is first acquired or what we do once we have determined A', is less clear, and
-            left up to the processor to handle, as an interface, starting with an XSLT transformation's nominal
-               <em>source</em> and (primary) <em>result</em>. Often, this gap has been bridged by extended functionality
-            provided by leading processors. Does your processor read and parse XML files off the file system? Can it be
-            connected to upstream processes in different ways? Can it use HTTP <code>GET</code> and <code>PUT</code>?
-            The answer may be Yes to any or all of these. Throughout its history, XSLT in later versions was also
-            extended in this direction, with features such as the <code>collection()</code> function,
-               <code>xsl:result-document</code>, <code>doc-available()</code> and other features we don't need if we are
-            using XProc.</p>
-               <p>Then too, XSLT is commonly run from scripts, in web hosting environments, and indeed from XQuery. Or you
-            might be able to configure your desktop software (Editor or IDE) to run your XSLT, or indeed acquire
-            specialized software just for reading and filtering collections or managing sets of file outputs in
-            XSLT-based workflows.</p>
-               <p>It is difficult not to think, however, that a gentler approach is also possible to the range of problems
-            related to making XSLT accessible in any environment – one that offers the feature set and flexibility we
-            need, but with less overhead, especially with regard to routine chores like designating sets of inputs and
+            used in a functionally pure, <q>stateless</q> way that does not interact with the system: no <q>side
+               effects</q>. This is related to its definitions of conformant processing (X inputs produce Y outputs) and
+            the determinism, based in mathematical formalisms, that underlies its idea of conformance. However one cost
+            of mathematical purity is that operations that do interact with stateful externalities – things such as
+            reading and writing files – are not in XSLT's <q>comfort zone</q>. It easily defines what a new structure A'
+            should look like for any given structure A. But how A is first acquired or what we do once we have
+            determined A', is less clear, and left up to the processor to handle, as an interface, starting with an XSLT
+            transformation's nominal <em>source</em> and (primary) <em>result</em>. Often, this gap has been bridged by
+            extended functionality in processors. Does your processor read and parse XML files off the file system? Can
+            it be connected to upstream data producers in different ways? Can it use HTTP <code>GET</code> and
+               <code>PUT</code>? The answer may be Yes to any or all of these. Throughout its history, XSLT in later
+            versions was also extended in this direction, with features such as the <code>collection()</code> function,
+               <code>xsl:result-document</code>, <code>doc-available()</code> and other features we may not need if we
+            are using XProc.</p>
+               <p>XSLT is commonly run from scripts, in web hosting environments and XQuery databases. Or you might be able to
+            configure your desktop software (Editor or IDE) to run your XSLT, or acquire specialized software just for
+            reading and filtering collections or managing sets of file outputs in XSLT-based workflows.</p>
+               <p>Yet XProc may offer a gentler approach, while it enables XSLT on the one hand when needed, while on the
+            other enables us largely to do without it, offering both a useful feature set and the flexibility we need,
+            but with less overhead, especially with regard to routine chores like designating sets of inputs and
             outputs, or sequencing operations. The principle of Least Power may well apply here: it saves our present
             and our future selves effort if we can arrange and manage to do things less. XProc lets us do less.</p>
-               <p>XProc lets us use XSLT when we must, but also keeps routine and simple things both simple and consistent,
-            without requiring much overhead. But it adapts itself well to new requirements as they become more
-            complicated. Ultimately, it spares the XSLT developer the problem of having to design, build and test
-            something like XProc.</p>
+               <p>XProc lets us use XSLT when we must, but also keeps routine and simple things both simple and consistent.
+            And it adapts itself well to new requirements as they become more complicated. Ultimately, it spares the
+            XSLT developer the problem of having to design, build and test something like XProc.</p>
                <section>
                   <h3>Running XSLT without XProc</h3>
                   <p>As a standard and an externally-specified technology, XSLT can in principle be implemented on any
@@ -2085,6 +2110,21 @@ <h3>Running XSLT without XProc</h3>
                   <p>Download and run Saxon to apply XSLT to XML and other inputs, without XProc.</p>
                </section>
             </section>
+            <section>
+               <h2>Using XSLT in XProc: avoiding annoyances XXX</h2>
+               <p>If you are an experienced XSLT user, congratulations! The power XProc puts into your hands is everything you
+            might think and hope.</p>
+               <p>There are a couple of small but potentially annoying considerations when embedding XSLT literals in your
+            XProc code. They do not apply when your XSLT is called from out of line, acquired by binding to an input
+            port or even <code>p:load</code>. If you acquire and even manipulate your XSLT without including literal
+            XSLT code in your XProc, that eliminates the syntax-level clashes at the roots of both these problems.</p>
+               <section>
+                  <h3>Text and attribute value syntax in embedded XSLT</h3>
+               </section>
+               <section>
+                  <h3>Namespaces in and for your XSLT</h3>
+               </section>
+            </section>
             <section>
                <h2>Learning XSLT the safer way</h2>
                <p>If setting out to learn XSLT, pause to read the following list of things to which you should give early
@@ -2789,7 +2829,7 @@ <h3>Namespaces and extension steps</h3>
                </section>
                <section>
                   <h3>Schema for XProc 3.0</h3>
-                  <p>See coverage of <a href="../unpack/unpack_399_src.html"
+                  <p>See coverage of <a href="../walkthrough/walkthrough_399_src.html"
                         class="LessonUnit">XProc, XML and XDM (the XML
                   Data Model)</a> in the prior lesson unit for a link to the schema for XProc.</p>
                </section>
@@ -2937,6 +2977,22 @@ <h2>Namespace fixup and namespace cleanup steps</h2>
             is a common remedy for <em>inflamed namespaces</em>, a condition that happens to XML that has been handled
             recklessly by too many handlers with too many namespaces. Also, <code>p:namespace-rename</code>.</p>
             </section>
+            <section>
+               <h2>Namespace tips and tricks XXX</h2>
+               <section>
+                  <h3>Coining new namespaces</h3>
+               </section>
+               <section>
+                  <h3>On-the-fly namespace declarations</h3>
+               </section>
+               <section>
+                  <h3>Overloading prefixes</h3>
+               </section>
+               <section>
+                  <h3>Matching with namespace wildcard</h3>
+                  <p>For example, <code>match="*:p"</code> will match any <code>p</code> element in any namespace.</p>
+               </section>
+            </section>
          </section>
          <section class="unit maker"
                   id="oscal-convert_401"
@@ -2948,14 +3004,13 @@ <h2>Goals</h2>
             </section>
             <section>
                <h2>Resources</h2>
-               <p>A <a href="../../../projects/oscal-convert/CONTENT-TYPE_worksheet.xpl">content-types worksheet XProc</a> is
-            offered for trying out content-type options on XProc inputs and outputs. If you only have thirty minutes,
-            consider looking at it before reading further. Your questions are more likely to be answered by a smart test
-            than by consulting a commentary.</p>
-               <p>The pipeline <a href="../../../projects/oscal-convert/READ-JSON-TESTING.xpl">READ-JSON-TESTING.xpl</a>
-            provides an experimental surface for working functionality specifically related to JSON and XDM map
-            objects.</p>
-               <p>See links given in the remarks below. This is a topic you can also learn by through trial and error.</p>
+               <p>A <a href="../../worksheets/CONTENT-TYPE_worksheet.xpl">content-types worksheet XProc</a> is offered for
+            trying out content-type options on XProc inputs and outputs.</p>
+               <p>The pipeline <a href="../../worksheets/READ-JSON-TESTING.xpl">READ-JSON-TESTING.xpl</a> provides an
+            experimental surface for working functionality specifically related to JSON and XDM map objects.</p>
+               <p>Find more treatment in <a href="oscal-convert_402_src.html"
+                     class="LessonUnit">the next lesson unit</a>.
+            This is a topic you can also learn by through trial and error.</p>
             </section>
             <section>
                <h2>Exercise some options</h2>
@@ -2965,10 +3020,21 @@ <h2>Exercise some options</h2>
             content type to another, according to <a href="https://spec.xproc.org/3.0/steps/#c.cast-content-type">rules
                given in the Specification</a>. Note that for this step to work, both inputs and outputs must conform to
             certain requirements: not everything can be cast!</p>
+               <ul>
+                  <li>Try specifying a content-type on input or outputs to constrain the inputs or outputs, producing errors
+               for mismatches</li>
+                  <li>Try using a cast-content-type step to explicitly cast between content types.</li>
+                  <li>Use the function <code>p:document-properties(.,'content-type')</code> to bring back the content type of
+               a document on a port or in a pipeline. In XPath, <code>.</code> refers to an designated as the (dynamic)
+               processing context: so <code>p:document-properties($doc,'content-type')</code> works for any $doc
+               considered by XProc to be or serve as a <em>document</em>.</li>
+                  <li>Interestingly, this means we can expect to find content-type='application/json' whenever an XProc
+               document is nothing more than an object or map – as can happen, by design.</li>
+               </ul>
                <p>
-                  <a href="../../../projects/oscal-convert/READ-JSON-TESTING.xpl">READ-JSON-TESTING.xpl</a> is a sandbox for
-            playing with JSON objects as XDM maps. The <a href="../../../projects/oscal-convert/CONTENT-TYPE_worksheet.xpl">content-types worksheet</a> is set up
-            for trying content-type options on inputs and outputs. </p>
+                  <a href="../../worksheets/READ-JSON-TESTING.xpl">READ-JSON-TESTING.xpl</a> is a sandbox for playing with
+            JSON objects as XDM maps. The <a href="../../worksheets/CONTENT-TYPE_worksheet.xpl">content-types
+               worksheet</a> is set up for trying content-type options on inputs and outputs. </p>
             </section>
          </section>
          <section class="unit learner"
@@ -2981,9 +3047,9 @@ <h2>Goals</h2>
             </section>
             <section>
                <h2>Resources</h2>
-               <p>A <a href="../../../projects/oscal-convert/CONTENT-TYPE_worksheet.xpl">content-types worksheet XProc</a> is
-            offered for trying out content-type options on XProc inputs and outputs. If you only have thirty minutes,
-            consider looking at it before reading further.</p>
+               <p>A <a href="../../worksheets/CONTENT-TYPE_worksheet.xpl">content-types worksheet XProc</a> is offered for
+            trying out content-type options on XProc inputs and outputs. If you only have thirty minutes, consider
+            looking at it before reading further.</p>
                <p>XProc content types are closely tied to its definition of a <em>document</em>, an object for which a string
             property <code>content-type</code> indicates the expected or nominal content type.See links given in the
             remarks below. This is a topic you can also learn by through trial and error.</p>
diff --git a/tutorial/worksheets/CONTENT-TYPE_worksheet.xpl b/tutorial/worksheets/CONTENT-TYPE_worksheet.xpl
index ab3e00f7..117d79ae 100644
--- a/tutorial/worksheets/CONTENT-TYPE_worksheet.xpl
+++ b/tutorial/worksheets/CONTENT-TYPE_worksheet.xpl
@@ -1,8 +1,18 @@
 <?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="3.0"
-   xmlns:ox="http://csrc.nist.gov/ns/oscal-xproc3" type="ox:CONTENT-TYPE_worksheet" name="CONTENT-TYPE_worksheet">
+   xmlns:ox="http://csrc.nist.gov/ns/oscal-xproc3" type="ox:CONTENT-TYPE_worksheet" name="CONTENT-TYPE_worksheet"
+   xmlns:xs="http://www.w3.org/2001/XMLSchema"
+   >
 
-<!-- Worksheet for trying content-type settings. -->
+<!-- Worksheet for trying content-type settings.
+   
+     Use p:cast-content-type to try casting, to see what happens
+     Demo also shows:
+       How to provide JSON inline and populate its values dynamically
+       How to query XDM maps
+       How to bind a function to a variable
+       
+   -->
 
 <!-- XProc Specification on content types: https://spec.xproc.org/master/head/xproc/#specified-content-types-->
    
@@ -14,30 +24,40 @@
        
        <!-- This option lets you put JSON in line - the @content-type forces a parse into an XDM map
             in this case the document's base URI is given as the base URI of the pipeline -->
-       <!--<p:inline  content-type="application/json" expand-text="false">{
+        <!-- with expand-text='true' TVT (text value template) syntax is ON
+        so regular { must be doubled -->
+       <p:inline  content-type="application/json" expand-text="true">{{
           "message": "Hello!",
-          "TO": "World"
-          }</p:inline>-->
+          "TO": "World",
+          "stardate": "{ (current-dateTime() - xs:dateTime('2024-11-12T07:44:05.207527900-05:00'))
+                         div xs:dayTimeDuration('PT1S') }"
+          }}</p:inline>
       <!--<p:inline content-type="application/json">"a string"</p:inline>-->
       <!-- we have to see to it the string is JSON, or breakage -->
-      <p:inline content-type="application/json">{ current-date() ! replace(string(.),'\D','') }</p:inline>
+      <!--<p:inline content-type="application/json">{  }</p:inline>-->
    </p:input>
    
    <p:output port="result" serialization="map{ 'indent': true() }" sequence="true"/>
 
    <!-- /end prologue -->
-
+   
+   <p:variable name="ox:document-info" as="function(*)"  
+      select="function($d as item()) as xs:string { p:document-property($d,'content-type') || ' at ' || p:document-property($d,'base-uri') }"/>
+   
    <!--Use identity step to report out properties ... -->
-   <p:identity message="[CONTENT-TYPE_worksheet] Seeing document at base uri { p:document-property(.,'base-uri') }"/>
-   <p:identity message="[CONTENT-TYPE_worksheet] Looking like content type { p:document-property(.,'content-type') }"/>
+   <!--<p:identity message="[CONTENT-TYPE_worksheet] Seeing document at base uri { p:document-property(.,'base-uri') }"/>
+   <p:identity message="[CONTENT-TYPE_worksheet] Looking like content type { p:document-property(.,'content-type') }"/>-->
    
+   <!--<p:identity message="[CONTENT-TYPE_worksheet] Seeing '{ p:document-property(.,'content-type') }' at base uri { p:document-property(.,'base-uri') }"/>-->
+   <p:identity message="[CONTENT-TYPE_worksheet] Seeing { $ox:document-info(.) }"/>
    
    <!-- An XDM map object is cast into an XPath map (vocabulary) -->
-   <!--<p:cast-content-type content-type="application/xml"/>-->
-   
-   <!--<p:cast-content-type content-type="application/json"/>-->
+   <p:cast-content-type content-type="application/xml"/>
    
-   <!--Interesting when we convert JSON to plain text, we get JSON syntax, but output serialization setting has no effect  -->
+   <p:identity message="[CONTENT-TYPE_worksheet] Seeing { $ox:document-info(.) }"/>
+      
+   <!--Interesting when we convert JSON to plain text, we get JSON syntax, i.e. serialized,
+       while now the output serialization setting has no effect (since it's text) -->
    <!--<p:cast-content-type content-type="text/plain"/>-->
    
 </p:declare-step>
\ No newline at end of file
diff --git a/tutorial/worksheets/READ-JSON-TESTING.xpl b/tutorial/worksheets/READ-JSON-TESTING.xpl
index 0347b795..35cc22ed 100644
--- a/tutorial/worksheets/READ-JSON-TESTING.xpl
+++ b/tutorial/worksheets/READ-JSON-TESTING.xpl
@@ -2,7 +2,8 @@
 <p:declare-step xmlns:p="http://www.w3.org/ns/xproc" xmlns:c="http://www.w3.org/ns/xproc-step" version="3.0"
    xmlns:ox="http://csrc.nist.gov/ns/oscal-xproc3" type="ox:READ-JSON-TESTING" name="READ-JSON-TESTING">
 
-
+<!-- A worksheet for messing a bit more with XDM map objects
+     (accommodating JSON object morphology and syntax) -->
    
    <p:input port="source">
          <p:inline  content-type="application/json" expand-text="false">{
@@ -40,7 +41,7 @@
    <!--<p:variable name="target" select="map:get($json-map,'message')" xmlns:map="http://www.w3.org/2005/xpath-functions/map"/>-->
    
    
-   <!--Alteratively, skip the p:load and go straight to (same effect)
+   <!--Alternatively, skip the p:load and go straight to (same effect)
    <p:variable name="json-map" select="json-doc('../data/misc/json/mixed.json')"/>
    This demonstrates how either way, we load into an XDM map object
    -->