Multi-scroll support: build.py and fetch.py take any open-data scroll (per-scroll voxel size, X-ray scan, renumbering by radius, optional ink, a second 1 um ink layer), make_manifest.py, the scroll picker's prize eligible badge and eligible-only toggle (window.unrollScrolls), and a 'Why N ink layers?' box written from each manifest's ink layers

.gitattributes

@@ -148,3 +148,4 @@ data/hi/w058_gpu.jpg filter=lfs diff=lfs merge=lfs -text
 data/gpu/w059.jpg filter=lfs diff=lfs merge=lfs -text
 data/hi/w059_gpu.jpg filter=lfs diff=lfs merge=lfs -text
 data/bench/*.png filter=lfs diff=lfs merge=lfs -text
+data/PHerc*/**/*.jpg filter=lfs diff=lfs merge=lfs -text

app.js

@@ -169,12 +169,57 @@ $('loader').querySelector('.mono').textContent = D?.loaderKicker || `${MAN.name.
   credit.innerHTML = `Data ${link(cr.text || MAN.name, cr.url)}${dt.license ? ` · ${link(dt.license, dt.url)}` : ''}${TRUSTED ? '' : ' · <span class="local-tag">local, not uploaded</span>'}`;
 
   // the scroll picker: hidden while there is only one scroll to choose from
+  // each registry entry may carry prize: { eligible, sets }, mirroring the badge on scrollprize.org's data browser
   const sel = $('scrollSel');
-  const opts = REG.scrolls.map((x) => [x.id, x.name || x.id]).concat(LOCALS.map((x) => [x.key, `${x.name} (local)`]));
-  for (const [k, n] of opts) { const o = document.createElement('option'); o.value = k; o.textContent = n; sel.appendChild(o); }
-  sel.value = SCROLL_KEY;
+  const isEligible = (k) => !!(REG.scrolls.find((x) => x.id === k)?.prize?.eligible);
+  const opts = REG.scrolls.map((x) => [x.id, `${x.name || x.id}${x.prize?.eligible ? ' 🏆' : ''}`]).concat(LOCALS.map((x) => [x.key, `${x.name} (local)`]));
+  let onlyEligible = params.get('prize') === '1';
+  const fill = () => {
+    sel.innerHTML = '';
+    for (const [k, n] of opts) {
+      if (onlyEligible && !isEligible(k) && k !== SCROLL_KEY) continue;
+      const o = document.createElement('option'); o.value = k; o.textContent = n; sel.appendChild(o);
+    }
+    sel.value = SCROLL_KEY;
+  };
+  fill();
   $('scrollPick').hidden = opts.length < 2;
   sel.onchange = () => switchScroll(sel.value);
+  const badge = $('prizeBadge'), cur = REG.scrolls.find((x) => x.id === SCROLL_KEY);
+  badge.hidden = !isEligible(SCROLL_KEY);
+  if (cur?.prize?.sets?.length) badge.dataset.sets = cur.prize.sets.join(', ');
+  const tog = $('prizeOnly');
+  tog.hidden = !REG.scrolls.some((x) => x.prize?.eligible);
+  tog.setAttribute('aria-pressed', String(onlyEligible));
+  const setOnly = (v) => { onlyEligible = !!v; tog.setAttribute('aria-pressed', String(onlyEligible)); tog.classList.toggle('on', onlyEligible); fill(); };
+  setOnly(onlyEligible);
+  tog.onclick = () => setOnly(!onlyEligible);
+  window.unrollScrolls = {
+    list: () => REG.scrolls.map((x) => ({ id: x.id, name: x.name, prizeEligible: !!x.prize?.eligible, prizeSets: x.prize?.sets || [] })),
+    current: () => SCROLL_KEY,
+    isPrizeEligible: (id = SCROLL_KEY) => isEligible(id),
+    setPrizeEligibleOnly: setOnly,
+    prizeEligibleOnly: () => onlyEligible,
+    visible: () => [...sel.options].map((o) => o.value),
+    open: (id) => switchScroll(id),
+  };
+}
+// the text for the "Why N ink layers?" box, from a list of ink layers (role ink or overlay); null for fewer than two
+function inkLayerWhy(inks) {
+  if (inks.length < 2) return null;
+  const words = ['no', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten'];
+  const n = words[inks.length] || String(inks.length);
+  const plain = (t) => String(t || '').replace(/<[^>]*>/g, '');
+  const parts = inks.map((l) => {
+    const res = l.resolutionUM ? ` on the ${l.resolutionUM} µm scan` : '';
+    return `${plain(l.label)}: ${plain(l.why || `${l.source || 'ink detection'}${res}`)}.`.replace(/\.\.$/, '.');
+  });
+  const r = inks.map((l) => l.resolutionUM).filter((x) => x > 0);
+  let tail = '';
+  if (r.length > 1 && Math.max(...r) / Math.min(...r) >= 1.5) {
+    tail = ` The finest is ${Math.min(...r)} µm and the coarsest ${Math.max(...r)} µm, about ${Math.round(Math.max(...r) / Math.min(...r))}x apart: finer scans give sharper ink, coarser ones show what cheaper scans can recover.`;
+  }
+  return { summary: `Why ${n} ink layers?`, text: `This scroll has ${n} ink layers. ${parts.join(' ')}${tail}` };
 }
 function switchScroll(key) {
   const h = new URLSearchParams(key && key !== DEFAULT_ID ? { s: key } : {});
@@ -183,7 +228,7 @@ function switchScroll(key) {
 }
 const OPEN = setupOpenOwn({ $, onOpen: switchScroll, currentKey: SCROLL_KEY });
 $('btnOpen').onclick = () => { lastOpener = $('btnOpen'); OPEN.open(); };
-window.__unroll = { scroll: () => ({ key: SCROLL_KEY, id: MAN.id, trusted: TRUSTED, windings: IDS, layers: MAN.layers.map((l) => l.role) }), open: OPEN };
+window.__unroll = { scroll: () => ({ key: SCROLL_KEY, id: MAN.id, trusted: TRUSTED, windings: IDS, layers: MAN.layers.map((l) => l.role), inkLayers: MAN.layers.filter((l) => l.role !== 'ct').length, prizeEligible: window.unrollScrolls?.isPrizeEligible() || false }), open: OPEN, scrolls: window.unrollScrolls, inkLayerWhy };
 
 let M, binBuf = null, texInk, texCT, MESHB = null;
 const blankImg = () => { const c = document.createElement('canvas'); c.width = c.height = 4; return c; };
@@ -779,8 +824,13 @@ for (const b of document.querySelectorAll('.chip[data-layer]')) {
   };
 }
 $('layerHint').textContent = LAYER_HINTS[layer] || '';
-$('layerWhy').hidden = !(L_OV && (D?.layerWhy || L_OV.why));
-if (!$('layerWhy').hidden) $('layerWhy').querySelector('p').textContent = D?.layerWhy || L_OV.why;
+// "Why N ink layers?": written from the manifest's own ink layers, so the count and the wording always match the scroll
+{
+  const inks = MAN.layers.filter((l) => l.role === 'ink' || l.role === 'overlay');
+  const why = inkLayerWhy(inks);
+  $('layerWhy').hidden = !why;
+  if (why) { $('layerWhy').querySelector('summary').textContent = why.summary; $('layerWhy').querySelector('p').textContent = why.text; }
+}
 if (L_OV && OV_IDS.size) {
   $('gpuChip').hidden = false;
   const band = document.createElement('div');

index.html

@@ -83,7 +83,7 @@ if (!/(^|[#&])s=/.test(location.hash)) ['scrolls/index.json', 'scrolls/PHerc0139
   <div class="mono dim kicker">PHERC. 0139 <span class="sep">/</span> HERCULANEUM <span class="sep">/</span> BURIED 79 CE</div>
   <h1>Unroll a scroll nobody has opened in <em>1,947 years.</em></h1>
   <p class="lede">37 of its windings have been traced through X‑ray CT by the Vesuvius Challenge, and neural networks found the ink on them. Drag to look around. Scrub to unroll.</p>
-  <div class="scroll-pick" id="scrollPick" hidden><label class="mono dim" for="scrollSel">SCROLL</label> <select id="scrollSel"></select></div>
+  <div class="scroll-pick" id="scrollPick" hidden><label class="mono dim" for="scrollSel">SCROLL</label> <select id="scrollSel"></select> <a class="prize-badge" id="prizeBadge" hidden href="https://scrollprize.org/prizes" target="_blank" rel="noopener" title="An open Vesuvius Challenge prize can be won on this scroll. See the prizes page">🏆 prize eligible</a> <button class="chip prize-only" id="prizeOnly" hidden aria-pressed="false" title="Show only scrolls marked prize eligible on scrollprize.org">🏆 prize eligible only</button></div>
 </header>
 
 <nav class="hud tr" aria-label="Layers">

scrolls/PHerc0139/manifest.json

@@ -47,7 +47,8 @@
    "notes": "ink: Vesuvius Challenge public detection on the 2.399 µm scan",
    "source": "Vesuvius Challenge public ink detection (ink-detection/downsampled)",
    "resolutionUM": 2.399,
-   "atlasFallback": "data/atlas_ink.jpg"
+   "atlasFallback": "data/atlas_ink.jpg",
+   "why": "the Vesuvius Challenge result on the fine 2.4 µm scan"
   },
   {
    "id": "gpu",
@@ -70,7 +71,8 @@
    "bandTitle": "Windings inked by our ink model (9 µm)",
    "source": "scrollprize/ink_9um (seed 42, step 75000) run on Hugging Face ZeroGPU (w046 to w051) and Modal (the other windings); per-run receipts in data/gpu/receipts/",
    "resolutionUM": 9.362,
-   "aboutHtml": "<b>Our ink model (9 µm)</b>, the cyan band, is ours. We ran the public <a href=\"https://huggingface.co/scrollprize/ink_9um\" target=\"_blank\" rel=\"noopener\">scrollprize/ink_9um</a> model over windings {windings}. The first batch was 37,141 patches in 57 s of measured GPU time on half an NVIDIA RTX PRO 6000 Blackwell. It reads the 9.362 µm scan, about four times coarser than the 2.4 µm scan behind the amber layer, so its ink map is noisier. w047 and w050 ran with patch overlap 0.5; w046, w048, w049 and w051 ran with less overlap, so their 128 px patch grid shows as faint square tiles. That grid is a stitching artifact, not ink. It is included at lower resolution on purpose: it shows what an open model can recover from cheaper, more widely available scans, as a reproducible baseline you can check against the published result. Windings other than w046 to w051 (w023 to w045 and w052 to w059) were run on Modal and agree with the ZeroGPU method to 0.9999 correlation (checked on a w046 rerun). Click a cyan winding to compare the two maps."
+   "aboutHtml": "<b>Our ink model (9 µm)</b>, the cyan band, is ours. We ran the public <a href=\"https://huggingface.co/scrollprize/ink_9um\" target=\"_blank\" rel=\"noopener\">scrollprize/ink_9um</a> model over windings {windings}. The first batch was 37,141 patches in 57 s of measured GPU time on half an NVIDIA RTX PRO 6000 Blackwell. It reads the 9.362 µm scan, about four times coarser than the 2.4 µm scan behind the amber layer, so its ink map is noisier. w047 and w050 ran with patch overlap 0.5; w046, w048, w049 and w051 ran with less overlap, so their 128 px patch grid shows as faint square tiles. That grid is a stitching artifact, not ink. It is included at lower resolution on purpose: it shows what an open model can recover from cheaper, more widely available scans, as a reproducible baseline you can check against the published result. Windings other than w046 to w051 (w023 to w045 and w052 to w059) were run on Modal and agree with the ZeroGPU method to 0.9999 correlation (checked on a w046 rerun). Click a cyan winding to compare the two maps.",
+   "why": "the open ink_9um model run by us on the coarser 9.4 µm scan, so it is blurrier. It shows what an open model can recover from cheaper scans, as a baseline you can check"
   }
  ],
  "credits": {

style.css

@@ -257,3 +257,9 @@ body.destroy.tool-water #gl { cursor: url("data:image/svg+xml,%3Csvg xmlns='http
 .roll-up.on { background: var(--ink); color: var(--bg); border-color: var(--ink); }
 @media (max-width: 720px) { .roll-up { padding: 8px; font-size: 10px; } }
 @media (max-width: 720px) { body.destroy #readout { display: none; } }
+
+.prize-badge { font-size: 11px; color: #f2c66d; border: 1px solid rgba(242,198,109,0.45); border-radius: 999px; padding: 3px 9px; text-decoration: none; white-space: nowrap; }
+.prize-badge:hover { background: rgba(242,198,109,0.12); }
+.scroll-pick .prize-only { font-size: 11px; padding: 3px 9px; }
+.scroll-pick .prize-only.on { border-color: rgba(242,198,109,0.7); color: #f2c66d; }
+.scroll-pick { flex-wrap: wrap; }

tests/e2e_scrolls.py

@@ -0,0 +1,33 @@
+"""Load registry scrolls in headless Chromium and screenshot each one.
+usage: python3 tests/e2e_scrolls.py <base url> <screenshot dir> [id ...]"""
+import json, os, sys
+from playwright.sync_api import sync_playwright
+base, shots, ids = sys.argv[1].rstrip('/') + '/', sys.argv[2], sys.argv[3:]
+os.makedirs(shots, exist_ok=True)
+fails = []
+with sync_playwright() as pw:
+    br = pw.chromium.launch(args=['--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'])
+    for sid in ids:
+        p = br.new_page(viewport={'width': 1440, 'height': 900})
+        errs = []
+        p.on('pageerror', lambda e: errs.append(str(e)))
+        p.goto(f'{base}#s={sid}', wait_until='load')
+        try:
+            p.wait_for_selector('#loader', state='detached', timeout=180000)
+            p.wait_for_timeout(2500)
+            info = p.evaluate('() => ({ s: window.__unroll.scroll(), why: document.querySelector("#layerWhy").hidden ? null : document.querySelector("#layerWhy summary").textContent, badge: !document.querySelector("#prizeBadge").hidden, opts: window.unrollScrolls.visible().length })')
+            p.evaluate('() => window.unrollScrolls.setPrizeEligibleOnly(true)')
+            only = p.evaluate('() => window.unrollScrolls.visible()')
+            p.evaluate('() => window.unrollScrolls.setPrizeEligibleOnly(false)')
+            ok = info['s']['id'] == sid and not errs
+            print(('ok   ' if ok else 'FAIL ') + sid, json.dumps({**info, 's': {k: info['s'][k] for k in ('id', 'layers', 'inkLayers', 'prizeEligible')}, 'nWindings': len(info['s']['windings']), 'eligibleOnly': only}), errs[:2])
+            if not ok: fails.append(sid)
+        except Exception as e:
+            print('FAIL', sid, str(e)[:200], errs[:2]); fails.append(sid)
+        # CDP capture: the page's render loop keeps Playwright's own screenshot waiting under software GL
+        import base64
+        cdp = p.context.new_cdp_session(p)
+        open(f'{shots}/scroll_{sid}.png', 'wb').write(base64.b64decode(cdp.send('Page.captureScreenshot', {'format': 'png'})['data']))
+        p.close()
+    br.close()
+sys.exit(1 if fails else 0)

tools/build.py

@@ -28,11 +28,15 @@ from PIL import Image
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 RAW = os.environ.get("UNROLL_RAW", f"{ROOT}/raw")
 OUT = os.environ.get("UNROLL_OUT", f"{ROOT}/data")
-B = "https://vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com"
-VOX_MM = 0.009362          # 9.362 um scan voxel
+B = "https://vesuvius-challenge-open-data.s3.amazonaws.com"
+SCROLL = os.environ.get("UNROLL_SCROLL", "PHerc0139")
+VOX_MM = float(os.environ.get("UNROLL_VOX_MM", "0.009362"))   # scan voxel of the meshes (9.362 um for PHerc0139)
 CELL_MM = 20 * VOX_MM      # tifxyz scale 0.05: one grid cell is 20 voxels
+CT_RES = os.environ.get("UNROLL_CT_RES", "9.362um")          # surface volume for the X-ray layer (any scan: it is a UV texture)
+NO_INK = os.environ.get("UNROLL_NO_INK") == "1"
+RENUMBER = os.environ.get("UNROLL_RENUMBER") == "1"          # name the windings w001.. by radius, innermost first
 STEP = 3                   # grid decimation for the browser mesh
-PPMM = 7.5                 # atlas pixels per mm
+PPMM = float(os.environ.get("UNROLL_PPMM", "7.5"))   # atlas pixels per mm (lowered for long scrolls)
 ATLAS = 4096
 PAD = 6
 HI_MAX = 2400
@@ -43,13 +47,25 @@ Image.MAX_IMAGE_PIXELS = None
 
 def fetch_ct(w, src, shape_hw):
     """Level-3 X-ray texture (mean of the middle layers) of a winding's 9.362 um surface volume."""
-    cache = f"{RAW}/{w}/ct_l3.npy"
+    cache = f"{RAW}/{src.get('w', w)}/ct_l3.npy"
     if os.path.exists(cache):
         return np.load(cache)
     seg = src["seg"]
-    sv = [s for s in src["sv"] if s.startswith("9.362um")][0]
-    base = f"{B}/PHerc0139/segments/{seg}/surface-volumes/{sv}/3"
+    sv = [s for s in src["sv"] if s.startswith(CT_RES) and "-L1" not in s][0]
+    root = f"{B}/{SCROLL}/segments/{seg}/surface-volumes/{sv}"
+    # the level nearest the grid's size (level 3 for 9 um scans; finer scans need a coarser level)
+    lvl = 3
+    for lv in range(3, 7):
+        try:
+            mt = json.loads(urllib.request.urlopen(f"{root}/{lv}/.zarray").read())
+        except urllib.error.HTTPError:
+            break
+        lvl = lv
+        if mt["shape"][1] <= shape_hw[0] * 8:
+            break
+    base = f"{root}/{lvl}"
     meta = json.loads(urllib.request.urlopen(f"{base}/.zarray").read())
+    assert meta.get("compressor") is None, f"compressed zarr not handled: {meta.get('compressor')}"
     D, H, W = meta["shape"]
     cz, ch, cw = meta["chunks"]
     sep = meta.get("dimension_separator") or "."
@@ -72,7 +88,8 @@ def fetch_ct(w, src, shape_hw):
         else:
             raise OSError(f"could not fetch {url}")
         a = np.frombuffer(raw, np.uint8).reshape(cz, ch, cw)
-        return ij, a[CT_LAYERS[0]:CT_LAYERS[1]].astype(np.float32).mean(0)
+        lo = CT_LAYERS[0] if cz >= 28 else max(0, cz // 2 - 3)
+        return ij, a[lo:lo + (CT_LAYERS[1] - CT_LAYERS[0])].astype(np.float32).mean(0)
 
     with ThreadPoolExecutor(4) as ex:
         for (i, j), tile in ex.map(one, jobs):
@@ -127,7 +144,7 @@ def shelf_pack(sizes, width):
 
 def main():
     os.makedirs(f"{OUT}/hi", exist_ok=True)
-    dirs = sorted(glob.glob(f"{RAW}/w*"))
+    dirs = sorted(glob.glob(f"{RAW}/[ws]*[0-9]"))
     names = [os.path.basename(d) for d in dirs]
     grids, srcs, metas = [], [], []
     for d in dirs:
@@ -136,7 +153,33 @@ def main():
         grids.append((x, y, z, v))
         srcs.append(json.load(open(f"{d}/source.json")))
         metas.append(json.load(open(f"{d}/meta.json")))
+    if RENUMBER:
+        # order by median distance from a first axis fit through all windings: the innermost becomes w001
+        allg = [np.concatenate([g[i][g[3]] for g in grids]) for i in range(3)]
+        ax0, ay0 = np.polyfit(allg[2], allg[0], 1), np.polyfit(allg[2], allg[1], 1)
+        rad = [float(np.median(np.hypot(g[0][g[3]] - np.polyval(ax0, g[2][g[3]]), g[1][g[3]] - np.polyval(ay0, g[2][g[3]]))))
+               for g in grids]
+        order = np.argsort(rad)
+        grids, srcs, metas, dirs = ([L[i] for i in order] for L in (grids, srcs, metas, dirs))
+        names = [f"w{k + 1:03d}" for k in range(len(dirs))]
+        print("renumbered by radius:", [(n, srcs[k]["seg"], round(rad[order[k]])) for k, n in enumerate(names)])
     ax, ay = axis_fit(grids)
+    rad2 = [float(np.median(np.hypot(g[0][g[3]] - np.polyval(ax, g[2][g[3]]), g[1][g[3]] - np.polyval(ay, g[2][g[3]])))) * VOX_MM
+            for g in grids]
+    if RENUMBER:
+        # second pass on the refined axis, so the ids follow the radius exactly
+        order = np.argsort(rad2)
+        grids, srcs, metas, dirs = ([L[i] for i in order] for L in (grids, srcs, metas, dirs))
+        rad2 = [rad2[i] for i in order]
+        ax, ay = axis_fit(grids)
+    print("winding order check (id, median radius mm):", [(n, round(r, 1)) for n, r in zip(names, rad2)])
+    bad = sum(1 for a, b in zip(rad2, rad2[1:]) if b < a)
+    print("radius decreases between consecutive ids:", bad)
+    global PPMM
+    if "UNROLL_PPMM" not in os.environ:
+        cells = sum(g[3].shape[0] * g[3].shape[1] for g in grids) * CELL_MM * CELL_MM
+        PPMM = min(PPMM, float(np.sqrt(0.62 * ATLAS * ATLAS / cells)))
+        print("PPMM", round(PPMM, 3))
     allz = np.concatenate([g[2][g[3]] for g in grids])
     zc = float((allz.min() + allz.max()) / 2)
     cx0, cy0 = float(np.polyval(ax, zc)), float(np.polyval(ay, zc))
@@ -148,11 +191,21 @@ def main():
         H, W = v.shape
         tw, th = int(round(W * CELL_MM * PPMM)), int(round(H * CELL_MM * PPMM))
         sizes[w] = (tw, th)
-        ink = Image.open(f"{d}/ink2um_ds8.jpg").convert("L")
-        ink_tiles[w] = local_contrast(ink.resize((tw, th), Image.LANCZOS), 2.2 * PPMM)
-        hi = ink.copy()
-        hi.thumbnail((HI_MAX, HI_MAX), Image.LANCZOS)
-        hi.save(f"{OUT}/hi/{w}.jpg", quality=84, optimize=True, progressive=True)
+        if not NO_INK:
+            ink = Image.open(f"{d}/ink2um_ds8.jpg").convert("L")
+            ink_tiles[w] = local_contrast(ink.resize((tw, th), Image.LANCZOS), 2.2 * PPMM)
+            hi = ink.copy()
+            hi.thumbnail((HI_MAX, HI_MAX), Image.LANCZOS)
+            hi.save(f"{OUT}/hi/{w}.jpg", quality=84, optimize=True, progressive=True)
+            if SCROLL != "PHerc0139" and os.path.exists(f"{d}/ink1um_ds8.jpg"):
+                # second published ink layer (1.129 um scan): a per-winding overlay texture plus a close-up
+                os.makedirs(f"{OUT}/ink1", exist_ok=True)
+                i1 = Image.open(f"{d}/ink1um_ds8.jpg").convert("L")
+                h1 = i1.copy()
+                h1.thumbnail((HI_MAX, HI_MAX), Image.LANCZOS)
+                h1.save(f"{OUT}/hi/{w}_1um.jpg", quality=84, optimize=True, progressive=True)
+                i1.thumbnail((1200, 1200), Image.LANCZOS)
+                i1.save(f"{OUT}/ink1/{w}.jpg", quality=80, optimize=True, progressive=True)
         ct = fetch_ct(w, src, (H, W))
         valid = ct > 0
         lo, hi_ = np.percentile(ct[valid], [1.5, 99.5]) if valid.any() else (0, 1)
@@ -164,12 +217,15 @@ def main():
     if used > ATLAS:
         sys.exit(f"atlas overflow: {used} px > {ATLAS}; lower PPMM")
     atlas_h = 1 << int(np.ceil(np.log2(used)))
-    atlases = {"ink": Image.new("L", (ATLAS, atlas_h), 0), "ct": Image.new("L", (ATLAS, atlas_h), 0)}
+    atlases = {"ct": Image.new("L", (ATLAS, atlas_h), 0)}
+    if not NO_INK:
+        atlases["ink"] = Image.new("L", (ATLAS, atlas_h), 0)
     for w in names:
-        atlases["ink"].paste(ink_tiles[w], pos[w])
-        atlases["ct"].paste(ct_tiles[w], pos[w])
+        for k in atlases:
+            atlases[k].paste((ink_tiles if k == "ink" else ct_tiles)[w], pos[w])
     for k, im in atlases.items():
         im.save(f"{OUT}/atlas_{k}.jpg", quality=88, optimize=True, progressive=True)
+        im.save(f"{OUT}/atlas_{k}.webp", quality=82, method=6)
     print("atlas", ATLAS, atlas_h, "used rows", used)
 
     # meshes
@@ -187,7 +243,9 @@ def main():
         px = np.where(vs, xs - cx0, 0)
         py = np.where(vs, ys - cy0, 0)
         pz = np.where(vs, zs - zc, 0)
-        arr = np.stack([px, py, pz], -1).round().astype(np.int16)
+        st = np.stack([px, py, pz], -1).round()
+        assert np.abs(st).max() < 32767, "coordinates overflow int16: use a coarser mesh"
+        arr = st.astype(np.int16)
         arr[~vs] = -32768
         b = arr.tobytes()
         blobs.append(b)
@@ -202,17 +260,16 @@ def main():
             "gridH": int(H), "gridW": int(W),
             "offset": offset, "bytes": len(b),
             "widthMM": round(W * CELL_MM, 2), "heightMM": round(H * CELL_MM, 2),
-            "areaCM2": round(meta["area_vx2"] * VOX_MM * VOX_MM / 100, 2),
+            "areaCM2": round((meta["area_vx2"] * VOX_MM * VOX_MM if "area_vx2" in meta else v.sum() * CELL_MM * CELL_MM) / 100, 2),
             "radiusMM": round(float(np.median(r)), 2),
             "atlas": [x0 / ATLAS, y0 / atlas_h, (x0 + tw) / ATLAS, (y0 + th) / atlas_h],
-            "hi": f"hi/{w}.jpg",
-            "ink_source": [f for f, _ in src["ink"] if "2.399um" in f][0],
+            **({} if NO_INK else {"hi": f"hi/{w}.jpg", "ink_source": src.get("ink_ds") or [f for f, _ in src["ink"] if "2.399um" in f][0]}),
             "mesh_source": src["mesh"],
         })
         offset += len(b)
     open(f"{OUT}/scroll.bin", "wb").write(b"".join(blobs))
     manifest = {
-        "scroll": "PHerc0139",
+        "scroll": SCROLL,
         "voxelMM": VOX_MM, "cellMM": CELL_MM,
         "axis": {"centre": [cx0, cy0, zc], "dxdz": ax[0], "dydz": ay[0]},
         "atlas": {"w": ATLAS, "h": atlas_h, "ppmm": PPMM},

tools/fetch.py

@@ -14,10 +14,14 @@ import urllib.parse
 import urllib.request
 from concurrent.futures import ThreadPoolExecutor
 
-B = "https://vesuvius-challenge-open-data.s3.us-east-1.amazonaws.com"
+B = "https://vesuvius-challenge-open-data.s3.amazonaws.com"
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 RAW = os.environ.get("UNROLL_RAW", f"{ROOT}/raw")
-SCROLL = "PHerc0139"
+SCROLL = os.environ.get("UNROLL_SCROLL", "PHerc0139")
+MESH_RES = os.environ.get("UNROLL_MESH_RES", "9.362um")      # which tifxyz to take (the coarse scan keeps int16 coordinates in range)
+MESH_VOL = os.environ.get("UNROLL_MESH_VOL", "")             # optional volume id, when a segment has two meshes at one resolution
+INK_RES = os.environ.get("UNROLL_INK_RES", "")               # which ink preview to call ink2um_ds8.jpg ("" = the non-1.129 um one, newest model)
+NO_INK = os.environ.get("UNROLL_NO_INK") == "1"              # X-ray only: fetch no ink at all
 
 
 def get(url, tries=5):
@@ -73,21 +77,36 @@ def main():
         inv = list(ex.map(segment, segs))
     json.dump(inv, open(f"{RAW}/inv_{SCROLL}.json", "w"), indent=1)
     jobs = []
-    for s in inv:
-        m = re.search(r"-(w\d{3})_", s["seg"])
-        meshes = [x for x in s.get("mesh", []) if "9.362um" in x]
-        if not m or not meshes:
+    named = [re.search(r"-(w\d{3})_", s["seg"]) for s in inv]
+    nums = [m.group(1) for m in named if m]
+    use_w = len(nums) >= 0.8 * len(inv) and len(set(nums)) == len(nums)
+    for s, m in zip(inv, named):
+        if use_w and not m:
             continue
-        w, mesh = m.group(1), meshes[0]
+        meshes = [x for x in s.get("mesh", []) if x.endswith(f"-{MESH_RES}.tifxyz") and MESH_VOL in x]
+        if not meshes:
+            continue
+        inks = sorted(s.get("ink_ds", []))
+        main_ink = [f for f in inks if (INK_RES in f if INK_RES else "1.129um" not in f)]
+        if not NO_INK and not main_ink:
+            print("skip", s["seg"], "(no ink preview)")
+            continue
+        # wNNN when the segment names carry unique winding numbers; otherwise the segment timestamp (build renumbers by radius)
+        w = m.group(1) if use_w else "s" + s["seg"].split("-")[0]
+        mesh = meshes[0]
         d = f"{RAW}/{w}"
         os.makedirs(d, exist_ok=True)
         base = f"{B}/{SCROLL}/segments/{s['seg']}"
         for f in ("x.tif", "y.tif", "z.tif", "meta.json"):
             jobs.append((f"{base}/mesh/{mesh}/{f}", f"{d}/{f}"))
-        for f in s.get("ink_ds", []):
-            tag = "ink1um" if "1.129um" in f else "ink2um"
-            jobs.append((f"{base}/ink-detection/downsampled/{f}", f"{d}/{tag}_ds8.jpg"))
-        json.dump({"seg": s["seg"], "w": w, "mesh": mesh, "sv": s.get("sv"), "ink": s.get("ink")},
+        if not NO_INK:
+            jobs.append((f"{base}/ink-detection/downsampled/{main_ink[-1]}", f"{d}/ink2um_ds8.jpg"))
+            if True:
+                for f in inks:
+                    if "1.129um" in f:
+                        jobs.append((f"{base}/ink-detection/downsampled/{f}", f"{d}/ink1um_ds8.jpg"))
+        json.dump({"seg": s["seg"], "w": w, "mesh": mesh, "sv": s.get("sv"), "ink": s.get("ink"),
+                   "ink_ds": None if NO_INK else main_ink[-1]},
                   open(f"{d}/source.json", "w"), indent=1)
 
     def fetch(job):

tools/make_manifest.py

@@ -0,0 +1,118 @@
+"""Write scrolls/<id>/manifest.json and the registry entry for a scroll built by tools/build.py.
+
+  python tools/make_manifest.py PHerc0814
+
+Text here is our own wording: no titles, authors or work names, nothing copied from the data browser.
+The prize field mirrors the "prize eligible" badge on scrollprize.org (see https://scrollprize.org/prizes).
+"""
+import json
+import os
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CITE = ("Giorgio Angelotti, Stephen Parsons, Sean Johnson, Elian Rafael Dal Prà, Johannes Rudolph, Paul Tafforeau, "
+        "Alessandro Mirone, Paul Henderson, Hendrik Schilling, Forrest McDonald, David Josey, Youssef Nader, C. Seth Parker, "
+        "W. Brent Seales. Vesuvius Challenge - CT Scans of Herculaneum Papyri. Vesuvius Challenge.")
+EDUCELAB = ("EduceLab-Scrolls: Parsons, S., Parker, C. S., Chapman, C., Hayashida, M., & Seales, W. B. (2023). "
+            "EduceLab-Scrolls: Verifiable Recovery of Text from Herculaneum Papyri using X-ray CT. ArXiv [Cs.CV]. "
+            "https://doi.org/10.48550/arXiv.2304.02084. Data used here were obtained from the EduceLab-Scrolls dataset.")
+CHECKED = "2026-10-16"
+
+# per scroll: display name, holder, scan of the meshes, X-ray scan, ink layers, prize sets
+S = {
+    "PHerc0814": dict(name="PHerc. 814", holder="Biblioteca Nazionale di Napoli", vox=9.362, ct=9.362, scan="ESRF",
+                      ink=2.399, ink1=1.129),
+    "PHerc0009B": dict(name="PHerc. 9B", holder="Biblioteca Nazionale di Napoli", vox=8.64, ct=8.64, scan="ESRF", ink=2.401),
+    "PHerc0343P": dict(name="PHerc. 343P", holder="Biblioteca Nazionale di Napoli", vox=8.64, ct=8.64, scan="ESRF", ink=2.215),
+    "PHerc0841": dict(name="PHerc. 841", holder="Biblioteca Nazionale di Napoli", vox=9.366, ct=9.366, scan="ESRF", ink=2.403),
+    "PHerc0172": dict(name="PHerc. 172 (Scroll 5)", holder="Bodleian Library, Oxford", vox=7.91, ct=7.91, scan="Diamond Light Source",
+                      ink=7.91),
+    "PHerc1667": dict(name="PHerc. 1667 (Scroll 4)", holder="Biblioteca Nazionale di Napoli", vox=7.91, ct=2.399, scan="ESRF",
+                      ink=2.399, ink1=1.129, educelab=True),
+    "PHerc1447": dict(name="PHerc. 1447", holder="Biblioteca Nazionale di Napoli", vox=8.64, ct=8.64, scan="ESRF",
+                      prize=["2027 Grand Prize"]),
+    "PHerc0800": dict(name="PHerc. 800", holder="Biblioteca Nazionale di Napoli", vox=8.64, ct=8.64, scan="ESRF",
+                      prize=["2027 Grand Prize", "First Letters"]),
+}
+
+
+def um(x):
+    return f"{x:g} µm"
+
+
+def main(sid):
+    c = S[sid]
+    d = f"data/{sid}"
+    M = json.load(open(f"{ROOT}/{d}/scroll.json"))
+    ids = [w["id"] for w in M["windings"]]
+    n = len(ids)
+    layers = [{
+        "id": "xray", "role": "ct", "label": "X‑ray", "atlas": f"{d}/atlas_ct.webp", "atlasFallback": f"{d}/atlas_ct.jpg",
+        "sizeHint": os.path.getsize(f"{ROOT}/{d}/atlas_ct.webp"),
+        "title": "Raw X-ray CT brightness on each segment. No ink detection.",
+        "hint": "Raw X-ray CT brightness, no ink detection.",
+        "source": f"Vesuvius Challenge surface volumes, {um(c['ct'])} scan", "resolutionUM": c["ct"],
+    }]
+    if c.get("ink"):
+        layers.append({
+            "id": "ink", "role": "ink", "label": f"Published ink ({um(c['ink'])})", "atlas": f"{d}/atlas_ink.webp",
+            "atlasFallback": f"{d}/atlas_ink.jpg", "sizeHint": os.path.getsize(f"{ROOT}/{d}/atlas_ink.webp"),
+            "hi": f"{d}/hi/{{id}}.jpg",
+            "title": f"Vesuvius Challenge's published ink detection on the {um(c['ink'])} scan.",
+            "hint": f"Published ink ({um(c['ink'])}): Vesuvius Challenge detection on the {um(c['ink'])} scan.",
+            "closeupLabel": f"Published ink ({um(c['ink'])})",
+            "source": "Vesuvius Challenge ink detection (ink-detection/downsampled), open data bucket",
+            "resolutionUM": c["ink"],
+        })
+    if c.get("ink1") and os.path.isdir(f"{ROOT}/{d}/ink1"):
+        cov = [i for i in ids if os.path.exists(f"{ROOT}/{d}/ink1/{i}.jpg")]
+        layers.append({
+            "id": "ink1", "role": "overlay", "label": f"Published ink ({um(c['ink1'])})",
+            "windings": cov if len(cov) < n else "all",
+            "texture": f"{d}/ink1/{{id}}.jpg", "hi": f"{d}/hi/{{id}}_1um.jpg", "sizeHint": 400000,
+            "title": f"Vesuvius Challenge's published ink detection on the finer {um(c['ink1'])} scan, on {len(cov)} of {n} segments.",
+            "hint": f"Published ink ({um(c['ink1'])}): Vesuvius Challenge detection on the {um(c['ink1'])} scan, {len(cov)} of {n} segments.",
+            "closeupLabel": f"Published ink ({um(c['ink1'])})", "readoutLabel": "INK 1 µm",
+            "bandTitle": f"Segments with published ink on the {um(c['ink1'])} scan",
+            "source": "Vesuvius Challenge ink detection (ink-detection/downsampled), open data bucket",
+            "resolutionUM": c["ink1"],
+        })
+    notes = ("Meshes, X-ray and ink images come only from the open data bucket vesuvius-challenge-open-data "
+             f"(s3://vesuvius-challenge-open-data/{sid}/), licensed CC BY-NC 4.0: attribution, non-commercial use. "
+             "This page shows images only: no transcriptions or readings of the text.")
+    if c.get("prize"):
+        notes += " This scroll is prize eligible on scrollprize.org; no ink model is run on it here."
+    credits = {"text": "Vesuvius Challenge", "url": f"https://scrollprize.org/data_browser/{sid}", "citation": CITE,
+               "holder": c["holder"]}
+    if c.get("educelab"):
+        credits["citation"] = CITE + " " + EDUCELAB
+    k = len([l for l in layers if l["role"] != "ct"])
+    kind = "X-ray only, no ink layer" if not k else ("one published ink layer" if k == 1 else f"{['', '', 'two', 'three', 'four'][k] if k < 5 else k} published ink layers")
+    man = {
+        "schema": "unroll-scroll/1", "id": sid, "name": c["name"],
+        "description": f"A carbonized Herculaneum papyrus scanned at {c['scan']}. {n} traced segments from the Vesuvius Challenge open data, {kind}.",
+        "voxelMM": c["vox"] / 1000, "base": "../../",
+        "geometry": {"format": "grid-int16", "index": f"{d}/scroll.json", "bin": f"{d}/scroll.bin",
+                     "sizeHint": os.path.getsize(f"{ROOT}/{d}/scroll.bin"),
+                     "source": f"Vesuvius Challenge {um(c['vox'])} tifxyz meshes, decimated by tools/build.py"},
+        "windings": ids, "outermost": "last",
+        "layers": layers,
+        "credits": credits,
+        "dataTerms": {"license": "CC BY‑NC 4.0", "url": "https://creativecommons.org/licenses/by-nc/4.0/", "notes": notes},
+        "notes": "Segment ids w001 and up are ours, ordered by median radius (innermost first); scroll.json keeps each source segment.",
+    }
+    os.makedirs(f"{ROOT}/scrolls/{sid}", exist_ok=True)
+    json.dump(man, open(f"{ROOT}/scrolls/{sid}/manifest.json", "w"), indent=1, ensure_ascii=False)
+    reg = json.load(open(f"{ROOT}/scrolls/index.json"))
+    entry = {"id": sid, "name": c["name"], "manifest": f"scrolls/{sid}/manifest.json",
+             "prize": {"eligible": bool(c.get("prize")), "sets": c.get("prize", []),
+                       "source": "https://scrollprize.org/prizes", "checked": CHECKED}}
+    reg["scrolls"] = [e for e in reg["scrolls"] if e["id"] != sid] + [entry]
+    for e in reg["scrolls"]:
+        e.setdefault("prize", {"eligible": False, "sets": [], "source": "https://scrollprize.org/prizes", "checked": CHECKED})
+    json.dump(reg, open(f"{ROOT}/scrolls/index.json", "w"), indent=1, ensure_ascii=False)
+    print("wrote", sid, n, "segments,", [l["id"] for l in layers])
+
+
+if __name__ == "__main__":
+    main(sys.argv[1])