One page scroll bar and American English

README.md

@@ -40,7 +40,7 @@ SHA-256), so they need no GPU quota; your own layers and From a segment always r
 
 ## For everyone
 
-- **Example**: public, labelled PHerc0841 crops from the Vesuvius Challenge open data, one click, no upload.
+- **Example**: public, labeled PHerc0841 crops from the Vesuvius Challenge open data, one click, no upload.
 - **Your layers**: a ZIP of layer images (`00.tif`, `01.tif`, ...) or a multi-page TIFF, 17 to 65 layers of one
   region, about 320 to 1024 px across at about 9 um.
 - **From a segment**: only have a screenshot of a released segment? Give the segment (`SCROLL/segments/SEGMENT`)
@@ -49,7 +49,7 @@ SHA-256), so they need no GPU quota; your own layers and From a segment always r
 - **What is crackle?**: a short guide to segments, layers, how to make the upload and how to read the answer.
 
 A single image or screenshot uploaded as a picture is refused with the reason: the models read 17 layers at once,
-and on public labelled crops they scored at chance from one layer. Two small models trained on single layers also
+and on public labeled crops they scored at chance from one layer. Two small models trained on single layers also
 failed their preregistered tests (tile AUC 0.57, and 0.48 on two unseen scrolls, against a bar of 0.80).
 
 ## For researchers

VENDORED.md

@@ -1,7 +1,7 @@
 # Copied files
 
-These files are Ink Lens's, copied unchanged from ChaseHendrick/Scrolls `spaces/ink-lens/` at commit c65e8a2
-(21 Oct 2026). Copy them again, never edit them here, so both tools run the same engine, gate and VC3D writer.
+These files are Ink Lens's, copied unchanged from ChaseHendrick/Scrolls `spaces/ink-lens/` at commit 11c0272
+(27 Oct 2026, PR #253). Copy them again, never edit them here, so both tools run the same engine, gate and VC3D writer.
 `tests/test_crackle_vc3d.py` checks every hash below.
 
 `engine.py` and `gate.py` run the readers and the control gate. `inklens.py`, `vc3dout.py`, `volio.py` and
@@ -12,10 +12,15 @@ files and reach the VC3D agent bridge. `samples.json` lists Ink Lens's public op
 
 | File | SHA-256 |
 | --- | --- |
-| engine.py | e47f4224409e066c57e9b107656b6a3b0c2bc0cb0e8ba9b57155f94d280aac5b |
+| engine.py | 280309c7bf86bd2d8c55bb64feb52168cbde230d02912fec72d1288260ccffa7 |
 | gate.py | 1036c20467c0aa1d2e6b4970cdd4be8126aebeb19b70dee497332d29b41ba31b |
 | inklens.py | df8abad85bde87e49a681499a5a6b911a182dc449b9c08174e475182740ca0e5 |
 | vc3dout.py | 6af807cb2e601332efe6bbf122692852aa9e36e3627dd554ec79754e2e2988bd |
 | volio.py | 881c7c1a50a81b93d673b87121abd747ebce1c29a64ca3bf1a527b8e81b8cd1a |
 | bridge.py | 6e1ce10a90d524baf20a861173dab8c7d4cfcf481f9f693f3a54a7cc19840aa0 |
-| samples.json | cf4561eb70fa1a4a9f9743a96775bd8869ef6195bbd39a6a47b7a31363b79ac4 |
+| samples.json | 80dec75266c1095e9cf77e81bea8c0c3c6e8662be5b7ca481a77adb4c94dd161 |
+
+`connect.json`, `connect.html` and `CONNECT.md` (the Connect your tool tab) and `onescroll.html` (the one page scroll
+bar fragment that `app.py` adds to the page head) are copied from ChaseHendrick/Scrolls `spaces/connect/crackle-check/`,
+where public kit's `spaceconnect render` makes them; change them there and copy them again. They are not in the table
+because they change whenever the shared panel does.

app.py

@@ -215,8 +215,8 @@ def check_file(path, um_per_px=None, flip=False, reader=None):
     """Crackle check of one uploaded region of surface layers.
 
     path: a ZIP of layer images, a multi-page TIFF, or an .npz with array 'volume' (layers first, 17 to 65 layers
-    centred on the papyrus surface, 128 to 2048 px a side). A single image is refused with the reason (one layer
-    is not enough). um_per_px: the pixel size of the upload in micrometres (blank or 0: about 9 um, used as it is).
+    centered on the papyrus surface, 128 to 2048 px a side). A single image is refused with the reason (one layer
+    is not enough). um_per_px: the pixel size of the upload in micrometers (blank or 0: about 9 um, used as it is).
     flip: reverse the layer order first. reader: readerv3 (Reader V3, the default), d9v2 or both (maps averaged).
     Returns (answer as Markdown, result dict, overlay preview, maps .npz with float32 forward and reverse and uint8
     kept). Model output, not a reading."""
@@ -293,7 +293,7 @@ def _example(sample_id, reader):
 
 
 def check_example(sample_id="0841-w00", reader=None):
-    """Crackle check of a public example: a 640 px crop of a labelled PHerc0841 segment (not prize-eligible), read
+    """Crackle check of a public example: a 640 px crop of a labeled PHerc0841 segment (not prize-eligible), read
     from the Vesuvius Challenge open-data bucket. sample_id: 0841-w00, 0841-ag896 or 0841-ag405. reader: readerv3
     (default), d9v2 or both. Same returns as /check. Results are cached per sample and reader. Model output."""
     out = _example(sample_id, reader)
@@ -324,7 +324,7 @@ def check_segment(segment, volume="", x=0, y=0, size=384, reader=None):
     """Crackle check of a spot on a released segment, for people who have only a screenshot: the Space reads that
     region's layers from the Vesuvius Challenge open-data bucket itself. segment: SCROLL/segments/SEGMENT (or its
     open-data URL). volume: one of the segment's surface volumes (blank: the cheapest usable one, see
