Folio Assistant Core
INGESTED COPY — not WHO, and not live. This page is rendered by folio-assistant from its own catalogue of WHO IRIS, modelled by reference: 235 nodes of a 273,559-item 361.55 GiB repository, of which 12 items are held here. The WHO logo is deliberately omitted, and the rendered covers are withheld from display for the same reason — they carry the emblem printed on the publications.
World Health
Organization
iris. Institutional Repository
for Information Sharing
Documentation•KG to portal

From this catalogue to somebody else’s portal

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.

Knowledge graph to public portalSix stages in three zones. The publisher's zone holds the knowledge graph, the selected subgraph, the serialized JSON-LD, the package with its manifest of digests, and the signature. The distribution zone holds the origin and, optionally, a cache in front of it. The consumer's zone holds the portal, which verifies the package before serving it to readers. The arrow from signature to origin is dashed and labelled "transport: undetermined".Publisher — owns the canonical URLKnowledge graph versioned store (git, or equivalent)Subgraph what may leave — editorialJSON-LD edges coerced @id, node IRIs are fragmentsPackage files + manifest of digests and sizesSignature over the manifest, per asset, or bothDistributionOrigin publication.host — a tool choiceCache / CDN optional layer, never the hostConsumerPortal Moodle, intranet, department pageVerify digests + signature; cannot check → unknownWHO signing DID — did:web + x5c chain static did.json on tng-cdn.who.int; the key is resolved from HERE, not read out of the packagetransport: undeterminedeither route, same bytes, and the same canonical URLwith a key the trustlist carries resolves the key The consumer owns nothing: the canonical URL is the origin's. A cache is a faster route to the same bytes; model it as the host and every citation breaks the day the cache changes. Money, traffic, graph size and latency decide the transport; each needs a denominator before it is an argument rather than a preference. A package that is signed and never verified is a package whose signature is decoration. A portal nobody asked is not a portal that checked. WHO's own trust network is this shape one layer down: static signed artefacts, served from a CDN, fetched a slice at a time. Stages: select · serialize · package · sign · distribute · verify.
Six stages in three zones. The publisher owns the canonical URL; the cache owns neither end. The dashed arrow is undetermined on purpose.

The one distinction the drawing exists for

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.

Where this instance actually is

#StageHere
1Select
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
2Serialize
kg-export emits the harness graph as JSON-LD; this instance’s catalogue is 235 nodes with 222 item(s).
built
3Package
There is no manifest. The pages and assets are published individually, so nothing here can detect a file that was removed.
not built
4Sign
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
5Distribute
11 generated page(s) and 172 cover(s) on GitHub Pages, with a jsDelivr route to the same bytes.
built
6Verify
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

The numbers a transport decision would be made with

Constraints need denominators. These are this instance’s, measured at generation time — not quoted, not remembered.

items222 here, of 273,559 upstreamthe completeness denominator
files1,057,223 upstreama different denominator; 3.86 files per item, so a fraction built from the wrong one is wrong by that factor
bytes31.91 MB held, of 361.55 GiB upstreamthe size-gate denominator, and the reason this catalogue is by reference
served11 page(s), 172 cover(s)what a publication period would actually move
readersnot measuredtraffic is bytes × requests, and nothing here counts requests. Unknown rather than assumed — an invented reader count would make every cost figure below it fiction

Trust: did:web + x5c chained to WHO’s signing DID

Owner 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.

Publishing a large graph: skeleton, payloads, one SQLite file per slice

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:

  1. The skeleton, as JSON-LD. Each named subgraph — a directory of a declared graph — is published at /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.
  2. Payloads, by content address. Heavy content — a body, a PDF, a page of sections — lives at /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.
  3. Per-slice SQLite. CI flattens one slice into a relational schema: one table per node type, one table per relation, and a contentless FTS5 index. It publishes the result as <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.

Measured: the four pilots

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.

slicefilesource as publishedfirst open
beans2.83 MB4.82 MB of bean files~190 ms
todos0.07 MB18 KB of JSON~110 ms
library2.48 MB3.59 MB of JSON~165 ms
kg3.40 MB3.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.

The slice budget, and what to do above it

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.

CDN caching

fileas builtrecommended behind a CDN
payloadnamed by its sha256, so its bytes never changecache forever (immutable); a new body is a new URL
subgraph JSON-LDa stable IRI whose content changes when the graph doesshort 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-storeshort 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 sha256cache 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.

How a client picks a slice

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.

What is deliberately not decided

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.