docs/reading-prefixes-and-datatypes.md -whitespace
# Verbatim integer corpus comments retain their original trailing spaces.
docs/reading-integer-occurrences.md -whitespace
+# Unified patches preserve upstream whitespace in context and removed lines.
+patches/*.patch -whitespace
# Common Lisp Topic Maps — Slice 19C
-Slice 19D0 makes pinned CXML sources available to ASDF through the Nix source
-environment, without changing the CTM/TMDM/CXTM implementation. **Parser
-qualification currently FAILS** on UTF-16 supplementary characters and invalid
-UTF-8; provisioning success is not an XTM-readiness claim. See
+Slice 19D0B qualifies local, versioned CXML/closure-common encoding corrections:
+**58 original and 88 additional XML checks PASS** in fresh offline SBCL 2.5.4.
+The required entry point is `topic-maps.xml:parse-octets` after offline source
+patch preparation; it enforces external-resource denial. No XTM deserializer
+is implemented. See [encoding qualification](docs/slice-19d0b-cxml-encoding.md).
+
+Slice 19D0 made pinned CXML sources available to ASDF through the Nix source
+environment. Its initial parser qualification failed on UTF-16 supplementary
+characters and invalid UTF-8; those historical failures are retained. See
[CXML provisioning and qualification](docs/slice-19d0-cxml.md) for exact hashes,
offline loading, external-entity policy, the failing probes and retained regression.
--- /dev/null
+# Slice 19D0B — CXML encoding qualification
+
+Base: `ec3f21e45c46849a6bb674194b6f7cc75b67bba1`.
+Nixpkgs remains `50ab793786d9de88ee30ec4e4c24fb4236fc2674`.
+Qualification is **PASS** with the local patches and mandatory byte boundary.
+No XTM deserializer or XTM contract is introduced.
+
+## Normative decisions
+
+The checked sources are [XML 1.0 Fifth Edition §2.2, §2.11, §4.3.3](https://www.w3.org/TR/2008/REC-xml-20081126/),
+[Unicode 16.0 §3.9.2–3, Table 3-7 and §3.10](https://www.unicode.org/versions/Unicode16.0.0/core-spec/chapter-3/),
+[RFC 2781 §2.2, §3.3, §4](https://www.rfc-editor.org/rfc/rfc2781.html), and
+[RFC 3629 §3–4](https://www.rfc-editor.org/rfc/rfc3629.html).
+
+XML requires UTF-8 and UTF-16 support and accepts supplementary characters in
+its Char range, including currently unassigned code points. Generic UTF-16
+requires a BOM. UTF-16LE/BE are distinct encoding schemes: these original inputs
+have an XML declaration that identifies their byte order. They are sufficiently
+labeled. XML Appendix F.1 describes provisional signature detection; it is
+informative, while declaration consistency and illegal-sequence rejection in
+§4.3.3 are normative. Missing labels and contradictory declarations are errors.
+XML line-end normalization also applies to UTF-16.
+
+Unicode UTF-16 pairs a high surrogate with a low surrogate; isolated units are
+invalid. UTF-8 must use its shortest form, valid continuation bytes and scalar
+range, excluding encoded surrogates. Incomplete sequences require more input
+until EOF, then fail. RFC 2781 distinguishes the explicit endian labels from
+generic UTF-16; RFC 3629 corroborates the UTF-8 byte ranges. These encoding
+rules do not change the project's Unicode NFC tables or add a Unicode library.
+
+## All eight original failures
+
+The exact Unicode source text, **complete input octets in hex**, byte count,
+SHA-256, detected encoding, before/after result, condition, diagnostic and
+applicable clauses for each case are in
+`reports/slice-19d0b/original-failures.json`. The source bytes are reconstructed
+independently with Python's standard codecs and passed directly to CXML.
+Diagnostics are observed parser messages; line/column reports are not promoted
+to exact byte offsets.
+
+| Original test | Bytes | Originally detected | Original result | Required/patched result | Cause |
+|---|---:|---|---|---|---|
+| `utf16le-bom:astral` | 114 | UTF-16 LE | rejects D83E DD8A | accepts `Grüße 水 🦊` | A |
+| `utf16be-bom:astral` | 114 | UTF-16 BE | rejects D83E DD8A | accepts `Grüße 水 🦊` | A |
+| `utf16le-explicit-no-bom:bmp` | 110 | UTF-8 | malformed markup | accepts `Grüße 水` | B |
+| `utf16le-explicit-no-bom:astral` | 116 | UTF-8 | malformed markup | accepts `Grüße 水 🦊` | B + A |
+| `utf16be-explicit-no-bom:bmp` | 110 | UTF-8 | NUL in markup | accepts `Grüße 水` | B |
+| `utf16be-explicit-no-bom:astral` | 116 | UTF-8 | NUL in markup | accepts `Grüße 水 🦊` | B + A |
+| `utf16-bom-without-declaration:astral` | 22 | UTF-16 LE | rejects D83E DD8A | accepts `水🦊` | A |
+| `invalid-utf8` | 9 | UTF-8 | accepts `C3 28` as U+00E8 | rejects invalid continuation | C |
+
+**A — closure-common defect.** The endian-specific `decode-sequence` methods
+in `encodings.lisp` check the first code unit `x` again where they must check
+the second, `y` (original lines 172/209). Valid supplementary content therefore
+fails. Fixing `x` to `y` preserves the existing code-point computation.
+
+**B — two implementation gaps, not incorrect expectations.** In
+`closure-common/xstream.lisp`, `figure-encoding` recognizes only BOM-based
+UTF-16. It defaults the four correctly labeled inputs to UTF-8 before CXML can
+read their declarations. CXML's `setup-encoding` additionally lacks explicit
+LE/BE handling, warns for generic UTF-16 and does not fully check consistency.
+The patch recognizes the four-byte XML signatures provisionally, preserves
+preread bytes and records the detection reason in the existing stream plist.
+`setup-encoding` then checks the actual declaration. A signature alone does not
+authorize generic BOM-less UTF-16, a missing label or a mismatched label.
+The existing `set-full-speed` transition also checks that a declaration was
+actually processed, so a leading ordinary processing instruction cannot bypass it.
+
+**C — closure-common defect.** The UTF-8 `decode-sequence` method masks tail
+bytes without validating their prefix. The patch validates continuation bytes,
+shortest forms, the maximum scalar and permitted leading bytes; obsolete
+five/six-byte forms fail. Incomplete UTF-8/UTF-16 sequences fail at EOF rather
+than being silently dropped or repeatedly retried. Both existing UTF-16
+decoders also receive their protocol-required CR/CRLF handling.
+
+The four endian-specific, BOM-less inputs are valid supported forms, though
+XML's mandatory UTF-8/UTF-16 support alone does not require these related
+schemes. **No original expectation was weakened or replaced.** In particular,
+the BOM-less tests were not changed to expect rejection. Their data includes
+`3c 00 3f 00` / `00 3c 00 3f` followed by the appropriate encoding declaration.
+
+## Patch and source provenance
+
+`patches/closure-common-19d0b.patch` changes only `encodings.lisp` and
+`xstream.lisp`. `patches/cxml-19d0b.patch` changes only `xml/xml-parse.lisp`.
+They modify the existing decoder and declaration paths; they do not introduce
+a second parser, decoder framework or Unicode data set.
+
+The original archives, seven Nix source directories and their recursive
+source hashes remain unchanged. `flake.lock` and the corpus remain unchanged.
+The Nix source environment now also records the local patch profile and
+SHA-256 of both patch files. No further dependency was downloaded.
+
+`scripts/prepare-cxml.py`:
+
+1. Evaluates the existing pinned Nix source environment offline.
+2. Verifies all seven original source hashes before writing outputs.
+3. Copies only the two affected packages into a **new** caller-selected directory.
+4. Checks local patch hashes against the Nix manifest and applies them with
+ the existing `patch` tool, with zero fuzz and no offsets.
+5. Checks the exact set of changed files; records original and resulting
+ file hashes and the effective ASDF registry in `provenance.json`.
+
+It never writes into `/nix/store`, overwrites an existing output directory or
+retrieves a resource. Two independent copies produce identical patched file
+hashes. Effective paths in recorded validation runs belonged to those temporary
+execution contexts; they are not persistent addresses. Reproduce them with the
+preparation command rather than reusing expired temporary paths.
+
+## Binding public call contract
+
+The optional ASDF system **`topic-maps/xml`** depends only on CXML, not on CTM,
+TMDM or HyperDoc. Future XTM deserialization **must call
+`topic-maps.xml:parse-octets`**, not bare `cxml:parse-octets`.
+
+The function accepts a specialized octet vector and a SAX handler, and returns
+the handler's SAX result without replacing its object identity. It:
+
+* Refuses libraries without the required local patch ABI markers.
+* Fixes namespace processing on and gives the caller no resolver/DTD overrides.
+* Wraps the receiver in an existing CXML SAX proxy that rejects every DOCTYPE
+ before forwarding it. Even a NIL/permissive receiver cannot bypass the guard.
+* Disallows internal subsets and uses a resolver that **signals**
+ `external-resource-forbidden`; returning NIL is forbidden.
+* Disables catalog lookup and binds a fresh DTD cache for each parse.
+
+The ABI markers protect against accidental loading of pristine dependencies;
+they are not an integrity defense against arbitrary Lisp code rewriting loaded
+functions. Source and patch integrity is checked during preparation.
+The underlying library's unsafe entry points are not made globally safe.
+The public boundary offers no already-decoded-string, filename, transport
+encoding or arbitrary parser-option interface.
+
+## Reproduction and inspection
+
+```sh
+cd /Users/rgb/workspace/topic-maps
+xml_sources=$(mktemp -d /tmp/topic-maps-xml.XXXXXX)
+export CL_SOURCE_REGISTRY="$(python3 scripts/prepare-cxml.py \
+ --directory "$xml_sources/patched" --registry)"
+/usr/bin/sandbox-exec -p '(version 1)(allow default)(deny network*)' \
+ /nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl \
+ --noinform --no-sysinit --no-userinit --script tests/cxml-probe.lisp
+
+python3 scripts/validate-cxml-19d0b.py \
+ --sbcl /nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl
+```
+
+In a fresh Lisp process with that registry:
+
+```lisp
+(require :asdf)
+(asdf:load-asd (truename "topic-maps.asd"))
+(asdf:load-system "topic-maps/xml")
+(let ((bytes (make-array 4 :element-type '(unsigned-byte 8)
+ :initial-contents '(60 114 47 62)))) ; <r/>
+ (describe (topic-maps.xml:parse-octets bytes (cxml-xmls:make-xmls-builder))))
+```
+
+The Nix manifest's `sourceRegistry` still denotes pristine upstream sources;
+the preparation step is mandatory for this API. Merely entering the old
+DevShell or loading unpatched CXML does not activate the patches. A fresh-process
+counterprobe loads precisely that unpatched environment and proves that the
+public boundary refuses it before parsing. This source-overlay workflow reuses
+the existing Nix/ASDF provisioning without realizing an uncached toolchain.
+
+## Validation evidence
+
+`reports/slice-19d0b/execution.json` records source/patch hashes, runtime and
+timestamps, independent source-copy reproduction, original and patched runs,
+the fresh unpatched-boundary counterprobe and the complete retained regression.
+
+* Original test program from the base commit, pristine sources: **50 PASS, 8 FAIL**.
+* **Unmodified original program**, patched sources: **58 PASS, 0 FAIL**.
+* Original 58 expectations through the binding public boundary, plus 88 focused
+ regressions: **146 PASS, 0 FAIL**, repeated in two fresh SBCL 2.5.4 processes.
+* Additional cases cover malformed/overlong/truncated UTF-8, invalid UTF-16
+ units, Unicode scalar boundaries, partial-input/EOF behavior, large refills,
+ line ends, missing/conflicting declarations, namespaces and the fixed API.
+* All external DTD/entity rejection checks and the NIL-resolver fallback
+ counterprobe remain. The fallback is intercepted before OPEN, so sandbox I/O
+ denial is never misreported as successful resolver refusal.
+* Full existing regression: **12,100 Lisp checks**, **2 Python tests** and
+ **16,294 NFC oracle comparisons** pass. All 24 retained JSON reports are
+ byte-identical to Slice 19C. CTM stays **204 PASS, 4 known FAIL, 65 NOT-RUN**.
+
+All Lisp observations run with network access denied. Nix evaluation uses
+`--offline`; patching consumes already materialized sources. The complete Nix
+toolchain/DevShell offline rebuild remains **NOT-RUN**. This is an offline
+source-patch/ASDF qualification using existing Nix runtime artifacts, not a claim
+that every Nix artifact was rebuilt offline or that all of XML is conformant.
+No XTM PASS, push, deployment, HyperDoc modification or persistent-image load.
# use the existing SBCL 2.5.4 without changing this Nixpkgs pin.
packages = pkgs.lib.unique (visit pkgs.sbclPackages.cxml);
in {
+ # This registry names pristine sources. prepare-cxml.py applies the
+ # following versioned patches to a separate copy before qualification/use.
+ patchProfile = "19d0b-1";
+ localPatches = map (name: {
+ package = name;
+ file = "patches/${name}-19d0b.patch";
+ sha256 = builtins.hashFile "sha256" (./patches + "/${name}-19d0b.patch");
+ }) [ "closure-common" "cxml" ];
sourceRegistry = "(:source-registry " +
pkgs.lib.concatMapStringsSep " "
(package: "(:tree \"${package.src}/\")") packages +
--- /dev/null
+--- a/encodings.lisp
++++ b/encodings.lisp
+@@ -1,4 +1,6 @@
+ (in-package :runes-encoding)
++
++(defparameter *topic-maps-encoding-patch* "19d0b-1")
+
+ (eval-when (:compile-toplevel :load-toplevel :execute)
+ (defparameter +buffer-byte+
+@@ -154,6 +156,7 @@
+ (when (%= wptr out-end)
+ (return))
+ (when (>= (%+ rptr 1) in-end)
++ (when (and eof? (< rptr in-end)) (xerror "Incomplete UTF-16 code unit"))
+ (return))
+ (let* ((hi (aref in rptr))
+ (lo (aref in (%+ 1 rptr)))
+@@ -161,22 +164,29 @@
+ (when (or (eql x #xFFFE) (eql x #xFFFF))
+ (xerror "not a valid code point: #x~X" x))
+ (when (<= #xDC00 x #xDFFF)
+- (xerror "unexpected high surrogate: #x~X" x))
++ (xerror "unexpected low surrogate: #x~X" x))
+ (when (<= #xD800 x #xDBFF)
+- ;; seen low surrogate, look for high surrogate now
++ ;; A high surrogate must be followed by a low surrogate.
+ (when (>= (%+ rptr 3) in-end)
++ (when eof? (xerror "Incomplete UTF-16 surrogate pair"))
+ (return))
+ (let* ((hi2 (aref in (%+ 2 rptr)))
+ (lo2 (aref in (%+ 3 rptr)))
+ (y (logior (ash hi2 8) lo2)))
+- (unless (<= #xDC00 x #xDFFF)
+- (xerror "expected a high surrogate but found: #x~X" x))
++ (unless (<= #xDC00 y #xDFFF)
++ (xerror "expected a low surrogate but found: #x~X" y))
+ #-rune-is-utf-16
+ (progn
+ (setf x (logior (ash (%- x #xd7c0) 10) (%and y #x3FF)))
+ (setf rptr (%+ 2 rptr))))
+ ;; end of surrogate handling
+ )
++ (when (= x #x0D)
++ (when (and (< (- in-end rptr) 4) (not eof?)) (return))
++ (when (and (>= (- in-end rptr) 4)
++ (= (logior (ash (aref in (+ rptr 2)) 8) (aref in (+ rptr 3))) #x0A))
++ (incf rptr 2))
++ (setf x #x0A))
+ (setf (aref out wptr) x)
+ (setf rptr (%+ 2 rptr))
+ (setf wptr (%+ 1 wptr))))
+@@ -191,6 +201,7 @@
+ (when (%= wptr out-end)
+ (return))
+ (when (>= (%+ rptr 1) in-end)
++ (when (and eof? (< rptr in-end)) (xerror "Incomplete UTF-16 code unit"))
+ (return))
+ (let* ((lo (aref in rptr))
+ (hi (aref in (%+ 1 rptr)))
+@@ -198,22 +209,29 @@
+ (when (or (eql x #xFFFE) (eql x #xFFFF))
+ (xerror "not a valid code point: #x~X" x))
+ (when (<= #xDC00 x #xDFFF)
+- (xerror "unexpected high surrogate: #x~X" x))
++ (xerror "unexpected low surrogate: #x~X" x))
+ (when (<= #xD800 x #xDBFF)
+- ;; seen low surrogate, look for high surrogate now
++ ;; A high surrogate must be followed by a low surrogate.
+ (when (>= (%+ rptr 3) in-end)
++ (when eof? (xerror "Incomplete UTF-16 surrogate pair"))
+ (return))
+ (let* ((lo2 (aref in (%+ 2 rptr)))
+ (hi2 (aref in (%+ 3 rptr)))
+ (y (logior (ash hi2 8) lo2)))
+- (unless (<= #xDC00 x #xDFFF)
+- (xerror "expected a high surrogate but found: #x~X" x))
++ (unless (<= #xDC00 y #xDFFF)
++ (xerror "expected a low surrogate but found: #x~X" y))
+ #-rune-is-utf-16
+ (progn
+ (setf x (logior (ash (%- x #xd7c0) 10) (%and y #x3FF)))
+ (setf rptr (%+ 2 rptr))))
+ ;; end of surrogate handling
+ )
++ (when (= x #x0D)
++ (when (and (< (- in-end rptr) 4) (not eof?)) (return))
++ (when (and (>= (- in-end rptr) 4)
++ (= (logior (ash (aref in (+ rptr 3)) 8) (aref in (+ rptr 2))) #x0A))
++ (incf rptr 2))
++ (setf x #x0A))
+ (setf (aref out wptr) x)
+ (setf rptr (%+ 2 rptr))
+ (setf wptr (%+ 1 wptr))))
+@@ -231,6 +249,11 @@
+ byte0)
+ (macrolet ((put (x)
+ `((lambda (x)
++ (when (< x (cond ((< byte0 #x80) 0)
++ ((< byte0 #xE0) #x80)
++ ((< byte0 #xF0) #x800)
++ (t #x10000)))
++ (xerror "Overlong UTF-8 sequence"))
+ (when (or (<= #xD800 x #xDBFF)
+ (<= #xDC00 x #xDFFF))
+ (xerror "surrogate encoded in UTF-8: #x~X." x))
+@@ -247,6 +270,11 @@
+ (setf (aref out wptr) x)
+ (setf wptr (%+ wptr 1)))))
+ ,x))
++ (continuation (offset)
++ `(let ((octet (aref in (%+ rptr ,offset))))
++ (unless (<= #x80 octet #xBF)
++ (xerror "Invalid UTF-8 continuation byte: #x~X" octet))
++ octet))
+ (put1 (x)
+ `(progn
+ (setf (aref out wptr) ,x)
+@@ -284,64 +312,40 @@
+ (xerror "Corrupted UTF-8 input (initial byte was #b~8,'0B)" byte0)
+ (setf rptr (%+ rptr 1)))
+
+- ((%<= #|#b11000000|# byte0 #b11011111)
++ ((%<= #xC2 byte0 #xDF)
+ (cond ((<= (%+ rptr 2) in-end)
+ (put
+ (dpb (ldb (byte 5 0) byte0) (byte 5 6)
+- (dpb (ldb (byte 6 0) (aref in (%+ rptr 1))) (byte 6 0)
++ (dpb (ldb (byte 6 0) (continuation 1)) (byte 6 0)
+ 0)))
+ (setf rptr (%+ rptr 2)))
+ (t
++ (when eof? (xerror "Incomplete UTF-8 sequence"))
+ (return))))
+
+- ((%<= #|#b11100000|# byte0 #b11101111)
++ ((%<= #xE0 byte0 #xEF)
+ (cond ((<= (%+ rptr 3) in-end)
+ (put
+ (dpb (ldb (byte 4 0) byte0) (byte 4 12)
+- (dpb (ldb (byte 6 0) (aref in (%+ 1 rptr))) (byte 6 6)
+- (dpb (ldb (byte 6 0) (aref in (%+ 2 rptr))) (byte 6 0)
++ (dpb (ldb (byte 6 0) (continuation 1)) (byte 6 6)
++ (dpb (ldb (byte 6 0) (continuation 2)) (byte 6 0)
+ 0))))
+ (setf rptr (%+ rptr 3)))
+ (t
++ (when eof? (xerror "Incomplete UTF-8 sequence"))
+ (return))))
+
+- ((%<= #|#b11110000|# byte0 #b11110111)
++ ((%<= #xF0 byte0 #xF4)
+ (cond ((<= (%+ rptr 4) in-end)
+ (put
+ (dpb (ldb (byte 3 0) byte0) (byte 3 18)
+- (dpb (ldb (byte 6 0) (aref in (%+ 1 rptr))) (byte 6 12)
+- (dpb (ldb (byte 6 0) (aref in (%+ 2 rptr))) (byte 6 6)
+- (dpb (ldb (byte 6 0) (aref in (%+ 3 rptr))) (byte 6 0)
++ (dpb (ldb (byte 6 0) (continuation 1)) (byte 6 12)
++ (dpb (ldb (byte 6 0) (continuation 2)) (byte 6 6)
++ (dpb (ldb (byte 6 0) (continuation 3)) (byte 6 0)
+ 0)))))
+ (setf rptr (%+ rptr 4)))
+ (t
+- (return))))
+-
+- ((%<= #|#b11111000|# byte0 #b11111011)
+- (cond ((<= (%+ rptr 5) in-end)
+- (put
+- (dpb (ldb (byte 2 0) byte0) (byte 2 24)
+- (dpb (ldb (byte 6 0) (aref in (%+ 1 rptr))) (byte 6 18)
+- (dpb (ldb (byte 6 0) (aref in (%+ 2 rptr))) (byte 6 12)
+- (dpb (ldb (byte 6 0) (aref in (%+ 3 rptr))) (byte 6 6)
+- (dpb (ldb (byte 6 0) (aref in (%+ 4 rptr))) (byte 6 0)
+- 0))))))
+- (setf rptr (%+ rptr 5)))
+- (t
+- (return))))
+-
+- ((%<= #|#b11111100|# byte0 #b11111101)
+- (cond ((<= (%+ rptr 6) in-end)
+- (put
+- (dpb (ldb (byte 1 0) byte0) (byte 1 30)
+- (dpb (ldb (byte 6 0) (aref in (%+ 1 rptr))) (byte 6 24)
+- (dpb (ldb (byte 6 0) (aref in (%+ 2 rptr))) (byte 6 18)
+- (dpb (ldb (byte 6 0) (aref in (%+ 3 rptr))) (byte 6 12)
+- (dpb (ldb (byte 6 0) (aref in (%+ 4 rptr))) (byte 6 6)
+- (dpb (ldb (byte 6 0) (aref in (%+ 5 rptr))) (byte 6 0)
+- 0)))))))
+- (setf rptr (%+ rptr 6)))
+- (t
++ (when eof? (xerror "Incomplete UTF-8 sequence"))
+ (return))))
+
+ (t
+--- a/xstream.lisp
++++ b/xstream.lisp
+@@ -317,7 +317,7 @@
+ (initial-encoding :guess))
+ ;; XXX if initial-speed isn't 1, encoding will me munged up
+ (assert (eql initial-speed 1))
+- (multiple-value-bind (encoding preread)
++ (multiple-value-bind (encoding preread detection)
+ (if (eq initial-encoding :guess)
+ (figure-encoding os-stream)
+ (values initial-encoding nil))
+@@ -337,6 +337,7 @@
+ :os-left-start 0
+ :os-left-end (length preread)
+ :encoding encoding
++ :plist (list :initial-encoding encoding :encoding-detection detection)
+ :name name))))
+
+ (defun make-rod-xstream (string &key name)
+@@ -364,23 +365,26 @@
+ (values :utf-8 nil))
+
+ (defmethod figure-encoding ((stream stream))
+- (let ((c0 (read-byte stream nil :eof)))
+- (cond ((eq c0 :eof)
+- (values :utf-8 nil))
+- (t
+- (let ((c1 (read-byte stream nil :eof)))
+- (cond ((eq c1 :eof)
+- (values :utf-8 (list c0)))
+- (t
+- (cond ((and (= c0 #xFE) (= c1 #xFF)) (values :utf-16-big-endian nil))
+- ((and (= c0 #xFF) (= c1 #xFE)) (values :utf-16-little-endian nil))
+- ((and (= c0 #xEF) (= c1 #xBB))
+- (let ((c2 (read-byte stream nil :eof)))
+- (if (= c2 #xBF)
+- (values :utf-8 nil)
+- (values :utf-8 (list c0 c1 c2)))))
+- (t
+- (values :utf-8 (list c0 c1)))))))))))
++ ;; Keep preread bytes and distinguish a BOM from a provisional XML signature.
++ (let* ((a (read-byte stream nil nil))
++ (b (and a (read-byte stream nil nil)))
++ (prefix (remove nil (list a b))))
++ (cond ((equal prefix '(254 255)) (values :utf-16-big-endian nil :bom))
++ ((equal prefix '(255 254)) (values :utf-16-little-endian nil :bom))
++ ((equal prefix '(239 187))
++ (let ((c (read-byte stream nil nil)))
++ (if (eql c 191) (values :utf-8 nil :bom)
++ (values :utf-8 (append prefix (and c (list c))) :default))))
++ ((or (equal prefix '(0 60)) (equal prefix '(60 0)))
++ (let* ((c (read-byte stream nil nil))
++ (d (and c (read-byte stream nil nil)))
++ (bytes (append prefix (remove nil (list c d)))))
++ (cond ((equal bytes '(0 60 0 63))
++ (values :utf-16-big-endian bytes :signature))
++ ((equal bytes '(60 0 63 0))
++ (values :utf-16-little-endian bytes :signature))
++ (t (values :utf-8 bytes :default)))))
++ (t (values :utf-8 prefix :default)))))
+
+ ;;; misc
+
--- /dev/null
+--- a/xml/xml-parse.lisp
++++ b/xml/xml-parse.lisp
+@@ -2517,22 +2517,41 @@
+ (otherwise
+ (wf-error input "p/markup-decl ~S" (peek-token input))))))
+
++(defparameter *topic-maps-encoding-patch* "19d0b-1")
++
+ (defun setup-encoding (input xml-header)
+- (when (xml-header-encoding xml-header)
+- (let ((enc (find-encoding (xml-header-encoding xml-header)))
+- (xstream (car (zstream-input-stack input))))
+- (cond ((eql enc :utf-8)
+- (let ((old (xstream-encoding xstream)))
+- (unless (eql old :utf-8)
+- (with-simple-restart (continue "Stick with ~a" old)
+- (wf-error input "Header says UTF-8, but BOM says ~a." old)))))
+- (enc (setf (xstream-encoding xstream) enc))
+- (t
+- (warn "There is no such encoding: ~S." (xml-header-encoding xml-header)))))))
++ (let* ((xstream (car (zstream-input-stack input)))
++ (initial (getf (xstream-plist xstream) :initial-encoding
++ (xstream-encoding xstream)))
++ (detection (getf (xstream-plist xstream) :encoding-detection))
++ (name (xml-header-encoding xml-header))
++ (declared (and name (string-upcase name)))
++ (utf16p (member initial '(:utf-16-big-endian :utf-16-little-endian))))
++ (cond ((null declared)
++ (when (eq detection :signature)
++ (wf-error input "BOM-less UTF-16LE/BE requires an explicit encoding declaration.")))
++ ((string= declared "UTF-16")
++ (unless (and utf16p (eq detection :bom))
++ (wf-error input "UTF-16 requires a matching BOM.")))
++ ((member declared '("UTF-16LE" "UTF-16BE") :test #'string=)
++ (unless (and (eq detection :signature)
++ (eq initial (if (string= declared "UTF-16LE")
++ :utf-16-little-endian :utf-16-big-endian)))
++ (wf-error input "UTF-16LE/BE declaration disagrees with the input encoding.")))
++ (t
++ (let ((encoding (find-encoding name)))
++ (unless encoding (wf-error input "Unknown encoding: ~A" name))
++ (when (or utf16p (and (eq detection :bom) (not (eq encoding :utf-8))))
++ (wf-error input "Encoding declaration ~A disagrees with the BOM/signature." name))
++ (setf (xstream-encoding xstream) encoding))))
++ (setf (getf (xstream-plist xstream) :encoding-declaration-checked) t)))
+
+ (defun set-full-speed (input)
+ (let ((xstream (car (zstream-input-stack input))))
+ (when xstream
++ (when (and (eq (getf (xstream-plist xstream) :encoding-detection) :signature)
++ (not (getf (xstream-plist xstream) :encoding-declaration-checked)))
++ (wf-error input "BOM-less UTF-16LE/BE requires an XML encoding declaration."))
+ (set-to-full-speed xstream))))
+
+ (defun p/ext-subset (input)
--- /dev/null
+{
+ "baseCommit": "ec3f21e45c46849a6bb674194b6f7cc75b67bba1",
+ "branch": "codex/ctm-slice-19d0b",
+ "startedAtUTC": "2026-10-18T16:26:56.678600+00:00",
+ "finishedAtUTC": "2026-10-18T16:27:46.172889+00:00",
+ "runtime": "SBCL 2.5.4",
+ "nixpkgsCommit": "50ab793786d9de88ee30ec4e4c24fb4236fc2674",
+ "nixSystem": "x86_64-darwin",
+ "sourceEnvironment": {
+ "localPatches": [
+ {
+ "file": "patches/closure-common-19d0b.patch",
+ "package": "closure-common",
+ "sha256": "bbe8e956a147f6f122025e3c355bb13cf0d55ad811d1d4003f9ab50976aed74a"
+ },
+ {
+ "file": "patches/cxml-19d0b.patch",
+ "package": "cxml",
+ "sha256": "86720fb7960057def9092e8e75332ce45348b9809766667b8e6b1901c7cf5f24"
+ }
+ ],
+ "manifest": [
+ {
+ "name": "cxml",
+ "sha256": "18fls3bx7vmnxfa6qara8fxp316d8kb3izar0kysvqg6l0a45a51",
+ "source": "/nix/store/5075y4alv1is8n78bcsfcaj0mfpqz195-source",
+ "url": "http://beta.quicklisp.org/archive/cxml/2020-06-10/cxml-20200610-git.tgz",
+ "version": "20200610-git"
+ },
+ {
+ "name": "closure-common",
+ "sha256": "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n",
+ "source": "/nix/store/yw7j44h85ilvrg9jsnwcyz048nbl3cl9-source",
+ "url": "http://beta.quicklisp.org/archive/closure-common/2018-10-18/closure-common-20181018-git.tgz",
+ "version": "20181018-git"
+ },
+ {
+ "name": "babel",
+ "sha256": "0359bj3yr6frybcmg8qr5vi4q8hzbsb7hmvxdc0jgkfz3c33q667",
+ "source": "/nix/store/76bbavhilddfxd2b56inkdzi6ym860cs-source",
+ "url": "http://beta.quicklisp.org/archive/babel/2024-10-12/babel-20241012-git.tgz",
+ "version": "20241012-git"
+ },
+ {
+ "name": "alexandria",
+ "sha256": "0jq0n59s0r9yl374f0zpdnaflb5g853yqvax7ka8rnypspyykwdw",
+ "source": "/nix/store/i6nnd3amy08a3f3v8q76nh9kw9434z29-source",
+ "url": "http://beta.quicklisp.org/archive/alexandria/2024-10-12/alexandria-20241012-git.tgz",
+ "version": "20241012-git"
+ },
+ {
+ "name": "trivial-features",
+ "sha256": "0r33ycg1wsmglbsychglzkd6fachnnqfzd0w9mhpwi6cz94hx7c3",
+ "source": "/nix/store/fldw3972prvmlv87f0qf69myk79kz1g4-source",
+ "url": "http://beta.quicklisp.org/archive/trivial-features/2023-06-18/trivial-features-20230618-git.tgz",
+ "version": "20230618-git"
+ },
+ {
+ "name": "trivial-gray-streams",
+ "sha256": "0iw6q5hx7x8sc5s7ikvsjccsksbm0rd13d54mkrg62sc56hjywrm",
+ "source": "/nix/store/sk5ab989c1q4yb1b6rwh0rsa5d2iiq5b-source",
+ "url": "http://beta.quicklisp.org/archive/trivial-gray-streams/2024-10-12/trivial-gray-streams-20241012-git.tgz",
+ "version": "20241012-git"
+ },
+ {
+ "name": "puri",
+ "sha256": "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd",
+ "source": "/nix/store/9h9dj9dlm06x99n3px6vsqh40c6djan8-source",
+ "url": "http://beta.quicklisp.org/archive/puri/2020-10-16/puri-20201016-git.tgz",
+ "version": "20201016-git"
+ }
+ ],
+ "patchProfile": "19d0b-1",
+ "sourceRegistry": "(:source-registry (:tree \"/nix/store/5075y4alv1is8n78bcsfcaj0mfpqz195-source/\") (:tree \"/nix/store/yw7j44h85ilvrg9jsnwcyz048nbl3cl9-source/\") (:tree \"/nix/store/76bbavhilddfxd2b56inkdzi6ym860cs-source/\") (:tree \"/nix/store/i6nnd3amy08a3f3v8q76nh9kw9434z29-source/\") (:tree \"/nix/store/fldw3972prvmlv87f0qf69myk79kz1g4-source/\") (:tree \"/nix/store/sk5ab989c1q4yb1b6rwh0rsa5d2iiq5b-source/\") (:tree \"/nix/store/9h9dj9dlm06x99n3px6vsqh40c6djan8-source/\") :ignore-inherited-configuration)"
+ },
+ "sourceSHA256": {
+ "flake.nix": "b369bfbafd868829ff146a58898d11221c76f19e6c6a38cac65ed4213ac926c4",
+ "flake.lock": "d5fabc162f32d7f15fb0afcbc7ea674a91e7719f3fd920401f615e8c24a5c5db",
+ "topic-maps.asd": "9ae08ca60394fcd95936a7f54cc5a5e3fafdd09ae5406d697206a92d18249b92",
+ "scripts/prepare-cxml.py": "93f21c4c513cb3f7afdd1dc98675d1bba027b027ebca69d68916aba01bce62c9",
+ "scripts/validate-cxml-19d0b.py": "cb556418bbae5140c8136d3ee76005611936e9a36bf7351c5f1a6ef85999c730",
+ "tests/cxml-probe.lisp": "15f6b43ff11fe69e0ba2ca7232505de9d86abf006bd0f04cece8dea6b1e9e0ff",
+ "tests/cxml-encoding-regressions.lisp": "e9129d0beba928e2bc557417b8807ded648e4db638bec9d25a2001dc1134e342",
+ "src/xml/package.lisp": "fb57cefcf977245115d96e2a69c7cb7c8e121164e91dec441d48f06be7df9a8c",
+ "src/xml/parser.lisp": "fc91d297feb8d79ae137f29ec2a1198986dd377dbff1c56aa826e204388013c5",
+ "patches/cxml-19d0b.patch": "86720fb7960057def9092e8e75332ce45348b9809766667b8e6b1901c7cf5f24",
+ "patches/closure-common-19d0b.patch": "bbe8e956a147f6f122025e3c355bb13cf0d55ad811d1d4003f9ab50976aed74a",
+ "README.md": "08142adbddcda9b532edcbebb2d2ea8b708ab840d5cd8be298f882d1c0039c73",
+ "docs/slice-19d0b-cxml-encoding.md": "ca3342a6226a7eb865107df70d4a8d5ce53f7b4960ff51791a63296bc2fe67f3"
+ },
+ "sourceHashesVerifiedBeforeAndAfter": true,
+ "newDependencyNetworkAcquisitions": 0,
+ "patchReproducibleAcrossTwoCopies": true,
+ "patchProvenance": [
+ {
+ "sources": [
+ {
+ "name": "cxml",
+ "sha256": "18fls3bx7vmnxfa6qara8fxp316d8kb3izar0kysvqg6l0a45a51",
+ "source": "/nix/store/5075y4alv1is8n78bcsfcaj0mfpqz195-source",
+ "url": "http://beta.quicklisp.org/archive/cxml/2020-06-10/cxml-20200610-git.tgz",
+ "version": "20200610-git"
+ },
+ {
+ "name": "closure-common",
+ "sha256": "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n",
+ "source": "/nix/store/yw7j44h85ilvrg9jsnwcyz048nbl3cl9-source",
+ "url": "http://beta.quicklisp.org/archive/closure-common/2018-10-18/closure-common-20181018-git.tgz",
+ "version": "20181018-git"
+ },
+ {
+ "name": "babel",
+ "sha256": "0359bj3yr6frybcmg8qr5vi4q8hzbsb7hmvxdc0jgkfz3c33q667",
+ "source": "/nix/store/76bbavhilddfxd2b56inkdzi6ym860cs-source",
+ "url": "http://beta.quicklisp.org/archive/babel/2024-10-12/babel-20241012-git.tgz",
+ "version": "20241012-git"
+ },
+ {
+ "name": "alexandria",
+ "sha256": "0jq0n59s0r9yl374f0zpdnaflb5g853yqvax7ka8rnypspyykwdw",
+ "source": "/nix/store/i6nnd3amy08a3f3v8q76nh9kw9434z29-source",
+ "url": "http://beta.quicklisp.org/archive/alexandria/2024-10-12/alexandria-20241012-git.tgz",
+ "version": "20241012-git"
+ },
+ {
+ "name": "trivial-features",
+ "sha256": "0r33ycg1wsmglbsychglzkd6fachnnqfzd0w9mhpwi6cz94hx7c3",
+ "source": "/nix/store/fldw3972prvmlv87f0qf69myk79kz1g4-source",
+ "url": "http://beta.quicklisp.org/archive/trivial-features/2023-06-18/trivial-features-20230618-git.tgz",
+ "version": "20230618-git"
+ },
+ {
+ "name": "trivial-gray-streams",
+ "sha256": "0iw6q5hx7x8sc5s7ikvsjccsksbm0rd13d54mkrg62sc56hjywrm",
+ "source": "/nix/store/sk5ab989c1q4yb1b6rwh0rsa5d2iiq5b-source",
+ "url": "http://beta.quicklisp.org/archive/trivial-gray-streams/2024-10-12/trivial-gray-streams-20241012-git.tgz",
+ "version": "20241012-git"
+ },
+ {
+ "name": "puri",
+ "sha256": "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd",
+ "source": "/nix/store/9h9dj9dlm06x99n3px6vsqh40c6djan8-source",
+ "url": "http://beta.quicklisp.org/archive/puri/2020-10-16/puri-20201016-git.tgz",
+ "version": "20201016-git"
+ }
+ ],
+ "patches": [
+ {
+ "package": "cxml",
+ "patch": "patches/cxml-19d0b.patch",
+ "sha256": "86720fb7960057def9092e8e75332ce45348b9809766667b8e6b1901c7cf5f24",
+ "changedFiles": {
+ "xml/xml-parse.lisp": {
+ "before": "ab9adf0468889ad59cce2eef51530504a77a2c460d73ca291f9625e0bad4ea00",
+ "after": "fe8be457127977b41a198d70426c3d194499af123a68cd165e27886993931d30"
+ }
+ },
+ "application": "patching file 'xml/xml-parse.lisp'"
+ },
+ {
+ "package": "closure-common",
+ "patch": "patches/closure-common-19d0b.patch",
+ "sha256": "bbe8e956a147f6f122025e3c355bb13cf0d55ad811d1d4003f9ab50976aed74a",
+ "changedFiles": {
+ "encodings.lisp": {
+ "before": "f7bf3ebbb2e37fdb8f497320a2e8770196f31a51cb74b43a48b82fa6b12cb442",
+ "after": "d9c1cd3f66ae2189988ada0da75568a198a17b082b1609b20a085eeb3b0e73e1"
+ },
+ "xstream.lisp": {
+ "before": "b373d1c4b880a1ee41e779db046f84e3a252d843700ece826151111269ce45e8",
+ "after": "1acdc5eecb03022488c0cf0274a021844035c6ad6aa5a9fd2cc1cd0c5819d338"
+ }
+ },
+ "application": "patching file encodings.lisp\npatching file xstream.lisp"
+ }
+ ],
+ "effectiveSources": [
+ {
+ "name": "cxml",
+ "source": "/private/var/folders/y1/yhhpj5wd7cb5325t8__1ct2r0000gn/T/topic-maps-19d0b-nwm74kgn/sources-1/cxml"
+ },
+ {
+ "name": "closure-common",
+ "source": "/private/var/folders/y1/yhhpj5wd7cb5325t8__1ct2r0000gn/T/topic-maps-19d0b-nwm74kgn/sources-1/closure-common"
+ },
+ {
+ "name": "babel",
+ "source": "/nix/store/76bbavhilddfxd2b56inkdzi6ym860cs-source"
+ },
+ {
+ "name": "alexandria",
+ "source": "/nix/store/i6nnd3amy08a3f3v8q76nh9kw9434z29-source"
+ },
+ {
+ "name": "trivial-features",
+ "source": "/nix/store/fldw3972prvmlv87f0qf69myk79kz1g4-source"
+ },
+ {
+ "name": "trivial-gray-streams",
+ "source": "/nix/store/sk5ab989c1q4yb1b6rwh0rsa5d2iiq5b-source"
+ },
+ {
+ "name": "puri",
+ "source": "/nix/store/9h9dj9dlm06x99n3px6vsqh40c6djan8-source"
+ }
+ ],
+ "sourceRegistry": "(:source-registry (:tree \"/private/var/folders/y1/yhhpj5wd7cb5325t8__1ct2r0000gn/T/topic-maps-19d0b-nwm74kgn/sources-1/cxml/\") (:tree \"/private/var/folders/y1/yhhpj5wd7cb5325t8__1ct2r0000gn/T/topic-maps-19d0b-nwm74kgn/sources-1/closure-common/\") (:tree \"/nix/store/76bbavhilddfxd2b56inkdzi6ym860cs-source/\") (:tree \"/nix/store/i6nnd3amy08a3f3v8q76nh9kw9434z29-source/\") (:tree \"/nix/store/fldw3972prvmlv87f0qf69myk79kz1g4-source/\") (:tree \"/nix/store/sk5ab989c1q4yb1b6rwh0rsa5d2iiq5b-source/\") (:tree \"/nix/store/9h9dj9dlm06x99n3px6vsqh40c6djan8-source/\") :ignore-inherited-configuration)"
+ },
+ {
+ "sources": [
+ {
+ "name": "cxml",
+ "sha256": "18fls3bx7vmnxfa6qara8fxp316d8kb3izar0kysvqg6l0a45a51",
+ "source": "/nix/store/5075y4alv1is8n78bcsfcaj0mfpqz195-source",
+ "url": "http://beta.quicklisp.org/archive/cxml/2020-06-10/cxml-20200610-git.tgz",
+ "version": "20200610-git"
+ },
+ {
+ "name": "closure-common",
+ "sha256": "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n",
+ "source": "/nix/store/yw7j44h85ilvrg9jsnwcyz048nbl3cl9-source",
+ "url": "http://beta.quicklisp.org/archive/closure-common/2018-10-18/closure-common-20181018-git.tgz",
+ "version": "20181018-git"
+ },
+ {
+ "name": "babel",
+ "sha256": "0359bj3yr6frybcmg8qr5vi4q8hzbsb7hmvxdc0jgkfz3c33q667",
+ "source": "/nix/store/76bbavhilddfxd2b56inkdzi6ym860cs-source",
+ "url": "http://beta.quicklisp.org/archive/babel/2024-10-12/babel-20241012-git.tgz",
+ "version": "20241012-git"
+ },
+ {
+ "name": "alexandria",
+ "sha256": "0jq0n59s0r9yl374f0zpdnaflb5g853yqvax7ka8rnypspyykwdw",
+ "source": "/nix/store/i6nnd3amy08a3f3v8q76nh9kw9434z29-source",
+ "url": "http://beta.quicklisp.org/archive/alexandria/2024-10-12/alexandria-20241012-git.tgz",
+ "version": "20241012-git"
+ },
+ {
+ "name": "trivial-features",
+ "sha256": "0r33ycg1wsmglbsychglzkd6fachnnqfzd0w9mhpwi6cz94hx7c3",
+ "source": "/nix/store/fldw3972prvmlv87f0qf69myk79kz1g4-source",
+ "url": "http://beta.quicklisp.org/archive/trivial-features/2023-06-18/trivial-features-20230618-git.tgz",
+ "version": "20230618-git"
+ },
+ {
+ "name": "trivial-gray-streams",
+ "sha256": "0iw6q5hx7x8sc5s7ikvsjccsksbm0rd13d54mkrg62sc56hjywrm",
+ "source": "/nix/store/sk5ab989c1q4yb1b6rwh0rsa5d2iiq5b-source",
+ "url": "http://beta.quicklisp.org/archive/trivial-gray-streams/2024-10-12/trivial-gray-streams-20241012-git.tgz",
+ "version": "20241012-git"
+ },
+ {
+ "name": "puri",
+ "sha256": "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd",
+ "source": "/nix/store/9h9dj9dlm06x99n3px6vsqh40c6djan8-source",
+ "url": "http://beta.quicklisp.org/archive/puri/2020-10-16/puri-20201016-git.tgz",
+ "version": "20201016-git"
+ }
+ ],
+ "patches": [
+ {
+ "package": "cxml",
+ "patch": "patches/cxml-19d0b.patch",
+ "sha256": "86720fb7960057def9092e8e75332ce45348b9809766667b8e6b1901c7cf5f24",
+ "changedFiles": {
+ "xml/xml-parse.lisp": {
+ "before": "ab9adf0468889ad59cce2eef51530504a77a2c460d73ca291f9625e0bad4ea00",
+ "after": "fe8be457127977b41a198d70426c3d194499af123a68cd165e27886993931d30"
+ }
+ },
+ "application": "patching file 'xml/xml-parse.lisp'"
+ },
+ {
+ "package": "closure-common",
+ "patch": "patches/closure-common-19d0b.patch",
+ "sha256": "bbe8e956a147f6f122025e3c355bb13cf0d55ad811d1d4003f9ab50976aed74a",
+ "changedFiles": {
+ "encodings.lisp": {
+ "before": "f7bf3ebbb2e37fdb8f497320a2e8770196f31a51cb74b43a48b82fa6b12cb442",
+ "after": "d9c1cd3f66ae2189988ada0da75568a198a17b082b1609b20a085eeb3b0e73e1"
+ },
+ "xstream.lisp": {
+ "before": "b373d1c4b880a1ee41e779db046f84e3a252d843700ece826151111269ce45e8",
+ "after": "1acdc5eecb03022488c0cf0274a021844035c6ad6aa5a9fd2cc1cd0c5819d338"
+ }
+ },
+ "application": "patching file encodings.lisp\npatching file xstream.lisp"
+ }
+ ],
+ "effectiveSources": [
+ {
+ "name": "cxml",
+ "source": "/private/var/folders/y1/yhhpj5wd7cb5325t8__1ct2r0000gn/T/topic-maps-19d0b-nwm74kgn/sources-2/cxml"
+ },
+ {
+ "name": "closure-common",
+ "source": "/private/var/folders/y1/yhhpj5wd7cb5325t8__1ct2r0000gn/T/topic-maps-19d0b-nwm74kgn/sources-2/closure-common"
+ },
+ {
+ "name": "babel",
+ "source": "/nix/store/76bbavhilddfxd2b56inkdzi6ym860cs-source"
+ },
+ {
+ "name": "alexandria",
+ "source": "/nix/store/i6nnd3amy08a3f3v8q76nh9kw9434z29-source"
+ },
+ {
+ "name": "trivial-features",
+ "source": "/nix/store/fldw3972prvmlv87f0qf69myk79kz1g4-source"
+ },
+ {
+ "name": "trivial-gray-streams",
+ "source": "/nix/store/sk5ab989c1q4yb1b6rwh0rsa5d2iiq5b-source"
+ },
+ {
+ "name": "puri",
+ "source": "/nix/store/9h9dj9dlm06x99n3px6vsqh40c6djan8-source"
+ }
+ ],
+ "sourceRegistry": "(:source-registry (:tree \"/private/var/folders/y1/yhhpj5wd7cb5325t8__1ct2r0000gn/T/topic-maps-19d0b-nwm74kgn/sources-2/cxml/\") (:tree \"/private/var/folders/y1/yhhpj5wd7cb5325t8__1ct2r0000gn/T/topic-maps-19d0b-nwm74kgn/sources-2/closure-common/\") (:tree \"/nix/store/76bbavhilddfxd2b56inkdzi6ym860cs-source/\") (:tree \"/nix/store/i6nnd3amy08a3f3v8q76nh9kw9434z29-source/\") (:tree \"/nix/store/fldw3972prvmlv87f0qf69myk79kz1g4-source/\") (:tree \"/nix/store/sk5ab989c1q4yb1b6rwh0rsa5d2iiq5b-source/\") (:tree \"/nix/store/9h9dj9dlm06x99n3px6vsqh40c6djan8-source/\") :ignore-inherited-configuration)"
+ }
+ ],
+ "temporarySourceContext": "Effective source copies existed only during these recorded processes; reproduce with prepare-cxml.py.",
+ "originalQualification": {
+ "label": "original-58",
+ "command": [
+ "/usr/bin/sandbox-exec",
+ "-p",
+ "(version 1)(allow default)(deny network*)",
+ "/nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl",
+ "--noinform",
+ "--no-sysinit",
+ "--no-userinit",
+ "--script",
+ "/dev/stdin"
+ ],
+ "exitCode": 1,
+ "freshProcess": true,
+ "network": "denied by sandbox-exec",
+ "startedAtUTC": "2026-10-18T16:27:12.352035+00:00",
+ "finishedAtUTC": "2026-10-18T16:27:13.939537+00:00",
+ "passedChecks": [
+ "asdf-cxml-found-and-loaded",
+ "asdf-dependency:closure-common",
+ "asdf-dependency:puri",
+ "asdf-dependency:babel",
+ "asdf-dependency:alexandria",
+ "asdf-dependency:trivial-features",
+ "asdf-dependency:trivial-gray-streams",
+ "namespace-expanded-element",
+ "unprefixed-attribute-has-no-namespace",
+ "prefixed-attribute-namespace",
+ "unicode-astral-character",
+ "default-namespace-and-nested-rebinding",
+ "utf8-no-bom:bmp",
+ "utf8-no-bom:astral",
+ "utf8-bom:bmp",
+ "utf8-bom:astral",
+ "utf16le-bom:bmp",
+ "utf16be-bom:bmp",
+ "utf16-bom-without-declaration:bmp",
+ "predefined-entities-and-character-references",
+ "xml-line-end-normalization",
+ "xml-attribute-whitespace-normalization",
+ "misnested",
+ "duplicate-attribute",
+ "duplicate-expanded-attribute",
+ "undeclared-prefix",
+ "multiple-roots",
+ "unclosed-root",
+ "undefined-entity",
+ "forbidden-nul-reference",
+ "forbidden-surrogate-reference",
+ "doctype-without-subset",
+ "internal-entity",
+ "external-file-dtd",
+ "external-network-dtd",
+ "external-general-entity",
+ "external-parameter-entity",
+ "safe-policy-never-invokes-external-resolver",
+ "resolver-file-dtd",
+ "resolver-file-dtd:called",
+ "resolver-network-dtd",
+ "resolver-network-dtd:called",
+ "resolver-file-entity",
+ "resolver-file-entity:called",
+ "resolver-network-entity",
+ "resolver-network-entity:called",
+ "resolver-parameter-entity",
+ "resolver-parameter-entity:called",
+ "nil-resolver-reaches-cxml-fallback",
+ "exactly-one-fallback-only-in-nil-counterprobe"
+ ],
+ "failedChecks": [
+ "utf16le-bom:astral",
+ "utf16be-bom:astral",
+ "utf16le-explicit-no-bom:bmp",
+ "utf16le-explicit-no-bom:astral",
+ "utf16be-explicit-no-bom:bmp",
+ "utf16be-explicit-no-bom:astral",
+ "utf16-bom-without-declaration:astral",
+ "invalid-utf8"
+ ]
+ },
+ "patchedUnmodifiedOriginalQualification": {
+ "label": "patched-original-58",
+ "command": [
+ "/usr/bin/sandbox-exec",
+ "-p",
+ "(version 1)(allow default)(deny network*)",
+ "/nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl",
+ "--noinform",
+ "--no-sysinit",
+ "--no-userinit",
+ "--script",
+ "/dev/stdin"
+ ],
+ "exitCode": 0,
+ "freshProcess": true,
+ "network": "denied by sandbox-exec",
+ "startedAtUTC": "2026-10-18T16:27:15.732095+00:00",
+ "finishedAtUTC": "2026-10-18T16:27:20.577539+00:00",
+ "passedChecks": [
+ "asdf-cxml-found-and-loaded",
+ "asdf-dependency:closure-common",
+ "asdf-dependency:puri",
+ "asdf-dependency:babel",
+ "asdf-dependency:alexandria",
+ "asdf-dependency:trivial-features",
+ "asdf-dependency:trivial-gray-streams",
+ "namespace-expanded-element",
+ "unprefixed-attribute-has-no-namespace",
+ "prefixed-attribute-namespace",
+ "unicode-astral-character",
+ "default-namespace-and-nested-rebinding",
+ "utf8-no-bom:bmp",
+ "utf8-no-bom:astral",
+ "utf8-bom:bmp",
+ "utf8-bom:astral",
+ "utf16le-bom:bmp",
+ "utf16le-bom:astral",
+ "utf16be-bom:bmp",
+ "utf16be-bom:astral",
+ "utf16le-explicit-no-bom:bmp",
+ "utf16le-explicit-no-bom:astral",
+ "utf16be-explicit-no-bom:bmp",
+ "utf16be-explicit-no-bom:astral",
+ "utf16-bom-without-declaration:bmp",
+ "utf16-bom-without-declaration:astral",
+ "predefined-entities-and-character-references",
+ "xml-line-end-normalization",
+ "xml-attribute-whitespace-normalization",
+ "misnested",
+ "duplicate-attribute",
+ "duplicate-expanded-attribute",
+ "undeclared-prefix",
+ "multiple-roots",
+ "unclosed-root",
+ "undefined-entity",
+ "forbidden-nul-reference",
+ "forbidden-surrogate-reference",
+ "invalid-utf8",
+ "doctype-without-subset",
+ "internal-entity",
+ "external-file-dtd",
+ "external-network-dtd",
+ "external-general-entity",
+ "external-parameter-entity",
+ "safe-policy-never-invokes-external-resolver",
+ "resolver-file-dtd",
+ "resolver-file-dtd:called",
+ "resolver-network-dtd",
+ "resolver-network-dtd:called",
+ "resolver-file-entity",
+ "resolver-file-entity:called",
+ "resolver-network-entity",
+ "resolver-network-entity:called",
+ "resolver-parameter-entity",
+ "resolver-parameter-entity:called",
+ "nil-resolver-reaches-cxml-fallback",
+ "exactly-one-fallback-only-in-nil-counterprobe"
+ ],
+ "failedChecks": []
+ },
+ "originalProbeSHA256": "386d8a6a01a22494b638d27a2f332d96b9f81902b53e3e0e87c04c66ea0a10b4",
+ "unpatchedBoundaryRefusal": {
+ "label": "unqualified-boundary",
+ "command": [
+ "/usr/bin/sandbox-exec",
+ "-p",
+ "(version 1)(allow default)(deny network*)",
+ "/nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl",
+ "--noinform",
+ "--no-sysinit",
+ "--no-userinit",
+ "--script",
+ "/dev/stdin"
+ ],
+ "exitCode": 0,
+ "freshProcess": true,
+ "network": "denied by sandbox-exec",
+ "startedAtUTC": "2026-10-18T16:27:14.851609+00:00",
+ "finishedAtUTC": "2026-10-18T16:27:15.732022+00:00"
+ },
+ "original58ExpectationsChanged": false,
+ "xmlRuns": [
+ {
+ "label": "qualified-1",
+ "command": [
+ "/usr/bin/sandbox-exec",
+ "-p",
+ "(version 1)(allow default)(deny network*)",
+ "/nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl",
+ "--noinform",
+ "--no-sysinit",
+ "--no-userinit",
+ "--script",
+ "/Users/rgb/workspace/topic-maps/tests/cxml-probe.lisp"
+ ],
+ "exitCode": 0,
+ "freshProcess": true,
+ "network": "denied by sandbox-exec",
+ "startedAtUTC": "2026-10-18T16:27:20.577824+00:00",
+ "finishedAtUTC": "2026-10-18T16:27:22.018242+00:00",
+ "passedChecks": [
+ "asdf-cxml-found-and-loaded",
+ "asdf-dependency:closure-common",
+ "asdf-dependency:puri",
+ "asdf-dependency:babel",
+ "asdf-dependency:alexandria",
+ "asdf-dependency:trivial-features",
+ "asdf-dependency:trivial-gray-streams",
+ "namespace-expanded-element",
+ "unprefixed-attribute-has-no-namespace",
+ "prefixed-attribute-namespace",
+ "unicode-astral-character",
+ "default-namespace-and-nested-rebinding",
+ "utf8-no-bom:bmp",
+ "utf8-no-bom:astral",
+ "utf8-bom:bmp",
+ "utf8-bom:astral",
+ "utf16le-bom:bmp",
+ "utf16le-bom:astral",
+ "utf16be-bom:bmp",
+ "utf16be-bom:astral",
+ "utf16le-explicit-no-bom:bmp",
+ "utf16le-explicit-no-bom:astral",
+ "utf16be-explicit-no-bom:bmp",
+ "utf16be-explicit-no-bom:astral",
+ "utf16-bom-without-declaration:bmp",
+ "utf16-bom-without-declaration:astral",
+ "predefined-entities-and-character-references",
+ "xml-line-end-normalization",
+ "xml-attribute-whitespace-normalization",
+ "misnested",
+ "duplicate-attribute",
+ "duplicate-expanded-attribute",
+ "undeclared-prefix",
+ "multiple-roots",
+ "unclosed-root",
+ "undefined-entity",
+ "forbidden-nul-reference",
+ "forbidden-surrogate-reference",
+ "invalid-utf8",
+ "doctype-without-subset",
+ "internal-entity",
+ "external-file-dtd",
+ "external-network-dtd",
+ "external-general-entity",
+ "external-parameter-entity",
+ "safe-policy-never-invokes-external-resolver",
+ "resolver-file-dtd",
+ "resolver-file-dtd:called",
+ "resolver-network-dtd",
+ "resolver-network-dtd:called",
+ "resolver-file-entity",
+ "resolver-file-entity:called",
+ "resolver-network-entity",
+ "resolver-network-entity:called",
+ "resolver-parameter-entity",
+ "resolver-parameter-entity:called",
+ "nil-resolver-reaches-cxml-fallback",
+ "exactly-one-fallback-only-in-nil-counterprobe",
+ "utf8-invalid:stray-continuation",
+ "utf8-invalid:bad-continuation",
+ "utf8-invalid:overlong-two",
+ "utf8-invalid:overlong-three",
+ "utf8-invalid:overlong-four",
+ "utf8-invalid:encoded-surrogate",
+ "utf8-invalid:above-unicode-limit",
+ "utf8-invalid:illegal-leading-f5",
+ "utf8-invalid:obsolete-five-byte-form",
+ "utf8-invalid:obsolete-six-byte-form",
+ "utf8-invalid:illegal-leading-ff",
+ "utf8-truncated:C2",
+ "utf8-truncated:E0A0",
+ "utf8-truncated:F09FA6",
+ "utf16-invalid:le:isolated-low",
+ "utf16-invalid:le:high-then-letter",
+ "utf16-invalid:le:high-then-high",
+ "utf16-truncated:le:odd-octet",
+ "utf16-truncated:le:unfinished-high",
+ "utf16-invalid:be:isolated-low",
+ "utf16-invalid:be:high-then-letter",
+ "utf16-invalid:be:high-then-high",
+ "utf16-truncated:be:odd-octet",
+ "utf16-truncated:be:unfinished-high",
+ "scalar-boundaries:UTF-8",
+ "line-ending-normalization:UTF-8",
+ "refill:UTF-8:8189",
+ "refill:UTF-8:8190",
+ "refill:UTF-8:8191",
+ "refill:UTF-8:8192",
+ "scalar-boundaries:UTF-16LE",
+ "line-ending-normalization:UTF-16LE",
+ "refill:UTF-16LE:8189",
+ "refill:UTF-16LE:8190",
+ "refill:UTF-16LE:8191",
+ "refill:UTF-16LE:8192",
+ "scalar-boundaries:UTF-16BE",
+ "line-ending-normalization:UTF-16BE",
+ "refill:UTF-16BE:8189",
+ "refill:UTF-16BE:8190",
+ "refill:UTF-16BE:8191",
+ "refill:UTF-16BE:8192",
+ "bomless-missing-or-wrong-label:UTF-16LE:UTF-16",
+ "bomless-missing-or-wrong-label:UTF-16LE:NIL",
+ "bomless-missing-or-wrong-label:UTF-16LE:UTF-8",
+ "bomless-without-declaration:UTF-16LE",
+ "bomless-pi-without-xml-declaration:UTF-16LE",
+ "bom-declaration-disagreement:UTF-16LE",
+ "opposite-endian-declaration:UTF-16LE",
+ "explicit-endian-label-with-bom:UTF-16LE",
+ "bomless-missing-or-wrong-label:UTF-16BE:UTF-16",
+ "bomless-missing-or-wrong-label:UTF-16BE:NIL",
+ "bomless-missing-or-wrong-label:UTF-16BE:UTF-8",
+ "bomless-without-declaration:UTF-16BE",
+ "bomless-pi-without-xml-declaration:UTF-16BE",
+ "bom-declaration-disagreement:UTF-16BE",
+ "opposite-endian-declaration:UTF-16BE",
+ "explicit-endian-label-with-bom:UTF-16BE",
+ "utf8-bom-wrong-declaration:UTF-16",
+ "utf8-bom-wrong-declaration:UTF-16LE",
+ "utf8-bom-wrong-declaration:UTF-16BE",
+ "utf8-bom-wrong-declaration:ISO-8859-1",
+ "unknown-encoding-is-fatal",
+ "encoding-name-case-insensitive",
+ "public-api-rejects-string-input",
+ "public-api-no-resolver-override",
+ "public-api-guard-with-nil-handler",
+ "public-resolver-signals",
+ "public-api-refuses-unqualified-dependency",
+ "public-api-returns-identical-sax-result",
+ "decoder-needs-more:UTF-8:1",
+ "decoder-incomplete-at-eof:UTF-8:1",
+ "decoder-needs-more:UTF-8:2",
+ "decoder-incomplete-at-eof:UTF-8:2",
+ "decoder-needs-more:UTF-8:3",
+ "decoder-incomplete-at-eof:UTF-8:3",
+ "decoder-needs-more:UTF-16-LITTLE-ENDIAN:1",
+ "decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:1",
+ "decoder-needs-more:UTF-16-LITTLE-ENDIAN:2",
+ "decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:2",
+ "decoder-needs-more:UTF-16-LITTLE-ENDIAN:3",
+ "decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:3",
+ "decoder-needs-more:UTF-16-BIG-ENDIAN:1",
+ "decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:1",
+ "decoder-needs-more:UTF-16-BIG-ENDIAN:2",
+ "decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:2",
+ "decoder-needs-more:UTF-16-BIG-ENDIAN:3",
+ "decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:3"
+ ],
+ "failedChecks": []
+ },
+ {
+ "label": "qualified-2",
+ "command": [
+ "/usr/bin/sandbox-exec",
+ "-p",
+ "(version 1)(allow default)(deny network*)",
+ "/nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl",
+ "--noinform",
+ "--no-sysinit",
+ "--no-userinit",
+ "--script",
+ "/Users/rgb/workspace/topic-maps/tests/cxml-probe.lisp"
+ ],
+ "exitCode": 0,
+ "freshProcess": true,
+ "network": "denied by sandbox-exec",
+ "startedAtUTC": "2026-10-18T16:27:22.018780+00:00",
+ "finishedAtUTC": "2026-10-18T16:27:27.558585+00:00",
+ "passedChecks": [
+ "asdf-cxml-found-and-loaded",
+ "asdf-dependency:closure-common",
+ "asdf-dependency:puri",
+ "asdf-dependency:babel",
+ "asdf-dependency:alexandria",
+ "asdf-dependency:trivial-features",
+ "asdf-dependency:trivial-gray-streams",
+ "namespace-expanded-element",
+ "unprefixed-attribute-has-no-namespace",
+ "prefixed-attribute-namespace",
+ "unicode-astral-character",
+ "default-namespace-and-nested-rebinding",
+ "utf8-no-bom:bmp",
+ "utf8-no-bom:astral",
+ "utf8-bom:bmp",
+ "utf8-bom:astral",
+ "utf16le-bom:bmp",
+ "utf16le-bom:astral",
+ "utf16be-bom:bmp",
+ "utf16be-bom:astral",
+ "utf16le-explicit-no-bom:bmp",
+ "utf16le-explicit-no-bom:astral",
+ "utf16be-explicit-no-bom:bmp",
+ "utf16be-explicit-no-bom:astral",
+ "utf16-bom-without-declaration:bmp",
+ "utf16-bom-without-declaration:astral",
+ "predefined-entities-and-character-references",
+ "xml-line-end-normalization",
+ "xml-attribute-whitespace-normalization",
+ "misnested",
+ "duplicate-attribute",
+ "duplicate-expanded-attribute",
+ "undeclared-prefix",
+ "multiple-roots",
+ "unclosed-root",
+ "undefined-entity",
+ "forbidden-nul-reference",
+ "forbidden-surrogate-reference",
+ "invalid-utf8",
+ "doctype-without-subset",
+ "internal-entity",
+ "external-file-dtd",
+ "external-network-dtd",
+ "external-general-entity",
+ "external-parameter-entity",
+ "safe-policy-never-invokes-external-resolver",
+ "resolver-file-dtd",
+ "resolver-file-dtd:called",
+ "resolver-network-dtd",
+ "resolver-network-dtd:called",
+ "resolver-file-entity",
+ "resolver-file-entity:called",
+ "resolver-network-entity",
+ "resolver-network-entity:called",
+ "resolver-parameter-entity",
+ "resolver-parameter-entity:called",
+ "nil-resolver-reaches-cxml-fallback",
+ "exactly-one-fallback-only-in-nil-counterprobe",
+ "utf8-invalid:stray-continuation",
+ "utf8-invalid:bad-continuation",
+ "utf8-invalid:overlong-two",
+ "utf8-invalid:overlong-three",
+ "utf8-invalid:overlong-four",
+ "utf8-invalid:encoded-surrogate",
+ "utf8-invalid:above-unicode-limit",
+ "utf8-invalid:illegal-leading-f5",
+ "utf8-invalid:obsolete-five-byte-form",
+ "utf8-invalid:obsolete-six-byte-form",
+ "utf8-invalid:illegal-leading-ff",
+ "utf8-truncated:C2",
+ "utf8-truncated:E0A0",
+ "utf8-truncated:F09FA6",
+ "utf16-invalid:le:isolated-low",
+ "utf16-invalid:le:high-then-letter",
+ "utf16-invalid:le:high-then-high",
+ "utf16-truncated:le:odd-octet",
+ "utf16-truncated:le:unfinished-high",
+ "utf16-invalid:be:isolated-low",
+ "utf16-invalid:be:high-then-letter",
+ "utf16-invalid:be:high-then-high",
+ "utf16-truncated:be:odd-octet",
+ "utf16-truncated:be:unfinished-high",
+ "scalar-boundaries:UTF-8",
+ "line-ending-normalization:UTF-8",
+ "refill:UTF-8:8189",
+ "refill:UTF-8:8190",
+ "refill:UTF-8:8191",
+ "refill:UTF-8:8192",
+ "scalar-boundaries:UTF-16LE",
+ "line-ending-normalization:UTF-16LE",
+ "refill:UTF-16LE:8189",
+ "refill:UTF-16LE:8190",
+ "refill:UTF-16LE:8191",
+ "refill:UTF-16LE:8192",
+ "scalar-boundaries:UTF-16BE",
+ "line-ending-normalization:UTF-16BE",
+ "refill:UTF-16BE:8189",
+ "refill:UTF-16BE:8190",
+ "refill:UTF-16BE:8191",
+ "refill:UTF-16BE:8192",
+ "bomless-missing-or-wrong-label:UTF-16LE:UTF-16",
+ "bomless-missing-or-wrong-label:UTF-16LE:NIL",
+ "bomless-missing-or-wrong-label:UTF-16LE:UTF-8",
+ "bomless-without-declaration:UTF-16LE",
+ "bomless-pi-without-xml-declaration:UTF-16LE",
+ "bom-declaration-disagreement:UTF-16LE",
+ "opposite-endian-declaration:UTF-16LE",
+ "explicit-endian-label-with-bom:UTF-16LE",
+ "bomless-missing-or-wrong-label:UTF-16BE:UTF-16",
+ "bomless-missing-or-wrong-label:UTF-16BE:NIL",
+ "bomless-missing-or-wrong-label:UTF-16BE:UTF-8",
+ "bomless-without-declaration:UTF-16BE",
+ "bomless-pi-without-xml-declaration:UTF-16BE",
+ "bom-declaration-disagreement:UTF-16BE",
+ "opposite-endian-declaration:UTF-16BE",
+ "explicit-endian-label-with-bom:UTF-16BE",
+ "utf8-bom-wrong-declaration:UTF-16",
+ "utf8-bom-wrong-declaration:UTF-16LE",
+ "utf8-bom-wrong-declaration:UTF-16BE",
+ "utf8-bom-wrong-declaration:ISO-8859-1",
+ "unknown-encoding-is-fatal",
+ "encoding-name-case-insensitive",
+ "public-api-rejects-string-input",
+ "public-api-no-resolver-override",
+ "public-api-guard-with-nil-handler",
+ "public-resolver-signals",
+ "public-api-refuses-unqualified-dependency",
+ "public-api-returns-identical-sax-result",
+ "decoder-needs-more:UTF-8:1",
+ "decoder-incomplete-at-eof:UTF-8:1",
+ "decoder-needs-more:UTF-8:2",
+ "decoder-incomplete-at-eof:UTF-8:2",
+ "decoder-needs-more:UTF-8:3",
+ "decoder-incomplete-at-eof:UTF-8:3",
+ "decoder-needs-more:UTF-16-LITTLE-ENDIAN:1",
+ "decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:1",
+ "decoder-needs-more:UTF-16-LITTLE-ENDIAN:2",
+ "decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:2",
+ "decoder-needs-more:UTF-16-LITTLE-ENDIAN:3",
+ "decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:3",
+ "decoder-needs-more:UTF-16-BIG-ENDIAN:1",
+ "decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:1",
+ "decoder-needs-more:UTF-16-BIG-ENDIAN:2",
+ "decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:2",
+ "decoder-needs-more:UTF-16-BIG-ENDIAN:3",
+ "decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:3"
+ ],
+ "failedChecks": []
+ }
+ ],
+ "originalDiagnosticContext": {
+ "label": "original-diagnostics",
+ "command": [
+ "/usr/bin/sandbox-exec",
+ "-p",
+ "(version 1)(allow default)(deny network*)",
+ "/nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl",
+ "--noinform",
+ "--no-sysinit",
+ "--no-userinit",
+ "--script",
+ "/dev/stdin"
+ ],
+ "exitCode": 0,
+ "freshProcess": true,
+ "network": "denied by sandbox-exec",
+ "startedAtUTC": "2026-10-18T16:27:13.940355+00:00",
+ "finishedAtUTC": "2026-10-18T16:27:14.851294+00:00"
+ },
+ "patchedDiagnosticContext": {
+ "label": "patched-diagnostics",
+ "command": [
+ "/usr/bin/sandbox-exec",
+ "-p",
+ "(version 1)(allow default)(deny network*)",
+ "/nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl",
+ "--noinform",
+ "--no-sysinit",
+ "--no-userinit",
+ "--script",
+ "/dev/stdin"
+ ],
+ "exitCode": 0,
+ "freshProcess": true,
+ "network": "denied by sandbox-exec",
+ "startedAtUTC": "2026-10-18T16:27:27.559246+00:00",
+ "finishedAtUTC": "2026-10-18T16:27:28.797341+00:00"
+ },
+ "xmlQualification": "PASS",
+ "xmlChecksPerRun": 146,
+ "xmlFailedChecks": 0,
+ "bindingPublicContract": "topic-maps.xml:parse-octets; verified patched dependencies; raw octets; mandatory namespace processing and DOCTYPE/entity denial; no caller overrides.",
+ "regressionChecks": {
+ "FOUNDATION": 54,
+ "CTM-IDENTITY-SEMANTICS": 123,
+ "CTM-MERGING-SEMANTICS": 646,
+ "CTM-ASSOCIATIONS-SEMANTICS": 657,
+ "CXTM": 445,
+ "OCCURRENCES": 1101,
+ "PREFIX-DATATYPES": 150,
+ "INTEGERS": 665,
+ "DECIMALS": 715,
+ "DATES": 1806,
+ "DATETIMES": 217,
+ "TIMEZONES": 1944,
+ "TYPED-NAMES": 106,
+ "SCOPES": 293,
+ "VARIANTS": 324,
+ "REFERENCES": 238,
+ "ITEM-IDENTIFIERS": 244,
+ "REIFICATION": 236,
+ "ASSOCIATION-ARITY": 337,
+ "TYPE-RELATIONSHIPS": 1016,
+ "TEMPLATES": 297,
+ "MAP-IMPORT": 275,
+ "MERGEMAP": 118,
+ "INCLUDE": 93
+ },
+ "totalLispChecks": 12100,
+ "importedStatuses": {
+ "pass": 204,
+ "fail": 4,
+ "unsupported": 0,
+ "not-run": 65
+ },
+ "byteIdenticalRetainedReports": [
+ "arity.json",
+ "associations.json",
+ "cxtm.json",
+ "dates.json",
+ "datetimes.json",
+ "decimals.json",
+ "identifiers.json",
+ "include.json",
+ "integers.json",
+ "map-import.json",
+ "mergemap.json",
+ "merging.json",
+ "occurrences.json",
+ "prefixes.json",
+ "references.json",
+ "reification.json",
+ "relationships.json",
+ "scopes.json",
+ "semantics.json",
+ "templates.json",
+ "timezones.json",
+ "typed-names.json",
+ "validation.json",
+ "variants.json"
+ ],
+ "newXTMContracts": 0,
+ "pinnedCorpusAndOriginalArchivesUnchanged": true,
+ "fullOfflineNixRebuild": "NOT-RUN; existing Nix artifacts plus offline source patching/ASDF compilation."
+}
--- /dev/null
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Building Closure with CHARACTER RUNES
+CXML-CHECK-PASS asdf-cxml-found-and-loaded
+CXML-CHECK-PASS asdf-dependency:closure-common
+CXML-CHECK-PASS asdf-dependency:puri
+CXML-CHECK-PASS asdf-dependency:babel
+CXML-CHECK-PASS asdf-dependency:alexandria
+CXML-CHECK-PASS asdf-dependency:trivial-features
+CXML-CHECK-PASS asdf-dependency:trivial-gray-streams
+CXML-CHECK-PASS namespace-expanded-element
+CXML-CHECK-PASS unprefixed-attribute-has-no-namespace
+CXML-CHECK-PASS prefixed-attribute-namespace
+CXML-CHECK-PASS unicode-astral-character
+CXML-CHECK-PASS default-namespace-and-nested-rebinding
+CXML-CHECK-PASS utf8-no-bom:bmp
+CXML-CHECK-PASS utf8-no-bom:astral
+CXML-CHECK-PASS utf8-bom:bmp
+CXML-CHECK-PASS utf8-bom:astral
+WARNING: There is no such encoding: "UTF-16".
+CXML-CHECK-PASS utf16le-bom:bmp
+WARNING: There is no such encoding: "UTF-16".
+CXML-CHECK-FAIL utf16le-bom:astral
+CXML-UNEXPECTED-REJECTION utf16le-bom:astral WELL-FORMEDNESS-VIOLATION: Document not well-formed: expected a high surrogate but found: #xD83E
+Location:
+ Line 1, column 41 in NIL
+
+WARNING: There is no such encoding: "UTF-16".
+CXML-CHECK-PASS utf16be-bom:bmp
+WARNING: There is no such encoding: "UTF-16".
+CXML-CHECK-FAIL utf16be-bom:astral
+CXML-UNEXPECTED-REJECTION utf16be-bom:astral WELL-FORMEDNESS-VIOLATION: Document not well-formed: expected a high surrogate but found: #xD83E
+Location:
+ Line 1, column 41 in NIL
+
+CXML-CHECK-FAIL utf16le-explicit-no-bom:bmp
+CXML-UNEXPECTED-REJECTION utf16le-explicit-no-bom:bmp WELL-FORMEDNESS-VIOLATION: Document not well-formed: Expected '!' or '?' after '<' in DTD.
+Context:
+ Line 1, column 2 in NIL
+
+CXML-CHECK-FAIL utf16le-explicit-no-bom:astral
+CXML-UNEXPECTED-REJECTION utf16le-explicit-no-bom:astral WELL-FORMEDNESS-VIOLATION: Document not well-formed: Expected '!' or '?' after '<' in DTD.
+Context:
+ Line 1, column 2 in NIL
+
+CXML-CHECK-FAIL utf16be-explicit-no-bom:bmp
+CXML-UNEXPECTED-REJECTION utf16be-explicit-no-bom:bmp WELL-FORMEDNESS-VIOLATION: Document not well-formed: Unexpected character #\Nul.
+Context:
+ Line 1, column 2 in NIL
+
+CXML-CHECK-FAIL utf16be-explicit-no-bom:astral
+CXML-UNEXPECTED-REJECTION utf16be-explicit-no-bom:astral WELL-FORMEDNESS-VIOLATION: Document not well-formed: Unexpected character #\Nul.
+Context:
+ Line 1, column 2 in NIL
+
+CXML-CHECK-PASS utf16-bom-without-declaration:bmp
+CXML-CHECK-FAIL utf16-bom-without-declaration:astral
+CXML-UNEXPECTED-REJECTION utf16-bom-without-declaration:astral WELL-FORMEDNESS-VIOLATION: Document not well-formed: expected a high surrogate but found: #xD83E
+Location:
+ Line 1, column 4 in NIL
+
+CXML-CHECK-PASS predefined-entities-and-character-references
+CXML-CHECK-PASS xml-line-end-normalization
+CXML-CHECK-PASS xml-attribute-whitespace-normalization
+CXML-CHECK-PASS misnested
+CXML-REJECTION misnested WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS duplicate-attribute
+CXML-REJECTION duplicate-attribute WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS duplicate-expanded-attribute
+CXML-REJECTION duplicate-expanded-attribute WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS undeclared-prefix
+CXML-REJECTION undeclared-prefix WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS multiple-roots
+CXML-REJECTION multiple-roots WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS unclosed-root
+CXML-REJECTION unclosed-root WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS undefined-entity
+CXML-REJECTION undefined-entity WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS forbidden-nul-reference
+CXML-REJECTION forbidden-nul-reference WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS forbidden-surrogate-reference
+CXML-REJECTION forbidden-surrogate-reference WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-FAIL invalid-utf8
+CXML-REJECTION invalid-utf8 NULL
+CXML-OBSERVATION invalid-utf8 decoded: U+00E8
+CXML-CHECK-PASS doctype-without-subset
+CXML-REJECTION doctype-without-subset DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS internal-entity
+CXML-REJECTION internal-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-file-dtd
+CXML-REJECTION external-file-dtd DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-network-dtd
+CXML-REJECTION external-network-dtd DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-general-entity
+CXML-REJECTION external-general-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-parameter-entity
+CXML-REJECTION external-parameter-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS safe-policy-never-invokes-external-resolver
+CXML-CHECK-PASS resolver-file-dtd
+CXML-REJECTION resolver-file-dtd EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-file-dtd:called
+CXML-CHECK-PASS resolver-network-dtd
+CXML-REJECTION resolver-network-dtd EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-network-dtd:called
+CXML-CHECK-PASS resolver-file-entity
+CXML-REJECTION resolver-file-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-file-entity:called
+CXML-CHECK-PASS resolver-network-entity
+CXML-REJECTION resolver-network-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-network-entity:called
+CXML-CHECK-PASS resolver-parameter-entity
+CXML-REJECTION resolver-parameter-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-parameter-entity:called
+CXML-CHECK-PASS nil-resolver-reaches-cxml-fallback
+CXML-REJECTION nil-resolver-reaches-cxml-fallback FALLBACK-REACHED
+CXML-CHECK-PASS exactly-one-fallback-only-in-nil-counterprobe
+CXML-SUMMARY 50 PASS 8 FAIL
--- /dev/null
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Building Closure with CHARACTER RUNES
+DIAG-ENCODING utf16le-bom:astral UTF-16-LITTLE-ENDIAN
+WARNING: There is no such encoding: "UTF-16".
+DIAG-REJECTED utf16le-bom:astral WELL-FORMEDNESS-VIOLATION Document not well-formed: expected a high surrogate but found: #xD83E Location: Line 1, column 41 in NIL
+DIAG-ENCODING utf16be-bom:astral UTF-16-BIG-ENDIAN
+WARNING: There is no such encoding: "UTF-16".
+DIAG-REJECTED utf16be-bom:astral WELL-FORMEDNESS-VIOLATION Document not well-formed: expected a high surrogate but found: #xD83E Location: Line 1, column 41 in NIL
+DIAG-ENCODING utf16le-explicit-no-bom:bmp UTF-8
+DIAG-REJECTED utf16le-explicit-no-bom:bmp WELL-FORMEDNESS-VIOLATION Document not well-formed: Expected '!' or '?' after '<' in DTD. Context: Line 1, column 2 in NIL
+DIAG-ENCODING utf16le-explicit-no-bom:astral UTF-8
+DIAG-REJECTED utf16le-explicit-no-bom:astral WELL-FORMEDNESS-VIOLATION Document not well-formed: Expected '!' or '?' after '<' in DTD. Context: Line 1, column 2 in NIL
+DIAG-ENCODING utf16be-explicit-no-bom:bmp UTF-8
+DIAG-REJECTED utf16be-explicit-no-bom:bmp WELL-FORMEDNESS-VIOLATION Document not well-formed: Unexpected character #\Nul. Context: Line 1, column 2 in NIL
+DIAG-ENCODING utf16be-explicit-no-bom:astral UTF-8
+DIAG-REJECTED utf16be-explicit-no-bom:astral WELL-FORMEDNESS-VIOLATION Document not well-formed: Unexpected character #\Nul. Context: Line 1, column 2 in NIL
+DIAG-ENCODING utf16-bom-without-declaration:astral UTF-16-LITTLE-ENDIAN
+DIAG-REJECTED utf16-bom-without-declaration:astral WELL-FORMEDNESS-VIOLATION Document not well-formed: expected a high surrogate but found: #xD83E Location: Line 1, column 4 in NIL
+DIAG-ENCODING invalid-utf8 UTF-8
+DIAG-ACCEPTED invalid-utf8 E8
--- /dev/null
+[
+ {
+ "name": "utf16le-bom:astral",
+ "source": "<?xml version='1.0' encoding='UTF-16'?><r>Grüße 水 🦊</r>",
+ "expectedText": "Grüße 水 🦊",
+ "declaredEncoding": "UTF-16",
+ "cause": "closure-common: UTF-16 second-unit check uses x instead of y",
+ "functions": [
+ "closure-common/encodings.lisp:decode-sequence"
+ ],
+ "normative": [
+ "XML 1.0 §2.2, §4.3.3",
+ "Unicode §3.9.2, §3.10",
+ "RFC 2781 §2.2, §3.3"
+ ],
+ "inputOctetsHex": "fffe3c003f0078006d006c002000760065007200730069006f006e003d00270031002e0030002700200065006e0063006f00640069006e0067003d0027005500540046002d003100360027003f003e003c0072003e0047007200fc00df0065002000346c20003ed88add3c002f0072003e00",
+ "inputLength": 114,
+ "inputSHA256": "a350d85bc08b9cca6f0a349ab707d38f88f557331c78f2433f7961dfbe3bef94",
+ "before": {
+ "recognizedEncoding": "UTF-16-LITTLE-ENDIAN",
+ "outcome": "rejected",
+ "condition": "WELL-FORMEDNESS-VIOLATION",
+ "diagnostic": "Document not well-formed: expected a high surrogate but found: #xD83E Location: Line 1, column 41 in NIL "
+ },
+ "after": {
+ "recognizedEncoding": "UTF-16-LITTLE-ENDIAN",
+ "outcome": "accepted",
+ "text": "Grüße 水 🦊"
+ }
+ },
+ {
+ "name": "utf16be-bom:astral",
+ "source": "<?xml version='1.0' encoding='UTF-16'?><r>Grüße 水 🦊</r>",
+ "expectedText": "Grüße 水 🦊",
+ "declaredEncoding": "UTF-16",
+ "cause": "closure-common: UTF-16 second-unit check uses x instead of y",
+ "functions": [
+ "closure-common/encodings.lisp:decode-sequence"
+ ],
+ "normative": [
+ "XML 1.0 §2.2, §4.3.3",
+ "Unicode §3.9.2, §3.10",
+ "RFC 2781 §2.2, §3.3"
+ ],
+ "inputOctetsHex": "feff003c003f0078006d006c002000760065007200730069006f006e003d00270031002e0030002700200065006e0063006f00640069006e0067003d0027005500540046002d003100360027003f003e003c0072003e0047007200fc00df006500206c340020d83edd8a003c002f0072003e",
+ "inputLength": 114,
+ "inputSHA256": "1d5b7d6b86355566c4f71bc31e983807a5184407d3d71796aa04314e1b87b0fe",
+ "before": {
+ "recognizedEncoding": "UTF-16-BIG-ENDIAN",
+ "outcome": "rejected",
+ "condition": "WELL-FORMEDNESS-VIOLATION",
+ "diagnostic": "Document not well-formed: expected a high surrogate but found: #xD83E Location: Line 1, column 41 in NIL "
+ },
+ "after": {
+ "recognizedEncoding": "UTF-16-BIG-ENDIAN",
+ "outcome": "accepted",
+ "text": "Grüße 水 🦊"
+ }
+ },
+ {
+ "name": "utf16le-explicit-no-bom:bmp",
+ "source": "<?xml version='1.0' encoding='UTF-16LE'?><r>Grüße 水</r>",
+ "expectedText": "Grüße 水",
+ "declaredEncoding": "UTF-16LE",
+ "cause": "closure-common: missing provisional XML signature; CXML: missing LE/BE declaration handling",
+ "functions": [
+ "closure-common/xstream.lisp:figure-encoding",
+ "cxml/xml/xml-parse.lisp:setup-encoding"
+ ],
+ "normative": [
+ "XML 1.0 §2.2, §4.3.3",
+ "Unicode §3.9.2, §3.10",
+ "RFC 2781 §2.2, §3.3"
+ ],
+ "inputOctetsHex": "3c003f0078006d006c002000760065007200730069006f006e003d00270031002e0030002700200065006e0063006f00640069006e0067003d0027005500540046002d00310036004c00450027003f003e003c0072003e0047007200fc00df0065002000346c3c002f0072003e00",
+ "inputLength": 110,
+ "inputSHA256": "36056a16aba724b321b4070007c6280aace1728a8c8c824de484a6a781dbb161",
+ "before": {
+ "recognizedEncoding": "UTF-8",
+ "outcome": "rejected",
+ "condition": "WELL-FORMEDNESS-VIOLATION",
+ "diagnostic": "Document not well-formed: Expected '!' or '?' after '<' in DTD. Context: Line 1, column 2 in NIL "
+ },
+ "after": {
+ "recognizedEncoding": "UTF-16-LITTLE-ENDIAN",
+ "outcome": "accepted",
+ "text": "Grüße 水"
+ }
+ },
+ {
+ "name": "utf16le-explicit-no-bom:astral",
+ "source": "<?xml version='1.0' encoding='UTF-16LE'?><r>Grüße 水 🦊</r>",
+ "expectedText": "Grüße 水 🦊",
+ "declaredEncoding": "UTF-16LE",
+ "cause": "closure-common: missing provisional XML signature; CXML: missing LE/BE declaration handling",
+ "functions": [
+ "closure-common/xstream.lisp:figure-encoding",
+ "cxml/xml/xml-parse.lisp:setup-encoding"
+ ],
+ "normative": [
+ "XML 1.0 §2.2, §4.3.3",
+ "Unicode §3.9.2, §3.10",
+ "RFC 2781 §2.2, §3.3"
+ ],
+ "inputOctetsHex": "3c003f0078006d006c002000760065007200730069006f006e003d00270031002e0030002700200065006e0063006f00640069006e0067003d0027005500540046002d00310036004c00450027003f003e003c0072003e0047007200fc00df0065002000346c20003ed88add3c002f0072003e00",
+ "inputLength": 116,
+ "inputSHA256": "70fbdbf015bfbafd25ed6e6b9c2d54bc17107cff0c3a2c21b28c635d8ee07ec5",
+ "before": {
+ "recognizedEncoding": "UTF-8",
+ "outcome": "rejected",
+ "condition": "WELL-FORMEDNESS-VIOLATION",
+ "diagnostic": "Document not well-formed: Expected '!' or '?' after '<' in DTD. Context: Line 1, column 2 in NIL "
+ },
+ "after": {
+ "recognizedEncoding": "UTF-16-LITTLE-ENDIAN",
+ "outcome": "accepted",
+ "text": "Grüße 水 🦊"
+ }
+ },
+ {
+ "name": "utf16be-explicit-no-bom:bmp",
+ "source": "<?xml version='1.0' encoding='UTF-16BE'?><r>Grüße 水</r>",
+ "expectedText": "Grüße 水",
+ "declaredEncoding": "UTF-16BE",
+ "cause": "closure-common: missing provisional XML signature; CXML: missing LE/BE declaration handling",
+ "functions": [
+ "closure-common/xstream.lisp:figure-encoding",
+ "cxml/xml/xml-parse.lisp:setup-encoding"
+ ],
+ "normative": [
+ "XML 1.0 §2.2, §4.3.3",
+ "Unicode §3.9.2, §3.10",
+ "RFC 2781 §2.2, §3.3"
+ ],
+ "inputOctetsHex": "003c003f0078006d006c002000760065007200730069006f006e003d00270031002e0030002700200065006e0063006f00640069006e0067003d0027005500540046002d00310036004200450027003f003e003c0072003e0047007200fc00df006500206c34003c002f0072003e",
+ "inputLength": 110,
+ "inputSHA256": "db4a7ca119811da696d756a2c2f72c6aa936abd9b6faf4ec42c003da9fb040ed",
+ "before": {
+ "recognizedEncoding": "UTF-8",
+ "outcome": "rejected",
+ "condition": "WELL-FORMEDNESS-VIOLATION",
+ "diagnostic": "Document not well-formed: Unexpected character #\\Nul. Context: Line 1, column 2 in NIL "
+ },
+ "after": {
+ "recognizedEncoding": "UTF-16-BIG-ENDIAN",
+ "outcome": "accepted",
+ "text": "Grüße 水"
+ }
+ },
+ {
+ "name": "utf16be-explicit-no-bom:astral",
+ "source": "<?xml version='1.0' encoding='UTF-16BE'?><r>Grüße 水 🦊</r>",
+ "expectedText": "Grüße 水 🦊",
+ "declaredEncoding": "UTF-16BE",
+ "cause": "closure-common: missing provisional XML signature; CXML: missing LE/BE declaration handling",
+ "functions": [
+ "closure-common/xstream.lisp:figure-encoding",
+ "cxml/xml/xml-parse.lisp:setup-encoding"
+ ],
+ "normative": [
+ "XML 1.0 §2.2, §4.3.3",
+ "Unicode §3.9.2, §3.10",
+ "RFC 2781 §2.2, §3.3"
+ ],
+ "inputOctetsHex": "003c003f0078006d006c002000760065007200730069006f006e003d00270031002e0030002700200065006e0063006f00640069006e0067003d0027005500540046002d00310036004200450027003f003e003c0072003e0047007200fc00df006500206c340020d83edd8a003c002f0072003e",
+ "inputLength": 116,
+ "inputSHA256": "489f8d26fcbe7a29b1670261ac916e8ba0b5cf2aded6e6cbf6b6ac6f66cbd05e",
+ "before": {
+ "recognizedEncoding": "UTF-8",
+ "outcome": "rejected",
+ "condition": "WELL-FORMEDNESS-VIOLATION",
+ "diagnostic": "Document not well-formed: Unexpected character #\\Nul. Context: Line 1, column 2 in NIL "
+ },
+ "after": {
+ "recognizedEncoding": "UTF-16-BIG-ENDIAN",
+ "outcome": "accepted",
+ "text": "Grüße 水 🦊"
+ }
+ },
+ {
+ "name": "utf16-bom-without-declaration:astral",
+ "source": "<r>水🦊</r>",
+ "expectedText": "水🦊",
+ "declaredEncoding": null,
+ "cause": "closure-common: UTF-16 second-unit check uses x instead of y",
+ "functions": [
+ "closure-common/encodings.lisp:decode-sequence"
+ ],
+ "normative": [
+ "XML 1.0 §2.2, §4.3.3",
+ "Unicode §3.9.2",
+ "RFC 2781 §2.2"
+ ],
+ "inputOctetsHex": "fffe3c0072003e00346c3ed88add3c002f0072003e00",
+ "inputLength": 22,
+ "inputSHA256": "3fdbd13f1c161760ff917eb6e1526e07e688c7e07e6be26cee72f869b160bb17",
+ "before": {
+ "recognizedEncoding": "UTF-16-LITTLE-ENDIAN",
+ "outcome": "rejected",
+ "condition": "WELL-FORMEDNESS-VIOLATION",
+ "diagnostic": "Document not well-formed: expected a high surrogate but found: #xD83E Location: Line 1, column 4 in NIL "
+ },
+ "after": {
+ "recognizedEncoding": "UTF-16-LITTLE-ENDIAN",
+ "outcome": "accepted",
+ "text": "水🦊"
+ }
+ },
+ {
+ "name": "invalid-utf8",
+ "source": null,
+ "expectedText": null,
+ "declaredEncoding": null,
+ "cause": "closure-common: UTF-8 continuation bytes masked without validation",
+ "functions": [
+ "closure-common/encodings.lisp:decode-sequence"
+ ],
+ "normative": [
+ "XML 1.0 §4.3.3",
+ "Unicode §3.9.3 / Table 3-7",
+ "RFC 3629 §3–4"
+ ],
+ "inputOctetsHex": "3c723ec3283c2f723e",
+ "inputLength": 9,
+ "inputSHA256": "941fc6ac5b589b0c192d98092723ca0e4e9f9813dd9be69a7ad42db09b6ec141",
+ "before": {
+ "recognizedEncoding": "UTF-8",
+ "outcome": "accepted",
+ "text": "è"
+ },
+ "after": {
+ "recognizedEncoding": "UTF-8",
+ "outcome": "rejected",
+ "condition": "WELL-FORMEDNESS-VIOLATION",
+ "diagnostic": "Document not well-formed: Invalid UTF-8 continuation byte: #x28 Location: Line 1, column 7 in NIL "
+ }
+ }
+]
--- /dev/null
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Building Closure with CHARACTER RUNES
+DIAG-ENCODING utf16le-bom:astral UTF-16-LITTLE-ENDIAN
+DIAG-ACCEPTED utf16le-bom:astral 47,72,FC,DF,65,20,6C34,20,1F98A
+DIAG-ENCODING utf16be-bom:astral UTF-16-BIG-ENDIAN
+DIAG-ACCEPTED utf16be-bom:astral 47,72,FC,DF,65,20,6C34,20,1F98A
+DIAG-ENCODING utf16le-explicit-no-bom:bmp UTF-16-LITTLE-ENDIAN
+DIAG-ACCEPTED utf16le-explicit-no-bom:bmp 47,72,FC,DF,65,20,6C34
+DIAG-ENCODING utf16le-explicit-no-bom:astral UTF-16-LITTLE-ENDIAN
+DIAG-ACCEPTED utf16le-explicit-no-bom:astral 47,72,FC,DF,65,20,6C34,20,1F98A
+DIAG-ENCODING utf16be-explicit-no-bom:bmp UTF-16-BIG-ENDIAN
+DIAG-ACCEPTED utf16be-explicit-no-bom:bmp 47,72,FC,DF,65,20,6C34
+DIAG-ENCODING utf16be-explicit-no-bom:astral UTF-16-BIG-ENDIAN
+DIAG-ACCEPTED utf16be-explicit-no-bom:astral 47,72,FC,DF,65,20,6C34,20,1F98A
+DIAG-ENCODING utf16-bom-without-declaration:astral UTF-16-LITTLE-ENDIAN
+DIAG-ACCEPTED utf16-bom-without-declaration:astral 6C34,1F98A
+DIAG-ENCODING invalid-utf8 UTF-8
+DIAG-REJECTED invalid-utf8 WELL-FORMEDNESS-VIOLATION Document not well-formed: Invalid UTF-8 continuation byte: #x28 Location: Line 1, column 7 in NIL
--- /dev/null
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Building Closure with CHARACTER RUNES
+CXML-CHECK-PASS asdf-cxml-found-and-loaded
+CXML-CHECK-PASS asdf-dependency:closure-common
+CXML-CHECK-PASS asdf-dependency:puri
+CXML-CHECK-PASS asdf-dependency:babel
+CXML-CHECK-PASS asdf-dependency:alexandria
+CXML-CHECK-PASS asdf-dependency:trivial-features
+CXML-CHECK-PASS asdf-dependency:trivial-gray-streams
+CXML-CHECK-PASS namespace-expanded-element
+CXML-CHECK-PASS unprefixed-attribute-has-no-namespace
+CXML-CHECK-PASS prefixed-attribute-namespace
+CXML-CHECK-PASS unicode-astral-character
+CXML-CHECK-PASS default-namespace-and-nested-rebinding
+CXML-CHECK-PASS utf8-no-bom:bmp
+CXML-CHECK-PASS utf8-no-bom:astral
+CXML-CHECK-PASS utf8-bom:bmp
+CXML-CHECK-PASS utf8-bom:astral
+CXML-CHECK-PASS utf16le-bom:bmp
+CXML-CHECK-PASS utf16le-bom:astral
+CXML-CHECK-PASS utf16be-bom:bmp
+CXML-CHECK-PASS utf16be-bom:astral
+CXML-CHECK-PASS utf16le-explicit-no-bom:bmp
+CXML-CHECK-PASS utf16le-explicit-no-bom:astral
+CXML-CHECK-PASS utf16be-explicit-no-bom:bmp
+CXML-CHECK-PASS utf16be-explicit-no-bom:astral
+CXML-CHECK-PASS utf16-bom-without-declaration:bmp
+CXML-CHECK-PASS utf16-bom-without-declaration:astral
+CXML-CHECK-PASS predefined-entities-and-character-references
+CXML-CHECK-PASS xml-line-end-normalization
+CXML-CHECK-PASS xml-attribute-whitespace-normalization
+CXML-CHECK-PASS misnested
+CXML-REJECTION misnested WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS duplicate-attribute
+CXML-REJECTION duplicate-attribute WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS duplicate-expanded-attribute
+CXML-REJECTION duplicate-expanded-attribute WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS undeclared-prefix
+CXML-REJECTION undeclared-prefix WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS multiple-roots
+CXML-REJECTION multiple-roots WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS unclosed-root
+CXML-REJECTION unclosed-root WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS undefined-entity
+CXML-REJECTION undefined-entity WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS forbidden-nul-reference
+CXML-REJECTION forbidden-nul-reference WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS forbidden-surrogate-reference
+CXML-REJECTION forbidden-surrogate-reference WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS invalid-utf8
+CXML-REJECTION invalid-utf8 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS doctype-without-subset
+CXML-REJECTION doctype-without-subset DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS internal-entity
+CXML-REJECTION internal-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-file-dtd
+CXML-REJECTION external-file-dtd DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-network-dtd
+CXML-REJECTION external-network-dtd DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-general-entity
+CXML-REJECTION external-general-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-parameter-entity
+CXML-REJECTION external-parameter-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS safe-policy-never-invokes-external-resolver
+CXML-CHECK-PASS resolver-file-dtd
+CXML-REJECTION resolver-file-dtd EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-file-dtd:called
+CXML-CHECK-PASS resolver-network-dtd
+CXML-REJECTION resolver-network-dtd EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-network-dtd:called
+CXML-CHECK-PASS resolver-file-entity
+CXML-REJECTION resolver-file-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-file-entity:called
+CXML-CHECK-PASS resolver-network-entity
+CXML-REJECTION resolver-network-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-network-entity:called
+CXML-CHECK-PASS resolver-parameter-entity
+CXML-REJECTION resolver-parameter-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-parameter-entity:called
+CXML-CHECK-PASS nil-resolver-reaches-cxml-fallback
+CXML-REJECTION nil-resolver-reaches-cxml-fallback FALLBACK-REACHED
+CXML-CHECK-PASS exactly-one-fallback-only-in-nil-counterprobe
+CXML-SUMMARY 58 PASS 0 FAIL
--- /dev/null
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Building Closure with CHARACTER RUNES
+CXML-CHECK-PASS asdf-cxml-found-and-loaded
+CXML-CHECK-PASS asdf-dependency:closure-common
+CXML-CHECK-PASS asdf-dependency:puri
+CXML-CHECK-PASS asdf-dependency:babel
+CXML-CHECK-PASS asdf-dependency:alexandria
+CXML-CHECK-PASS asdf-dependency:trivial-features
+CXML-CHECK-PASS asdf-dependency:trivial-gray-streams
+CXML-CHECK-PASS namespace-expanded-element
+CXML-CHECK-PASS unprefixed-attribute-has-no-namespace
+CXML-CHECK-PASS prefixed-attribute-namespace
+CXML-CHECK-PASS unicode-astral-character
+CXML-CHECK-PASS default-namespace-and-nested-rebinding
+CXML-CHECK-PASS utf8-no-bom:bmp
+CXML-CHECK-PASS utf8-no-bom:astral
+CXML-CHECK-PASS utf8-bom:bmp
+CXML-CHECK-PASS utf8-bom:astral
+CXML-CHECK-PASS utf16le-bom:bmp
+CXML-CHECK-PASS utf16le-bom:astral
+CXML-CHECK-PASS utf16be-bom:bmp
+CXML-CHECK-PASS utf16be-bom:astral
+CXML-CHECK-PASS utf16le-explicit-no-bom:bmp
+CXML-CHECK-PASS utf16le-explicit-no-bom:astral
+CXML-CHECK-PASS utf16be-explicit-no-bom:bmp
+CXML-CHECK-PASS utf16be-explicit-no-bom:astral
+CXML-CHECK-PASS utf16-bom-without-declaration:bmp
+CXML-CHECK-PASS utf16-bom-without-declaration:astral
+CXML-CHECK-PASS predefined-entities-and-character-references
+CXML-CHECK-PASS xml-line-end-normalization
+CXML-CHECK-PASS xml-attribute-whitespace-normalization
+CXML-CHECK-PASS misnested
+CXML-REJECTION misnested WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS duplicate-attribute
+CXML-REJECTION duplicate-attribute WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS duplicate-expanded-attribute
+CXML-REJECTION duplicate-expanded-attribute WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS undeclared-prefix
+CXML-REJECTION undeclared-prefix WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS multiple-roots
+CXML-REJECTION multiple-roots WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS unclosed-root
+CXML-REJECTION unclosed-root WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS undefined-entity
+CXML-REJECTION undefined-entity WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS forbidden-nul-reference
+CXML-REJECTION forbidden-nul-reference WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS forbidden-surrogate-reference
+CXML-REJECTION forbidden-surrogate-reference WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS invalid-utf8
+CXML-REJECTION invalid-utf8 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS doctype-without-subset
+CXML-REJECTION doctype-without-subset DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS internal-entity
+CXML-REJECTION internal-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-file-dtd
+CXML-REJECTION external-file-dtd DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-network-dtd
+CXML-REJECTION external-network-dtd DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-general-entity
+CXML-REJECTION external-general-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-parameter-entity
+CXML-REJECTION external-parameter-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS safe-policy-never-invokes-external-resolver
+CXML-CHECK-PASS resolver-file-dtd
+CXML-REJECTION resolver-file-dtd EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-file-dtd:called
+CXML-CHECK-PASS resolver-network-dtd
+CXML-REJECTION resolver-network-dtd EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-network-dtd:called
+CXML-CHECK-PASS resolver-file-entity
+CXML-REJECTION resolver-file-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-file-entity:called
+CXML-CHECK-PASS resolver-network-entity
+CXML-REJECTION resolver-network-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-network-entity:called
+CXML-CHECK-PASS resolver-parameter-entity
+CXML-REJECTION resolver-parameter-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-parameter-entity:called
+CXML-CHECK-PASS nil-resolver-reaches-cxml-fallback
+CXML-REJECTION nil-resolver-reaches-cxml-fallback FALLBACK-REACHED
+CXML-CHECK-PASS exactly-one-fallback-only-in-nil-counterprobe
+CXML-CHECK-PASS utf8-invalid:stray-continuation
+CXML-REJECTION utf8-invalid:stray-continuation WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:bad-continuation
+CXML-REJECTION utf8-invalid:bad-continuation WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:overlong-two
+CXML-REJECTION utf8-invalid:overlong-two WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:overlong-three
+CXML-REJECTION utf8-invalid:overlong-three WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:overlong-four
+CXML-REJECTION utf8-invalid:overlong-four WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:encoded-surrogate
+CXML-REJECTION utf8-invalid:encoded-surrogate WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:above-unicode-limit
+CXML-REJECTION utf8-invalid:above-unicode-limit WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:illegal-leading-f5
+CXML-REJECTION utf8-invalid:illegal-leading-f5 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:obsolete-five-byte-form
+CXML-REJECTION utf8-invalid:obsolete-five-byte-form WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:obsolete-six-byte-form
+CXML-REJECTION utf8-invalid:obsolete-six-byte-form WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:illegal-leading-ff
+CXML-REJECTION utf8-invalid:illegal-leading-ff WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-truncated:C2
+CXML-REJECTION utf8-truncated:C2 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-truncated:E0A0
+CXML-REJECTION utf8-truncated:E0A0 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-truncated:F09FA6
+CXML-REJECTION utf8-truncated:F09FA6 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:le:isolated-low
+CXML-REJECTION utf16-invalid:le:isolated-low WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:le:high-then-letter
+CXML-REJECTION utf16-invalid:le:high-then-letter WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:le:high-then-high
+CXML-REJECTION utf16-invalid:le:high-then-high WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-truncated:le:odd-octet
+CXML-REJECTION utf16-truncated:le:odd-octet WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-truncated:le:unfinished-high
+CXML-REJECTION utf16-truncated:le:unfinished-high WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:be:isolated-low
+CXML-REJECTION utf16-invalid:be:isolated-low WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:be:high-then-letter
+CXML-REJECTION utf16-invalid:be:high-then-letter WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:be:high-then-high
+CXML-REJECTION utf16-invalid:be:high-then-high WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-truncated:be:odd-octet
+CXML-REJECTION utf16-truncated:be:odd-octet WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-truncated:be:unfinished-high
+CXML-REJECTION utf16-truncated:be:unfinished-high WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS scalar-boundaries:UTF-8
+CXML-CHECK-PASS line-ending-normalization:UTF-8
+CXML-CHECK-PASS refill:UTF-8:8189
+CXML-CHECK-PASS refill:UTF-8:8190
+CXML-CHECK-PASS refill:UTF-8:8191
+CXML-CHECK-PASS refill:UTF-8:8192
+CXML-CHECK-PASS scalar-boundaries:UTF-16LE
+CXML-CHECK-PASS line-ending-normalization:UTF-16LE
+CXML-CHECK-PASS refill:UTF-16LE:8189
+CXML-CHECK-PASS refill:UTF-16LE:8190
+CXML-CHECK-PASS refill:UTF-16LE:8191
+CXML-CHECK-PASS refill:UTF-16LE:8192
+CXML-CHECK-PASS scalar-boundaries:UTF-16BE
+CXML-CHECK-PASS line-ending-normalization:UTF-16BE
+CXML-CHECK-PASS refill:UTF-16BE:8189
+CXML-CHECK-PASS refill:UTF-16BE:8190
+CXML-CHECK-PASS refill:UTF-16BE:8191
+CXML-CHECK-PASS refill:UTF-16BE:8192
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16LE:UTF-16
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16LE:UTF-16 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16LE:NIL
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16LE:NIL WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16LE:UTF-8
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16LE:UTF-8 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-without-declaration:UTF-16LE
+CXML-REJECTION bomless-without-declaration:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-pi-without-xml-declaration:UTF-16LE
+CXML-REJECTION bomless-pi-without-xml-declaration:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bom-declaration-disagreement:UTF-16LE
+CXML-REJECTION bom-declaration-disagreement:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS opposite-endian-declaration:UTF-16LE
+CXML-REJECTION opposite-endian-declaration:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS explicit-endian-label-with-bom:UTF-16LE
+CXML-REJECTION explicit-endian-label-with-bom:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16BE:UTF-16
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16BE:UTF-16 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16BE:NIL
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16BE:NIL WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16BE:UTF-8
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16BE:UTF-8 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-without-declaration:UTF-16BE
+CXML-REJECTION bomless-without-declaration:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-pi-without-xml-declaration:UTF-16BE
+CXML-REJECTION bomless-pi-without-xml-declaration:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bom-declaration-disagreement:UTF-16BE
+CXML-REJECTION bom-declaration-disagreement:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS opposite-endian-declaration:UTF-16BE
+CXML-REJECTION opposite-endian-declaration:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS explicit-endian-label-with-bom:UTF-16BE
+CXML-REJECTION explicit-endian-label-with-bom:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-bom-wrong-declaration:UTF-16
+CXML-REJECTION utf8-bom-wrong-declaration:UTF-16 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-bom-wrong-declaration:UTF-16LE
+CXML-REJECTION utf8-bom-wrong-declaration:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-bom-wrong-declaration:UTF-16BE
+CXML-REJECTION utf8-bom-wrong-declaration:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-bom-wrong-declaration:ISO-8859-1
+CXML-REJECTION utf8-bom-wrong-declaration:ISO-8859-1 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS unknown-encoding-is-fatal
+CXML-REJECTION unknown-encoding-is-fatal WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS encoding-name-case-insensitive
+CXML-CHECK-PASS public-api-rejects-string-input
+CXML-REJECTION public-api-rejects-string-input SIMPLE-TYPE-ERROR
+CXML-CHECK-PASS public-api-no-resolver-override
+CXML-REJECTION public-api-no-resolver-override SIMPLE-PROGRAM-ERROR
+CXML-CHECK-PASS public-api-guard-with-nil-handler
+CXML-REJECTION public-api-guard-with-nil-handler DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS public-resolver-signals
+CXML-REJECTION public-resolver-signals EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS public-api-refuses-unqualified-dependency
+CXML-REJECTION public-api-refuses-unqualified-dependency UNQUALIFIED-PARSER
+CXML-CHECK-PASS public-api-returns-identical-sax-result
+CXML-CHECK-PASS decoder-needs-more:UTF-8:1
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-8:1
+CXML-REJECTION decoder-incomplete-at-eof:UTF-8:1 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-8:2
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-8:2
+CXML-REJECTION decoder-incomplete-at-eof:UTF-8:2 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-8:3
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-8:3
+CXML-REJECTION decoder-incomplete-at-eof:UTF-8:3 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-LITTLE-ENDIAN:1
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:1
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:1 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-LITTLE-ENDIAN:2
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:2
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:2 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-LITTLE-ENDIAN:3
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:3
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:3 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-BIG-ENDIAN:1
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:1
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:1 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-BIG-ENDIAN:2
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:2
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:2 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-BIG-ENDIAN:3
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:3
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:3 ENCODING-ERROR
+CXML-SUMMARY 146 PASS 0 FAIL
--- /dev/null
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Building Closure with CHARACTER RUNES
+CXML-CHECK-PASS asdf-cxml-found-and-loaded
+CXML-CHECK-PASS asdf-dependency:closure-common
+CXML-CHECK-PASS asdf-dependency:puri
+CXML-CHECK-PASS asdf-dependency:babel
+CXML-CHECK-PASS asdf-dependency:alexandria
+CXML-CHECK-PASS asdf-dependency:trivial-features
+CXML-CHECK-PASS asdf-dependency:trivial-gray-streams
+CXML-CHECK-PASS namespace-expanded-element
+CXML-CHECK-PASS unprefixed-attribute-has-no-namespace
+CXML-CHECK-PASS prefixed-attribute-namespace
+CXML-CHECK-PASS unicode-astral-character
+CXML-CHECK-PASS default-namespace-and-nested-rebinding
+CXML-CHECK-PASS utf8-no-bom:bmp
+CXML-CHECK-PASS utf8-no-bom:astral
+CXML-CHECK-PASS utf8-bom:bmp
+CXML-CHECK-PASS utf8-bom:astral
+CXML-CHECK-PASS utf16le-bom:bmp
+CXML-CHECK-PASS utf16le-bom:astral
+CXML-CHECK-PASS utf16be-bom:bmp
+CXML-CHECK-PASS utf16be-bom:astral
+CXML-CHECK-PASS utf16le-explicit-no-bom:bmp
+CXML-CHECK-PASS utf16le-explicit-no-bom:astral
+CXML-CHECK-PASS utf16be-explicit-no-bom:bmp
+CXML-CHECK-PASS utf16be-explicit-no-bom:astral
+CXML-CHECK-PASS utf16-bom-without-declaration:bmp
+CXML-CHECK-PASS utf16-bom-without-declaration:astral
+CXML-CHECK-PASS predefined-entities-and-character-references
+CXML-CHECK-PASS xml-line-end-normalization
+CXML-CHECK-PASS xml-attribute-whitespace-normalization
+CXML-CHECK-PASS misnested
+CXML-REJECTION misnested WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS duplicate-attribute
+CXML-REJECTION duplicate-attribute WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS duplicate-expanded-attribute
+CXML-REJECTION duplicate-expanded-attribute WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS undeclared-prefix
+CXML-REJECTION undeclared-prefix WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS multiple-roots
+CXML-REJECTION multiple-roots WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS unclosed-root
+CXML-REJECTION unclosed-root WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS undefined-entity
+CXML-REJECTION undefined-entity WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS forbidden-nul-reference
+CXML-REJECTION forbidden-nul-reference WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS forbidden-surrogate-reference
+CXML-REJECTION forbidden-surrogate-reference WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS invalid-utf8
+CXML-REJECTION invalid-utf8 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS doctype-without-subset
+CXML-REJECTION doctype-without-subset DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS internal-entity
+CXML-REJECTION internal-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-file-dtd
+CXML-REJECTION external-file-dtd DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-network-dtd
+CXML-REJECTION external-network-dtd DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-general-entity
+CXML-REJECTION external-general-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS external-parameter-entity
+CXML-REJECTION external-parameter-entity DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS safe-policy-never-invokes-external-resolver
+CXML-CHECK-PASS resolver-file-dtd
+CXML-REJECTION resolver-file-dtd EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-file-dtd:called
+CXML-CHECK-PASS resolver-network-dtd
+CXML-REJECTION resolver-network-dtd EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-network-dtd:called
+CXML-CHECK-PASS resolver-file-entity
+CXML-REJECTION resolver-file-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-file-entity:called
+CXML-CHECK-PASS resolver-network-entity
+CXML-REJECTION resolver-network-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-network-entity:called
+CXML-CHECK-PASS resolver-parameter-entity
+CXML-REJECTION resolver-parameter-entity EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS resolver-parameter-entity:called
+CXML-CHECK-PASS nil-resolver-reaches-cxml-fallback
+CXML-REJECTION nil-resolver-reaches-cxml-fallback FALLBACK-REACHED
+CXML-CHECK-PASS exactly-one-fallback-only-in-nil-counterprobe
+CXML-CHECK-PASS utf8-invalid:stray-continuation
+CXML-REJECTION utf8-invalid:stray-continuation WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:bad-continuation
+CXML-REJECTION utf8-invalid:bad-continuation WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:overlong-two
+CXML-REJECTION utf8-invalid:overlong-two WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:overlong-three
+CXML-REJECTION utf8-invalid:overlong-three WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:overlong-four
+CXML-REJECTION utf8-invalid:overlong-four WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:encoded-surrogate
+CXML-REJECTION utf8-invalid:encoded-surrogate WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:above-unicode-limit
+CXML-REJECTION utf8-invalid:above-unicode-limit WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:illegal-leading-f5
+CXML-REJECTION utf8-invalid:illegal-leading-f5 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:obsolete-five-byte-form
+CXML-REJECTION utf8-invalid:obsolete-five-byte-form WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:obsolete-six-byte-form
+CXML-REJECTION utf8-invalid:obsolete-six-byte-form WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-invalid:illegal-leading-ff
+CXML-REJECTION utf8-invalid:illegal-leading-ff WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-truncated:C2
+CXML-REJECTION utf8-truncated:C2 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-truncated:E0A0
+CXML-REJECTION utf8-truncated:E0A0 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-truncated:F09FA6
+CXML-REJECTION utf8-truncated:F09FA6 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:le:isolated-low
+CXML-REJECTION utf16-invalid:le:isolated-low WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:le:high-then-letter
+CXML-REJECTION utf16-invalid:le:high-then-letter WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:le:high-then-high
+CXML-REJECTION utf16-invalid:le:high-then-high WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-truncated:le:odd-octet
+CXML-REJECTION utf16-truncated:le:odd-octet WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-truncated:le:unfinished-high
+CXML-REJECTION utf16-truncated:le:unfinished-high WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:be:isolated-low
+CXML-REJECTION utf16-invalid:be:isolated-low WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:be:high-then-letter
+CXML-REJECTION utf16-invalid:be:high-then-letter WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-invalid:be:high-then-high
+CXML-REJECTION utf16-invalid:be:high-then-high WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-truncated:be:odd-octet
+CXML-REJECTION utf16-truncated:be:odd-octet WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf16-truncated:be:unfinished-high
+CXML-REJECTION utf16-truncated:be:unfinished-high WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS scalar-boundaries:UTF-8
+CXML-CHECK-PASS line-ending-normalization:UTF-8
+CXML-CHECK-PASS refill:UTF-8:8189
+CXML-CHECK-PASS refill:UTF-8:8190
+CXML-CHECK-PASS refill:UTF-8:8191
+CXML-CHECK-PASS refill:UTF-8:8192
+CXML-CHECK-PASS scalar-boundaries:UTF-16LE
+CXML-CHECK-PASS line-ending-normalization:UTF-16LE
+CXML-CHECK-PASS refill:UTF-16LE:8189
+CXML-CHECK-PASS refill:UTF-16LE:8190
+CXML-CHECK-PASS refill:UTF-16LE:8191
+CXML-CHECK-PASS refill:UTF-16LE:8192
+CXML-CHECK-PASS scalar-boundaries:UTF-16BE
+CXML-CHECK-PASS line-ending-normalization:UTF-16BE
+CXML-CHECK-PASS refill:UTF-16BE:8189
+CXML-CHECK-PASS refill:UTF-16BE:8190
+CXML-CHECK-PASS refill:UTF-16BE:8191
+CXML-CHECK-PASS refill:UTF-16BE:8192
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16LE:UTF-16
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16LE:UTF-16 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16LE:NIL
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16LE:NIL WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16LE:UTF-8
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16LE:UTF-8 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-without-declaration:UTF-16LE
+CXML-REJECTION bomless-without-declaration:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-pi-without-xml-declaration:UTF-16LE
+CXML-REJECTION bomless-pi-without-xml-declaration:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bom-declaration-disagreement:UTF-16LE
+CXML-REJECTION bom-declaration-disagreement:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS opposite-endian-declaration:UTF-16LE
+CXML-REJECTION opposite-endian-declaration:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS explicit-endian-label-with-bom:UTF-16LE
+CXML-REJECTION explicit-endian-label-with-bom:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16BE:UTF-16
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16BE:UTF-16 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16BE:NIL
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16BE:NIL WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-missing-or-wrong-label:UTF-16BE:UTF-8
+CXML-REJECTION bomless-missing-or-wrong-label:UTF-16BE:UTF-8 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-without-declaration:UTF-16BE
+CXML-REJECTION bomless-without-declaration:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bomless-pi-without-xml-declaration:UTF-16BE
+CXML-REJECTION bomless-pi-without-xml-declaration:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS bom-declaration-disagreement:UTF-16BE
+CXML-REJECTION bom-declaration-disagreement:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS opposite-endian-declaration:UTF-16BE
+CXML-REJECTION opposite-endian-declaration:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS explicit-endian-label-with-bom:UTF-16BE
+CXML-REJECTION explicit-endian-label-with-bom:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-bom-wrong-declaration:UTF-16
+CXML-REJECTION utf8-bom-wrong-declaration:UTF-16 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-bom-wrong-declaration:UTF-16LE
+CXML-REJECTION utf8-bom-wrong-declaration:UTF-16LE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-bom-wrong-declaration:UTF-16BE
+CXML-REJECTION utf8-bom-wrong-declaration:UTF-16BE WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS utf8-bom-wrong-declaration:ISO-8859-1
+CXML-REJECTION utf8-bom-wrong-declaration:ISO-8859-1 WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS unknown-encoding-is-fatal
+CXML-REJECTION unknown-encoding-is-fatal WELL-FORMEDNESS-VIOLATION
+CXML-CHECK-PASS encoding-name-case-insensitive
+CXML-CHECK-PASS public-api-rejects-string-input
+CXML-REJECTION public-api-rejects-string-input SIMPLE-TYPE-ERROR
+CXML-CHECK-PASS public-api-no-resolver-override
+CXML-REJECTION public-api-no-resolver-override SIMPLE-PROGRAM-ERROR
+CXML-CHECK-PASS public-api-guard-with-nil-handler
+CXML-REJECTION public-api-guard-with-nil-handler DOCTYPE-FORBIDDEN
+CXML-CHECK-PASS public-resolver-signals
+CXML-REJECTION public-resolver-signals EXTERNAL-RESOURCE-FORBIDDEN
+CXML-CHECK-PASS public-api-refuses-unqualified-dependency
+CXML-REJECTION public-api-refuses-unqualified-dependency UNQUALIFIED-PARSER
+CXML-CHECK-PASS public-api-returns-identical-sax-result
+CXML-CHECK-PASS decoder-needs-more:UTF-8:1
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-8:1
+CXML-REJECTION decoder-incomplete-at-eof:UTF-8:1 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-8:2
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-8:2
+CXML-REJECTION decoder-incomplete-at-eof:UTF-8:2 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-8:3
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-8:3
+CXML-REJECTION decoder-incomplete-at-eof:UTF-8:3 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-LITTLE-ENDIAN:1
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:1
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:1 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-LITTLE-ENDIAN:2
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:2
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:2 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-LITTLE-ENDIAN:3
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:3
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-LITTLE-ENDIAN:3 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-BIG-ENDIAN:1
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:1
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:1 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-BIG-ENDIAN:2
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:2
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:2 ENCODING-ERROR
+CXML-CHECK-PASS decoder-needs-more:UTF-16-BIG-ENDIAN:3
+CXML-CHECK-PASS decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:3
+CXML-REJECTION decoder-incomplete-at-eof:UTF-16-BIG-ENDIAN:3 ENCODING-ERROR
+CXML-SUMMARY 146 PASS 0 FAIL
--- /dev/null
+{"importedStatuses": {"fail": 4, "not-run": 65, "pass": 204, "unsupported": 0}, "regressionChecks": {"ASSOCIATION-ARITY": 337, "CTM-ASSOCIATIONS-SEMANTICS": 657, "CTM-IDENTITY-SEMANTICS": 123, "CTM-MERGING-SEMANTICS": 646, "CXTM": 445, "DATES": 1806, "DATETIMES": 217, "DECIMALS": 715, "FOUNDATION": 54, "INCLUDE": 93, "INTEGERS": 665, "ITEM-IDENTIFIERS": 244, "MAP-IMPORT": 275, "MERGEMAP": 118, "OCCURRENCES": 1101, "PREFIX-DATATYPES": 150, "REFERENCES": 238, "REIFICATION": 236, "SCOPES": 293, "TEMPLATES": 297, "TIMEZONES": 1944, "TYPE-RELATIONSHIPS": 1016, "TYPED-NAMES": 106, "VARIANTS": 324}, "runtime": "SBCL 2.5.4", "totalLispChecks": 12100}
+SLICE-19C-VALIDATION-PASS: fresh offline regression; seven byte-exact Include originals, three rejections, two original mismatches; retained contracts unchanged
--- /dev/null
+{
+ "baseCommit": "5e716c078b885e97ebe858230ce7d8578e65ae4b",
+ "branch": "codex/ctm-slice-19c",
+ "runtime": "SBCL 2.5.4",
+ "startedAtUTC": "2026-10-18T16:27:29.844160+00:00",
+ "finishedAtUTC": "2026-10-18T16:27:43.298765+00:00",
+ "command": [
+ "/usr/bin/sandbox-exec",
+ "-p",
+ "(version 1)(allow default)(deny network*)",
+ "/usr/bin/env",
+ "PYTHONDONTWRITEBYTECODE=1",
+ "SBCL=/nix/store/hlsiblxpxr1hax3dw9x8znd6zy097ddj-sbcl-2.5.4/bin/sbcl",
+ "TOPIC_MAPS_REPORT=/var/folders/y1/yhhpj5wd7cb5325t8__1ct2r0000gn/T/tmdm-slice-19c-validation-pzy8er7b/validation.json",
+ "/Users/rgb/workspace/topic-maps/scripts/test.sh"
+ ],
+ "exitCode": 0,
+ "freshSBCL": true,
+ "network": "denied by sandbox-exec",
+ "regressionChecks": {
+ "FOUNDATION": 54,
+ "CTM-IDENTITY-SEMANTICS": 123,
+ "CTM-MERGING-SEMANTICS": 646,
+ "CTM-ASSOCIATIONS-SEMANTICS": 657,
+ "CXTM": 445,
+ "OCCURRENCES": 1101,
+ "PREFIX-DATATYPES": 150,
+ "INTEGERS": 665,
+ "DECIMALS": 715,
+ "DATES": 1806,
+ "DATETIMES": 217,
+ "TIMEZONES": 1944,
+ "TYPED-NAMES": 106,
+ "SCOPES": 293,
+ "VARIANTS": 324,
+ "REFERENCES": 238,
+ "ITEM-IDENTIFIERS": 244,
+ "REIFICATION": 236,
+ "ASSOCIATION-ARITY": 337,
+ "TYPE-RELATIONSHIPS": 1016,
+ "TEMPLATES": 297,
+ "MAP-IMPORT": 275,
+ "MERGEMAP": 118,
+ "INCLUDE": 93
+ },
+ "totalLispChecks": 12100,
+ "importedStatuses": {
+ "pass": 204,
+ "fail": 4,
+ "unsupported": 0,
+ "not-run": 65
+ },
+ "importedStatusChanges": [
+ [
+ "ctm/in/include-prefix.ctm",
+ "not-run",
+ "pass"
+ ],
+ [
+ "ctm/in/include-prefix2.ctm",
+ "not-run",
+ "pass"
+ ],
+ [
+ "ctm/in/include-template-wildcard.ctm",
+ "not-run",
+ "pass"
+ ],
+ [
+ "ctm/in/include-template.ctm",
+ "not-run",
+ "fail"
+ ],
+ [
+ "ctm/in/include-tm-reifier.ctm",
+ "not-run",
+ "pass"
+ ],
+ [
+ "ctm/in/include-topicref.ctm",
+ "not-run",
+ "pass"
+ ],
+ [
+ "ctm/in/include-wildcard.ctm",
+ "not-run",
+ "pass"
+ ],
+ [
+ "ctm/in/include-wildcard2.ctm",
+ "not-run",
+ "fail"
+ ],
+ [
+ "ctm/in/include.ctm",
+ "not-run",
+ "pass"
+ ],
+ [
+ "ctm/invalid/include-prefix.ctm",
+ "not-run",
+ "pass"
+ ],
+ [
+ "ctm/invalid/include-prefix2.ctm",
+ "not-run",
+ "pass"
+ ],
+ [
+ "ctm/invalid/include-xtm.ctm",
+ "not-run",
+ "pass"
+ ]
+ ],
+ "retainedOriginalCXTMOutputsAndModelObservationsUnchanged": true,
+ "originalCorpusAndReferencesUnchanged": true,
+ "tmdmAndCxtmSourcesUnchanged": true,
+ "documentedInspectionPassed": true,
+ "baseLexerCounterprobePassed": true,
+ "sourceSHA256": {
+ "src/package.lisp": "1f80cc513a004287bf2691ee7e2d03ea9eec929ddcf980a38c055ae9d29a59c4",
+ "src/filesystem.lisp": "472bd62e0d836939fd145741cb9077e923f3cba82e04dc644d059ac2c4c9296f",
+ "src/corpus.lisp": "af7f3b93a170db36ab5a962bfa13aaff38288b3e3e5c32e44cc15367f4c238a0",
+ "src/report.lisp": "b548959df4de210068718f4f041e29132782046093cf3236662d983cb23bd4fe",
+ "src/cxtm/package.lisp": "ead818427000962e3bcd374711d311204d615fa313d1f8c4d89a63c7f47cd97b",
+ "src/cxtm/canonicalizer.lisp": "ddf277a41595a07638d16ceaa886560e0303477fa5fe0cd47a0058803946c1f7",
+ "src/cxtm/nfc-data.lisp": "d6e93694673f37d1b46cbb8afb1948a913efa2a218755b19ecf7bedda9e7d844",
+ "src/cxtm/unicode.lisp": "fc96efb81c0dd503d28821751675539eb517304f039a82cec7866a51cfa8297a",
+ "src/xml/package.lisp": "fb57cefcf977245115d96e2a69c7cb7c8e121164e91dec441d48f06be7df9a8c",
+ "src/xml/parser.lisp": "fc91d297feb8d79ae137f29ec2a1198986dd377dbff1c56aa826e204388013c5",
+ "src/tmdm/package.lisp": "2891303aec12c19cff574c26d0fc6371dc1c1c4147768b5fc870fefdf02e5ac0",
+ "src/tmdm/integers.lisp": "4b37be581f871f59ac06d7ed47435266d09b4b68ce2310d00716aabd7c8f8c31",
+ "src/tmdm/merging.lisp": "05e5b61e525b9ae3ef50bc3e5ae7137e279a49517146dbc8992c18c689be2de5",
+ "src/tmdm/item-identifiers.lisp": "49dcabb67dc5b0e0548d6092ecf6f9145f1e32809a30975ce5897208a0a83e74",
+ "src/tmdm/datetimes.lisp": "97fab02c50b92bdb6ff66babe38d794ee78cfe23cff8ed2e102fe7b565a12402",
+ "src/tmdm/occurrences.lisp": "1b184a0f325ddaae148ffce8b81c3e8666e356044acbf06eca44da588f590ab5",
+ "src/tmdm/variants.lisp": "f8f4be9cbb58d17ea9bcac1fe19db593b24dc97a5c7eb3bbe9b4413489122e79",
+ "src/tmdm/dates.lisp": "cce7999eeb4df5d39aab1152a73971ae21e20059fd57b9b2a6b202b608e2535c",
+ "src/tmdm/reification.lisp": "9476931118aa964c88b672012a13098a08ae752e3f5c29c27343e985aad2a638",
+ "src/tmdm/associations.lisp": "cc86f08693a0f4be141757f003f9be476bbb9fe0805484dec8d1692eb7aeef18",
+ "src/tmdm/core-subjects.lisp": "bbf2f10392fc30f2a1d951215642aae1acf7664c52ff2455d1504f9d90fc4904",
+ "src/tmdm/decimals.lisp": "9b27880929a42afd89b1745860582ca48f41e2d7ce02bd7422cf3b730464867a",
+ "src/tmdm/import.lisp": "e072f8381504eea93b8c87bf9146a55c9807fc0d441d1c025b24f6ff93a16769",
+ "src/tmdm/items.lisp": "2d1a7d30b7cbdcdbf8ab7e402307729e2b34184efcb1a8e26b07a5c8012a2c36",
+ "src/ctm/package.lisp": "344f43ed94b7c4dc5d049593cbd969c3bf1d3c0084104980c8b12e294745bde1",
+ "src/ctm/reader.lisp": "9f6dd86110f3098230f4e584cfd66130c38d53ed491a2dc07c95acce6f68f777",
+ "src/ctm/templates.lisp": "3b9774c975fe03457666c65bb50132602ef4db9120ceda5003b0bb89785faff4",
+ "src/ctm/resources.lisp": "cecf5799f10b64a3fc4df848e08fa0894190408a3ff0c86876b161e8dcce7cd1",
+ "src/ctm/unicode.lisp": "55ce1af0b45d0f75a4162f8aba9fa8c1fd87ef1ef5f374efa85fe2f3c17f219f",
+ "src/ctm/lexer.lisp": "cfafe8a136bf7bbe7f8846282127d92e92d8ddbbdae3c239410cab1bf5fa7cc0",
+ "src/ctm/iri.lisp": "700c53d48cf11585c69f9355e4f12ca8500edaad5371fdf1d3662f980d97b7db",
+ "src/ctm/conditions.lisp": "9d422ded9ba0dd953faf1c862dd7e4de0e191f49868571db438e8df5f5f632a4",
+ "tests/ctm-report.lisp": "c202e0360ea46bdb13d82bcc1a7f86c03fc1506e926ba1327448126918ff7697",
+ "tests/ctm-merging.lisp": "12f8d4c05f58ab698346aee3561dc69024866db0e9ad4e57ecdd3b944dcf1371",
+ "tests/package.lisp": "446b55f7e7917fdd68a5c797b20518535144ae636a630c08e0f866c71153f969",
+ "tests/ctm-decimals.lisp": "714293c865e355f89aa9911011067c3425c12be5e1bf838be1b4a682c53dd866",
+ "tests/cxtm.lisp": "aadd4df99d450494965d37a63d884b64f96bf41d8c9db4eb30b9dd91951d46b0",
+ "tests/association-report.lisp": "53bae4008ad496220ab9521f26f03883eb075252f910fbae1dbc19b97750b18f",
+ "tests/ctm-mergemap.lisp": "5e6f9cadeb172caca12818defb8c6847885a32144fb1cb48d33b0e8522a752f3",
+ "tests/ctm-datetime-timezones.lisp": "9ca6eeb63e9dc9c312e3d834e1c1fc3fd7da4a2c02fbd2e2b64759fd4bdd3a49",
+ "tests/ctm-scopes.lisp": "a817a847537a8a37d12069794e1100365901dcff79accfa08d88cca1ad1b3605",
+ "tests/ctm-templates.lisp": "d252d655740f5ee4acf319edd534effa7c0e7ecf179bc2f5f93c120c596f50c0",
+ "tests/ctm-occurrences.lisp": "530f8bde9e4e16cc2979fbf79c0490bd822bdb227a71b6730777fb2eaa5f5c72",
+ "tests/ctm-dates.lisp": "da85e2e71da0f17c38238bf121b598e34af87b9f726ccbfce648a6ae8e0aad81",
+ "tests/ctm-typed-names.lisp": "2013317b66d0fb245d2ea390b4340dd2dbf42044edabf7d63b603b9a99bccfba",
+ "tests/ctm-include.lisp": "1429a04ab1f31d731a8391dbe820da2a642c4d8f56667911c9a553a6214d2eef",
+ "tests/item-identifiers.lisp": "d544e6dfd10f95cf156841f5bf392581774bbff291b0cfa59f3e465c0159cdd9",
+ "tests/ctm-associations.lisp": "3ca2021fe19fd43e5a0fa4f3f40efb7e3ddeb377f5eab73f3472016fafa77ea5",
+ "tests/ctm-prefixes.lisp": "bc3527604cacc0dbe6c16db3cd544e1adbd241ef68d0679c2e180c59ad997a1d",
+ "tests/ctm-references.lisp": "9393da9625af6981b20bfa17b06e9c0d264be01c778c808fd48c0ba3bf24f5bd",
+ "tests/cxml-encoding-regressions.lisp": "e9129d0beba928e2bc557417b8807ded648e4db638bec9d25a2001dc1134e342",
+ "tests/cxml-probe.lisp": "15f6b43ff11fe69e0ba2ca7232505de9d86abf006bd0f04cece8dea6b1e9e0ff",
+ "tests/foundation.lisp": "93ddfa5e5f5f17285bf1280f17bc24fcab127d191c9496756629d18707167fea",
+ "tests/test_corpus.py": "fd7ccdb2e1b814a4dd0944cee6c09ebab0a332dde30741094905b854d09a88a6",
+ "tests/ctm-package.lisp": "78c788d026a13565eeb6183ca2874484d3a52ee71b3846eab30fa9d34ad0c385",
+ "tests/association-graphs.lisp": "c3bab14683c0fe9dc3dc9e1ef724793862e3ae883d3d783f057cdac9afbd989c",
+ "tests/ctm-variants.lisp": "4744308544eba36d5f0c3355c060a0297beaf5ad5494b780395ec822c94d49ab",
+ "tests/ctm-association-arity.lisp": "adedd0aa2bf6087d20a7a51630927a7076009d566b1c9acbd11407e7d6fcf52f",
+ "tests/map-import.lisp": "718ee7b7319d53895c5bd9fb0175a8f93be5de14a661d37080a8c59231114f56",
+ "tests/reification.lisp": "19e192c9249ad40d45b57710aa6102e28bc9ac14f828b76d29121a42e1d1bdbe",
+ "tests/ctm-integers.lisp": "18b7fa387fbd3cfae3e245ea0010c4665d09db75e278cb63522d6220506ca7e4",
+ "tests/ctm-datetimes.lisp": "130a8997497b4e5d2d0f19ec7e77988019f28c287c234b5ef7e442fd4a3439cd",
+ "tests/ctm-identity.lisp": "c5ee9360c6e4f731a436950ea0966315a21204f3e853088a712763bafccb7ff7",
+ "tests/merge-graphs.lisp": "6ae0d02a2e28eada4c2b4531078277fc4d6f07cb4a0f816614d3bef3ab2da21e",
+ "tests/ctm-type-relationships.lisp": "857ef9a44ac78f73816a9cf7853076adc4546b236a1ec3b49acb2ee31a659936",
+ "scripts/check-timezones.py": "2d14d8cca241c909b01edbfad7975ee714d7301e13f47b7aba10020cc4576d54",
+ "scripts/validate-slice-18.py": "34e9130487e7038e2b194118cd69707ae1f94ad4b483b4f28f26d9d2ddc8bd65",
+ "scripts/check-typed-names.py": "ef6b052f552dfd008e05282e7d2d8ae8b537a945acedfc4e7c0a46ea4f822d4c",
+ "scripts/validate-slice-6.py": "4f952ad9a60f0591c7512ad6aa1dc33956cebc935476cfa10de7d79905c49daa",
+ "scripts/check-include.py": "12b4b6e721759430f865d28df88b56d12d2a74682d9e52f8fafaf72acef0fcda",
+ "scripts/validate-slice-7.py": "c4639f6a1aface28b914a0c1c9fb54fcb9bfcda7b14141f7c14a855b55545d99",
+ "scripts/check-cxtm.py": "6bee9e15db460c649afd5100fb96da5d2b24b335983c9a0711582f6e18be94b5",
+ "scripts/check-variants.py": "b46beb92b0765129b96a9df1b424c190789977a1d50a249af47893fa1733602f",
+ "scripts/check-mergemap.py": "730011714e35731bb803d4176a53925f283cadf1c632dac3922dbb6bcac7734a",
+ "scripts/fresh-sbcl.lisp": "771cce103925aae2cffaa9e9438a67ad9b823b4faf8465ecc05cf0044a18427e",
+ "scripts/validate-cxml-19d0b.py": "cb556418bbae5140c8136d3ee76005611936e9a36bf7351c5f1a6ef85999c730",
+ "scripts/validate-slice-17b.py": "ab39eb21bae6e273ed3e4217932cafee81af8f8e731d71aed75f36d038814a8f",
+ "scripts/check-scopes.py": "291931a3e7e6d903bb7acbcb41aa149e7d63897646745194ca876d9353f929c1",
+ "scripts/validate-slice-19a.py": "6702e11fa9ac91ac59fe4c78fab0d39f494d84cbdc95522c0587cf04199e0624",
+ "scripts/validate-slice-16b.py": "0518d1cff552278bd142d9fd0886f9617bbf52ca5b6964bcc4e75d0735bc462c",
+ "scripts/check-merging.py": "6f4d8242524f0ecaed334d88fb5f2a127910dac3d67cd10f00bdfe7d22a4c76d",
+ "scripts/validate-slice-8.py": "8c98cbd0e007c93fddf35c0525b86563c559113213d9323275cd255fa95363a4",
+ "scripts/check-integers.py": "cfa6c01f08ffd523ce2b8a9924bcd406a0532e689bbd05f8a204a43ed6276690",
+ "scripts/check-dates.py": "62e536da481bfe3b304077b319f9d3935f229e4474c747b8957f7c44e75f79de",
+ "scripts/check-templates.py": "2e86af6f506160e26bc982ff87679fd56e962d2d1bd251c000ae7f6d43ca90cb",
+ "scripts/prepare-cxml.py": "93f21c4c513cb3f7afdd1dc98675d1bba027b027ebca69d68916aba01bce62c9",
+ "scripts/validate-slice-13.py": "d17711a21a78fa58d1e18310cd4aa5b5fc13939d7d34a7edddbe0ca5b0ec3091",
+ "scripts/check-nfc.py": "4616fb09ed145358b7fcebc89354af5c50e4863560dfc7eb3b1ee9c1ab0f4e18",
+ "scripts/check-associations.py": "91f61e3656f9f56e2e43a1f513ebbb7ea54499845e4a5c1336e06f2a4547d251",
+ "scripts/check-references.py": "8d8bba4b1ab048a1122b20f1dd64e04fd12deadb805b6b5579c286b16818b7c7",
+ "scripts/validate-slice-9.py": "0e523de6d7d952a0958129be3c4427af17f9bb7445a8af8206cd399d6232d1a5",
+ "scripts/validate-slice-14.py": "1b30337fb575903afbdfd1e220eabc5686e5057bbc42796a2931079aff5be874",
+ "scripts/check-prefixes.py": "754eaee06045603b7bc0f75f2c4973d18692e038ee374e490eac48e033eb51b3",
+ "scripts/validate-slice-10.py": "cb41eef305655b5efafeb8c9471772969fdd9546b593c8f5358c515e215e9102",
+ "scripts/validate-slice-12a.py": "85533b3497cfb805f32866a9866659a67cf303325c8c2c0f50790a01e3c41486",
+ "scripts/validate-slice-19c.py": "387c1018157c7b72196ffc13e37250fe329077f3ec1800a6a796e3659ff11383",
+ "scripts/check-occurrences.py": "d78236ad469277cf8c2c27e99d7a976625c607acc48ddc622f01b0e881b5eef4",
+ "scripts/check-semantics.py": "a70164a461a90d0dc09e73c97d0db7cc338022bf8a069b0f056734603da0c48e",
+ "scripts/validate-slice-17a.py": "b682dfe4973e24062f0cab1ff2f6e4561fb087ddb5f32e2b0b12203b37c534bd",
+ "scripts/validate-slice-11.py": "47b90a0a035333ceebc9db5113303f16ad093acee0461006c2fe6e08d5f4f44f",
+ "scripts/check-report.py": "12f4244da6258330a1a3bb36bf127748e5945b0ba79ed35d52083cabbda7801d",
+ "scripts/validate-slice-16a.py": "8e68f8721cf296cdb8709e17476fa3cf6a2fe498e93b63f477c316fb94ce67df",
+ "scripts/validate-slice-19b.py": "3c521657431306cec21445c169c78808a76c597933aa7387526471ff8085513c",
+ "scripts/validate-slice-15.py": "836fb574b7fe75594a635ffe317cd960b5dfff3a92fb9a6fd5e7713385573820",
+ "scripts/check-arity.py": "d59bdafabc43ef6bf7f562fc3a486735e1a5e490ac14830ee66c562f64a8266b",
+ "scripts/check-decimals.py": "cf02664d7bab57d4515a297a8301cbf5f30d3db3d04698627920c86eccb379d5",
+ "scripts/validate-cxml.py": "c6e1864c4adc14d9108b9295c5922666dcbe860d38f216f0b95253b76f9544e6",
+ "scripts/check-datetimes.py": "23e3c7ee8d99ba2664db4f7a835115a2aa9c1a71b4a9278f9ca2331877f01b56",
+ "scripts/check-map-import.py": "1e5d1212bf386ed16b5beef835e5f669c33edf03c796dd1d4ed36bc61d105b51",
+ "scripts/generate-nfc-data.py": "14db9a2ad100ec6cb24b31451a65aba9621bf01c4980a2432c70e4a7248fdbae",
+ "scripts/check-reification.py": "0874e679719aa00ce40da3ec23c93351823b8aa88b761c5949238500c0fd7cef",
+ "scripts/check-relationships.py": "a6dca44999a5ed6900f8ec1ff0a3fc8c7b5ab486ea126a0b69e7f34a710a4746",
+ "scripts/test.sh": "d0f71d116a41b36b5fe92a9dd724929daca4a2971f6d50390b9a5716b9c150c7",
+ "scripts/corpus.py": "c2324e68b2d29c0cb1492301d7df2d6598cae3930bbf48d3572318a01c324a12",
+ "scripts/check-item-identifiers.py": "df26cb283defcebad0bbd50f4213369108a35a9a57ca4fd68e98903839d44196",
+ "docs/slice-14-validation.md": "a39744fc590075058051f13cd45d050148f3b4d0b31d59f4fa5c7d004509bebb",
+ "docs/slice-19d0-cxml.md": "8f27f930b29f4b268510ec9be51584fc9f7d3d38591702f4c4b77e12c6f04686",
+ "docs/slice-10-validation.md": "c7e1d9a724a134270057fe82ac68abef88f87704071db9a576b5eb540586d1a9",
+ "docs/reading-first-occurrences.md": "dc02cf0d1839a51b74526d330882fb639ce28efe246d9792dca3fb0c56e45cc2",
+ "docs/slice-4-validation.md": "6d7dde9ef071af5fcd850f401742eb149b26aa48b258de227ef779e43442eb32",
+ "docs/reading-scope.md": "aa48ae3f9339f70d7eea68dbf35075a1136d28527bd2252d6e2186e2ade64dd3",
+ "docs/architecture.md": "3fd353ba4fababd5d4e865f90a9fc16bf4b6d8566a22bf644a96879c0ab1b042",
+ "docs/slice-7-validation.md": "036d14f9a07df4fb5b65484fb606c74a474b02106cab076032420ab9b47ad9ed",
+ "docs/reading-map-content-import.md": "ba93b829e766bc43f2e5a379da22e069c513c2db7eef899fbcd7b12b5a41ccb3",
+ "docs/slice-3-validation.md": "b0cd084e8932826f50dd6eb0dbbcbf549f0bdfaad536105562bb09ee4aa4e3f0",
+ "docs/slice-13-validation.md": "2a03c0bda1c4a90e97f7dc250d4093e7c93cd79e023fd4b38e66747d68efab22",
+ "docs/slice-19c-validation.md": "81b9d2314f8c4429a97532d39e3dba13882f9ccdf1916013e225fbb9ba60c992",
+ "docs/reading-variants.md": "eac4ae6f2ebeb048999c8400def71fc9e82a607711ecc1675fe707feb0a8ffe2",
+ "docs/reading-reification.md": "2097cd0d45ca5b2c0a971b06f7f9d6bf817d3fe00640942193733d70fdaff58e",
+ "docs/validation.md": "447a4a8568ea58dfebc6aff615101f90cef87f7fceacf5ccc1fc109b47680899",
+ "docs/slice-9-validation.md": "a4ae4d7b72edb283438b78c511e9c1e34f8f77ca5d82cd9fbbe386a51062ea05",
+ "docs/inventory.md": "b2c3660cd20991532a7a86229372df0468130bbfdb9fa7ed780f5dde251545bc",
+ "docs/slice-1a-validation.md": "6147ee80f9f9218fd6269277643c35023cca64be978e8f35955885a0f2c02ef1",
+ "docs/slice-19d0b-cxml-encoding.md": "ca3342a6226a7eb865107df70d4a8d5ce53f7b4960ff51791a63296bc2fe67f3",
+ "docs/reading-canonical-topic-maps.md": "5f00de1a0b06e1959054c8a16658f3d084a95d0a504c1cd6f4c8f7e082c8fd3c",
+ "docs/reading-date-occurrences.md": "b2e2af09ac6eb2c2847009b54247f348338b84b79993c47fc963ee9bc7d8cb04",
+ "docs/slice-16a-validation.md": "42844e0f1b5558d5d04399a00baf79124c0cf5cbb8561d159be697900e6c0aca",
+ "docs/reading-integer-occurrences.md": "c4d6f0e3ff723f2982428717b715802bb825eda148ac5a2b3438981b597ac6c0",
+ "docs/reading-ctm-templates.md": "2f3994eaa6019a36075272e6d834f19499b64f4582bb2b856044960bdcd9784b",
+ "docs/slice-17b-validation.md": "4c9af675f3948ce67162bf46b0f9bdb7568b937705f0091e75489aeb7e51b2a3",
+ "docs/slice-19a-validation.md": "4989a796495262facd66ab5943649f3d71ab4e33cddd16784b9ee0936bd2467b",
+ "docs/reading-ctm-mergemap.md": "2369f6283c34ca46ef7e35951e286cd8a11285851b5f11937f98faeac97f227d",
+ "docs/reading-first-five-ctm-documents.md": "a79e3efeed240a3d5d9af38203a2389157c1cda5638923b0fca1cbdb6c8cca1f",
+ "docs/reading-datetime-occurrences.md": "c5b5d9fd4a037fcb30cf99e1e121141e6f1216691aa924c0b8b75d919ff8285a",
+ "docs/reading-ctm-include.md": "cd2029c34e01507306483c29a326fa0760ffd5198f7592b945a6a275a7eca4a0",
+ "docs/slice-19b-validation.md": "d159b3a654ce0e2eba41abcba520b06044f8cc258e5956716c7598730f1588d2",
+ "docs/slice-18-validation.md": "7921f377621bbbcfd8569a5587fc547fd5959b00f9ad6e450311b5f57d8187be",
+ "docs/reading-association-arity.md": "07ad03813255ad5dc46aa8b102001bf674b17d3668e88981f8f4135e4c700377",
+ "docs/reading-type-relationships.md": "f466c14bde43e94d80e4e0fde52f4178d748bcb11ef91460bd7d17143d772df7",
+ "docs/slice-16b-validation.md": "946d82defb77ed28a83a177e46357859b7f6e84c34c7e6abbb14c455d3a88bad",
+ "docs/reading-topic-merging.md": "bd18b2d98e645c7db79be589ae3155480745c7418be665912ea45013a9462ee4",
+ "docs/reading-prefixes-and-datatypes.md": "3b4ab5f8942918a8a432106fcfc47e7e7da220d9e42a803cc6f4b0c282c9db69",
+ "docs/slice-17a-validation.md": "a828452295e5230b131d536340af82cfaea51952972a4c2e75d9d18682c558b3",
+ "docs/slice-8-validation.md": "80b511a8a565a317b50754aa5e940c32b06f651e7e7c8bdc371281619529186e",
+ "docs/coverage.md": "968d387b3ec3bcdffba519314d3e7e126588c3ccc1ced4589330fe9592f5d8c1",
+ "docs/reading-datetime-timezones.md": "34f8679eb85b24c3f0a2f1c21c3c43e63e971ca0b35ed1cfcd5b1b8a44412a76",
+ "docs/slice-1-api-and-boundaries.md": "be21952b837e455d9ab6c5e5e533d5e21c9dfd07697aed643c905f8008fdb6ad",
+ "docs/slice-2-validation.md": "aca317eb521b968602239ae96751a42faf1f05fd0894b544f510a6e8687eba32",
+ "docs/reading-topic-references.md": "7513d32cf9ea168207767f2ddffdfa0a5789c90d2eea632eb94e1b9c11a8f72b",
+ "docs/reading-first-ctm-associations.md": "7b00b101a4099fb8dfb8517aa506b2fbd1df23e8c0d4ec68ddfd934b050f9084",
+ "docs/reading-item-identifiers.md": "191078ebb1aeb74f2a5b18fb4ef16258f769c831b93891ccfc8464376797abad",
+ "docs/slice-6-validation.md": "df184ae861adb74167768e3cd2da66ab5f18e69b7dca773eef5f7aa201fc518f",
+ "docs/slice-12a-validation.md": "17ae0257cd109387e97362d0d3e66358964213f78cf903c3a825cda906fb8aba",
+ "docs/reading-typed-topic-names.md": "01e5929305f479c6133f441f0e122df651b33adcf2ce695175e4bf9043b2e39f",
+ "docs/reading-decimal-occurrences.md": "89fc7fa561066af1ae51330a9cb5d12906608af6e4832a009e7ab4be88fa6311",
+ "docs/slice-11-validation.md": "3cfcabca71691a22f3d12a051c314ce77a6720f4321093fd6d30b46a7ed63596",
+ "docs/slice-15-validation.md": "e5a69a535065b9c7675168428d0cdc46dd11515b841b6eca9fbf7ed0542378fa",
+ "docs/slice-1-validation.md": "c706bdb5816c32c1a547bd2aee89741131efedb1e325bb16c879154831f46bbc",
+ "docs/slice-5-validation.md": "ae44d9702db286eafe67a4094e713f1a5e994b7697659a7ee2438537c9cf5a48",
+ "topic-maps.asd": "9ae08ca60394fcd95936a7f54cc5a5e3fafdd09ae5406d697206a92d18249b92",
+ "README.md": "08142adbddcda9b532edcbebb2d2ea8b708ab840d5cd8be298f882d1c0039c73"
+ },
+ "qualification": "CTM Include with immediate-parent Document/Wildcard environments, per-level aliases and source-preserving Templates. All twelve originals execute: seven byte-equal positives, three rejections, two explicit mismatches. Two retained DateTime FAILs unchanged; XTM remains NOT-RUN.",
+ "artifactsSHA256": {
+ "actual/include-prefix.ctm.cxtm": "b03a943988df0e1ccc3a822ed8430c4664efbfb4245a117fec263bf27ead4497",
+ "actual/include-prefix2.ctm.cxtm": "2a44eb756e08549856f2b12b048f993740b7b1f590d331b3c9c15db8d48bc3db",
+ "actual/include-template-wildcard.ctm.cxtm": "3ba753012de6e8976059dadf78e60f7f447d2910df79b12e8b2f8fdd0a61dd10",
+ "actual/include-template.ctm.cxtm": "15326a49da9e44f4a3f886414aa2134cf3ba0f7682bb52259e3b64138ac5e864",
+ "actual/include-tm-reifier.ctm.cxtm": "473a5807db2c0a090d9cf61259a0dc96a6f49f797418ed5516e5bc96ee1472b4",
+ "actual/include-topicref.ctm.cxtm": "95af4ff7d130903b00b38727edef08e944e6ce0c555f514327d3294517f24658",
+ "actual/include-wildcard.ctm.cxtm": "0e06b660af3d44b6a1eb5b5d8e896dfa54a435b3daf089d0c77e48f67186cdba",
+ "actual/include-wildcard2.ctm.cxtm": "be6e7114120452715b740956b25d8c1ec263814d2210e6ea323976055ecc082e",
+ "actual/include.ctm.cxtm": "ec6600347d32624ee3f7c0e73d2a4dc9ba11eecd3c033f021e95e0e3aac69d60",
+ "arity.json": "02ffd2fbfd379ec140e13f665190c84e6781af9394fe194e8ddef4175e21b7e0",
+ "associations.json": "31b1e7a0552904f8f1bcbb6028d461a04460c3945d0534773bbbb57034e2e64f",
+ "base-control.log": "39badc7277e408144b9c1c00d82aaf77d4b760209448d0d4001a3f103656f7d3",
+ "cxtm.json": "10612369817fbd336f8035648abade081a2c6848408f6533b1a79c013cb318b5",
+ "dates.json": "92c38576019d05ff80903b189a264b3b85d422957797be7b8c0459348e4e8580",
+ "datetimes.json": "4badf7237d6e25df7b5e30673adf04b259ab57750562deea3635ff5c78d847c4",
+ "decimals.json": "3147c6d3ae1a8cf6041d4008be3dc177411139a5737b8122c9e1b41eb188d1ed",
+ "describe.log": "762b3a7f19dbc1bc1d0471cb6090a0bbe31fe55f23eb31989ab62ac0813c84a9",
+ "identifiers.json": "5107966e75b2599a8b3b02b82e320967eb7588263ab129011a079dd77d3582a9",
+ "include.json": "f740b70dfbf8e5790f4ab8ac3df3e40ef62fa18a47dcee7f12f2e6d7c573eea7",
+ "integers.json": "a117e7eecbbd4092725c95e9f3f10dd1c0279f5ce3575c29c94e5bd6020ae45d",
+ "map-import.json": "883052223d825e6e0b86b128e4e0ebb92432e57395cebf32a42c43f43530864e",
+ "mergemap.json": "6f78d3ca676093514fd5def2699f233458ded4a39e949b7a9716f5a645b33802",
+ "merging.json": "d38e3ba85aaaceb63bcd481b1c3670f70efca876afc4b5ff92032c91c099d5c3",
+ "occurrences.json": "4b4889e62153fbcb658c75c752ea2bb39244cbf08596abb3190473a47119144d",
+ "prefixes.json": "01ea278fc301c98539e60a327bcf1d9976ba7abd23113a3e1c109a2d60bfe623",
+ "references.json": "bfe5fd9aca4701d10853c33e984663b50a6acb67e767d5d5c2f84f3bd98b521d",
+ "reification.json": "c5037082b0fd507707290b434ab648e4645341899362fd11be6752d579997890",
+ "relationships.json": "d96021c0f00c98129f54646535f0995ca5f9c39d2f0b8a8814d00e2eab37171c",
+ "scopes.json": "1f05cb6c023553798cd94940384c3170d3aaac7d513d9769c07dc096a034158b",
+ "semantics.json": "7ae0747a6fd87e7726513f3d8e3b49c6c123337a3364922c005c35216a62d561",
+ "templates.json": "9f1e6f3508dbfd745dd9aee47f4a6c3d82620347c2b63c188e353334f554b311",
+ "tests.log": "2b2a01291df4b21595a853420e815c21dae643c271649031610bc2f7f75f48cb",
+ "timezones.json": "cd17799042eb4c76a7bbfcc81d1c82e3f88b390ed106dbf5c5d7ee5e8b136142",
+ "typed-names.json": "9df3ea1fcc45d82c16d79eab0348630a9eb3bd3e36715af820576b3008276630",
+ "validation.json": "c4a303e4baf0d5ce41f3b1e1c4e8be90104eb1946a344305873b339e1089672a",
+ "variants.json": "8a7d5c5cf202f4cb1f1b444675ed4042bf7d3a343132291d4a2985d55db27804"
+ }
+}
--- /dev/null
+CORPUS-INTEGRITY-PASS: {"auxiliary": 22, "baselines": 231, "invalid": 42, "missingBaselines": [], "unmatchedBaselines": [], "valid": 231}
+..
+----------------------------------------------------------------------
+Ran 2 tests in 0.018s
+
+OK
+FOUNDATION-PASS: 54 infrastructure checks; 231 valid, 42 invalid, 231 baselines, 22 auxiliaries; 273 CTM cases NOT-RUN, zero CTM passes.
+CTM-IDENTITY-SEMANTICS-PASS: 123 checks, 5 imported semantic cases, required prefix rejection; no CXTM equality passes.
+CTM-MERGING-SEMANTICS-PASS: 646 checks, 11 pinned semantic cases; no CXTM equality passes.
+CTM-ASSOCIATIONS-SEMANTICS-PASS: 657 checks, 8 pinned cases; no CXTM equality passes.
+CXTM ctm/in/simple.ctm: PASS
+CXTM ctm/in/subject-identifier.ctm: PASS
+CXTM ctm/in/subject-locator.ctm: PASS
+CXTM ctm/in/item-identifier.ctm: PASS
+CXTM ctm/in/name.ctm: PASS
+CXTM ctm/in/topic-subject-identifier.ctm: PASS
+CXTM ctm/in/topic-subject-identifier-wrapped.ctm: PASS
+CXTM ctm/in/topic-subject-identifier-duplicate.ctm: PASS
+CXTM ctm/in/topic-subject-locator.ctm: PASS
+CXTM ctm/in/topic-subject-locator-wrapped.ctm: PASS
+CXTM ctm/in/topic-subject-locator-semi.ctm: PASS
+CXTM ctm/in/topic-subject-locator-duplicate.ctm: PASS
+CXTM ctm/in/topic-item-identifier.ctm: PASS
+CXTM ctm/in/topic-item-identifier-wrapped.ctm: PASS
+CXTM ctm/in/topic-item-identifier-duplicate.ctm: PASS
+CXTM ctm/in/name-duplicate.ctm: PASS
+CXTM ctm/in/association.ctm: PASS
+CXTM ctm/in/association-binary.ctm: PASS
+CXTM ctm/in/association-binary-duplicate.ctm: PASS
+CXTM ctm/in/association-type-sid.ctm: PASS
+CXTM ctm/in/association-with-comment.ctm: PASS
+CXTM ctm/in/association-with-comment2.ctm: PASS
+CXTM ctm/in/association-with-comment3.ctm: PASS
+CXTM ctm/in/association-with-comment4.ctm: PASS
+CXTM-PASS: 445 checks; 24 original byte comparisons; 25 imported PASS, 248 NOT-RUN.
+OCCURRENCE-CXTM ctm/in/occurrence-string.ctm: PASS
+OCCURRENCE-CXTM ctm/in/occurrence-string2.ctm: PASS
+OCCURRENCE-CXTM ctm/in/occurrence-uri-relative.ctm: PASS
+OCCURRENCE-CXTM ctm/in/occurrence-two.ctm: PASS
+OCCURRENCES-PASS: 1101 checks; 4 new byte-equal baselines; 29 imported PASS, 244 NOT-RUN.
+PREFIX-CXTM ctm/in/occurrence-explicit-datatype.ctm: PASS (359 bytes)
+PREFIX-CXTM ctm/in/occurrence-datatype-unknown.ctm: PASS (339 bytes)
+PREFIX-CXTM ctm/in/prefix-duplicate.ctm: PASS (141 bytes)
+PREFIX-CXTM ctm/in/prefix-duplicate2.ctm: PASS (260 bytes)
+PREFIX-CXTM ctm/in/prefix-multiline.ctm: PASS (141 bytes)
+PREFIX-REJECTION ctm/invalid/prefix-collision.ctm: PREFIX-COLLISION in ctm/invalid/prefix-collision.ctm at CHARACTER 43 (line 2, column 9): Prefix "ex" is already bound to "http://www.example.org/", not "http://www.example.net/".
+PREFIX-REJECTION ctm/invalid/prefix-undefined2.ctm: UNDEFINED-PREFIX in ctm/invalid/prefix-undefined2.ctm at CHARACTER 136 (line 6, column 15): Prefix "xsd" has no binding.
+PREFIX-DATATYPES-PASS: 150 checks; 5 new byte-exact baselines, 2 specific rejections; 36 imported PASS, 237 NOT-RUN.
+INTEGER-CXTM ctm/in/occurrence-integer.ctm: PASS (351 bytes)
+INTEGER-CXTM ctm/in/occurrence-integer2.ctm: PASS (351 bytes)
+INTEGER-CXTM ctm/in/occurrence-integer-plus-sign.ctm: PASS (351 bytes)
+INTEGER-CXTM ctm/in/occurrence-integer-minus-sign.ctm: PASS (352 bytes)
+INTEGER-CXTM ctm/in/occurrence-integer-leading-zeros.ctm: PASS (1741 bytes)
+INTEGER-CXTM ctm/in/occurrence-explicit-datatype2.ctm: PASS (352 bytes)
+INTEGERS-PASS: 665 checks; 6 new byte-exact baselines; 42 imported PASS, 231 NOT-RUN.
+DECIMAL-CXTM ctm/in/occurrence-decimal.ctm: PASS (353 bytes)
+DECIMAL-CXTM ctm/in/occurrence-decimal-dot.ctm: PASS (353 bytes)
+DECIMAL-CXTM ctm/in/occurrence-decimal-dot-neg.ctm: PASS (354 bytes)
+DECIMAL-CXTM ctm/in/occurrence-decimal-leading-zeros.ctm: PASS (353 bytes)
+DECIMAL-CXTM ctm/in/occurrence-decimal-minus-sign.ctm: PASS (354 bytes)
+DECIMAL-CXTM ctm/in/occurrence-decimal-plus-sign.ctm: PASS (353 bytes)
+DECIMAL-CXTM ctm/in/occurrence-decimal-1.0.ctm: PASS (353 bytes)
+DECIMALS-PASS: 715 checks; 7 new byte-exact baselines; 49 imported PASS, 224 NOT-RUN.
+DATE-CXTM ctm/in/occurrence-date.ctm: PASS (357 bytes)
+DATE-CXTM ctm/in/occurrence-date2.ctm: PASS (357 bytes)
+DATE-CXTM ctm/in/occurrence-date3.ctm: PASS (1066 bytes)
+DATE-CXTM ctm/in/occurrence-date-negative.ctm: PASS (358 bytes)
+DATE-CXTM ctm/in/occurrence-date-another-century.ctm: PASS (359 bytes)
+DATE-REJECTION ctm/invalid/date-invalid-day.ctm: PASS (INVALID-DATE-DAY at 2:14)
+DATE-REJECTION ctm/invalid/date-invalid-month.ctm: PASS (INVALID-DATE-MONTH at 2:14)
+DATE-REJECTION ctm/invalid/date-invalid-year.ctm: PASS (INVALID-DATE-YEAR at 2:14)
+DATE-REJECTION ctm/invalid/date-invalid-year2.ctm: PASS (INVALID-DATE-YEAR at 6:14)
+DATE-REJECTION ctm/invalid/date-invalid-year3.ctm: PASS (INVALID-DATE-YEAR at 6:14)
+DATES-PASS: 1806 checks; 5 new exact baselines and 5 specific rejections; 59 imported PASS, 214 NOT-RUN.
+DATETIME-CXTM ctm/in/occurrence-datetime.ctm: PASS (370 bytes)
+DATETIME-CXTM ctm/in/occurrence-datetime2.ctm: FAIL-known-baseline-discrepancy (370 bytes)
+DATETIME-CXTM ctm/in/occurrence-datetime-fractional.ctm: PASS (677 bytes)
+DATETIME-CXTM ctm/in/occurrence-datetime-timezone.ctm: PASS (674 bytes)
+DATETIME-CXTM ctm/in/occurrence-datetime-timezone2.ctm: FAIL-known-baseline-discrepancy (674 bytes)
+DATETIMES-PASS: 217 semantic checks; corpus: 62 PASS, 2 known normative discrepancy FAIL, 209 NOT-RUN.
+TIMEZONES-PASS: 1944 checks; 1681 signed offset minutes, pure canonicalization and lexical TMDM equality.
+TYPED-NAME-CXTM ctm/in/name.ctm: PASS
+TYPED-NAME-CXTM ctm/in/name2.ctm: PASS
+TYPED-NAME-CXTM ctm/in/name-type.ctm: PASS
+TYPED-NAME-CXTM ctm/in/name-duplicate.ctm: PASS
+TYPED-NAMES-PASS: 106 checks; four original comparisons; 64 PASS, 2 known FAIL, 207 NOT-RUN.
+SCOPE-CXTM ctm/in/name-scope.ctm: PASS (615 bytes)
+SCOPE-CXTM ctm/in/occurrence-scope.ctm: PASS (646 bytes)
+SCOPE-CXTM ctm/in/association-scope.ctm: PASS (794 bytes)
+SCOPES-PASS: 293 checks; 3 original byte-exact comparisons; 67 PASS, 2 known FAIL, 204 NOT-RUN.
+VARIANT-CXTM ctm/in/variant.ctm: PASS (592 bytes)
+VARIANT-CXTM ctm/in/variants.ctm: PASS (857 bytes)
+VARIANT-CXTM ctm/in/variant-duplicate.ctm: PASS (592 bytes)
+VARIANTS-PASS: 324 checks; 3 original byte-exact comparisons, 1 specific rejection; 71 PASS, 2 known FAIL, 200 NOT-RUN.
+REFERENCE-CXTM ctm/in/wildcard.ctm: PASS (113 bytes), counter 1
+REFERENCE-CXTM ctm/in/wildcard-named.ctm: PASS (117 bytes), counter 1
+REFERENCE-CXTM ctm/in/wildcard-named2.ctm: PASS (301 bytes), counter 3
+REFERENCE-CXTM ctm/in/wildcard-named-merge.ctm: PASS (117 bytes), counter 1
+REFERENCE-CXTM ctm/in/association-scope-embedded.ctm: PASS (1651 bytes), counter 2
+REFERENCE-CXTM ctm/in/association-scope-embedded2.ctm: PASS (1863 bytes), counter 3
+REFERENCE-CXTM ctm/in/association-type-embedded.ctm: PASS (727 bytes), counter 1
+REFERENCE-CXTM ctm/in/association-type-embedded-merge.ctm: PASS (622 bytes), counter 2
+REFERENCE-CXTM ctm/in/embedded-semicolon.ctm: PASS (727 bytes), counter 1
+REFERENCE-CXTM ctm/in/name-scope-embedded.ctm: PASS (1331 bytes), counter 2
+REFERENCE-CXTM ctm/in/name-scope-embedded2.ctm: PASS (1543 bytes), counter 3
+REFERENCE-CXTM ctm/in/name-type-embedded.ctm: PASS (495 bytes), counter 1
+REFERENCE-CXTM ctm/in/nested-twice.ctm: PASS (737 bytes), counter 2
+REFERENCE-CXTM ctm/in/occurrence-scope-embedded.ctm: PASS (1503 bytes), counter 2
+REFERENCE-CXTM ctm/in/occurrence-scope-embedded2.ctm: PASS (1715 bytes), counter 3
+REFERENCE-CXTM ctm/in/occurrence-type-embedded.ctm: PASS (573 bytes), counter 1
+REFERENCE-CXTM ctm/in/role-player-embedded.ctm: PASS (721 bytes), counter 1
+REFERENCE-CXTM ctm/in/role-type-embedded.ctm: PASS (721 bytes), counter 1
+REFERENCE-CXTM ctm/in/subject-identifier-embedded.ctm: PASS (597 bytes), counter 1
+REFERENCE-CXTM ctm/in/variant-scope-embedded.ctm: PASS (1637 bytes), counter 3
+REFERENCE-CXTM ctm/in/variant-scope-embedded2.ctm: PASS (1985 bytes), counter 4
+REFERENCES-PASS: 238 checks; 21 original byte-exact comparisons and 1 specific rejection; 93 PASS, 2 known FAIL, 178 NOT-RUN.
+ITEM-IDENTIFIERS-PASS: 244 checks; 7 manually constructed original XTM2 baseline comparisons; no XTM reader or imported status changes.
+REIFICATION-CXTM ctm/in/tm-reifier.ctm: PASS (126 bytes)
+REIFICATION-CXTM ctm/in/tm-reifier2.ctm: PASS (347 bytes)
+REIFICATION-CXTM ctm/in/tm-reifier3.ctm: PASS (128 bytes)
+REIFICATION-CXTM ctm/in/name-reifier.ctm: PASS (433 bytes)
+REIFICATION-CXTM ctm/in/variant-reifier.ctm: PASS (697 bytes)
+REIFICATION-CXTM ctm/in/occurrence-reifier.ctm: PASS (464 bytes)
+REIFICATION-CXTM ctm/in/occurrence-reifier-nested.ctm: PASS (678 bytes)
+REIFICATION-CXTM ctm/in/occurrence-reifier-nested-nested.ctm: PASS (947 bytes)
+REIFICATION-CXTM ctm/in/association-reifier.ctm: PASS (612 bytes)
+REIFICATION-CXTM ctm/in/role-reifier.ctm: PASS (612 bytes)
+REIFICATION-CXTM ctm/in/role-duplicate-reified-qnames.ctm: PASS (736 bytes)
+REIFICATION-PASS: 236 checks; 11 original byte-exact comparisons, 2 specific rejections; 106 PASS, 2 known FAIL, 165 NOT-RUN.
+ARITY-CXTM ctm/in/association-duplicate-role.ctm: PASS (1157 bytes)
+ASSOCIATION-ARITY-PASS: 337 checks; one new original CTM/CXTM contract; 107 PASS, 2 known FAIL, 164 NOT-RUN.
+RELATIONSHIP-CXTM ctm/in/isa-relationship.ctm: PASS (963 bytes)
+RELATIONSHIP-CXTM ctm/in/isa-relationship-duplicate.ctm: PASS (963 bytes)
+RELATIONSHIP-CXTM ctm/in/isa-relationship-duplicate2.ctm: PASS (963 bytes)
+RELATIONSHIP-CXTM ctm/in/isa-relationship-embedded.ctm: PASS (1181 bytes)
+RELATIONSHIP-CXTM ctm/in/isa-relationship-type-qname.ctm: PASS (991 bytes)
+RELATIONSHIP-CXTM ctm/in/ako-relationship.ctm: PASS (977 bytes)
+RELATIONSHIP-CXTM ctm/in/ako-relationship-duplicate.ctm: PASS (977 bytes)
+RELATIONSHIP-CXTM ctm/in/ako-relationship-duplicate2.ctm: PASS (977 bytes)
+RELATIONSHIP-CXTM ctm/in/ako-relationship-embedded.ctm: PASS (1190 bytes)
+RELATIONSHIP-CXTM ctm/in/ako-relationship-supertype-qname.ctm: PASS (1005 bytes)
+RELATIONSHIP-CXTM ctm/in/ako-merge-away.ctm: PASS (1590 bytes)
+RELATIONSHIP-CXTM ctm/in/subject-identifier-topicref.ctm: PASS (989 bytes)
+RELATIONSHIP-CXTM ctm/in/item-identifier-topicref.ctm: PASS (985 bytes)
+TYPE-RELATIONSHIPS-PASS: 1016 checks; 13 original CXTM contracts; 120 PASS, 2 known FAIL, 151 NOT-RUN.
+TEMPLATE-CXTM ctm/in/association-scope-embedded3.ctm: PASS (2431 bytes)
+TEMPLATE-CXTM ctm/in/association-scope-embedded4.ctm: PASS (3613 bytes)
+TEMPLATE-CXTM ctm/in/name-scope-embedded3.ctm: PASS (2105 bytes)
+TEMPLATE-CXTM ctm/in/name-scope-embedded4.ctm: PASS (3284 bytes)
+TEMPLATE-CXTM ctm/in/occurrence-scope-embedded3.ctm: PASS (2277 bytes)
+TEMPLATE-CXTM ctm/in/occurrence-scope-embedded4.ctm: PASS (3457 bytes)
+TEMPLATE-CXTM ctm/in/prefix-template-scope.ctm: PASS (263 bytes)
+TEMPLATE-CXTM ctm/in/template-ambiguous-parameter.ctm: PASS (376 bytes)
+TEMPLATE-CXTM ctm/in/template-ambiguous-parameter2.ctm: PASS (407 bytes)
+TEMPLATE-CXTM ctm/in/template-ambiguous-parameter3.ctm: PASS (399 bytes)
+TEMPLATE-CXTM ctm/in/template-ambiguous-parameter4.ctm: PASS (1506 bytes)
+TEMPLATE-CXTM ctm/in/template-assoc-embedded-topic.ctm: PASS (23 bytes)
+TEMPLATE-CXTM ctm/in/template-duplicate-name.ctm: PASS (438 bytes)
+TEMPLATE-CXTM ctm/in/template-forward-ref.ctm: PASS (825 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-embedded.ctm: PASS (401 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-embedded2.ctm: PASS (401 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-noargs-isa.ctm: PASS (963 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-noargs2.ctm: PASS (828 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-prefix-notation.ctm: PASS (328 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-twice.ctm: PASS (402 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-wildcard-named.ctm: PASS (331 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-wildcard-named2.ctm: PASS (331 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-wildcard-named3.ctm: PASS (646 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-wildcard-named4.ctm: PASS (331 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-wildcard-named5.ctm: PASS (577 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-wildcard-named6.ctm: PASS (581 bytes)
+TEMPLATE-CXTM ctm/in/template-invocation-wildcard.ctm: PASS (484 bytes)
+TEMPLATE-CXTM ctm/in/template-item-identifier.ctm: PASS (131 bytes)
+TEMPLATE-CXTM ctm/in/template-item-identifier2.ctm: PASS (131 bytes)
+TEMPLATE-CXTM ctm/in/template-item-identifier4.ctm: PASS (157 bytes)
+TEMPLATE-CXTM ctm/in/template-nested-occtype.ctm: PASS (576 bytes)
+TEMPLATE-CXTM ctm/in/template-nested-occtype2.ctm: PASS (737 bytes)
+TEMPLATE-CXTM ctm/in/template-noop.ctm: PASS (23 bytes)
+TEMPLATE-CXTM ctm/in/template-noop2.ctm: PASS (23 bytes)
+TEMPLATE-CXTM ctm/in/template-noop3.ctm: PASS (23 bytes)
+TEMPLATE-CXTM ctm/in/template-references.ctm: PASS (23 bytes)
+TEMPLATE-CXTM ctm/in/template-simple.ctm: PASS (114 bytes)
+TEMPLATE-CXTM ctm/in/template-subject-identifier.ctm: PASS (141 bytes)
+TEMPLATE-CXTM ctm/in/template-subject-locator.ctm: PASS (131 bytes)
+TEMPLATE-CXTM ctm/in/template-subject-locator2.ctm: PASS (131 bytes)
+TEMPLATE-CXTM ctm/in/template-subject-locator4.ctm: PASS (194 bytes)
+TEMPLATE-CXTM ctm/in/template-topic-nested.ctm: PASS (678 bytes)
+TEMPLATE-CXTM ctm/in/template-topic-nested2.ctm: PASS (596 bytes)
+TEMPLATE-CXTM ctm/in/template-typed-value.ctm: PASS (351 bytes)
+TEMPLATE-CXTM ctm/in/template-wildcard-named.ctm: PASS (211 bytes)
+TEMPLATE-CXTM ctm/in/template-wildcard-named2.ctm: PASS (211 bytes)
+TEMPLATE-CXTM ctm/in/template-wildcard-named3.ctm: PASS (211 bytes)
+TEMPLATE-CXTM ctm/in/template-wildcard-named4.ctm: PASS (919 bytes)
+TEMPLATE-CXTM ctm/in/template-wildcard.ctm: PASS (203 bytes)
+TEMPLATE-CXTM ctm/in/template-wildcard2.ctm: PASS (293 bytes)
+TEMPLATE-CXTM ctm/in/tmlab-tmql-issue-48.ctm: PASS (2358 bytes)
+TEMPLATE-CXTM ctm/in/topic-embedded-template-invocation.ctm: PASS (1357 bytes)
+TEMPLATE-CXTM ctm/in/topic-identifier-eq-template-name.ctm: PASS (207 bytes)
+TEMPLATE-CXTM ctm/in/topic-template-invocation-unary.ctm: PASS (328 bytes)
+TEMPLATE-CXTM ctm/in/topic-template-invocation.ctm: PASS (328 bytes)
+TEMPLATE-CXTM ctm/in/variant-scope-embedded3.ctm: PASS (2547 bytes)
+TEMPLATE-CXTM ctm/in/variant-scope-embedded4.ctm: PASS (3734 bytes)
+TEMPLATE-REJECTION ctm/invalid/embedded-topic-template.ctm: PASS (INVALID-TEMPLATE-BODY)
+TEMPLATE-REJECTION ctm/invalid/occurrence-explicit-datatype-as-parameter.ctm: PASS (VARIABLE-DATATYPE)
+TEMPLATE-REJECTION ctm/invalid/prefix-template-scope.ctm: PASS (INVALID-TEMPLATE-BODY)
+TEMPLATE-REJECTION ctm/invalid/template-bad-type.ctm: PASS (INVALID-TEMPLATE-ARGUMENT)
+TEMPLATE-REJECTION ctm/invalid/template-missing-args.ctm: PASS (TEMPLATE-ARITY)
+TEMPLATE-REJECTION ctm/invalid/template-missing-def.ctm: PASS (UNDEFINED-TEMPLATE)
+TEMPLATE-REJECTION ctm/invalid/template-name-collision.ctm: PASS (DUPLICATE-TEMPLATE)
+TEMPLATE-REJECTION ctm/invalid/tm-reifier-in-template.ctm: PASS (INVALID-TEMPLATE-BODY)
+TEMPLATE-REJECTION ctm/invalid/variable-undefined.ctm: PASS (VARIABLE-OUTSIDE-TEMPLATE)
+TEMPLATE-REJECTION ctm/invalid/variable-undefined2.ctm: PASS (VARIABLE-OUTSIDE-TEMPLATE)
+TEMPLATES-PASS: 297 checks; 57 byte-exact originals, 10 specific rejections; 187 PASS, 2 known FAIL, 84 NOT-RUN.
+MAP-IMPORT-PASS: 275 checks; no CTM import contracts executed.
+MERGEMAP-CXTM ctm/in/mergemap.ctm: PASS (1511 bytes)
+MERGEMAP-CXTM ctm/in/mergemap-syntax-qname.ctm: PASS (1511 bytes)
+MERGEMAP-CXTM ctm/in/mergemap-template.ctm: PASS (1529 bytes)
+MERGEMAP-CXTM ctm/in/mergemap-tm-reifier.ctm: PASS (134 bytes)
+MERGEMAP-REJECTION ctm/invalid/mergemap-missing-syntax-iri.ctm: PASS (EXPECTED-MERGEMAP-NOTATION)
+MERGEMAP-REJECTION ctm/invalid/mergemap-template.ctm: PASS (UNDEFINED-TEMPLATE)
+MERGEMAP-REJECTION ctm/invalid/mergemap-unknown-syntax.ctm: PASS (UNKNOWN-MERGEMAP-NOTATION)
+MERGEMAP-PASS: 118 checks; four byte-exact originals, three specific rejections.
+INCLUDE-CXTM ctm/in/include.ctm: PASS (1939/1939 bytes)
+INCLUDE-CXTM ctm/in/include-prefix.ctm: PASS (140/140 bytes)
+INCLUDE-CXTM ctm/in/include-prefix2.ctm: PASS (261/261 bytes)
+INCLUDE-CXTM ctm/in/include-template.ctm: FAIL (353/401 bytes)
+INCLUDE-CXTM ctm/in/include-template-wildcard.ctm: PASS (330/330 bytes)
+INCLUDE-CXTM ctm/in/include-tm-reifier.ctm: PASS (375/375 bytes)
+INCLUDE-CXTM ctm/in/include-topicref.ctm: PASS (1490/1490 bytes)
+INCLUDE-CXTM ctm/in/include-wildcard.ctm: PASS (499/499 bytes)
+INCLUDE-CXTM ctm/in/include-wildcard2.ctm: FAIL (719/669 bytes)
+INCLUDE-REJECTION ctm/invalid/include-prefix.ctm: PASS (UNDEFINED-PREFIX)
+INCLUDE-REJECTION ctm/invalid/include-prefix2.ctm: PASS (UNDEFINED-PREFIX)
+INCLUDE-REJECTION ctm/invalid/include-xtm.ctm: PASS (INVALID-IRI)
+INCLUDE-PASS: 93 checks; seven byte-exact originals, three rejections, two explicit baseline FAILs.
+NFC-ORACLE-PASS: 16294 independent Unicode 15.1.0 comparisons (canonical mappings, all Hangul, 1000 seeded combining sequences)
+REPORT-JSON-PASS: deterministic schema, draft qualification, case contracts and only warranted imported status changes
+BASELINE-SEMANTIC-EVIDENCE-PASS: five frozen baselines support the selected properties; no canonicalization claimed
+MERGING-BASELINE-SEMANTIC-EVIDENCE-PASS: 11 frozen baselines; no canonicalization or canonical numbering
+ASSOCIATION-BASELINE-SEMANTIC-EVIDENCE-PASS: 8 frozen baselines, Role items and roles-played; no canonicalization
+CXTM-INDEPENDENT-PASS: 176 byte-exact unchanged baselines; 4 explicit normative discrepancy; canonical XML and reference integrity
+OCCURRENCE-INDEPENDENT-PASS: four original sources, actual parents/types, lexical values, datatype locators, no extra items
+PREFIX-INDEPENDENT-PASS: 7 original sources, 5 model observations, 2 specific rejections with independently checked positions
+INTEGER-INDEPENDENT-PASS: 6 original sources/model observations; 143 arithmetic-oracle probes, including 10000-digit integers
+DECIMAL-INDEPENDENT-PASS: 7 original sources/model observations; 157 Decimal arithmetic-oracle probes, including 10000-digit components
+DATE-INDEPENDENT-PASS: 5 original sources/model observations; 5 specific rejections; 396 arbitrary-precision calendar probes; 15 century decisions
+DATETIME-INDEPENDENT-PASS: 5 original model observations; 45 exact calendar/fraction probes; 2 documented discrepancies
+TIMEZONE-INDEPENDENT-PASS: 1774 exact UTC probes; 1681 signed offset minutes; stored strings and CXTM checked separately
+TYPED-NAMES-INDEPENDENT-PASS: four original sources, exact identifier sets and Name value/Parent/Type relations
+SCOPES-INDEPENDENT-PASS: three original model observations, Topic identity categories and Scope sets; independent XML ordering/Role references
+VARIANTS-INDEPENDENT-PASS: three original model observations; Parent identity, datatype locators, Scope sets and XML ordering
+REFERENCES-INDEPENDENT-PASS: 21 original model graphs; identity categories, generated locators/counters, Parent/Type/Player/Scope/Variant relations
+ITEM-IDENTIFIERS-INDEPENDENT-PASS: 7 hand-built original XTM2 baseline matches; all seven II positions, locator ordering and Topic references; no XTM deserialization claim
+REIFICATION-INDEPENDENT-PASS: 11 original model observations, canonical Topic identity and bidirectional Reifier references; 2 specific rejection reasons/positions
+ARITY-INDEPENDENT-PASS: original Topic/Role object observations; 12 canonical XML witnesses with complete Role references
+RELATIONSHIPS-INDEPENDENT-PASS: 13 original TMDM reference graphs; eight exact Core Subject locators; 304 atomic conflict observations
+TEMPLATES-INDEPENDENT-PASS: 57 original model graphs and 10 specific rejection contracts
+MAP-IMPORT-REPORT-PASS: model/metadata/reference evidence only; imported contracts unchanged
+MERGEMAP-INDEPENDENT-PASS: four unchanged byte baselines/model identities; three intended negative causes and exact resources
+INCLUDE-INDEPENDENT-PASS: nine model traces, each alias level, separate two baseline discrepancies, three intended negative causes
--- /dev/null
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Checking for wide character support... WARNING: Lisp implementation doesn't use UTF-16, but accepts surrogate code points.
+ yes, using code points.
+;;; Building Closure with CHARACTER RUNES
+UNPATCHED-BOUNDARY-PASS
--- /dev/null
+#!/usr/bin/env python3
+"""Apply the versioned XML encoding patches to verified Nix sources, offline."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import shutil
+import subprocess
+
+ROOT = Path(__file__).resolve().parent.parent
+NIX_EVAL = ['nix', 'eval', '--offline', '--option', 'eval-cache', 'false']
+PATCHES = {'closure-common': ['encodings.lisp', 'xstream.lisp'],
+ 'cxml': ['xml/xml-parse.lisp']}
+
+
+def command(args):
+ return subprocess.check_output(args, cwd=ROOT, text=True).strip()
+
+
+def source_environment():
+ system = command(NIX_EVAL + ['--impure', '--raw', '--expr', 'builtins.currentSystem'])
+ return system, json.loads(command(NIX_EVAL + ['--json', '.#lib.cxmlEnvironment',
+ '--apply', 'f: f "' + system + '"']))
+
+
+def digest(path):
+ return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def registry(paths):
+ return '(:source-registry ' + ' '.join('(:tree ' + json.dumps(str(p) + '/') + ')'
+ for p in paths) + ' :ignore-inherited-configuration)'
+
+
+def prepare(environment, target):
+ target = Path(target).resolve()
+ # Verify every pristine input before creating or changing an output.
+ for package in environment['manifest']:
+ source = Path(package['source'])
+ assert source.is_dir(), 'Missing local source: ' + package['name']
+ actual = command(['nix', 'hash', 'path', '--type', 'sha256', '--base32', str(source)])
+ assert actual == package['sha256'], 'SOURCE HASH MISMATCH: ' + package['name']
+ target.mkdir(parents=True, exist_ok=False)
+ provenance = {'sources': environment['manifest'], 'patches': [], 'effectiveSources': []}
+ for package in environment['manifest']:
+ name = package['name']
+ source = Path(package['source'])
+ effective = source
+ if name in PATCHES:
+ effective = target / name
+ shutil.copytree(source, effective)
+ for path in [effective, *effective.rglob('*')]:
+ path.chmod(path.stat().st_mode | 0o200)
+ before = {str(p.relative_to(effective)): digest(p)
+ for p in effective.rglob('*') if p.is_file()}
+ patch = ROOT / 'patches' / (name + '-19d0b.patch')
+ pinned_patch = next(p for p in environment['localPatches'] if p['package'] == name)
+ assert digest(patch) == pinned_patch['sha256'], 'LOCAL PATCH HASH MISMATCH: ' + name
+ applied = subprocess.run(['patch', '--batch', '--fuzz=0', '-p1',
+ '-d', str(effective), '-i', str(patch)],
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+ assert applied.returncode == 0, applied.stdout
+ assert 'offset' not in applied.stdout and 'fuzz' not in applied.stdout, applied.stdout
+ after = {str(p.relative_to(effective)): digest(p)
+ for p in effective.rglob('*') if p.is_file()}
+ assert before.keys() == after.keys(), 'Unexpected files from patch'
+ changed = sorted(p for p in before if before[p] != after[p])
+ assert changed == sorted(PATCHES[name]), changed
+ provenance['patches'].append({
+ 'package': name, 'patch': str(patch.relative_to(ROOT)), 'sha256': digest(patch),
+ 'changedFiles': {p: {'before': before[p], 'after': after[p]} for p in changed},
+ 'application': applied.stdout.strip()})
+ provenance['effectiveSources'].append({'name': name, 'source': str(effective)})
+ provenance['sourceRegistry'] = registry([p['source'] for p in provenance['effectiveSources']])
+ (target / 'provenance.json').write_text(json.dumps(provenance, indent=2) + '\n')
+ return provenance
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('--directory', required=True, type=Path, help='New output directory; never overwritten')
+ parser.add_argument('--registry', action='store_true', help='Print only CL_SOURCE_REGISTRY')
+ args = parser.parse_args()
+ _, environment = source_environment()
+ provenance = prepare(environment, args.directory)
+ print(provenance['sourceRegistry'] if args.registry else json.dumps(provenance, indent=2))
+
+
+if __name__ == '__main__':
+ main()
--- /dev/null
+#!/usr/bin/env python3
+"""Reproduce the eight original failures; qualify local patches fully offline."""
+import argparse
+import datetime
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import tempfile
+
+ROOT = Path(__file__).resolve().parent.parent
+BASE = 'ec3f21e45c46849a6bb674194b6f7cc75b67bba1'
+PIN = '50ab793786d9de88ee30ec4e4c24fb4236fc2674'
+POLICY = '(version 1)(allow default)(deny network*)'
+NIX_EVAL = ['nix', 'eval', '--offline', '--option', 'eval-cache', 'false']
+
+
+def command(args):
+ return subprocess.check_output(args, cwd=ROOT, text=True).strip()
+
+
+def sha(path):
+ return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def failures():
+ cases = []
+ for name, encoding, bom, label in [
+ ('utf16le-bom', 'utf-16le', b'\xff\xfe', 'UTF-16'),
+ ('utf16be-bom', 'utf-16be', b'\xfe\xff', 'UTF-16'),
+ ('utf16le-explicit-no-bom', 'utf-16le', b'', 'UTF-16LE'),
+ ('utf16be-explicit-no-bom', 'utf-16be', b'', 'UTF-16BE')]:
+ for content, suffix in [('Grüße 水', 'bmp'), ('Grüße 水 🦊', 'astral')]:
+ if bom and suffix == 'bmp':
+ continue
+ source = "<?xml version='1.0' encoding='" + label + "'?><r>" + content + '</r>'
+ cases.append({'name': name + ':' + suffix, 'source': source,
+ 'octets': bom + source.encode(encoding), 'expectedText': content,
+ 'declaredEncoding': label,
+ 'cause': 'closure-common: UTF-16 second-unit check uses x instead of y'
+ if bom else 'closure-common: missing provisional XML signature; CXML: missing LE/BE declaration handling',
+ 'functions': ['closure-common/encodings.lisp:decode-sequence'] if bom else
+ ['closure-common/xstream.lisp:figure-encoding', 'cxml/xml/xml-parse.lisp:setup-encoding'],
+ 'normative': ['XML 1.0 §2.2, §4.3.3', 'Unicode §3.9.2, §3.10', 'RFC 2781 §2.2, §3.3']})
+ cases.append({'name': 'utf16-bom-without-declaration:astral', 'source': '<r>水🦊</r>',
+ 'octets': b'\xff\xfe' + '<r>水🦊</r>'.encode('utf-16le'), 'expectedText': '水🦊',
+ 'declaredEncoding': None, 'cause': 'closure-common: UTF-16 second-unit check uses x instead of y',
+ 'functions': ['closure-common/encodings.lisp:decode-sequence'],
+ 'normative': ['XML 1.0 §2.2, §4.3.3', 'Unicode §3.9.2', 'RFC 2781 §2.2']})
+ cases.append({'name': 'invalid-utf8', 'source': None, 'octets': b'<r>\xc3\x28</r>',
+ 'expectedText': None, 'declaredEncoding': None,
+ 'cause': 'closure-common: UTF-8 continuation bytes masked without validation',
+ 'functions': ['closure-common/encodings.lisp:decode-sequence'],
+ 'normative': ['XML 1.0 §4.3.3', 'Unicode §3.9.3 / Table 3-7', 'RFC 3629 §3–4']})
+ return cases
+
+
+def run_lisp(runtime, registry, output, label, *, source=None, script=None):
+ invocation = ['/usr/bin/sandbox-exec', '-p', POLICY, runtime,
+ '--noinform', '--no-sysinit', '--no-userinit', '--script',
+ str(script) if script else '/dev/stdin']
+ started = datetime.datetime.now(datetime.timezone.utc).isoformat()
+ result = subprocess.run(invocation, cwd=ROOT,
+ env=dict(os.environ, CL_SOURCE_REGISTRY=registry, PYTHONDONTWRITEBYTECODE='1'),
+ input=source.encode() if source else None,
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=120)
+ (output / (label + '.log')).write_bytes(result.stdout)
+ return result, {'label': label, 'command': invocation, 'exitCode': result.returncode,
+ 'freshProcess': True, 'network': 'denied by sandbox-exec',
+ 'startedAtUTC': started,
+ 'finishedAtUTC': datetime.datetime.now(datetime.timezone.utc).isoformat()}
+
+
+def checks(result, context):
+ log = result.stdout.decode()
+ passed = re.findall(r'^CXML-CHECK-PASS (.+)$', log, re.M)
+ failed = re.findall(r'^CXML-CHECK-FAIL (.+)$', log, re.M)
+ assert len(set(passed + failed)) == len(passed + failed)
+ assert 'CXML-SUMMARY ' + str(len(passed)) + ' PASS ' + str(len(failed)) + ' FAIL' in log
+ assert (result.returncode == 0) == (not failed)
+ return dict(context, passedChecks=passed, failedChecks=failed)
+
+
+def diagnostic_source(cases):
+ source = '''(require :asdf)
+(setf *compile-verbose* nil *load-verbose* nil)
+(asdf:load-system "cxml")
+(defun diagnose (id bytes)
+ (format t "DIAG-ENCODING ~A ~A~%" id
+ (runes::figure-encoding (cxml::make-octet-input-stream bytes)))
+ (handler-case
+ (let* ((node (cxml:parse-octets bytes (cxml-xmls:make-xmls-builder)
+ :disallow-internal-subset t
+ :entity-resolver (lambda (p s) (declare (ignore p s)) (error "External resource forbidden"))))
+ (text (apply #'concatenate 'string (cxml-xmls:node-children node))))
+ (format t "DIAG-ACCEPTED ~A ~{~X~^,~}~%" id (map 'list #'char-code text)))
+ (error (c) (format t "DIAG-REJECTED ~A ~A ~A~%" id (type-of c)
+ (substitute #\\Space #\\Newline (princ-to-string c))))))
+'''
+ for c in cases:
+ source += '(diagnose ' + json.dumps(c['name']) + ' (make-array ' + str(len(c['octets']))
+ source += " :element-type '(unsigned-byte 8) :initial-contents '(" + ' '.join(map(str, c['octets'])) + ')))\n'
+ return source
+
+
+def read_diagnostics(result, cases):
+ assert result.returncode == 0
+ lines = result.stdout.decode().splitlines()
+ observations = {}
+ for c in cases:
+ name = c['name']
+ encoding = next(l.split(' ', 2)[2] for l in lines if l.startswith('DIAG-ENCODING ' + name + ' '))
+ accepted = next((l for l in lines if l.startswith('DIAG-ACCEPTED ' + name + ' ')), None)
+ if accepted:
+ codes = accepted.split(' ', 2)[2]
+ observations[name] = {'recognizedEncoding': encoding, 'outcome': 'accepted',
+ 'text': ''.join(chr(int(n, 16)) for n in codes.split(','))}
+ else:
+ rejected = next(l.split(' ', 3) for l in lines if l.startswith('DIAG-REJECTED ' + name + ' '))
+ observations[name] = {'recognizedEncoding': encoding, 'outcome': 'rejected',
+ 'condition': rejected[2], 'diagnostic': rejected[3]}
+ return observations
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('--sbcl', default=os.environ.get('SBCL', 'sbcl'))
+ parser.add_argument('--output', type=Path, default=ROOT / 'reports/slice-19d0b')
+ args = parser.parse_args()
+ runtime = shutil.which(args.sbcl)
+ assert runtime and command([runtime, '--version']) == 'SBCL 2.5.4'
+ output = args.output.resolve()
+ output.mkdir(parents=True, exist_ok=True)
+ started = datetime.datetime.now(datetime.timezone.utc).isoformat()
+ system = command(NIX_EVAL + ['--impure', '--raw', '--expr', 'builtins.currentSystem'])
+ environment = json.loads(command(NIX_EVAL + ['--json', '.#lib.cxmlEnvironment',
+ '--apply', 'f: f "' + system + '"']))
+ assert json.loads((ROOT / 'flake.lock').read_text())['nodes']['nixpkgs']['locked']['rev'] == PIN
+ snapshot = subprocess.check_output(['git', 'show', BASE + ':tests/cxml-probe.lisp'], cwd=ROOT).decode()
+ original_evidence = json.loads(command(['git', 'show', BASE + ':reports/slice-19d0/execution.json']))
+ expected_checks = set(original_evidence['xmlRuns'][0]['checks'] + original_evidence['xmlRuns'][0]['failedChecks'])
+ protected = {str(p.relative_to(ROOT)): sha(p)
+ for directory in ['vendor/cxtm', 'references', 'reports/slice-19d0']
+ for p in (ROOT / directory).rglob('*') if p.is_file()}
+ files = ['flake.nix', 'flake.lock', 'topic-maps.asd', 'scripts/prepare-cxml.py',
+ 'scripts/validate-cxml-19d0b.py', 'tests/cxml-probe.lisp',
+ 'tests/cxml-encoding-regressions.lisp', 'src/xml/package.lisp', 'src/xml/parser.lisp',
+ 'patches/cxml-19d0b.patch', 'patches/closure-common-19d0b.patch',
+ 'README.md', 'docs/slice-19d0b-cxml-encoding.md']
+ source_hashes = {p: sha(ROOT / p) for p in files}
+ cases = failures()
+ with tempfile.TemporaryDirectory(prefix='topic-maps-19d0b-') as temp:
+ temp = Path(temp)
+ patched = []
+ for number in [1, 2]:
+ patched.append(json.loads(command(['python3', str(ROOT / 'scripts/prepare-cxml.py'),
+ '--directory', str(temp / ('sources-' + str(number)))])))
+ assert patched[0]['patches'] == patched[1]['patches']
+ pristine, context = run_lisp(runtime, environment['sourceRegistry'], output, 'original-58', source=snapshot)
+ baseline = checks(pristine, context)
+ assert len(baseline['passedChecks']) == 50 and len(baseline['failedChecks']) == 8
+ assert set(baseline['failedChecks']) == {c['name'] for c in cases}
+ before_result, before_context = run_lisp(runtime, environment['sourceRegistry'], output,
+ 'original-diagnostics', source=diagnostic_source(cases))
+ before = read_diagnostics(before_result, cases)
+ unqualified_source = '''(require :asdf)
+(asdf:load-asd (truename "topic-maps.asd"))
+(asdf:load-system "topic-maps/xml")
+(handler-case
+ (progn (topic-maps.xml:parse-octets
+ (make-array 4 :element-type '(unsigned-byte 8) :initial-contents '(60 114 47 62)) nil)
+ (error "Unpatched dependency unexpectedly accepted"))
+ (topic-maps.xml:unqualified-parser () (format t "UNPATCHED-BOUNDARY-PASS~%")))
+'''
+ unqualified_result, unqualified_context = run_lisp(
+ runtime, environment['sourceRegistry'], output, 'unqualified-boundary', source=unqualified_source)
+ assert unqualified_result.returncode == 0 and b'UNPATCHED-BOUNDARY-PASS' in unqualified_result.stdout
+ raw_result, context = run_lisp(runtime, patched[0]['sourceRegistry'], output,
+ 'patched-original-58', source=snapshot)
+ raw = checks(raw_result, context)
+ assert not raw['failedChecks'] and set(raw['passedChecks']) == expected_checks
+ xml_runs = []
+ for number, provenance in enumerate(patched, 1):
+ result, context = run_lisp(runtime, provenance['sourceRegistry'], output,
+ 'qualified-' + str(number), script=ROOT / 'tests/cxml-probe.lisp')
+ run = checks(result, context)
+ assert not run['failedChecks'] and expected_checks <= set(run['passedChecks'])
+ xml_runs.append(run)
+ assert xml_runs[0]['passedChecks'] == xml_runs[1]['passedChecks']
+ after_result, after_context = run_lisp(runtime, patched[0]['sourceRegistry'], output,
+ 'patched-diagnostics', source=diagnostic_source(cases))
+ after = read_diagnostics(after_result, cases)
+ failure_report = []
+ for c in cases:
+ observation = after[c['name']]
+ assert (observation['outcome'] == 'accepted') == (c['expectedText'] is not None)
+ if c['expectedText'] is not None:
+ assert observation['text'] == c['expectedText']
+ else:
+ assert observation['condition'] == 'WELL-FORMEDNESS-VIOLATION'
+ failure_report.append({k: v for k, v in c.items() if k != 'octets'} | {
+ 'inputOctetsHex': c['octets'].hex(), 'inputLength': len(c['octets']),
+ 'inputSHA256': hashlib.sha256(c['octets']).hexdigest(),
+ 'before': before[c['name']], 'after': observation})
+ (output / 'original-failures.json').write_text(json.dumps(failure_report, ensure_ascii=False, indent=2) + '\n')
+ invocation = ['python3', str(ROOT / 'scripts/validate-slice-19c.py'), '--sbcl', runtime,
+ '--output', str(temp / 'regression')]
+ result = subprocess.run(invocation, cwd=ROOT,
+ env=dict(os.environ, CL_SOURCE_REGISTRY=patched[0]['sourceRegistry'], PYTHONDONTWRITEBYTECODE='1'),
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=180)
+ (output / 'regression-driver.log').write_bytes(result.stdout)
+ assert result.returncode == 0, 'Retained regression failed'
+ regression = json.loads((temp / 'regression/execution.json').read_text())
+ assert regression['importedStatuses'] == {'pass': 204, 'fail': 4, 'unsupported': 0, 'not-run': 65}
+ assert regression['totalLispChecks'] == 12100
+ identical_reports = []
+ for previous in sorted((ROOT / 'reports/slice-19c').glob('*.json')):
+ if previous.name != 'execution.json':
+ assert (temp / 'regression' / previous.name).read_bytes() == previous.read_bytes(), previous.name
+ identical_reports.append(previous.name)
+ for name in ['execution.json', 'tests.log']:
+ shutil.copyfile(temp / 'regression' / name, output / ('regression-' + name))
+ assert not command(['git', 'diff', BASE, '--', 'src/tmdm', 'src/ctm', 'src/cxtm',
+ 'vendor', 'references', 'flake.lock', 'scripts/test.sh'])
+ assert protected == {p: sha(ROOT / p) for p in protected}
+ assert source_hashes == {p: sha(ROOT / p) for p in source_hashes}
+ for package in environment['manifest']:
+ assert command(['nix', 'hash', 'path', '--type', 'sha256', '--base32', package['source']]) == package['sha256']
+ evidence = {'baseCommit': BASE, 'branch': command(['git', 'branch', '--show-current']),
+ 'startedAtUTC': started, 'finishedAtUTC': datetime.datetime.now(datetime.timezone.utc).isoformat(),
+ 'runtime': 'SBCL 2.5.4', 'nixpkgsCommit': PIN, 'nixSystem': system,
+ 'sourceEnvironment': environment, 'sourceSHA256': source_hashes,
+ 'sourceHashesVerifiedBeforeAndAfter': True, 'newDependencyNetworkAcquisitions': 0,
+ 'patchReproducibleAcrossTwoCopies': True, 'patchProvenance': patched,
+ 'temporarySourceContext': 'Effective source copies existed only during these recorded processes; reproduce with prepare-cxml.py.',
+ 'originalQualification': baseline, 'patchedUnmodifiedOriginalQualification': raw,
+ 'originalProbeSHA256': hashlib.sha256(snapshot.encode()).hexdigest(),
+ 'unpatchedBoundaryRefusal': unqualified_context,
+ 'original58ExpectationsChanged': False, 'xmlRuns': xml_runs,
+ 'originalDiagnosticContext': before_context, 'patchedDiagnosticContext': after_context,
+ 'xmlQualification': 'PASS', 'xmlChecksPerRun': len(xml_runs[0]['passedChecks']), 'xmlFailedChecks': 0,
+ 'bindingPublicContract': 'topic-maps.xml:parse-octets; verified patched dependencies; raw octets; mandatory namespace processing and DOCTYPE/entity denial; no caller overrides.',
+ 'regressionChecks': regression['regressionChecks'], 'totalLispChecks': regression['totalLispChecks'],
+ 'importedStatuses': regression['importedStatuses'], 'byteIdenticalRetainedReports': identical_reports,
+ 'newXTMContracts': 0, 'pinnedCorpusAndOriginalArchivesUnchanged': True,
+ 'fullOfflineNixRebuild': 'NOT-RUN; existing Nix artifacts plus offline source patching/ASDF compilation.'}
+ (output / 'execution.json').write_text(json.dumps(evidence, indent=2) + '\n')
+ print(json.dumps({k: evidence[k] for k in ['runtime', 'xmlQualification', 'xmlChecksPerRun',
+ 'xmlFailedChecks', 'original58ExpectationsChanged', 'totalLispChecks', 'importedStatuses']}, indent=2))
+
+
+if __name__ == '__main__':
+ main()
--- /dev/null
+(defpackage #:topic-maps.xml
+ (:use #:cl)
+ (:export #:parse-octets #:doctype-forbidden #:external-resource-forbidden
+ #:unqualified-parser #:denied-system-id))
--- /dev/null
+(in-package #:topic-maps.xml)
+
+(define-condition doctype-forbidden (error) ())
+(define-condition external-resource-forbidden (error)
+ ((system-id :initarg :system-id :reader denied-system-id)))
+(define-condition unqualified-parser (error) ())
+
+(defclass closed-handler (cxml:sax-proxy) ())
+
+(defmethod sax:start-dtd ((handler closed-handler) name public-id system-id)
+ (declare (ignore handler name public-id system-id))
+ (error 'doctype-forbidden))
+
+(defun deny-external-resource (public-id system-id)
+ (declare (ignore public-id))
+ ;; Returning NIL enables CXML's OPEN fallback. Always signal instead.
+ (error 'external-resource-forbidden :system-id system-id))
+
+(defun parse-octets (bytes handler)
+ "Parse XML bytes, returning HANDLER's SAX result. Required XTM boundary.
+No parser options can disable namespace processing or external-resource denial.
+Reject all DOCTYPEs. Do not accept a filename or an already decoded string."
+ (check-type bytes (vector (unsigned-byte 8)))
+ (unless (and (boundp 'cxml::*topic-maps-encoding-patch*)
+ (equal (symbol-value 'cxml::*topic-maps-encoding-patch*) "19d0b-1")
+ (boundp 'runes-encoding::*topic-maps-encoding-patch*)
+ (equal (symbol-value 'runes-encoding::*topic-maps-encoding-patch*) "19d0b-1"))
+ (error 'unqualified-parser))
+ (let ((sax:*namespace-processing* t)
+ (sax:*include-xmlns-attributes* nil)
+ (cxml:*catalog* nil)
+ (cxml:*cache-all-dtds* nil)
+ (cxml:*dtd-cache* (cxml:make-dtd-cache)))
+ (cxml:parse-octets bytes (make-instance 'closed-handler :chained-handler handler)
+ :validate nil :disallow-internal-subset t
+ :entity-resolver #'deny-external-resource)))
--- /dev/null
+;;;; Additional checks. The original 58 check names/expectations are retained.
+(in-package #:topic-maps.cxml-probe)
+
+(defun encoded-document (encoding content &key bom (declaration "UTF-8"))
+ (octets (if declaration
+ (format nil "<?xml version='1.0' encoding='~A'?><r>~A</r>" declaration content)
+ (format nil "<r>~A</r>" content))
+ encoding bom))
+
+(defun bad-content (name content encoding &key bom declaration)
+ (let* ((header (if declaration
+ (format nil "<?xml version='1.0' encoding='~A'?><r>" declaration)
+ "<r>"))
+ (input (concatenate '(vector (unsigned-byte 8))
+ (octets header encoding bom) content (octets "</r>" encoding))))
+ (expect-condition name 'cxml:well-formedness-violation
+ (lambda () (parse-bytes input)))))
+
+(dolist (spec '(("stray-continuation" 128)
+ ("bad-continuation" 195 40)
+ ("overlong-two" 192 175)
+ ("overlong-three" 224 128 175)
+ ("overlong-four" 240 128 128 175)
+ ("encoded-surrogate" 237 160 128)
+ ("above-unicode-limit" 244 144 128 128)
+ ("illegal-leading-f5" 245 128 128 128)
+ ("obsolete-five-byte-form" 248 128 128 128 175)
+ ("obsolete-six-byte-form" 252 128 128 128 128 175)
+ ("illegal-leading-ff" 255)))
+ (bad-content (concatenate 'string "utf8-invalid:" (car spec))
+ (coerce (cdr spec) '(vector (unsigned-byte 8))) :utf-8))
+
+;; EOF is deliberately inside a sequence, rather than followed by XML markup.
+(dolist (bytes '(#(194) #(224 160) #(240 159 166)))
+ (expect-condition (format nil "utf8-truncated:~{~2,'0X~}" (coerce bytes 'list))
+ 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (concatenate '(vector (unsigned-byte 8))
+ (octets "<r>") bytes)))))
+
+(dolist (encoding '(:utf-16le :utf-16be))
+ (let* ((le (eq encoding :utf-16le))
+ (label (if le "le" "be")))
+ (dolist (spec (if le
+ '(("isolated-low" 0 220) ("high-then-letter" 0 216 65 0)
+ ("high-then-high" 0 216 0 216))
+ '(("isolated-low" 220 0) ("high-then-letter" 216 0 0 65)
+ ("high-then-high" 216 0 216 0))))
+ (bad-content (concatenate 'string "utf16-invalid:" label ":" (car spec))
+ (coerce (cdr spec) '(vector (unsigned-byte 8))) encoding :bom t))
+ (dolist (spec (if le '(("odd-octet" 65) ("unfinished-high" 0 216))
+ '(("odd-octet" 65) ("unfinished-high" 216 0))))
+ (expect-condition (concatenate 'string "utf16-truncated:" label ":" (car spec))
+ 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (concatenate '(vector (unsigned-byte 8))
+ (octets "<r>" encoding t)
+ (coerce (cdr spec) '(vector (unsigned-byte 8))))))))))
+
+(dolist (encoding '(:utf-8 :utf-16le :utf-16be))
+ (let* ((bom (not (eq encoding :utf-8)))
+ (declaration (if bom "UTF-16" "UTF-8"))
+ (characters (coerce (mapcar #'code-char '(#xD7FF #xE000 #xFFFD #x10000 #x10FFFF)) 'string)))
+ (check-decoded-text (format nil "scalar-boundaries:~A" encoding)
+ (encoded-document encoding characters :bom bom :declaration declaration)
+ characters)
+ (check-decoded-text (format nil "line-ending-normalization:~A" encoding)
+ (encoded-document encoding (format nil "a~C~Cb~Cc" #\Return #\Newline #\Return)
+ :bom bom :declaration declaration)
+ (format nil "a~%b~%c"))
+ ;; Cross the parser's 8192-byte refill with a multi-unit scalar.
+ (dolist (length '(8189 8190 8191 8192))
+ (let ((content (concatenate 'string (make-string length :initial-element #\x) "🦊水")))
+ (check-decoded-text (format nil "refill:~A:~D" encoding length)
+ (encoded-document encoding content :bom bom :declaration declaration)
+ content)))))
+
+;; Signatures alone do not authorize silently treating generic UTF-16 as LE/BE.
+(dolist (encoding '(:utf-16le :utf-16be))
+ (dolist (declaration '("UTF-16" nil "UTF-8"))
+ (let ((source (if declaration
+ (format nil "<?xml version='1.0' encoding='~A'?><r/>" declaration)
+ "<?xml version='1.0'?><r/>")))
+ (expect-condition (format nil "bomless-missing-or-wrong-label:~A:~A" encoding declaration)
+ 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (octets source encoding))))))
+ (expect-condition (format nil "bomless-without-declaration:~A" encoding)
+ 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (octets "<r/>" encoding))))
+ (expect-condition (format nil "bomless-pi-without-xml-declaration:~A" encoding)
+ 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (octets "<?pi?><r/>" encoding))))
+ (expect-condition (format nil "bom-declaration-disagreement:~A" encoding)
+ 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (encoded-document encoding "x" :bom t :declaration "UTF-8"))))
+ (expect-condition (format nil "opposite-endian-declaration:~A" encoding)
+ 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (encoded-document encoding "x"
+ :declaration (if (eq encoding :utf-16le) "UTF-16BE" "UTF-16LE")))))
+ (expect-condition (format nil "explicit-endian-label-with-bom:~A" encoding)
+ 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (encoded-document encoding "x" :bom t
+ :declaration (if (eq encoding :utf-16le) "UTF-16LE" "UTF-16BE"))))))
+(dolist (declaration '("UTF-16" "UTF-16LE" "UTF-16BE" "ISO-8859-1"))
+ (expect-condition (concatenate 'string "utf8-bom-wrong-declaration:" declaration)
+ 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (encoded-document :utf-8 "x" :bom t :declaration declaration)))))
+(expect-condition "unknown-encoding-is-fatal" 'cxml:well-formedness-violation
+ (lambda () (parse-bytes (encoded-document :utf-8 "x" :declaration "x-not-a-real-encoding"))))
+(check-decoded-text "encoding-name-case-insensitive"
+ (encoded-document :utf-16le "🦊" :declaration "utf-16le") "🦊")
+
+;; The public boundary enforces the policy even for a permissive SAX receiver.
+(expect-condition "public-api-rejects-string-input" 'type-error
+ (lambda () (topic-maps.xml:parse-octets "<r/>" nil)))
+(expect-condition "public-api-no-resolver-override" 'program-error
+ (lambda () (uiop:symbol-call :topic-maps.xml :parse-octets
+ (octets "<r/>") nil :entity-resolver (constantly nil))))
+(expect-condition "public-api-guard-with-nil-handler" 'topic-maps.xml:doctype-forbidden
+ (lambda () (topic-maps.xml:parse-octets
+ (octets "<!DOCTYPE r SYSTEM 'file:///tmp/must-not-open'><r/>") nil)))
+(expect-condition "public-resolver-signals" 'topic-maps.xml:external-resource-forbidden
+ (lambda () (topic-maps.xml::deny-external-resource
+ nil (puri:parse-uri "http://127.0.0.1:9/must-not-fetch"))))
+(let ((original (symbol-value 'cxml::*topic-maps-encoding-patch*)))
+ (unwind-protect
+ (progn
+ (setf (symbol-value 'cxml::*topic-maps-encoding-patch*) nil)
+ (expect-condition "public-api-refuses-unqualified-dependency" 'topic-maps.xml:unqualified-parser
+ (lambda () (topic-maps.xml:parse-octets (octets "<r/>") nil))))
+ (setf (symbol-value 'cxml::*topic-maps-encoding-patch*) original)))
+(let ((handler (make-instance 'observation)))
+ (check "public-api-returns-identical-sax-result"
+ (eq handler (topic-maps.xml:parse-octets (octets "<r/>") handler))))
+
+;; Exercise the existing decoder's partial-input contract (no second decoder).
+(dolist (encoding '(:utf-8 :utf-16-little-endian :utf-16-big-endian))
+ (let* ((input (octets "🦊" (ecase encoding (:utf-8 :utf-8)
+ (:utf-16-little-endian :utf-16le)
+ (:utf-16-big-endian :utf-16be))))
+ (output (make-array 8 :element-type '(unsigned-byte 32))))
+ (dolist (end '(1 2 3))
+ (multiple-value-bind (written read)
+ (runes-encoding:decode-sequence encoding input 0 end output 0 8 nil)
+ (check (format nil "decoder-needs-more:~A:~D" encoding end)
+ (and (zerop written) (zerop read))))
+ (expect-condition (format nil "decoder-incomplete-at-eof:~A:~D" encoding end)
+ 'runes-encoding:encoding-error
+ (lambda () (runes-encoding:decode-sequence encoding input 0 end output 0 8 t))))))
(assert (string= (lisp-implementation-version) "2.5.4"))
(assert (asdf:find-system "cxml" nil))
(asdf:load-system "cxml")
+(asdf:load-asd (merge-pathnames "../topic-maps.asd" *load-truename*))
+(asdf:load-system "topic-maps/xml")
(defpackage #:topic-maps.cxml-probe (:use #:cl))
(in-package #:topic-maps.cxml-probe)
(check name (typep condition class))
(format t "CXML-REJECTION ~A ~A~%" name (type-of condition))))
-(define-condition doctype-forbidden (error) ())
+(deftype doctype-forbidden () 'topic-maps.xml:doctype-forbidden)
(define-condition external-resource-forbidden (error)
((system-id :initarg :system-id :reader denied-system-id)))
(define-condition fallback-reached (error) ())
(defmethod sax:start-dtd ((handler observation) name public-id system-id)
(declare (ignore name public-id system-id))
- (unless (allow-doctype handler) (error 'doctype-forbidden)))
+ (unless (allow-doctype handler) (error 'topic-maps.xml:doctype-forbidden)))
(defun deny-external-resource (public-id system-id)
(declare (ignore public-id))
(error 'external-resource-forbidden :system-id system-id))
(defun parse-bytes (bytes &key resolver-probe)
+ (unless resolver-probe
+ (return-from parse-bytes
+ (topic-maps.xml:parse-octets bytes (make-instance 'observation))))
(let ((sax:*namespace-processing* t)
(sax:*include-xmlns-attributes* nil)
(cxml:*catalog* nil)
(check "exactly-one-fallback-only-in-nil-counterprobe" (= *fallback-calls* 1)))
(setf (fdefinition 'cxml::uri-to-pathname) original)))
+(load (merge-pathnames "cxml-encoding-regressions.lisp" *load-truename*))
+
(format t "CXML-SUMMARY ~D PASS ~D FAIL~%"
(- (length *checks*) (length *failed-checks*)) (length *failed-checks*))
(when *failed-checks* (uiop:quit 1))
;;;; The foundation remains independent; reader/model are opt-in secondary systems.
+(asdf:defsystem "topic-maps/xml"
+ :description "Pinned, patched CXML byte boundary with mandatory external-resource denial; no XTM"
+ :version "0.0.1" :license "MIT" :depends-on ("cxml") :serial t
+ :components ((:file "src/xml/package") (:file "src/xml/parser")))
+
(asdf:defsystem "topic-maps"
:description "Independent CTM test foundation; no parsing or deserialization"
:version "0.0.0"