-    /list_volumes). x, y: the centre, in that volume's pixels (column, row). size: 320 to 640 px on the readers'
+    /list_volumes). x, y: the center, in that volume's pixels (column, row). size: 320 to 640 px on the readers'
     9.4 um grid. reader: readerv3 (default), d9v2 or both. Same returns as /check. Model output."""
     out = _segment(segment, volume, x, y, size, reader)
     return out["markdown"], out["result"], out["preview"], out["npz"]
@@ -338,7 +338,7 @@ def list_volumes(segment):
 
 
 def list_readers():
-    """The readers this Space offers, with licence, source and what each was held out from, and the examples."""
+    """The readers this Space offers, with license, source and what each was held out from, and the examples."""
     info = {}
     for n in READERS:
         r = engine.READERS.get(n) or koine_engine.KOINE_READERS[n]
@@ -406,6 +406,10 @@ CSS = """
 # The page's outer padding sits outside the block Gradio scopes css= to, so the phone gutter goes in <head>.
 HEAD = """<style>@media (max-width: 600px) { .gradio-container { padding-left: 0 !important; padding-right: 0 !important; }
   .gradio-container > .main { padding-left: 16px !important; padding-right: 16px !important; } }</style>"""
+# One page scroll bar: frames fit their content and the page scrolls (copied from public Scrolls'
+# spaces/connect/crackle-check/, made by kit spaceconnect render; see VENDORED.md).
+ONESCROLL = HERE / "onescroll.html"
+HEAD = HEAD + (ONESCROLL.read_text() if ONESCROLL.exists() else "")
 
 INTRO = """<div class="cc-hero">
 <h1>Crackle Check</h1>
@@ -456,7 +460,7 @@ def idle_html():
     ct, ov = _asset_uri("w00-ct.webp"), _asset_uri("w00-overlay.webp")
     if not (ex and ct and ov):
         return IDLE
-    pair = (_figure(ct, "Grey papyrus CT texture", "Middle CT layer")
+    pair = (_figure(ct, "Gray papyrus CT texture", "Middle CT layer")
             + _figure(ov, "The same CT with amber patches", "Ink signal above the control, in amber"))
     return (f'<div class="cc-verdict cc-idle"><div class="cc-kicker">What an answer looks like</div>'
             f'<div class="word">{ex["answer"]}</div><div class="sub">{ex["title"]}, a public example read by '
@@ -473,10 +477,10 @@ def learn_figures():
     inked, plain = _asset_uri("strip-inked.webp"), _asset_uri("strip-plain.webp")
     if inked and plain:
         out["crackle"] = ('<div class="cc-figs">'
-                          + _figure(inked, "Five grey CT tiles of papyrus at increasing depth",
+                          + _figure(inked, "Five gray CT tiles of papyrus at increasing depth",
                                     "<b>Where the model sees ink</b> (Reader V3) on PHerc0841 w00, one spot at five depths "
                                     "(layers 4 to 24 of 28)", "cc-wide")
-                          + _figure(plain, "Five grey CT tiles of papyrus at increasing depth",
+                          + _figure(plain, "Five gray CT tiles of papyrus at increasing depth",
                                     "<b>Plain papyrus</b> nearby, where it sees none, at the same depths", "cc-wide")
                           + '<div class="cc-cap">Hard to tell apart by eye in any one layer. The texture changes '
                             'through the depth, and the models compare all the layers at once, which is why one '
@@ -487,7 +491,7 @@ def learn_figures():
         uri, ex = _asset_uri(f"{short}-composite.webp"), _examples_info().get(sid)
         if uri and ex:
             tiles.append(_figure(uri, "Four square papyrus panels: CT, CT with amber patches, a score map and its "
-                                      "nearly grey control",
+                                      "nearly gray control",
                                  f"<b>{ex['title']}</b>: {ex['answer']}, {ex['excess']:.1f} x the control. Left to "
                                  "right: CT, kept signal, your order, control", "cc-wide"))
     out["answer"] = (f'<div class="cc-figs">{figures.gauge_svg()}' + "".join(tiles)
@@ -561,7 +565,7 @@ The scans are 3D volumes. A **segment** is one sheet of papyrus traced through t
 `64.tif`). Ink sits in depth, so the models read **17 layers at once**: one screenshot is not enough.
 
 1. Pick a region about 3 to 10 mm across (about 320 to 1024 px at 9 um) on a segment.
-2. Take the same crop from at least 17 layers centred on the surface. From a segment's `layers` folder of 65,
+2. Take the same crop from at least 17 layers centered on the surface. From a segment's `layers` folder of 65,
    layers 22 to 42 work, or send all of them.
 3. ZIP the images, keeping their numbered names, or save them as one multi-page TIFF. Upload it on the Check tab.
 
@@ -585,7 +589,7 @@ scale.
 
 LEARN_FAQ = """## Questions people ask
 
-**Can I upload a screenshot?** Not as a picture. On public labelled crops both models scored at chance from one
+**Can I upload a screenshot?** Not as a picture. On public labeled crops both models scored at chance from one
 layer. Two small models trained on single layers also failed their preregistered tests: tile AUC 0.57, and 0.48 on two
 scrolls the model never saw, both against a bar of 0.80. If the screenshot is from a released segment, use **From a segment** instead: give the segment and the spot,
 and the Space reads the real layers there from the open data.
