diff --git a/best_practices.md b/best_practices.md
new file mode 100644
index 00000000..8f87bc4d
--- /dev/null
+++ b/best_practices.md
@@ -0,0 +1,26 @@
+# Enumerations
+
+It is _*highly*_ recommended that DFDL schema authors avoid whitespace within the definition of
+symbolic enumeration constants. Underscores should be use instead of spaces.
+
+## Enumerations and Validity
+
+The above example also illustrates an optional technique which segregates the enumeration values
+into some that are schema-valid, and some that are not, based on an additional pattern facet which
+constrains the valid symbolic values to names that begin with "OK_"[^checkConstraints].
+
+[^checkConstraints] This particular MIL-STD-2045 schema
+(as of this writing 2025-10-27) enforces the pattern facet at parse time, so it
+is a parse error if the selected symbolic enumeration does not start with `"OK_"` meaning
+only numeric values 2, 4, 5, 6, and 7 are considered well-formed. However,
+this enforcement is not required and is not actually considered best practice.
+
+[TBD]:
+Bug? In MIL-STD-2045, this string type has a dfdl:checkConstraints(.) assert on it. So these 
+facets are
+enforced and cause a parse error if data does not adhere to them. 
+This is probably a mistake in
+the schema, which should at least have a DFDL variable to control whether or not this
+dfdl:assert will fail or not. 
+Best practice is to NOT use dfdl:checkConstraints(.), so as to
+cleanly separate the concepts of well-formed and valid data. 
diff --git a/site/_data/footer.yml b/site/_data/footer.yml
new file mode 100644
index 00000000..52c64ae8
--- /dev/null
+++ b/site/_data/footer.yml
@@ -0,0 +1,8 @@
+org_name: "The Apache Software Foundation"
+org_url: "https://www.apache.org"
+license_name: "Apache License, Version 2.0"
+copyright_year: "2025"
+license_url: "https://www.apache.org/licenses/LICENSE-2.0"
+trademark_text: "Apache, Apache Daffodil, Daffodil, and the Apache Daffodil logo are trademarks of The Apache Software Foundation."
+daffodil_logo: ../assets/themes/apache/img/apache-daffodil-logo.png
+asf_logo: ../assets/themes/apache/img/asf_logo_wide.png
diff --git a/site/_includes/themes/apache/default.html b/site/_includes/themes/apache/default.html
index 264b9e14..462887ba 100644
--- a/site/_includes/themes/apache/default.html
+++ b/site/_includes/themes/apache/default.html
@@ -25,6 +25,10 @@
     {% include themes/apache/_navigation.html %}
 
     <div class="container">
+      {% if page.pdf %}
+      {% assign filename_without_extension = page.path | split: '.' | first %}
+      <div><i>This page is available as a <a href="../pdf/{{ filename_without_extension }}.pdf" target="_blank">downloadable PDF</a></i></div>
+      {% endif %}
       {{ content }}
       <footer>
         {% include themes/apache/footer.html %}
diff --git a/site/_includes/themes/apache/footer.html b/site/_includes/themes/apache/footer.html
index 2a0b2ed1..ef003e0b 100644
--- a/site/_includes/themes/apache/footer.html
+++ b/site/_includes/themes/apache/footer.html
@@ -1,16 +1,14 @@
 <footer class="site-footer">
     <div class="wrapper">
-        <div class="footer-col-wrapper" style="font-size: .85em;">
+        <div class="footer-col-wrapper" style="font-size:.85em;">
             <hr>
-            <div>
-                <div style="text-align: center;">
-                    Copyright &copy; 2025 <a href="https://www.apache.org">The Apache Software Foundation</a>.
-                    Licensed under the <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache License, Version
-                    2.0</a>.
-                    <br>
-                    Apache, Apache Daffodil, Daffodil, and the Apache Daffodil logo
-                    are trademarks of The Apache Software Foundation.
-                </div>
+            <div style="text-align:center;">
+                Copyright &copy; {{ site.data.footer.copyright_year }}
+                <a href="{{ site.data.footer.org_url }}">{{ site.data.footer.org_name }}</a>.
+                Licensed under the
+                <a href="{{ site.data.footer.license_url }}">{{ site.data.footer.license_name }}</a>.
+                <br>
+                {{ site.data.footer.trademark_text }}
             </div>
         </div>
     </div>
