feat: zipped packages, target set, checklists, audit fixes and a stress test

Features for the next six months (accessible HTML export, paperpack and
Lode on packages, the personal bundle):

- Zipped packages: the oracle writes and reads `.sct.zip` archives under
  the rules of spec/12 §12.2; validate.py and load.py accept them; a
  byte-identical zip of the tiny package joins the fixtures, and two
  broken archives (traversal, symbolic link) join fixtures/invalid.
- The target set of targeted F3 (spec/08 §8.10) is computed by the
  oracle and pinned by vectors/targets.jsonl under each digit rule; the
  rule now covers cells as well as sentences and the leaves of anchored
  containers, and defines a node's section.
- scienting-checklist/1 (provisional): a conformance check of an export,
  covered by a receipt as ["checklist", id, hash] (spec/08 §8.11), with a
  WCAG 2.1 AA fixture and its receipt.
- QA reports are signed like receipts (spec/08 §8.9).
- A `description` annotation body with role alt or long, so an
  accessible export can find a confirmed figure description; the layer
  fixture carries one, and the store's body-kind constraint allows it.
- scienting-spot-check/1, the seed payload, is registered with a schema.
- exercise, submission and grade are provisional until a course has
  used them.

Audit fixes, each with a vector or a broken package where one was
missing:

- Folder packages: symbolic links are refused on validate and load,
  manifest paths must not collide under case folding, listed files are
  matched by exact name, files are hashed in chunks under a size limit.
- Files are compared byte for byte, so CR LF, a byte order mark, NaN,
  a lone surrogate or invalid UTF-8 is refused instead of translated;
  integers beyond 2^53 are read as doubles, as canonical JSON writes them.
- Receipts: signature.key must equal by and the key must be valid when
  signed; a qa receipt's nodes must be the sample at the original's
  hashes, its scope must name qa.of, its errors must be sampled nodes;
  statuses are computed once, iteratively, so chains of spot-checks
  hundreds deep settle; Base64 and manifest shape errors become refusals
  instead of tracebacks; counts and the fidelity of roster-less packages
  are recomputed.
- The gate enforces rule 11 of spec/11 §11.4: changed nodes are
  validated against the node schema and the references between nodes
  are checked, so a set to a bad value, an insert with unknown
  properties or a delete of a referenced header cell is refused; a
  relabel to null drops the label; a reclassify drops foreign
  attributes; a split strips whitespace across runs; ids.jsonl order
  follows spec/04 §4.4 in every state; a move after itself is refused.
- Anchors: the relabel rule requires that nothing else changed below the
  node; an alias chain ending in a deletion no longer crashes resolve.
- Notation: a script after an empty group applies to the previous atom
  ({}^{14}C); letters are defined by Unicode block in spec/05 §5.4 and
  the oracle; \left) is complex.
- Page fingerprints delete whitespace before folding, so "10 -20" and
  "10-20" fold alike (spec/07 §7.1).
- Grades are summed with exact decimals; the reviewer error bound is
  computed with integer arithmetic.
- receipts and revocations are keyed by (doc_key, id) in SQL, since one
  revocation may be carried by several packages.

Checking:

- tools/stress.py: seeded randomized property tests over canonical JSON,
  normalization, notation, random correction walks, anchor resolution,
  Merkle roots, spot-check samples, error bounds, fingerprints, mutated
  archives and packages, rights and spot-check chains; CI runs it.
- check.py verifies every count and version the prose states against
  the repository, the zipped fixture and crafted archives, the checklist
  coverage, and nine more broken packages.
- CONTRIBUTING.md gains a release checklist.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

tools/oracle/notation.py

@@ -79,14 +79,19 @@ class NotSimple(Exception):
     pass
 
 
+# The Latin and Greek letter blocks of spec/05 \u00a75.4: Basic Latin through Latin Extended-B, Greek and Coptic without
+# the Coptic letters, Latin Extended Additional, and Greek Extended.
+LETTER_RANGES = ((0x0041, 0x024F), (0x0370, 0x03E1), (0x03F0, 0x03FF), (0x1E00, 0x1EFF), (0x1F00, 0x1FFF))
+
+
 def is_letter(ch):
-    """A Latin or Greek letter, or the micro sign."""
+    """A letter of General Category L in the Latin or Greek blocks, or the micro sign."""
     if ch == "\u00b5":
         return True
     if not unicodedata.category(ch).startswith("L"):
         return False
-    name = unicodedata.name(ch, "")
-    return name.startswith("LATIN ") or name.startswith("GREEK ")
+    cp = ord(ch)
+    return any(lo <= cp <= hi for lo, hi in LETTER_RANGES)
 
 
 def fold_char(ch):
@@ -222,9 +227,9 @@ class _TexParser:
             elif kind == "ch" and val == "{":
                 inner = self.seq(True)
                 nxt = self.peek()
-                if nxt in (("ch", "_"), ("ch", "^")) and len(inner) != 1:
+                if nxt in (("ch", "_"), ("ch", "^")) and len(inner) > 1:
                     raise NotSimple("script on a multi-atom group")
-                atoms.extend(inner)
+                atoms.extend(inner)  # an empty group leaves a following script to the previous atom or an empty base
             else:
                 atoms.extend(self.command_or_char(kind, val))
 
@@ -245,7 +250,7 @@ class _TexParser:
             return self.arg()
         if val in ("left", "right"):
             tok = self.take()
-            if tok in (("ch", "("), ("ch", ")")):
+            if tok == ("ch", "(" if val == "left" else ")"):
                 return [Atom(tok[1])]
             raise NotSimple("\\left or \\right with another delimiter")
         raise NotSimple("command \\" + val)