This instance is a worked example of a general pattern: a knowledge
graph reaching readers the repository never hears about. The pattern is the platform’s —
the skill is kg-to-portal and the process is
kg-to-portal.bpmn. What is on this page is the part only who-iris can
say: which stages are actually built here, with this instance’s own numbers.
A CDN is not a publication host. It is a layer in front of one. PUBLICATION_HOSTS answers what serves the rendering; a cache
answers what stands between the server and the reader. Model the cache as the
host and the published URL becomes the cache’s — then the day the cache changes,
every citation breaks and the old URL stays warm for as long as its TTL says.
This page is served from GitHub Pages and its assets are also reachable through jsDelivr. Both are tool choices. The canonical answer is the one the catalogue records; the CDN is an accelerated route to the same bytes.
| # | Stage | Here |
|---|---|---|
| 1 | Select Everything in this catalogue is publishable, so the editorial cut has never had to refuse anything. An untested filter is not a working one. | partial |
| 2 | Serializekg-export emits the harness graph as JSON-LD; this instance’s catalogue is 235 nodes with 222 item(s). | built |
| 3 | Package There is no manifest. The pages and assets are published individually, so nothing here can detect a file that was removed. | not built |
| 4 | Sign Nothing on this preview site is signed. The catalogue records a sha256 per bitstream, which is a digest and not an attestation — anyone who can change the bytes can change the digest beside them. On the Cloudflare CDN export, each item and each release is signed with a detached JWS (ES256) under a did:web key whose publicKeyJwk.x5c chains to WHO’s signing DID; see below. | not built |
| 5 | Distribute 11 generated page(s) and 172 cover(s) on GitHub Pages, with a jsDelivr route to the same bytes. | built |
| 6 | Verify No consumer verifies anything, because there is nothing signed to verify. This is the stage that gets dropped, and it is dropped here. | not built |
Constraints need denominators. These are this instance’s, measured at generation time — not quoted, not remembered.
| items | 222 here, of 273,559 upstream | the completeness denominator |
|---|---|---|
| files | 1,057,223 upstream | a different denominator; 3.86 files per item, so a fraction built from the wrong one is wrong by that factor |
| bytes | 31.91 MB held, of 361.55 GiB upstream | the size-gate denominator, and the reason this catalogue is by reference |
| served | 11 page(s), 172 cover(s) | what a publication period would actually move |
| readers | not measured | traffic is bytes × requests, and nothing here counts requests. Unknown rather than assumed — an invented reader count would make every cost figure below it fiction |
did:web + x5c chained to WHO’s signing DIDOwner decision, 2026-10-30 (superseding the earlier GDHCN trustlist sketch):
the IRIS CDN export is signed with a subordinate P-256 key published as a
verificationMethod of a W3C did:web DID document
whose publicKeyJwk.x5c certificate chain ends at WHO’s signing DID
(did:web:raw.githubusercontent.com:WorldHealthOrganization:tng-participants-prod:main:WHO:signing:DID).
No GDHCN trust list is assumed. See
IRIS CDN Exporter: signing options and
IRIS CDN Exporter: processes.
bagit.txt, date-free bag-info.txt, sorted
manifest-sha256.txt, and tagmanifest-sha256.txt).items/<handle>/manifest-sha256.txt and detached signature
manifest-sha256.txt.jws; the release signs
tagmanifest-sha256.txt as tagmanifest-sha256.txt.jws.did:web document from its HTTPS origin, checks that kid is
listed in assertionMethod, verifies the ES256 signature, and validates the
x5c certificate chain up to WHO’s signing-DID public key.A corpus the size of IRIS can only be searched on the client if the client never downloads the whole graph. The platform’s answer is late materialization. The graph is published as three things:
/subgraph/<harness>/<path>/ as
index.jsonld (pointers to its members and child subgraphs) and
index.hydrated.jsonld (every member inline, with metadata only). The root
has the pointer file only, so no single file is ever the whole graph./payload/sha256/<hex>, named by the hash of its
bytes, with a <hex>.json sidecar giving its media type. A node carries a
payload link with sha256 and bytes, so a consumer can
decide whether to fetch before it fetches.<slice>.<sha256>.sqlite3, named by the
hash of its bytes, with a <slice>.sqlite3.json manifest at a fixed path
beside it that names the file. A row holds only the payload
pointer, never the payload. The browser downloads the file, checks its sha256 against the
manifest, imports it into the Origin Private File System, and opens it with the official
SQLite WASM build. Nothing is parsed.The contract is in the kg-export skill, under “Named subgraphs”,
“Payloads” and “Per-slice SQLite”. The procedure is the
slice-sqlite-publish process. This page does not restate that contract’s
rules; where the two differ, the skill is right.
These are the platform’s own slices, not this catalogue’s. They
were measured on 2026-10-03 (bean q8ar). The first open was measured in Chromium
on loopback against a plain static server with no COOP/COEP headers, and includes the download
and the sha256 check.
| slice | file | source as published | first open |
|---|---|---|---|
| beans | 2.83 MB | 4.82 MB of bean files | ~190 ms |
| todos | 0.07 MB | 18 KB of JSON | ~110 ms |
| library | 2.48 MB | 3.59 MB of JSON | ~165 ms |
| kg | 3.40 MB | 3.03 MB of JSON-LD (the whole-repo graph, without bodies) | ~180 ms |
The VFS is opfs-sahpool, running in a Worker. It needs neither
SharedArrayBuffer nor COOP/COEP, which GitHub Pages cannot send. Reopening from OPFS took about
85 ms, with no download. Without a Worker or OPFS, the verified bytes are opened in memory
instead, and the page reports which mode it used.
No who-iris slice is built, and none of these numbers is a who-iris
number. Nothing here was measured against a CDN, either: cdn.jsdelivr.net
is egress-blocked from the container that generates this page.
As built: the budget is about 5 MB per file
(SIZE_BUDGET_BYTES). It is reported in the manifest as overBudget
and is not gated. The process says what to do over budget: try the no-body variant first, then
stop and report the measurement. All four pilots are under it.
Why IRIS will not fit one slice. This is arithmetic on the pilots, not a
measurement. The pilots hold between 1.1 KB per node
(kg, 3,121 nodes) and 4.0 KB per row
(beans, 723 rows). At those rates, the 273,559 upstream items would make one file of roughly 298 to 1071 MB, before any per-bitstream row. That is about 60 to 214 times the budget.
Recommended, not built: split by subgraph. A slice is one
SliceDef, and nothing in the builder requires a slice to be a whole graph. A
DSpace community or collection is already a directory-shaped subgraph, so the natural cut is
one slice per community or collection. If one of those is still over budget, split it at the
next level down. Do not split by row count: a slice should match a subgraph IRI a reader can
name. Each split slice keeps the full contract, with its own manifest, row digest and
determinism check. A small routing slice would let one search span all of IRIS.
It would hold only titles, identifiers and the subgraph each item belongs to, so the client can
then open the one slice that has the rows. That is the skeleton pattern again, one level up.
| file | as built | recommended behind a CDN |
|---|---|---|
| payload | named by its sha256, so its bytes never change | cache forever (immutable); a new body is a new URL |
| subgraph JSON-LD | a stable IRI whose content changes when the graph does | short TTL; a long one serves an old skeleton whose payload links may have been removed as orphans since |
| slice manifest | <slice>.sqlite3.json at a fixed path; it names the slice file; the client fetches it with no-store | short TTL or none; it is the one file that says which build is current |
| slice file | <slice>.<sha256>.sqlite3, named by its sha256, so its bytes never change; OPFS keys its copy by the same sha256 | cache forever (immutable); a new build is a new URL |
This section has been corrected twice. It first said that only the
manifest needs a short TTL, because the client keys its copy by sha256. That held for the
browser’s OPFS copy, not for a CDN: the slice file was then published at the same path
every build, so a CDN could serve old bytes against a new manifest, the client would refuse
them on the sha256 check, and search was down until the cache expired. That is now fixed
(bean wixl). The slice file is published at
assets/slices/<slice>.<sha256>.sqlite3, and the manifest’s
file names it. A fresh manifest names a file no cache has seen. A stale one names
an older file that still matches it.
Why not under /payload/sha256/: a payload is a node’s
body, linked from that node and removed once nothing links to it. A slice file is linked from
no node, so the payload tree would treat it as an orphan. It takes the payload rule that
matters, immutable bytes at a hash-named address, without joining that tree.
What a CDN can still hold, as built: for one manifest TTL, a stale
manifest together with the older file it names, which is a consistent pair. It can also hold
an older file that nothing names until that file expires, or a stale manifest whose file the
origin has stopped serving. The page reports that last case as a 404 and asks for a reload. A
manifest that names a file with a different sha256 is refused with a visible
message, never opened. Each deploy writes only the current file. Old ones do not pile up on
the host. GitHub Pages sends max-age=600 for every file and cannot be told to send
anything else, so on Pages the manifest’s short TTL is ten minutes.
No CDN layer has been chosen (bean l9v6, still proposed). Whichever
one is chosen stands in front of the publication host, as above. The slice files and
payloads go out through the same publish-to-CDN step as every other page (bean
7dek, Process_RenderKgToCdn), behind the same four gates (bean
xies). The URL-layout check that xies asks for must therefore cover
/payload/sha256/ and assets/slices/ too.
As built: assets/slices/index.json
(folio-slice-index/v1) lists every slice built into the site. The one search page,
slices/search.html?slice=<name>, lists them when no slice is named. Given a
name, it reads everything else it needs from the search block of that
slice’s manifest. The reader picks. The page checks the name against a pattern before
using it in a path.
Recommended for who-iris, not built: keep the reader’s choice, and
make the choices follow the catalogue’s community and collection tree. A reader browsing
a community opens that community’s slice, named in its index.jsonld. A
reader searching all of IRIS opens the routing slice first. Several slices can be open at once,
because each is its own file in the pool. What that costs on a phone has not been
measured.
The ingestion method is undetermined, and the process diagram reaches a gateway with no default branch rather than naming one. A pull from the portal, a push to an object store, a git fetch, a signed tarball on a schedule — they differ in who initiates, in what must be reachable from where, and in what happens when a publication is missed. Drawing one as the obvious branch would record a decision nobody made.
The store must be versioned; which store is a deployment choice. Hosted git is one satisfaction of that requirement, not the requirement. A portal showing a graph needs to be able to say which graph — an unversioned store cannot answer “what did this look like last term”, and that is the question a reading list asks every year.
Nothing here was measured against a live CDN. cdn.jsdelivr.net is egress-blocked from the container that generates these pages,
so every CDN figure would be quoted rather than measured. The owner confirmed one link by hand
on 2026-09-20, and that is the whole of the evidence.
What ingesting these documents cost — the requirements this instance paid for, generated from the skill that records them.