diff --git a/site/_pandoc/Makefile b/site/_pandoc/Makefile
new file mode 100644
index 00000000..f70bb0ae
--- /dev/null
+++ b/site/_pandoc/Makefile
@@ -0,0 +1,56 @@
+# ==========================================================
+# Pandoc PDF generator for Jekyll site
+# Scans Markdown files with "pdf: true" in YAML front matter
+# and produces PDFs in the site's ./pdf/ directory
+# ==========================================================
+SHELL := /bin/bash
+
+# --- Configuration ---
+SITE_ROOT := ..
+
+PANDOC := pandoc
+
+# Output directory for generated PDFs (at site root)
+PDF_OUTDIR := $(SITE_ROOT)/pdf
+
+DEFAULTS := $(SITE_ROOT)/_pandoc/basic.yaml
+
+# This is coarse, but we take any markdown file containing a line of "pdf: true" regardless of location in the file.
+# but we exclude directories that begin with "_".
+MD_CANDIDATES=$(shell grep -Rlx 'pdf: true' $(SITE_ROOT) --exclude-dir '_*')
+
+# --- Files to build ---
+PDF_SRCS := $(MD_CANDIDATES)
+PDFS     := $(patsubst $(SITE_ROOT)/%.md,$(PDF_OUTDIR)/%.pdf,$(PDF_SRCS))
+
+# --- Default target ---
+all: $(PDFS)
+	@echo "Generated $(words $(PDFS)) PDF(s) in $(PDF_OUTDIR)"
+
+# --- Rule to ensure output dirs exist and build each PDF ---
+$(PDF_OUTDIR)/%.pdf: $(SITE_ROOT)/%.md | make-dirs
+	@mkdir -p $(dir $@)
+	@echo "📄 Building $@"
+	$(PANDOC) --defaults=$(DEFAULTS) \
+	  -L only.lua \
+	  -f markdown+markdown_in_html_blocks \
+	  --metadata-file=$(SITE_ROOT)/_data/footer.yml \
+	  -V numberoffset=0 \
+	  --from markdown --to pdf -o $@
+
+# --- Create directories as needed ---
+.PHONY: make-dirs
+make-dirs:
+	@mkdir -p $(PDF_OUTDIR)
+
+# --- Cleanup ---
+.PHONY: clean
+clean:
+	@echo "Removing generated PDFs"
+	@rm -rf $(PDF_OUTDIR)
+
+# --- Debugging helpers ---
+.PHONY: list
+list:
+	@echo "Markdown files with pdf:true:"
+	@for f in $(PDF_SRCS); do echo " - $$f"; done
diff --git a/site/_pandoc/README.md b/site/_pandoc/README.md
new file mode 100755
index 00000000..980a492d
--- /dev/null
+++ b/site/_pandoc/README.md
@@ -0,0 +1,133 @@
+---
+layout: page
+title: Pandoc + Jekyll Integration
+pdf: false
+---
+# Pandoc + Jekyll Integration
+
+This directory contains tools for generating **PDF versions** of selected Jekyll pages while keeping the same Markdown files usable by Jekyll for the website.
+
+The goal is to have **one Markdown source** that:
+- renders cleanly in the Jekyll site (for HTML),
+- and can also be converted into a polished PDF using **Pandoc + LaTeX**.
+
+---
+
+## Directory Layout
+
+```
+_pandoc/
+│
+├── README.md              ← this file
+├── Makefile               ← builds all PDFs
+├── template_basic.latex   ← custom LaTeX template used by pandoc
+├── only.lua               ← pandoc preprocessor for jekyll-only and pandoc-only 
+└── ../pdf/                ← generated PDFs appear here
+```
+
+At the root of the Jekyll site:
+
+```
+_data/footer.yml           ← footer used by pandoc for PDF pages
+assets/...                 ← added logos used by PDF footer/header
+pdf/                       ← PDFs are created here
+```
+
+---
+
+##  How It Works
+
+### 1. Mark pages that should have PDFs
+
+Any Markdown file (".md" extension) can be tagged with:
+
+```yaml
+---
+title: Example Page
+layout: page
+pdf: true
+---
+```
+The markdown dialect used must then be in the subset common to both jekyll and pandoc.  
+
+The Makefile will scan the markdown files and automatically detect files intended to become PDFs.
+
+---
+
+### 3. The Makefile
+
+The `_pandoc/Makefile` automates the whole process.
+
+It:
+
+1. Scans the site for Markdown files with `pdf: true`.
+2. Invokes Pandoc with the configured LaTeX template to produce a PDF.
+
+The resulting PDFs go into:
+
+```
+site/pdf
+```
+
+---
+
+## Example Commands
+
+From inside the `_pandoc/` directory:
+
+### Build all PDFs
+```bash
+make
+```
+
+### Clean all generated PDFs
+```bash
+make clean
+```
+
+### List all Markdown files with `pdf: true`
+```bash
+make list
+```
+
+### Force rebuild of one PDF
+```bash
+make ../pdf/about.pdf
+```
+
+---
+
+## Recommended Workflow
+
+1. Write Markdown pages normally for your Jekyll site.
+2. When you also want a PDF version, add `pdf: true` to front matter.
+3. From `_pandoc/`, run:
+   ```bash
+   make
+   ```
+4. Find the generated PDFs in `pdf/`.
+
+---
+
+**Maintainer Notes**
+
+- `_pandoc/Makefile` assumes it’s run from `_pandoc/`, with site root as `..`
+- Pandoc and AWK must be available on your `PATH`
+- Tested with pandoc v3.1.3 
+
+Note that this manual build process is temporary and at some point will be done automatically by 
+the site rebuild process, that is, at the same time the jekyll processing is done.
+
+---
+
+## Pandoc Tools Installation
+
+These tools run on Linux.
+
+On Ubuntu you have to install these things:
+
+    sudo apt install pandoc texlive-latex-base texlive-latex-recommended \
+      texlive-fonts-recommended texlive-xetex texlive-latex-extra
+
+For other distros of Linux different commands will be needed, but the same list of packages must 
+be installed.
diff --git a/site/_pandoc/basic.yaml b/site/_pandoc/basic.yaml
new file mode 100644
index 00000000..fd56449a
--- /dev/null
+++ b/site/_pandoc/basic.yaml
@@ -0,0 +1,6 @@
+pdf-engine: xelatex
+template: template_basic.tex
+toc: true
+number-sections: true
+from: markdown+pipe_tables+autolink_bare_uris+bracketed_spans+markdown_attribute+raw_tex
+listings: true
diff --git a/site/_pandoc/only.lua b/site/_pandoc/only.lua
new file mode 100644
index 00000000..3b80d7c6
--- /dev/null
+++ b/site/_pandoc/only.lua
@@ -0,0 +1,60 @@
+-- only.lua: drop .only-jekyll, keep contents of .only-pandoc
+-- Handles both native Div/Span nodes and raw HTML <div> wrappers.
+
+local List = require 'pandoc.List'
+
+local function has_class(classes, cls)
+  return classes and List.includes(classes, cls)
+end
+
+-- Native block divs (Pandoc recognized <div class="..."> as Div)
+function Div(el)
+  if has_class(el.classes, 'only-jekyll') then
+    return {}                  -- drop entirely
+  elseif has_class(el.classes, 'only-pandoc') then
+    return el.content          -- unwrap: keep inner blocks
+  end
+end
+
+-- Native inline spans
+function Span(el)
+  if has_class(el.classes, 'only-jekyll') then
+    return {}
+  elseif has_class(el.classes, 'only-pandoc') then
+    return el.content
+  end
+end
+
+-- Fallback for raw HTML wrappers when Pandoc didn’t turn them into Divs.
+function Pandoc(doc)
+  local out = List()
+  local mode = nil  -- nil | 'drop' | 'keep'
+
+  local function is_open_of(txt, klass)
+    -- match <div ... class="... klass ...">
+    return txt:match('<div[^>]-class=[\'"][^\'"]-' .. klass .. '[^\'"]-[\'"]')
+  end
+
+  for _, blk in ipairs(doc.blocks) do
+    if blk.t == 'RawBlock' and blk.format:match('html') then
+      local t = blk.text
+      if is_open_of(t, 'only%-jekyll') then
+        mode = 'drop'   -- drop wrapper and its inner content
+      elseif is_open_of(t, 'only%-pandoc') then
+        mode = 'keep'   -- drop wrapper, keep inner content
+      elseif t:match('</div>') and mode ~= nil then
+        mode = nil
+      else
+        if not mode or mode == 'keep' then out:insert(blk) end
+      end
+    else
+      if not mode then
+        out:insert(blk)
+      elseif mode == 'keep' then
+        out:insert(blk)
+      end
+    end
+  end
+
+  return pandoc.Pandoc(out, doc.meta)
+end
diff --git a/site/_pandoc/template_basic.tex b/site/_pandoc/template_basic.tex
new file mode 100755
index 00000000..cd9027e5
--- /dev/null
+++ b/site/_pandoc/template_basic.tex
@@ -0,0 +1,130 @@
+\documentclass[11pt]{article}
+\usepackage{fontspec}
+\setmainfont{DejaVu Sans}
+\usepackage{graphicx}
+\usepackage{fancyhdr}
+\usepackage{ifthen}
+\usepackage{longtable}
+\usepackage{booktabs}
+\usepackage{tabularx}
+\usepackage{listings}
+\usepackage[dvipsnames]{xcolor}
+\definecolor{FaintPinkWatermark}{rgb}{1,0.95,0.95}
+\usepackage{parskip}
+\usepackage{hyperref}
+\hypersetup{
+  colorlinks=true,
+  linkcolor=blue,
+  urlcolor=blue,
+  citecolor=blue
+}
+\usepackage{array} % for Version History Tables custom column definitions
+\usepackage{etoolbox}
+\usepackage{mdframed}
+\AtBeginDocument{\color{black}}
+\usepackage{geometry}         % Page margins
+\geometry{top=1in, bottom=1.5in, left=1in, right=1in}
+
+% for CUI Block
+\usepackage[absolute,overlay]{textpos}
+\usepackage{tcolorbox}
+\setlength{\TPHorizModule}{1mm}
+\setlength{\TPVertModule}{1mm}
+
+% quote blocks need grey background and italics. That got lost somehow.
+\BeforeBeginEnvironment{quote}{\vspace{1em}\begin{mdframed}[backgroundcolor=gray!10, roundcorner=4pt, innertopmargin=6pt, innerbottommargin=6pt]\itshape}
+\AfterEndEnvironment{quote}{\end{mdframed}}
+
+% Watermark setup if variable is defined
+$if(watermark)$
+  \usepackage{draftwatermark}
+  \SetWatermarkText{$watermark$}
+  \SetWatermarkScale{1.8}
+  \SetWatermarkColor{FaintPinkWatermark}
+$endif$
+
+\newcommand{\leftheadermacro}{%
+    {\includegraphics[width=0.2\textwidth]{$daffodil_logo$}}
+}
+
+\newcommand{\rightheadermacro}{%
+  \textsf{\small $title$}
+}
+
+\newcommand{\leftfootermacro}{\vspace{-1.0cm}
+  \footnotesize
+  \parbox{0.7\textwidth}{%
+    Copyright \textcopyright{} {$copyright_year$} \href{$org_url$}{$org_name$}. \\
+  Licensed under the \href{$license_url$}{$license_name$}. \\
+  $trademark_text$
+  }
+}
+
+\newcommand{\rightfootermacro}{%
+    {\includegraphics[height=2.0\baselineskip]{$asf_logo$}} \\
+  Page \thepage
+}
+
+\fancyhf{}
+\fancyhead[L]{\leftheadermacro}
+\fancyhead[R]{\rightheadermacro}
+\fancyfoot[L]{\leftfootermacro}
+\fancyfoot[R]{\rightfootermacro}
+\renewcommand{\headrulewidth}{0.4pt}
+\renewcommand{\footrulewidth}{0.4pt}
+
+
+\fancypagestyle{plain}{\pagestyle{fancy}} % used for the title page.
+
+% Define \tightlist for Pandoc-generated lists
+\providecommand{\tightlist}{%
+  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}
+}
+
+% Listings setup
+\lstset{
+  basicstyle=\ttfamily\small,
+  backgroundcolor=\color[gray]{0.95},
+  frame=single,
+  framerule=0pt,
+  xleftmargin=1em,
+  xrightmargin=1em,
+  breaklines=true,
+  showstringspaces=false
+}
+
+% list spacing needs to be slightly more relaxed
+\usepackage{enumitem}
+\setlist[itemize]{itemsep=3pt, topsep=4pt}
+
+\usepackage{tocloft}                      % Table of contents dot leaders
+\renewcommand{\cftdotsep}{1.5}
+\renewcommand{\cftsecleader}{\cftdotfill{\cftdotsep}}
+
+% missing the passthrough command needed for backticked words.
+\providecommand{\passthrough}[1]{\texttt{#1}}
+
+\begin{document}
+\pagestyle{fancy}
+% \begingroup
+\normalcolor
+
+% Manually typeset title block
+% Centered document title
+\begin{center}
+  {\LARGE \textbf{$title$}}
+\end{center}
+\vspace{2em}
+\enlargethispage{-0.5cm} % adjust first page size so footer doesn't crash into text.
+\hrule
+\tableofcontents
+\thispagestyle{fancy}
+\vspace{0.5cm}
+\hrule
+\vspace{0.5cm}
+% \endgroup
+
+$body$
+
+
+\end{document}
diff --git a/site/assets/themes/apache/css/style.css b/site/assets/themes/apache/css/style.css
index 9c1d5607..6b35cbc4 100644
--- a/site/assets/themes/apache/css/style.css
+++ b/site/assets/themes/apache/css/style.css
@@ -506,3 +506,6 @@ dt code {
 	color: inherit;
 	background-color: inherit;
 }
+
+/* allows pages to contain pandoc-only sections for use when creating PDFs */
+.only-pandoc { display: none; }
diff --git a/site/assets/themes/apache/img/asf_logo_wide.png b/site/assets/themes/apache/img/asf_logo_wide.png
new file mode 100644
index 00000000..f4a34ee4
Binary files /dev/null and b/site/assets/themes/apache/img/asf_logo_wide.png differ
diff --git a/site/dfdl-extensions.md b/site/dfdl-extensions.md
index 35a18bfd..3e7d14d3 100644
--- a/site/dfdl-extensions.md
+++ b/site/dfdl-extensions.md
@@ -1,7 +1,8 @@
 ---
 layout: page
-title: DFDL Extensions
+title: Daffodil Extensions of DFDL 
 group: nav-right
+pdf: true
 ---
 <!--
 {% comment %}
@@ -21,38 +22,58 @@ See the License for the specific language governing permissions and
 limitations under the License.
 {% endcomment %}
 -->
+<!-- 
+The :target="_blank" syntax below makes this open in a new tab 
+and work in the PDF and jekyll web page.
+But displays as literal text in the IDE markdown previewer. 
+--> 
+
+<div class="only-jekyll" markdown="1">
+
+### Table of Contents
+{:.no_toc}
+
+1. use ordered table of contents 
+{:toc}
+</div>
+
+# Introduction
 
 Daffodil provides extensions to the DFDL specification. 
-These properties are in the namespace defined by the URI 
+These functions and properties are in the namespace defined by the URI 
 ``http://www.ogf.org/dfdl/dfdl-1.0/extensions`` which is normally bound to the ``dfdlx`` prefix 
 like so: 
 
 
 ``` xml
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-           xmlns:dfdl="http://www.ogf.org/dfdl/dfdl-1.0/"
-           xmlns:dfdlx="http://www.ogf.org/dfdl/dfdl-1.0/extensions"
+<schema xmlns="http://www.w3.org/2001/XMLSchema"
+        xmlns:dfdl="http://www.ogf.org/dfdl/dfdl-1.0/"
+        xmlns:dfdlx="http://www.ogf.org/dfdl/dfdl-1.0/extensions"
 >
 ```
 
-The following symbols defined in this namespace are described below.
+The DFDL language extensions described below have Long Term Support (LTS) in Daffodil 
+going forward, and are proposed for inclusion in a future revision of the DFDL 
+standard. 
+DFDL schema authors can depend on the features and behaviors defined here without fear 
+that these extensions will be withdrawn in the future. 
 
-### Expression Functions
+# Expression Functions
 
-``daf:error()``
+## `daf:error(messageArg)`
 
-   : A function that can be used in DFDL expressions. This functions does not return a value or accept any arguments. When called, it causes a Parse Error or Unparse Error.
+A function that can be used in DFDL expressions. This functions does not return a value or accept any arguments. When called, it causes a Parse Error or Unparse Error.
 
      *This function is deprecated as of Daffodil 2.0.0. 
       Use the ``fn:error(...)`` function instead.*
 
-``dfdlx:trace($value, $label)``
+## `dfdlx:trace($value, $label)`
 
-   : A function that can be used in DFDL expressions, similar to the ``fn:trace()`` function. This logs the string ``$label`` followed by ``$value`` converted to a string and returns ``$value``. The second argument must be of type ``xs:string``.
+A function that can be used in DFDL expressions, similar to the ``fn:trace()`` function. This logs the string ``$label`` followed by ``$value`` converted to a string and returns ``$value``. The second argument must be of type ``xs:string``.
 
-``dfdlx:lookAhead(offset, bitSize)``
+## `dfdlx:lookAhead(offset, bitSize)`
 
-   : Read ``bitSize`` bits, where the first bit is located at an ``offset`` (in bits)
+Read `bitSize` bits, where the first bit is located at an ``offset`` (in bits)
    from the current location. The result is a ``xs:nonNegativeInteger``. Restrictions:
    
 - offset >=0
@@ -67,7 +88,7 @@ and data location.
 - DFDL property changes between the current location and the location containing
 the data being read will not be used.
   
-#### Examples of `dfdlx:lookAhead`
+### Examples of `dfdlx:lookAhead`
    The following two elements both populate element `a` with the value of the next 3 bits as an 
    unsignedInt. They are not completely equivalent because the first will consume 3 bits of the 
    input stream where the second will not advance the input stream.
@@ -87,46 +108,334 @@ found after fields `a` and `b`:
 <xs:element name="tag" type="xs:int" dfdl:length="8" />
 ```
 
-Bitwise Functions
+## Bitwise Functions: `bitAnd`, `bitOr`, `bitXor`, `bitNot`, `leftShift`, `rightShift`
+
+These functions are defined on types `long`, `int`, `short`, `byte`, `unsignedLong`, 
+`unsignedInt`, `unsignedShort`, and `unsignedByte`
+
+### `dfdlx:bitAnd(arg1, arg2)`
+
+This computes the bitwise AND of two integers. 
+
+- Both arguments must be signed, or both must be unsigned.
+- If the two arguments are not the same type the smaller one is converted into the type of the 
+larger one. 
+- If the smaller argument is signed, this conversion does sign-extension.
+- The result type is the that of the largest argument. 
+
+### `dfdlx:bitOr(arg1, arg2)`
+
+This computes the bitwise OR of two integers.
+
+- Both arguments must be signed, or both must be unsigned.
+- If the two arguments are not the same type the smaller one is converted into the type of the
+larger one.
+- If the smaller argument is signed, this conversion does sign-extension.
+- The result type is the that of the largest argument.
+
+### `dfdlx:bitXor(arg1, arg2)`
+
+This computes the bitwise Exclusive OR of two integers.
+
+- Both arguments must be signed, or both must be unsigned.
+- If the two arguments are not the same type the smaller one is converted into the type of the
+larger one. 
+- If the smaller argument is signed, this conversion does sign-extension.
+- The result type is the that of the largest argument.
+
+### `dfdlx:bitNot(arg)`
 
-   : TBD, but the complete list (all ``dfdlx``) is `BitAnd`, `BitNot`, `BitOr`, `BitXor`, `LeftShift`, 
-   `RightShift`
+This computes the bitwise NOT of an integer. Every bit is inverted. The result type is the same 
+as the argument type. 
 
-``dfdlx:doubleFromRawLong`` and ``dfdlx:doubleToRawLong``
+### `dfdlx:leftShift(value, shiftCount)`
 
-   : Converting binary floating point numbers to/from base 10 text can result in lost information.
-The base 10 representation, converted back to binary representation, may not be bit-for-bit 
-   identical. These functions can be used to carry 8-byte double precision IEEE floating point 
-   numbers as type `xs:long` so that no information is lost. The DFDL schema can still obtain 
-   and operate on the floating point value by converting these `xs:long` values into type 
-   `xs:double`, and back if necessary for unparsing a new value. 
+This is the _logical_ shift left, meaning that bits are shifted from less-significant positions 
+to more-significant positions. 
 
-### Properties
+- The left-most bits shifted out are discarded. 
+- Zeros are shifted in for the right-most bits. 
+- The result type is the same as the `value` argument type. 
+- It is a processing error if the `shiftCount` argument is < 0.
+- It is a processing error if the `shiftCount` argument is greater than the number of 
+  bits in the type of the value argument. 
 
-``dfdlx:parseUnparsePolicy``
+### `dfdlx:rightShift(value, shiftCount)`
 
-   : A property applied to simple and complex elements, which specifies whether the element supports only parsing, only unparsing, or both parsing and unparse. Valid values for this property are ``parse``, ``unparse``, or ``both``. This allows one to leave off properties that are required for only parse or only unparse, such as ``dfdl:outputValueCalc`` or ``dfdl:outputNewLine``, so that one may have a valid schema if only a subset of functionality is needed.
+This is the _arithmetic_ shift right, meaning bits move from most-significant to 
+less-significant positions.
+If _logical_ (zero-filling) shift right is needed, you must use unsigned types.
 
-     All elements must have a compatible parseUnparsePolicy with the compilation parseUnparsePolicy (which is defined by the root element daf:parseUnparsePolicy and/or the Daffodil parseUnparsePolicy tunable) or it is a Schema Definition Error. An element is defined to have a compatible parseUnparsePolicy if it has the same value as the compilation parseUnparsePolicy or if it has the value ``both``.
+- The `value` argument is shifted by the `shiftCount`.
+- The right-most bits shifted out are discarded. 
+- If the `value` is signed, then the sign bit is shifted in for the left-most bits.
+- If the `value` is unsigned, then zeros are shifted in for the left-most bits. 
+- The result type is the same as the `value` argument type.
+- It is a processing error if the `shiftCount` argument is < 0.
+- It is a processing error if the `shiftCount` argument is greater than the number of
+  bits in the type of the value argument.
 
-     For compatibility, if this property is not defined, it is assumed to be ``both``.
+## `dfdlx:doubleFromRawLong(longArg)` and `dfdlx:doubleToRawLong(doubleArg)`
 
-``dfdlx:layer``
+IEEE binary float and double values that are not NaN will parse to base 10 text and unparse back
+to the same exact IEEE binary bits. 
+However, the same cannot be said for NaN (not a number) values, of which there are many bit 
+patterns. 
+To preserve float and double NaN values bit for bit you can use these functions to compute
+`xs:long` values that enable the DFDL Infoset to preserve the bits of a float or double value 
+even if it is a NaN. 
 
-   : [Layers](/layers) provide algorithmic capabilities for decoding/encoding data or computing 
+
+
+# Properties
+
+## `dfdlx:parseUnparsePolicy`
+
+A property applied to simple and complex elements, which specifies whether the element supports only parsing, only unparsing, or both parsing and unparse. Valid values for this property are ``parse``, ``unparse``, or ``both``. This allows one to leave off properties that are required for only parse or only unparse, such as ``dfdl:outputValueCalc`` or ``dfdl:outputNewLine``, so that one may have a valid schema if only a subset of functionality is needed.
+
+All elements must have a compatible parseUnparsePolicy with the compilation parseUnparsePolicy (which is defined by the root element daf:parseUnparsePolicy and/or the Daffodil parseUnparsePolicy tunable) or it is a Schema Definition Error. An element is defined to have a compatible parseUnparsePolicy if it has the same value as the compilation parseUnparsePolicy or if it has the value ``both``.
+
+For compatibility, if this property is not defined, it is assumed to be ``both``.
+
+## `dfdlx:layer`
+
+_Layers_ provide algorithmic capabilities for decoding/encoding data or computing 
    checksums. Some are built-in to Daffodil. New layers can be created in Java/Scala and 
    plugged-in to Daffodil dynamically. 
+There is [separate Layer documentation](/layers).
+
+## `dfdlx:direction`
+
+This property can appear only on DFDL `defineVariable` statement annotations.
+This property has possible values `both` (the default), `parseOnly`, or `unparseOnly`. 
+It declares 
+whether the variable is to be available for only parsing, only unparsing, or both. 
+Since this is a newly introduced extension property and existing schemas won't contain a definition 
+for it, it has a default value of `both`. 
+
+This property can conflict with the `dfdlx:parseUnparsePolicy` property which takes the same 
+values (`both`, `parseOnly`, and `unparseOnly`).
+If `dfdlx:parseUnparsePolicy='parseOnly' then it is a Schema Definition Error if 
+variables in the DFDL schema have `dfdlx:direction='unparseOnly'. 
+Similarly if `dfdlx:parseUnparsePolicy='unparseOnly' then it is a Schema Definition Error if
+variables in the DFDL schema have `dfdlx:direction='parseOnly'. 
+
+It is a Schema Definition Error if a variable defined with direction `parseOnly` is accessed 
+from an expression used by the unparser. 
+Symmetrically, it is a Schema Definition Error if a variable defined with direction
+`unparseOnly` is accessed from an expression used by the parser.
+This error is detected at DFDL schema compilation time, not runtime. 
+
+These properties take expressions for their values and are generally evaluated at both parse and 
+unparse time. 
+Hence, unless the whole schema is constrained by `dfdlx:parseUnparsePolicy`, any expressions for 
+these properties[^moreProps] cannot  
+cannot reference DFDL variables with `dfdlx:direction` of `parseOnly` or `unparseOnly`. 
+
+- `byteOrder`
+- `encoding`
+- `initiator`
+- `terminator`
+- `separator`
+- `escapeCharacter`
+- `escapeEscapeCharacter`
+- `length`
+- `occursCount`
+- `textStandardDecimalSeparator`
+- `textStandardGroupingSeparator`
+- `textStandardExponentRep`
+- `binaryFloatRep`
+- `textBooleanTrueRep`
+- `textbooleanFalseRep`
+- `calendarLanguage`
+- `dfdl:setVariable`, a `dfdl:newVariableInstance` default value expression, or a
+  `dfdl:defineVariable` default value expression when
+  that variable being set/defaulted is itself referenced from a another expression and the variable 
+  being set/defaulted has `dfdlx:direction` of `both` (the default)
+
+[^moreProps] New properties added as part of errata corrections to the DFDL v1.0 standard which 
+take expressions for their values will need to be added to this list or those for 
+parser-specific or unparser-specific properties. 
+  
+Parser-specific expressions include
+
+- `dfdl:inputValueCalc`
+- `dfdl:length` (when dfdl:lengthKind='explicit')
+- `dfdl:occursCount` (when `dfdl:occursCountKind='expression')
+- `dfdl:choiceDispatchKey`
+- the `message` and `test` attributes of the `dfdl:assert` and `dfdl:discriminator` statement annotations
+- `dfdl:setVariable`, a `dfdl:newVariableInstance` default value expression, or a
+  `dfdl:defineVariable` default value expression when
+  that variable being set/defaulted is itself referenced from a another expression being
+  accessed at parser creation time, and the variable being set/defaulted has `dfdlx:direction`
+  of `parseOnly`
+
+Unparser-specific expressions include:
+
+- `dfdl:outputValueCalc`
+- `dfdl:length` (when `dfdl:lengthKind='explicit')
+- `dfdl:outputNewLine`
+- `dfdl:setVariable`, a `dfdl:newVariableInstance` default value expression, or a 
+  `dfdl:defineVariable` default value expression when 
+  that variable being set/defaulted is itself referenced from a another expression being 
+  accessed at unparser creation time, and the variable being set/defaulted has `dfdlx:direction` 
+  of `unparseOnly` 
+
+
+## Enumerations: `dfdlx:repType`, `dfdlx:repValues`, and `dfdlx:repValueRanges`
+
+These properties work together to allow DFDL schemas to define _enumerations_;
+that is, symbolic representations for integer constants. 
+When parsing, Daffodil will convert these integers into the corresponding string values. 
+When unparsing, Daffodil will convert strings into the corresponding integers. 
+
+An element of type (or derived from) `xs:string` can be defined using XSD `enumeration` facets 
+which constrain the valid values of this string. 
+These enumeration values are effectively symbolic constants. 
+The `dfdlx:repType` and `dfdlx:repValues` properties are then used to define the correspondence of 
+the symbolic strings to the corresponding integer values.
+
+### `dfdlx:repType`
+
+The value of this property is an XSD QName of a simple type definition that must be derived
+from `xs:int`, or `xs:unsignedInt`. 
+A simple type definition for a string can be annotated with `dfdlx:repType` 
+in order to declare that the representation of the string is not as text characters but is a 
+numeric integer value. 
+The type referenced from `dfdlx:repType` is usually a fixed length binary integer, but can be any
+DFDL type derived from `xs:int` or `xs:unsignedInt`, with any DFDL representation properties. 
+
+The mapping between the representation integer and the symbolic constants is specified using the 
+`dfdlx:repValues` and/or `dfdlx:repValueRanges` properties. 
+
+### `dfdlx:repValues`
+
+The value of this property is one or more integer values within 
+the numeric range defined for the type referenced by `dfdlx:repType`. When more than one value 
+is specified, they are in a whitespace separated list. 
+
+This property is placed on the `xs:enumeration` facets of a symbolic string constant having a 
+`dfdlx:repType`. 
+At parse time, if the value of the `dfdlx:repType` integer is found within the `dfdlx:repValues` 
+list, then the infoset value for the symbolic string gets the corresponing enumeration facet value.
+It is a parse error if no `xs:enumeration` has a `dfdlx:repValues` nor `dfdlx:repValueRanges` 
+(see below) assign a symbolic equivalent to the `dfdlx:repType` integer.
+At unparse time, the symbolic constant is mapped to the first integer in the dfdlx:repValues list. 
+It is an unparse error if the symbolic string value is not found among the `xs:enumeration` 
+facet values of the symbolic string type. 
+
+
+### `dfdlx:repValueRanges`
+
+The value of this property is a list of integers of even length 2 or greater. The integers at 
+odd positions (starting with position 1) define the inclusive lower bound of a range of 
+integers.
+The integers at even positions (starting with position 2) define the corresponding inclusive 
+upper bound of a range of integers.
+
+This property is placed on the `xs:enumeration` facets of a symbolic string constant having a
+`dfdlx:repType`.
+
+At parse time, the integer value of the `dfdlx:repType` is used to search the numeric ranges. 
+If it is found in any of the numeric ranges for a specific `xs:enumeration` facet, then the 
+facet's value is used as the corresponding symbolic value. 
+It is a parse error if no `xs:enumeration` has a `dfdlx:repValues` (see above) nor 
+`dfdlx:repValueRanges` assign a symbolic equivalent to the `dfdlx:repType` integer. 
+At unparse time, the symbolic string value's corresponding `xs:enumeration` facet is found and 
+if the `xs:enumeration` contains both `dfdlx:repValues` and `dfdlx:repValueRanges` then the 
+`dfdlx:repValues` is used to determine the corresponing `dfdl:repType` integer value to unparse, 
+as described above for the `dfdl:repValues` property. 
+If the `xs:enumeration` has no `dfdlx:repValues` property, then the smallest numeric value in the  
+`dfdlx:repValueRanges` list is unparsed for the `dfdlx:repType` integer. 
+
+TBD: is this correct? Or is it the lower bound of the first range?
+
+TBD: is this correct that dfdlx:repValues always supercedes dfdlx:repValueRanges?
+
+### Examples of Numeric Enumerations in Daffodil DFDL
+
+A simple example of a basic enum is:
+
+```xml schema
+
+  <simpleType name="rep3Bit" dfdl:lengthUnits="bits" dfdl:length="3" dfdl:lengthKind="explicit">
+    <restriction base="xs:unsignedInt"/>
+  </simpleType>
+    
+  <simpleType name="precedenceEnum" dfdlx:repType="pre:rep3Bit">
+    <restriction base="xs:string">
+      <enumeration value="Reserved_0" dfdlx:repValues="0"/>
+      <enumeration value="Reserved_1" dfdlx:repValues="1"/>
+      <enumeration value="Emergency" dfdlx:repValues="2"/>
+      <enumeration value="Reserved_3" dfdlx:repValues="3"/>
+      <enumeration value="Flash" dfdlx:repValues="4"/>
+      <enumeration value="Immediate" dfdlx:repValues="5"/>
+      <enumeration value="Priority" dfdlx:repValues="6"/>
+      <enumeration value="Routine" dfdlx:repValues="7"/>
+    </restriction>
+  </simpleType>
+  ```
+
+Above we see the `dfdlx:repType` is `rep3Bit` which is a 3 bit `xs:unsignedInt`. This can
+represent the values 0 to 7 which one can see are the `dfdlx:repValues` of the `xs:enumeration`
+facets for this enumeration string type which is named `precedenceEnum`.
+
+In the above you can also see that the symbolic strings are in one-to-one correspondence with 
+every possible value of the 3-bit representation integer. 
+This one-to-one correspondence assures that data that is first parsed and then unparsed will 
+recreate the exact numeric bits used.
+
+However, in data security applications the following may be preferred:
+```xml schema
+ <simpleType name="precedenceEnum" dfdlx:repType="pre:rep3Bit">
+    <restriction base="xs:string">
+      <enumeration value="Reserved" dfdlx:repValues="0 1 3"/>
+      <enumeration value="Emergency" dfdlx:repValues="2"/>
+      <enumeration value="Flash" dfdlx:repValues="4"/>
+      <enumeration value="Immediate" dfdlx:repValues="5"/>
+      <enumeration value="Priority" dfdlx:repValues="6"/>
+      <enumeration value="Routine" dfdlx:repValues="7"/>
+    </restriction>
+  </simpleType>
+```
+
+In the above we see that three numeric values, 0, 1, and 3 are the `dfdlx:repValues` mapped to 
+the symbolic string `Reserved`. 
+This technique has the advantage of blocking covert signals being transmitted by use of the 
+different reserved values since when unparsed, the constant string `Reserved` will always be 
+_canonicalized_ to integer 0. 
+Putting data into canonical form when unparsing generally improves data security.
+
+The next example illustrates use of the `dfdlx:repValueRanges` property:
+
+
+```xml schema
 
-``dfdlx:direction``
+  <simpleType name="rep5Bit" dfdl:lengthUnits="bits" dfdl:length="5" dfdl:lengthKind="explicit">
+    <restriction base="xs:unsignedInt"/>
+  </simpleType>
+    
+  <simpleType name="versionEnum" dfdlx:repType="pre:rep4Bit">
+    <restriction base="xs:string">
+      <enumeration value="Undefined" dfdlx:repValues="0" dfdlx:repValueRanges="5 10 12 17"/>
+      <enumeration value="B" dfdlx:repValues="1"/>
+      <enumeration value="C" dfdlx:repValues="2"/>
+      <enumeration value="D" dfdlx:repValues="3"/>
+      <enumeration value="E" dfdlx:repValues="4"/>
+      <enumeration value="Q" dfdlx:repValues="11"/>
+      <enumeration value="NotImplemented" dfdl:repValueRanges="18 31"/>
+    </restriction>
+  </simpleType>
+  ```
 
-   : TBD
+In the above the enumeration specifies that many of the values are considered `Undefined` 
+including values 0, 5 through 10, and 12 through 17. 
+A second range from 18 to 31 correspond to constant `NotImplemented`. 
 
-``dfdlx:repType``, ``dfdlx:repValues``, and ``dfdlx:repValueRanges``
 
-   : TBD
 
-### Extended Behaviors
+# Extended Behaviors for DFDL Types
 
-Type ``xs:hexBinary``
+## Type ``xs:hexBinary``
 
-   : Daffodil allows `dfdlx:lengthUnits='bits'` for this simple type. 
+Daffodil allows `dfdlx:lengthUnits='bits'` for this simple type. 
diff --git a/site/layers.md b/site/layers.md
index 157a038a..f28782df 100644
--- a/site/layers.md
+++ b/site/layers.md
@@ -3,8 +3,8 @@ description: Pluggable Extensions to Enable Algorithmic Transformations
   in DFDL
 group: 'nav-right'
 layout: page
-title: 'Layers - Algorithmic
-  Extensions for DFDL'
+title: 'Layers - Algorithmic Extensions for DFDL'
+pdf: true
 ---
 <!--
 {% comment %}
@@ -25,13 +25,8 @@ limitations under the License.
 {% endcomment %}
 -->
 
-### Table of Contents
-{:.no_toc}
 
-1. use ordered table of contents
-{:toc}
-
-## Introduction
+# Introduction
 
 This page describes a DFDL language extension known as _Layers_.
 
@@ -58,7 +53,7 @@ There is no limit to this depth.
 In the section on [Using Layers](#UsingLayers) below we will look at an example that uses 
 multiple layers together. 
 
-### Built-in Layers
+## Built-in Layers
 
 Daffodil includes several built-in layers:
 - [base64_MIME](#base64-mime-layer)
@@ -78,20 +73,20 @@ Each of the built-in layers will be
 [documented separately below](#daffodil-built-in-layer-documentation) with examples of their 
 usage.
 
-### Custom Plug-In Layers
+## Custom Plug-In Layers
 
 Additional layers can be written in Java or Scala and deployed as _plug-ins_ for Daffodil.
 These are generally packaged as DFDL _layer schemas_, a kind of _component schema_,
 that provide the layer packaged for import by other DFDL _assembly_ schemas that use the 
 layer in the data format they describe. 
 
-### Layer Kinds: Transforming Layers and Checksum Layers
+## Layer Kinds: Transforming Layers and Checksum Layers
 
 There are two different kinds of layers, though they share many characteristics. They are 
 _transforming_ layers, and _checksum_ layers. Both run small algorithms over part (or all) of 
 the data stream. The difference is the purpose of the algorithm and its output. 
 
-#### Transforming Layers
+### Transforming Layers
 
 These layers decode data (when parsing), and encode data (when unparsing). 
 The simplest example of a transforming layer is the `base64_MIME` layer which 
@@ -106,7 +101,7 @@ Custom transforming layers are created by deriving an implementation from the Da
 [`Layer`](/docs/latest/javadoc/org/apache/daffodil/runtime1/layers/api/Layer.html) class 
 which is introduced in a later section. 
 
-#### Checksum Layers
+### Checksum Layers
 
 Checksum layers are a simplified kind of layer which do not decode or encode data, they simply 
 pass through the data unmodified, but while doing so they compute a checksum, hash, or Cyclic
@@ -131,7 +126,7 @@ class, which is introduced in a later section.
 
 ----
 
-## Using Layers
+# Using Layers
 
 To use a layer you must know
 - the layer's namespace URI
@@ -155,7 +150,7 @@ to receive results back from the layer (usually for checksum layers).
 
 Lastly, there is the concept of _layer length limiting_.
 
-### Layer Length Limiting
+## Layer Length Limiting
 
 A layer can process an entire input file/stream.
 Such a layer is said to be _unlimited_.
@@ -175,7 +170,7 @@ There are these ways to do layer limiting, that differ in important ways:
 - using a Utility Layer that is built-in to Daffodil
 - binding a DFDL variable specific to a particular layer
 
-#### Layer Limiting using Enclosing Elements of Specified Length
+### Layer Limiting using Enclosing Elements of Specified Length
 
 If the `sequence` for a layer is the model group of the
 complex type of an element, and that element has specified length (meaning it has 
@@ -185,14 +180,14 @@ of the element limits the length of the layer within it.
 In this case the length of the layer is limited when parsing, but it is NOT limited when
 unparsing.
 
-#### Layer Limiting using the Utility Layers 
+### Layer Limiting using the Utility Layers 
 
 Some layers do not decode or encode data but only restrict the length for other layers, for 
 example by using a length layer variable or delimiter. 
 See the [`boundaryMark` layer](#boundarymark-layer)
 and [`fixedLength` layer](#fixedlength-layer) for examples.
 
-#### Layer Limiting by Binding a DFDL Variable 
+### Layer Limiting by Binding a DFDL Variable 
 
 Some layers will define a DFDL variable that must be set to a non-negative
 integer value to specify the layer length that the layer will use. 
@@ -203,7 +198,7 @@ Layers may specify restrictions on the minimum and maximum allowed values of the
 and passing an out-of-range value for the variable is a processing error.
 
 
-## Example: Line Folding
+# Example: Line Folding
 
 Consider the line folding layer, specifically the `lineFolded_IMF` layer, 
 which is built-in to Daffodil.
@@ -220,7 +215,7 @@ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
 ```
 This data has been _line folded_ at roughly 72 characters by inserting a CRLF
 before an existing space in the data. 
-Each line ends with a CRLF (\r\n) and the second through fourth lines begin 
+Each line ends with a CRLF (`\r\n`) and the second through fourth lines begin 
 with a space as a way of indicating that they are extension lines. 
 This data is supposed to be reassembled to form a long single-line string by removing
 all CRLF pairs.
@@ -265,7 +260,7 @@ Other examples will show how the layer length can be limited to a sub-region of
 
 More detailed documentation for the [Line Folded Layers](#line-folded-layers) is below.
 
-## Example: Base64, GZip, and BoundaryMark Layers used Together
+# Example: Base64, GZip, and BoundaryMark Layers used Together
 
 In this example, the data consists of a preliminary string, a section of CSV-like data, and a 
 final string element.
@@ -435,7 +430,7 @@ The above schema works both to parse, but also to unparse this data.
 
 ----
 
-## Using Custom Plug-In Layers
+# Using Custom Plug-In Layers
 
 A custom plug-in layer is used in the same manner as the built-in Daffodil layers with just a few
 additional details:
@@ -468,7 +463,7 @@ Further details on how to define custom plug-in layers is in the Javadoc for the
 ----
 ----
 
-## Daffodil Built-In Layer Documentation
+# Daffodil Built-In Layer Documentation
 
 Each of the layers built-in to the Daffodil implementation are documented in a section below 
 which gives the name, namespace, variables, and some usage notes.
@@ -483,7 +478,7 @@ The built-in layers are:
 
 ----
 
-### Base64 MIME Layer
+## Base64 MIME Layer
 
 - Name: base64_MIME
 - Namespace URI: urn:org.apache.daffodil.layers.base64_MIME
@@ -498,14 +493,14 @@ This uses the standard `java.util.Base64` classes, specifically the MIME encodin
 
 This is specified by [RFC 2045](https://www.ietf.org/rfc/rfc2045.txt).
 The encoded output must be represented in lines of no more than 76 characters 
-each and uses a carriage return '\r' followed immediately by a linefeed '\n' as the line separator. 
+each and uses a carriage return `\r` followed immediately by a linefeed `\n` as the line separator. 
 No line separator is added to the end of the encoded output. 
 All line separators or other characters not found in the base64 alphabet table are ignored in
 decoding operation.
 
 ----
 
-### BoundaryMark Layer
+## BoundaryMark Layer
 
 - Name: boundaryMark
 - Namespace URI: urn:org.apache.daffodil.layers.boundaryMark
@@ -549,7 +544,7 @@ for the boundary mark string.
 
 ----
 
-### Byte-Swapping Layers
+## Byte-Swapping Layers
 
 - Layer Names:
   - `twobyteswap`  
@@ -584,7 +579,7 @@ word size a processing error occurs.
 
 ----
 
-### FixedLength Layer
+## FixedLength Layer
 
 - Name: fixedLength
 - Namespace URI: urn:org.apache.daffodil.layers.fixedLength
@@ -604,7 +599,7 @@ The entire fixed length region of the data will be pulled into a byte buffer in
 
 ----
 
-### GZIP Layer
+## GZIP Layer
 
 - Name: gzip
 - Namespace URI: urn:org.apache.daffodil.layers.gzip
@@ -628,7 +623,7 @@ always writes a consistent header (header byte 9 of 255) regardless of the Java
 
 ----
 
-### Line Folded Layers
+## Line Folded Layers
 
 - Layer Names:
   - [lineFolded_IMF](#layer-name-linefolded_imf) - conforms to IETF RFC 2822 Internet Message 
@@ -642,7 +637,7 @@ always writes a consistent header (header byte 9 of 255) regardless of the Java
       <xs:import namespace="urn:org.apache.daffodil.layers.lineFolded"
          schemaLocation="/org/apache/daffodil/layers/xsd/lineFoldedLayer.dfdl.xsd"/>
 ```
-#### General Usage
+### General Usage
 
 There is a limitation on the compatibility of line folding of data
 with adjacent parts of the format which also use line-endings.
@@ -650,11 +645,11 @@ For example, line folding can interact badly with surrounding elements of `dfdl:
 'pattern'` if the pattern is, for example `".*?\\r\\n(?!(?:\\t|\\ ))"` which is anything up to
 and including a CRLF not followed by a space or tab. 
 The problem is that line folding
-converts isolated \n or \r into \r\n, and if this just happens to be followed by a
+converts isolated `\n` or `\r` into `\r\n`, and if this just happens to be followed by a
 non space/tab character this will have inserted an end-of-data in the middle of the
 data.
 
-#### Layer Name: lineFolded_IMF
+### Layer Name: lineFolded_IMF
 
 For IMF, unfolding simply removes CRLFs if they are followed by a space or tab.
 
@@ -690,7 +685,7 @@ are smaller than those of IMF, and which do not require accommodation by having
 pre-existing spaces/tabs in the data. So such data will always be short
 enough lines.
 
-#### Layer Name: lineFolded_iCalendar
+### Layer Name: lineFolded_iCalendar
 
 For iCalendar (including vCard and vCalendar), the maximum is 75 bytes plus the CRLF, for
 a total of 77. Folding is inserted by inserting CRLF + a space or tab. The
diff --git a/site/pdf/dfdl-extensions.pdf b/site/pdf/dfdl-extensions.pdf
new file mode 100644
index 00000000..181ab127
Binary files /dev/null and b/site/pdf/dfdl-extensions.pdf differ
diff --git a/site/pdf/layers.pdf b/site/pdf/layers.pdf
new file mode 100644
index 00000000..b36d4b6f
Binary files /dev/null and b/site/pdf/layers.pdf differ
diff --git a/site/unsupported.md b/site/unsupported.md
index 64db8e01..1b2e03b5 100644
--- a/site/unsupported.md
+++ b/site/unsupported.md
@@ -51,7 +51,7 @@ that there has been no intention to support as of this release.
 #### XML Schema Features
 
 * fixed {% jira 117 %}
-* default {% jira 115 %} {% jira 1277 %}
+* default {% jira 115 %}
 
 #### Properties and Property Enumerations