@@ -611,8 +615,8 @@ def researchers_md():
 
 Each reader runs on your stack in the order sent and with the layers reversed, in one GPU call. d9v2 runs on
 [Ink Lens](https://github.com/ChaseHendrick/Scrolls/blob/main/docs/tools/ink-lens.md)'s engine (128 px patches,
-three 17-layer depth windows when 21 or more layers are sent); Reader V3 runs the team's koine inference (centre 17
-layers, 384 px patches, 50 % overlap, floored Hann blend, robust normalisation), reproduced patch for patch (maps
+three 17-layer depth windows when 21 or more layers are sent); Reader V3 runs the team's koine inference (center 17
+layers, 384 px patches, 50 % overlap, floored Hann blend, robust normalization), reproduced patch for patch (maps
 match koine's own CLI, correlation 1.000). "Both" averages the readers' maps. The gate (`{gate.RULE_ID}`): papyrus
 is the middle layer above its 5th percentile; T is the 99th percentile of the reversed map on papyrus; excess is the
 share of papyrus your order puts above T divided by 1 %. Yes from 3, Maybe from 1.5, Too small under 100,000
@@ -625,11 +629,11 @@ preregistered ranking (0.890 against 0.862 for Reader v2 and 0.861 for d9v2, 21
 ranking's paired rule it was level with Reader v2, and its author benchmarked on PHerc0841 before release, so the
 crops are not unseen by its selection.
 
-| Id | Reader | Licence | Held out | SHA-256 |
+| Id | Reader | License | Held out | SHA-256 |
 | --- | --- | --- | --- | --- |
 {readers}
 
-To add a reader, add an entry with a fixed URL, SHA-256 and licence to Ink Lens's `engine.READERS` (128 px villa
+To add a reader, add an entry with a fixed URL, SHA-256 and license to Ink Lens's `engine.READERS` (128 px villa
 readers) or `koine_engine.KOINE_READERS` (koine readers) and its name to `CRACKLE_READERS`.
 
 ## Measured (Model output, development measurement on public PHerc0841, 21 Oct 2026)
@@ -755,12 +759,12 @@ def build_demo():
                         mode = gr.State("example")
                         with gr.Tabs():
                             with gr.Tab("Example") as tab_ex:
-                                gr.Markdown("A 640 px crop of a public, labelled PHerc0841 segment from the "
+                                gr.Markdown("A 640 px crop of a public, labeled PHerc0841 segment from the "
                                             "Vesuvius Challenge open data. No upload needed.", elem_classes="cc-note")
                                 sid = gr.Dropdown(samples, value=EXAMPLES[0], label="Example")
                             with gr.Tab("Your layers") as tab_up:
                                 gr.Markdown("A ZIP of layer images, one multi-page TIFF, or an .npz with a `volume` "
-                                            "array: 17 to 65 layers centred on the papyrus surface.",
+                                            "array: 17 to 65 layers centered on the papyrus surface.",
                                             elem_classes="cc-note")
                                 f = gr.File(label="Layers", show_label=False,
                                             file_types=[".zip", ".tif", ".tiff", ".npz", ".png", ".jpg", ".jpeg"],
@@ -781,7 +785,7 @@ def build_demo():
                                 with gr.Row():
                                     sx = gr.Number(value=None, label="x (column)", precision=0, minimum=0)
                                     sy = gr.Number(value=None, label="y (row)", precision=0, minimum=0)
-                                gr.Markdown("The centre of the spot, in that surface volume's pixels (a 2.4 um volume "
+                                gr.Markdown("The center of the spot, in that surface volume's pixels (a 2.4 um volume "
                                             "has about four times the pixels of a 9 um one).", elem_classes="cc-caption")
                                 with gr.Accordion("Options", open=False, elem_classes="cc-acc"):
                                     size = gr.Slider(link.MIN_SIDE, link.MAX_SIDE, value=link.SIDE, step=32,

assets/ag896-composite.webp.json

@@ -5,7 +5,7 @@
  "tool": "crackle-check",
  "kind": "figure",
  "caption": "PHerc0841 auto-grown 896, a 640 px public crop, left to right: the middle CT layer; the kept ink signal in amber over it; the model score in the stored layer order; the same with the layers reversed (the control), on one scale, amber above the control's 99th percentile, read by Reader V3. Answer Yes, 28.4 times the control. Model output, not a reading. PHerc0841, segment 20260220214732-auto_grown_20260220144552896, 9.366 um voxels. Data: Vesuvius Challenge, CC BY-NC 4.0.",
- "alt": "Four square papyrus CT panels: plain grey, then with amber patches, then a grey and amber score map, then its nearly all grey control.",
+ "alt": "Four square papyrus CT panels: plain gray, then with amber patches, then a gray and amber score map, then its nearly all gray control.",
  "sources": [
   "https://vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com/PHerc0841/segments/20260220214732-auto_grown_20260220144552896/surface-volumes/9.366um-1.2m-113keV-volume-20250821151531.zarr (crop [2496, 3136, 1600, 2240])",
   "https://huggingface.co/spaces/SharpMeow/crackle-check"

assets/strip-inked.webp.json

@@ -4,7 +4,7 @@
  "tool": "crackle-check",
  "kind": "still",
  "caption": "PHerc0841 w00, the window where the models keep the most ink (192 px at rows 192, columns 64 of the example crop), at layers 4, 9, 14, 19, 24 of 28. The window was chosen from the models' kept map; the picture itself is CT only. PHerc0841, segment 20260220213127-w00, 9.366 um voxels. Data: Vesuvius Challenge, CC BY-NC 4.0.",
- "alt": "Five grey CT tiles of papyrus side by side at increasing depth.",
+ "alt": "Five gray CT tiles of papyrus side by side at increasing depth.",
  "sources": [
   "https://vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com/PHerc0841/segments/20260220213127-w00/surface-volumes/9.366um-1.2m-113keV-volume-20250821151531.zarr (crop [2624, 3264, 2688, 3328])",
   "https://huggingface.co/spaces/SharpMeow/crackle-check"

assets/strip-plain.webp.json

@@ -4,7 +4,7 @@
  "tool": "crackle-check",
  "kind": "still",
  "caption": "PHerc0841 w00, a window of plain papyrus where they keep none (192 px at rows 272, columns 288 of the example crop), at layers 4, 9, 14, 19, 24 of 28. The window was chosen from the models' kept map; the picture itself is CT only. PHerc0841, segment 20260220213127-w00, 9.366 um voxels. Data: Vesuvius Challenge, CC BY-NC 4.0.",
- "alt": "Five grey CT tiles of papyrus side by side at increasing depth.",
+ "alt": "Five gray CT tiles of papyrus side by side at increasing depth.",
  "sources": [
   "https://vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com/PHerc0841/segments/20260220213127-w00/surface-volumes/9.366um-1.2m-113keV-volume-20250821151531.zarr (crop [2624, 3264, 2688, 3328])",
   "https://huggingface.co/spaces/SharpMeow/crackle-check"

assets/w00-composite.webp.json

@@ -5,7 +5,7 @@
  "tool": "crackle-check",
  "kind": "figure",
  "caption": "PHerc0841 w00, a 640 px public crop, left to right: the middle CT layer; the kept ink signal in amber over it; the model score in the stored layer order; the same with the layers reversed (the control), on one scale, amber above the control's 99th percentile, read by Reader V3. Answer Yes, 18.2 times the control. Model output, not a reading. PHerc0841, segment 20260220213127-w00, 9.366 um voxels. Data: Vesuvius Challenge, CC BY-NC 4.0.",
- "alt": "Four square papyrus CT panels: plain grey, then with amber patches, then a grey and amber score map, then its nearly all grey control.",
+ "alt": "Four square papyrus CT panels: plain gray, then with amber patches, then a gray and amber score map, then its nearly all gray control.",
  "sources": [
   "https://vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com/PHerc0841/segments/20260220213127-w00/surface-volumes/9.366um-1.2m-113keV-volume-20250821151531.zarr (crop [2624, 3264, 2688, 3328])",
   "https://huggingface.co/spaces/SharpMeow/crackle-check"

assets/w00-ct.webp.json

@@ -4,7 +4,7 @@
  "tool": "crackle-check",
  "kind": "still",
  "caption": "The middle CT layer of the PHerc0841 w00 example crop. PHerc0841, segment 20260220213127-w00, 9.366 um voxels. Data: Vesuvius Challenge, CC BY-NC 4.0.",
- "alt": "Grey papyrus CT texture.",
+ "alt": "Gray papyrus CT texture.",
  "sources": [
   "https://vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com/PHerc0841/segments/20260220213127-w00/surface-volumes/9.366um-1.2m-113keV-volume-20250821151531.zarr (crop [2624, 3264, 2688, 3328])",
   "https://huggingface.co/spaces/SharpMeow/crackle-check"

assets/w00-overlay.webp.json

@@ -5,7 +5,7 @@
  "tool": "crackle-check",
  "kind": "still",
  "caption": "The middle CT layer of the PHerc0841 w00 example crop with the kept ink signal in amber (Reader V3). Model output, not a reading. PHerc0841, segment 20260220213127-w00, 9.366 um voxels. Data: Vesuvius Challenge, CC BY-NC 4.0.",
- "alt": "Grey papyrus CT texture with amber patches.",
+ "alt": "Gray papyrus CT texture with amber patches.",
  "sources": [
   "https://vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com/PHerc0841/segments/20260220213127-w00/surface-volumes/9.366um-1.2m-113keV-volume-20250821151531.zarr (crop [2624, 3264, 2688, 3328])",
   "https://huggingface.co/spaces/SharpMeow/crackle-check"

crackle.py

@@ -37,10 +37,10 @@ ANSWERS = {
 
 SINGLE_IMAGE = (
     "**One image is not enough to tell.** Crackle is a 3D texture: the ink models read a stack of layers through the "
-    "papyrus surface. Given a single layer, like a screenshot, they score at chance (measured on public labelled "
+    "papyrus surface. Given a single layer, like a screenshot, they score at chance (measured on public labeled "
     "crops), so this tool will not guess. Send the same region as a stack of layers instead: a ZIP of the layer "
     "images (for example 00.tif to 64.tif from a segment's `layers` folder, or from VC3D or `vc_render_tifxyz`), or "
-    "one multi-page TIFF, at least 17 layers centred on the surface. If the picture is from a released segment, the "
+    "one multi-page TIFF, at least 17 layers centered on the surface. If the picture is from a released segment, the "
     "From a segment tab (API /check_segment) reads its layers from the open data for you: give the segment and the "
     "spot.")
 
@@ -72,7 +72,7 @@ def prepare(array, kind, um_per_px=None, flip=False):
         raise CheckError(f"{a.shape[0]} layers: the model reads {engine.DEPTH} layers at once, so send at least "
                          f"{engine.DEPTH} (21 or more lets it average three depth windows)")
     if a.shape[0] > engine.MAX_LAYERS:
-        raise CheckError(f"{a.shape[0]} layers: send at most {engine.MAX_LAYERS}, centred on the papyrus surface")
+        raise CheckError(f"{a.shape[0]} layers: send at most {engine.MAX_LAYERS}, centered on the papyrus surface")
     notes = []
     if flip:
         a = a[::-1]
@@ -102,7 +102,7 @@ def judge(F, R, volume):
 
 
 def preview(volume, kept):
-    """The middle layer in grey with kept ink in amber, RGB uint8."""
+    """The middle layer in gray with kept ink in amber, RGB uint8."""
     ct = volume[volume.shape[0] // 2].astype(np.float32)
     lo, hi = np.percentile(ct, [1, 99])
     g = np.clip((ct - lo) / max(hi - lo, 1e-6), 0, 1)
@@ -133,7 +133,7 @@ def check(array, kind, run, um_per_px=None, flip=False, notes=()):
     return out["markdown"], out["result"], out["preview"]
 
 
-def grey(volume):
+def gray(volume):
     """The middle layer, stretched to its 1st to 99th percentile, as RGB uint8 (the overlay's background)."""
     return preview(volume, np.zeros(volume.shape[1:], np.float32))
 
@@ -159,7 +159,7 @@ def run_check(array, kind, run, um_per_px=None, flip=False, notes=()):
             g = gate.decide(m["forward"], m["reverse"], ct)
             result["per_reader"][name] = {"answer": ANSWERS[g["status"]][0], "excess": g["excess"]}
     kept_u8 = gate.to_u8(kept)
-    return {"markdown": answer(d, hint, notes), "result": result, "preview": preview(stack, kept), "middle": grey(stack),
+    return {"markdown": answer(d, hint, notes), "result": result, "preview": preview(stack, kept), "middle": gray(stack),
             "forward": out["forward"], "reverse": out["reverse"], "kept": kept_u8,
             "figures": figures.compare_html(stack, out["forward"], out["reverse"], d),
             "panels": figures.composite(stack, out["forward"], out["reverse"], kept_u8, d) if d.get("threshold") else None}

crackle_vc3d.py

@@ -169,7 +169,7 @@ def recheck(volume, um_per_px, maps, result):
 # ---------------------------------------------------------------- VC3D files
 
 def resize_nearest(a, shape):
-    """a resampled to shape by nearest neighbour (the run rescales regions far from 9.4 um; the overlay needs the
+    """a resampled to shape by nearest neighbor (the run rescales regions far from 9.4 um; the overlay needs the
     pooled render's grid back)."""
     import numpy as np
     if a.shape == tuple(shape):

engine.py

@@ -3,13 +3,13 @@
 The model is built by villa's own flat ink inference (vesuvius.ink_detection.inference.infer.configure_model, at the
 commit pinned in VILLA_COMMIT) from a checkpoint downloaded by URL and refused unless its SHA-256 matches. The patch
 schedule (128 px patches, stride 64, the last flush with the end), the layer choice (center crop, reversed for the
-control), villa's per-patch robust normalisation and the Hann blend are villa's; two things differ from villa's
+control), villa's per-patch robust normalization and the Hann blend are villa's; two things differ from villa's
 command line, both to fit one ZeroGPU call:
 
-1. the robust normalisation runs batched on the device (robust_torch), checked against villa's CPU function
+1. the robust normalization runs batched on the device (robust_torch), checked against villa's CPU function
    (robust_np is a line-for-line copy of villa's normalize_robust for a patch with no mask; tests/test_inklens.py
    compares them, and compares robust_np with villa's own function when villa is importable);
-2. the maps stay float (0 to 1) instead of villa's uint8 encoding, so the control-set threshold is not quantised.
+2. the maps stay float (0 to 1) instead of villa's uint8 encoding, so the control-set threshold is not quantized.
 
 run_reference() is the same algorithm in numpy with any predict function: the tests run it with a stand-in model,
 and the torch path is checked against it.
@@ -72,7 +72,7 @@ BATCH = 64
 MIN_SIDE, MAX_SIDE = PATCH, 2048
 MIN_LAYERS, MAX_LAYERS = DEPTH, 65
 # One call's duration: a fixed start plus a per-patch allowance, capped. The per-patch figure is an estimate (3 to
-# 6 ms per patch with batched fp16 and normalisation on the GPU) with a margin; every receipt records the measured
+# 6 ms per patch with batched fp16 and normalization on the GPU) with a margin; every receipt records the measured
 # seconds so the first calls calibrate it.
 GPU_START_S, GPU_PER_PATCH_S, GPU_MAX_S = 4.0, 0.012, 40
 
@@ -175,7 +175,7 @@ def passes(windows):
     return [(o, d) for o in WINDOW_OFFSETS[windows] for d in ("forward", "reverse")]
 
 
-# ---------------------------------------------------------------- villa's normalisation, numpy and torch
+# ---------------------------------------------------------------- villa's normalization, numpy and torch
 
 def robust_np(patch):
     """villa's normalize_robust (vesuvius/image_proc/intensity/normalization.py at VILLA_COMMIT) with no mask:
@@ -469,7 +469,7 @@ class Engine:
                 for b0 in range(0, len(coords), batch):
                     chunk = coords[b0:b0 + batch]
                     raw = torch.stack([sub[:, y:y + PATCH, x:x + PATCH] for y, x in chunk])   # (B, 17, 128, 128)
-                    keep = raw.reshape(len(chunk), -1).any(dim=1)   # villa skips all-zero patches, before normalising
+                    keep = raw.reshape(len(chunk), -1).any(dim=1)   # villa skips all-zero patches, before normalizing
                     if not bool(keep.any()):
                         continue
                     if not bool(keep.all()):

figures.py

@@ -1,8 +1,8 @@
 """Crackle Check pictures: the maps beside their control, where the scores fall, and the answer scale (numpy, Pillow).
 
 Everything here draws what the gate already measured; nothing changes the answer. Map tiles are WebP data URIs and
-the charts are inline SVG that take the page's text colour, so they read in light and dark themes alike. The colours
-follow the overlay: grey for CT and for map values under the control's threshold T, copper to amber to ivory above T,
+the charts are inline SVG that take the page's text color, so they read in light and dark themes alike. The colors
+follow the overlay: gray for CT and for map values under the control's threshold T, copper to amber to ivory above T,
 so amber always means "passes the control's 99th percentile". Everything drawn is model output, not a reading.
 """
 
@@ -29,7 +29,7 @@ def ramp(t):
     return np.stack([np.interp(t, xs, [c[i] / 255.0 for _, c in RAMP]) for i in range(3)], -1)
 
 
-def ct_grey(ct):
+def ct_gray(ct):
     """A CT layer stretched to its 1st to 99th percentile, float 0 to 1."""
     ct = np.asarray(ct, np.float32)
     lo, hi = np.percentile(ct, [1, 99])
@@ -37,7 +37,7 @@ def ct_grey(ct):
 
 
 def heat(m, threshold, top, papyrus_mask):
-    """One map as RGB uint8: under T a dim grey that rises with the value, at or above T the copper ramp.
+    """One map as RGB uint8: under T a dim gray that rises with the value, at or above T the copper ramp.
 
     The same T and top are used for a map and its control, so the two tiles are on one scale."""
     m = np.asarray(m, np.float32)
@@ -77,8 +77,8 @@ def gauge_svg(excess=None, width=440):
              f'aria-label="Answer scale: No under 1.5, Maybe 1.5 to 3, Yes from 3 times the control'
              + (f'; this region {_f(excess)} times' if excess is not None else '') + '" '
              'style="width:100%;max-width:560px;height:auto;font:12px ui-sans-serif,system-ui,sans-serif">']
-    for a, b, colour, label in zones:
-        parts.append(f'<rect x="{x(a):.1f}" y="{top}" width="{x(b) - x(a):.1f}" height="{bar}" fill="{colour}" '
+    for a, b, color, label in zones:
+        parts.append(f'<rect x="{x(a):.1f}" y="{top}" width="{x(b) - x(a):.1f}" height="{bar}" fill="{color}" '
                      f'opacity=".8"/>')
         parts.append(f'<text x="{(x(a) + x(b)) / 2:.1f}" y="{top - 7}" text-anchor="middle" fill="currentColor" '
                      f'opacity=".85">{label}</text>')
@@ -102,7 +102,7 @@ def gauge_svg(excess=None, width=440):
 
 
 def histogram_svg(F, R, mask, threshold, width=440, height=170):
-    """Where the scores fall on the papyrus: the control's (reversed) scores in grey, yours in amber, T dashed.
+    """Where the scores fall on the papyrus: the control's (reversed) scores in gray, yours in amber, T dashed.
 
     Bar heights are the share of papyrus pixels per bin on a square-root axis, so the 1 % tail stays visible."""
     f, r = np.asarray(F, np.float32)[mask], np.asarray(R, np.float32)[mask]
@@ -118,14 +118,14 @@ def histogram_svg(F, R, mask, threshold, width=440, height=170):
     X = lambda v: left + pw * (v - lo) / max(hi - lo, 1e-9)  # noqa: E731
     Y = lambda share: top + ph * (1 - np.sqrt(share) / peak)  # noqa: E731
 
-    def bars(h, colour, opacity, inset):
+    def bars(h, color, opacity, inset):
         out = []
         for i, s in enumerate(h):
             if s <= 0:
                 continue
             y = Y(s)
             out.append(f'<rect x="{left + i * bw + inset:.1f}" y="{y:.1f}" width="{max(bw - 2 * inset, 0.5):.1f}" '
-                       f'height="{top + ph - y:.1f}" fill="{colour}" opacity="{opacity}"/>')
+                       f'height="{top + ph - y:.1f}" fill="{color}" opacity="{opacity}"/>')
         return "".join(out)
 
     tx = X(threshold)
@@ -171,10 +171,10 @@ def compare_html(volume, F, R, decision):
                      f'{(share or 0):.1%} of papyrus above T</figcaption></figure>')
     return (f'<div class="cc-figs"><div class="cc-h">The map and its control, on one scale</div>'
             f'<div class="cc-pair">{"".join(tiles)}</div>'
-            '<div class="cc-cap">Amber: model score above T, the level only 1 % of the control passes. Grey: below T. '
+            '<div class="cc-cap">Amber: model score above T, the level only 1 % of the control passes. Gray: below T. '
             'Black: not papyrus.</div>'
             f'<div class="cc-h">Where the scores fall</div>{histogram_svg(F, R, mask, T)}'
-            '<div class="cc-cap">Share of papyrus pixels at each score (square-root scale): the control in grey, your '
+            '<div class="cc-cap">Share of papyrus pixels at each score (square-root scale): the control in gray, your '
             'order in amber. The answer is your share above T divided by the control\'s 1 %. Model output, not a '
             'reading.</div></div>')
 
@@ -183,7 +183,7 @@ def composite(volume, F, R, kept, decision, side=480, gap=12, background=(23, 26
     """CT, the overlay and the two maps in one RGB strip (for the README and the downloads), no text baked in."""
     from PIL import Image
     ct = np.asarray(volume)[np.asarray(volume).shape[0] // 2]
-    g = ct_grey(ct)
+    g = ct_gray(ct)
     mask = gate.papyrus(ct)
     T = decision.get("threshold") or 1.0
     top = float(np.percentile(np.concatenate([F[mask], R[mask]]), 99.8)) if mask.any() else 1.0

koine_engine.py

@@ -3,11 +3,11 @@
 Ink Lens's engine (engine.py, a copied file this folder never edits) runs 128 px villa-flat readers. Koine readers use
 larger patches (Reader V3: 17 x 384 x 384), so they get this small engine with the same contract: run(volume) returns
 {"forward", "reverse", ...} float32 maps in 0 to 1, the reverse map from the same layers in reversed depth order. It
-follows koine's own inference (koine_machines/inference/infer.py at the pinned commit): the centre 17 layers, robust
+follows koine's own inference (koine_machines/inference/infer.py at the pinned commit): the center 17 layers, robust
 or /255 preprocessing per patch, sigmoid of the model's logits, patches at 50 % overlap blended with koine's floored
 Hann map, all-zero patches skipped. The checkpoint is SHA-256 pinned and loaded with torch.load(weights_only=True).
 
-To add a reader, add an entry to KOINE_READERS (a fixed URL, its SHA-256 and licence); app.py lists it.
+To add a reader, add an entry to KOINE_READERS (a fixed URL, its SHA-256 and license); app.py lists it.
 """
 
 from __future__ import annotations
@@ -78,7 +78,7 @@ def _tarball(tmp):
 
 def ensure_koine(cache=engine.CACHE):
     """koine_machines on sys.path (KOINE_SRC, a local ink-detection folder, when set), plus villa's vesuvius package
-    from engine.ensure_villa for the robust normalisation koine imports."""
+    from engine.ensure_villa for the robust normalization koine imports."""
     engine.ensure_villa(cache)
     if os.environ.get("KOINE_SRC"):
         src = Path(os.environ["KOINE_SRC"]).expanduser().resolve()
@@ -167,7 +167,7 @@ class KoineReader:
         depth, patch = self.info["depth"], self.info["patch"]
         if L < depth:
             raise engine.EngineError(f"{L} layers: {self.name} reads {depth}")
-        start = L // 2 - depth // 2               # koine's centre crop (upper centre when uneven)
+        start = L // 2 - depth // 2               # koine's center crop (upper center when uneven)
         sub = vol[start:start + depth]
         ph, pw = max(H, patch), max(W, patch)     # a region smaller than one patch is padded with zeros
         padded = np.zeros((depth, ph, pw), np.uint8)

link.py

@@ -7,7 +7,7 @@ them toward the readers' 9 um grid and hands the stack to the usual check. Nothi
 
   scroll, segment = parse("PHerc0841/segments/20260220213127-w00")      # or a bucket URL, or "PHerc0841 SEGMENT"
   vols = volumes(scroll, segment)                                       # its surface volumes, cheapest first
-  stack, um, note = region(scroll, segment, vols[0]["name"], x, y)      # x, y: the centre, in that volume's pixels
+  stack, um, note = region(scroll, segment, vols[0]["name"], x, y)      # x, y: the center, in that volume's pixels
 """
 
 from __future__ import annotations
@@ -137,7 +137,7 @@ def label(v):
 
 def region(scroll, segment, name, x, y, side=SIDE, fetch=volio._get, opener=volio.open_zarr):
     """(stack uint8 layers x rows x columns on about the 9.4 um grid, um per pixel after pooling, note) for the
-    side x side region centred on column x, row y of the named surface volume (its own pixels). A region that runs
+    side x side region centered on column x, row y of the named surface volume (its own pixels). A region that runs
     past an edge is moved inside it and the note says so."""
     side = int(side)
     if not MIN_SIDE <= side <= MAX_SIDE:
@@ -177,7 +177,7 @@ def region(scroll, segment, name, x, y, side=SIDE, fetch=volio._get, opener=voli
         c = stack.shape[0] // 2
         stack = stack[c - engine.MAX_LAYERS // 2:c - engine.MAX_LAYERS // 2 + engine.MAX_LAYERS]
     moved = (x0 + src // 2, y0 + src // 2) != (x, y)
-    note = (f"open data {scroll}/segments/{segment}/surface-volumes/{name}, centre x {x0 + src // 2}, "
+    note = (f"open data {scroll}/segments/{segment}/surface-volumes/{name}, center x {x0 + src // 2}, "
             f"y {y0 + src // 2}, {src} px at {um} um" + (f", pooled {pool} x {pool} x {pool}" if pool > 1 else "")
             + (" (moved inside the volume's edge)" if moved else ""))
     return np.ascontiguousarray(stack), round(um * pool, 4), note

onescroll.html

@@ -0,0 +1,62 @@
+<!-- space-onescroll:start -->
+<!-- one page scroll bar: written by python -m kit spaceconnect render; do not edit -->
+<style>iframe[srcdoc]{display:block;max-height:none!important}</style>
+<script>
+(function () {
+  if (window.__oneScroll) return;
+  window.__oneScroll = true;
+  var CSS = 'html,body{height:auto!important;min-height:0!important}html{overflow:hidden!important}';
+  function size(f) {
+    var d, st = f.__os;
+    try { d = f.contentDocument; } catch (e) { return; }
+    if (!d || !d.body || st.off) return;
+    var de = d.documentElement, r = Math.ceil(de.getBoundingClientRect().height), over = de.scrollHeight;
+    var ch = f.clientHeight, t = r;
+    if (over > ch + 1) t = Math.max(r, over);
+    else if (r >= st.r) t = Math.max(r, ch);
+    st.r = r;
+    if (Math.abs(t - ch) < 2) return;
+    var now = Date.now();
+    st.n = now - st.t0 < 4000 ? st.n + 1 : 1;
+    if (st.n === 1) st.t0 = now;
+    if (st.n > 40) { st.off = true; f.removeAttribute('scrolling'); var g = d.getElementById('space-onescroll'); if (g) g.remove(); return; }
+    f.style.setProperty('height', t + 'px', 'important');
+  }
+  function attach(f) {
+    var d, st = f.__os;
+    try { d = f.contentDocument; } catch (e) { return; }
+    if (!d || !d.documentElement || st.doc === d) return;
+    st.doc = d; st.r = Infinity; st.n = 0; st.off = false;
+    if (!d.getElementById('space-onescroll')) {
+      var s = d.createElement('style'); s.id = 'space-onescroll'; s.textContent = CSS;
+      (d.head || d.documentElement).appendChild(s);
+    }
+    f.setAttribute('scrolling', 'no');
+    f.style.setProperty('min-height', '0', 'important');
+    f.style.setProperty('max-height', 'none', 'important');
+    var w = d.defaultView, go = function () { size(f); };
+    if (w && w.ResizeObserver) { var ro = new w.ResizeObserver(go); ro.observe(d.documentElement); if (d.body) ro.observe(d.body); }
+    d.addEventListener('load', go, true);
+    go();
+  }
+  function bind(f) {
+    if (f.__os || f.getAttribute('data-scroll') === 'inner') return;
+    try { if (!f.contentDocument) return; } catch (e) { return; }
+    f.__os = {t0: 0, n: 0, r: 0};
+    f.addEventListener('load', function () { attach(f); });
+    if (f.contentDocument.readyState !== 'loading') attach(f);
+    else f.contentDocument.addEventListener('DOMContentLoaded', function () { attach(f); });
+  }
+  function scan() { var fs = document.getElementsByTagName('iframe'); for (var i = 0; i < fs.length; i++) bind(fs[i]); }
+  function start() {
+    scan();
+    new MutationObserver(scan).observe(document.documentElement, {childList: true, subtree: true});
+    window.addEventListener('resize', function () {
+      var fs = document.getElementsByTagName('iframe');
+      for (var i = 0; i < fs.length; i++) if (fs[i].__os) size(fs[i]);
+    });
+  }
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', start); else start();
+})();
+</script>
+<!-- space-onescroll:end -->

samples.json

@@ -1,5 +1,5 @@
 {
- "note": "Public crops of released segments that are not prize-eligible. Ink Lens reads them anonymously from the open-data bucket when someone runs one; nothing is bundled. Crops are (y0, y1, x0, x1) on the segment's 9 um surface volume, the 640 px windows of densest labeled ink used in docs/results.json. A window chosen with the labels gives a development number, not a blind test.",
+ "note": "Public crops of released segments that are not prize-eligible. Ink Lens reads them anonymously from the open-data bucket when someone runs one; nothing is bundled. Crops are (y0, y1, x0, x1) on the segment's 9 um surface volume, the 640 px windows of densest labeled ink used in docs/results.json. A window chosen with the labels gives a development number, not a blind test. scan24: the same segment on its finer scan (about 2.4 um), where every model of the comparison runs: its crop is on the 9.6 um grid (the labels' level 2, the 2.4 um render pooled 4x), centered where the 9 um crop is, by the two canvases' proportions; ct is the scan the 3D models read.",
  "bucket": "https://vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com",
  "samples": [
   {
@@ -11,9 +11,37 @@
    "labels": "ink-labels/2.403um-volume-20260319124803/20260918",
    "tifxyz": "mesh/20260220213127-on-20250821151531-9.366um.tifxyz",
    "um_per_px": 9.366,
-   "surface_shape": [4220, 4760],
-   "crop": [2624, 3264, 2688, 3328],
-   "role": "development"
+   "surface_shape": [
+    4220,
+    4760
+   ],
+   "crop": [
+    2624,
+    3264,
+    2688,
+    3328
+   ],
+   "role": "development",
+   "scan24": {
+    "surface_volume": "surface-volumes/2.403um-0.22m-77keV-volume-20260319124803.zarr",
+    "um_per_px": 2.403,
+    "level0_shape": [
+     16460,
+     18560
+    ],
+    "grid_shape": [
+     4115,
+     4640
+    ],
+    "crop": [
+     2551,
+     3191,
+     2612,
+     3252
+    ],
+    "tifxyz": "mesh/20260220213127-on-20260319124803-2.403um.tifxyz",
+    "ct": "PHerc0841/volumes/20260319124803-2.403um-0.2m-77keV-masked.zarr"
+   }
   },
   {
    "id": "0841-ag896",
@@ -23,9 +51,37 @@
    "surface_volume": "surface-volumes/9.366um-1.2m-113keV-volume-20250821151531.zarr",
    "labels": "ink-labels/2.403um-volume-20260319124803/20260918",
    "um_per_px": 9.366,
-   "surface_shape": [4640, 4720],
-   "crop": [2496, 3136, 1600, 2240],
-   "role": "development"
+   "surface_shape": [
+    4640,
+    4720
+   ],
+   "crop": [
+    2496,
+    3136,
+    1600,
+    2240
+   ],
+   "role": "development",
+   "scan24": {
+    "surface_volume": "surface-volumes/2.403um-0.22m-77keV-volume-20260319124803.zarr",
+    "um_per_px": 2.403,
+    "level0_shape": [
+     18080,
+     18400
+    ],
+    "grid_shape": [
+     4520,
+     4600
+    ],
+    "crop": [
+     2423,
+     3063,
+     1551,
+     2191
+    ],
+    "tifxyz": "mesh/20260220214732-on-20260319124803-2.403um.tifxyz",
+    "ct": "PHerc0841/volumes/20260319124803-2.403um-0.2m-77keV-masked.zarr"
+   }
   },
   {
    "id": "0841-ag405",
@@ -35,9 +91,37 @@
    "surface_volume": "surface-volumes/9.366um-1.2m-113keV-volume-20250821151531.zarr",
    "labels": "ink-labels/2.403um-volume-20260319124803/20260918",
    "um_per_px": 9.366,
-   "surface_shape": [3760, 4900],
-   "crop": [1024, 1664, 2496, 3136],
-   "role": "development"
+   "surface_shape": [
+    3760,
+    4900
+   ],
+   "crop": [
+    1024,
+    1664,
+    2496,
+    3136
+   ],
+   "role": "development",
+   "scan24": {
+    "surface_volume": "surface-volumes/2.403um-0.22m-77keV-volume-20260319124803.zarr",
+    "um_per_px": 2.403,
+    "level0_shape": [
+     14660,
+     19100
+    ],
+    "grid_shape": [
+     3665,
+     4775
+    ],
+    "crop": [
+     990,
+     1630,
+     2424,
+     3064
+    ],
+    "tifxyz": "mesh/20260221022814-on-20260319124803-2.403um.tifxyz",
+    "ct": "PHerc0841/volumes/20260319124803-2.403um-0.2m-77keV-masked.zarr"
+   }
   },
   {
    "id": "0139-w035",
@@ -47,9 +131,37 @@
    "surface_volume": "surface-volumes/9.362um-1.2m-113keV-volume-20250728140407.zarr",
    "labels": "ink-labels/2.399um-volume-20260102150214/20260918",
    "um_per_px": 9.362,
-   "surface_shape": [5820, 5240],
-   "crop": [1920, 2560, 2304, 2944],
-   "role": "training"
+   "surface_shape": [
+    5820,
+    5240
+   ],
+   "crop": [
+    1920,
+    2560,
+    2304,
+    2944
+   ],
+   "role": "training",
+   "scan24": {
+    "surface_volume": "surface-volumes/2.399um-0.22m-78keV-volume-20260102150214.zarr",
+    "um_per_px": 2.399,
+    "level0_shape": [
+     22640,
+     20400
+    ],
+    "grid_shape": [
+     5660,
+     5100
+    ],
+    "crop": [
+     1858,
+     2498,
+     2234,
+     2874
+    ],
+    "tifxyz": "mesh/20260317000000-on-20260102150214-2.399um.tifxyz",
+    "ct": "PHerc0139/volumes/20260102150214-2.399um-0.2m-78keV-masked.zarr"
+   }
   }
  ]
 }

upload.py

@@ -2,7 +2,7 @@
 
 Accepted: a single image (PNG, JPEG, WebP, BMP, one-page TIFF), a multi-page TIFF of surface layers, a ZIP of layer
 images (ordered by the numbers in their names, as villa and VC3D name them: 00.tif, 01.tif, ...), or an .npz with an
-array "volume" (Ink Lens's region format). Colour is turned to grey, 16-bit is scaled to 8-bit. Nothing is kept.
+array "volume" (Ink Lens's region format). Color is turned to gray, 16-bit is scaled to 8-bit. Nothing is kept.
 """
 
 from __future__ import annotations
@@ -25,7 +25,7 @@ class UploadError(ValueError):
 
 
 def to_u8(a):
-    """Grey uint8 from a 2D or (H, W, C) array of any integer or float type."""
+    """Gray uint8 from a 2D or (H, W, C) array of any integer or float type."""
     a = np.asarray(a)
     if a.ndim == 3 and a.shape[-1] in (3, 4):
         rgb_u8 = a.dtype == np.uint8