1. Abstract
A patient's most consequential results come from laboratories: tumor and germline sequencing, pathology, circulating tumor DNA, pharmacogenomics. JupyterHealth Exchange, the open platform behind the Edge Medicine program at UC Berkeley and UCSF, receives wearable data through client apps and a patient's hospital record through SMART on FHIR Patient Access, and serves it over FHIR R5, REST and MCP. It has no door for a laboratory. Results still arrive as a PDF or a portal login, move as copies, and escape the patient's consent and the laboratory's chain of custody.
The BioFS Lab Connector is that door. Every result file keeps its bytes in the laboratory's or the patient's encrypted vault and is addressed by a biocid://, a stable identifier bound to the patient's key and to the producing laboratory's LabNFT, its on-chain credential. The patient's consent is a revocable token checked on every read, mapped onto the Exchange's study scopes so 1 signature grants or withdraws in both systems. The Connector publishes FHIR R5 DiagnosticReport, DocumentReference, ImagingStudy and Consent resources with the biocid as the attachment URL and the laboratory as the performer, so provenance is explicit and the file is fetched only under license. A Hub notebook reads the Exchange with jupyterhealth-client and the file with the biofs client; a SMART on FHIR app opens the same view from the chart.
A reference implementation is live in the GenoBank.io patient dashboard: on a vault of 17 hospital imports, 526 genomic files and 7 imaging studies it builds a transaction Bundle of 1 Consent plus 1 resource per selected item, with no bytes inside. The paper gives the mapping, the revocation path, deployment routes for patients and laboratories, the evaluation endpoints, and the limits of what a browser, an Exchange and a consent token can enforce.
2. The Missing Door
In resected pancreatic cancer the decisions that matter concentrate in the 90 days after surgery: adjuvant chemotherapy, trial enrollment, and, for a growing number of patients, an individualized therapy manufactured from the tumor's own sequence. In the case GenoBank.io reports in a manuscript in preparation, 5 custodians held the pieces of 1 patient's record: a tumor sequencing laboratory, an annotation laboratory, a germline laboratory, a circulating tumor DNA provider and the hospital's Epic record. None of them held all the pieces. The results reached the patient over weeks. The only party standing where all the results meet is the patient, and the patient is the only party structurally prevented from bringing them together.
Each laboratory returns a PDF or a portal login to the ordering clinician. Integration happens at the tumor board, by hand. Where results do move, they move as copies: a report is downloaded, emailed and uploaded, and every copy escapes the patient's consent and the laboratory's chain of custody. The patient holds a federal right of access to these results and information blocking is prohibited (45 C.F.R. § 164.524; the ONC Cures Act final rule), so a laboratory can no longer refuse the patient as a recipient. What is missing is not the right but the mechanism: a way for a laboratory to deliver a result into the patient's own analysis environment, under the patient's consent, with provenance, revocation and erasure that reach the file itself.
A laboratory result should enter a research exchange the way it leaves the laboratory: as 1 file, under 1 chain of custody, readable only while the patient's consent stands. Copying it into the exchange breaks all 3 properties. Pointing at it preserves them.
3. What JupyterHealth Exchange Is
JupyterHealth Exchange is a Django application that shares patient-consented health data with authorized users through a web interface and REST, MCP and FHIR APIs [1]. Its entities follow the HL7 FHIR model. Practitioners and Patients authenticate with OAuth 2.0 and OpenID Connect; a Patient receives an invitation link whose code is exchanged for an access token. An Organization groups Practitioners, Patients and Studies. A Study is a FHIR Group of Patients with 1 or more Clients (apps that talk to the Exchange), 1 or more Data Sources (anything that produces data) and 1 or more Scope Requests (blood pressure, heart rate, and so on). When a Patient is added to a Study, the Patient must consent to the requested Scopes before any Observation can be uploaded or shared. Observations reference a Patient as subject and a Data Source as device; personal device data are expected in Open mHealth JSON, and Observation data are stored as a base64 encoded valueAttachment [1].
Two kinds of Client exist. Patient apps use the authorization code grant and onboard Patients through invitation URLs. Practitioner API clients use the client credentials grant for direct API access [1]. The demonstration clients show the doors the Exchange has today: CareX for blood pressure and questionnaires, CommonHealth for glucose meters and other devices, Open Wearables for rings and watches, and an EHR Patient Portal client that pulls every FHIR resource of the patient's hospital record through Patient Access [1]. The documentation describes the surrounding pieces: the JupyterHealth Hub (a JupyterHub for analysis), the jupyterhealth-client Python package, a SMART on FHIR provider template that launches a dashboard from the electronic health record, and an MCP server so an agent can answer questions over consented data [2].
Every one of those doors carries data that is small, frequent and already structured. None of them carries a sequencing run, a pathology slide or a CT study, and none of them represents the laboratory that produced a result as a party with its own key.
4. Why a Genome Is Not a Glucose Reading
The Exchange's data model is right for the data it was built for. A glucose reading is a few hundred bytes; a base64 attachment inside an Observation costs nothing and keeps the record self-contained. Laboratory results break that assumption in 3 ways.
Weight. A single tumor BAM file in the case above is 8.3 GB; a whole exome run in FASTQ is larger; a contrast CT study runs to more than 1,000 images. A base64 attachment grows the payload by a third and puts the bytes inside the Exchange's database, where they are backed up, replicated and retained on the Exchange's schedule rather than the patient's.
Identity. A genome identifies the person and their relatives. Once it is copied into an exchange it is a second controlled copy with its own access list, and every notebook that reads it can write a third. Under the GDPR genetic data are a special category of personal data, and pseudonymized data remain personal data (Section 13). The honest unit of control for such a file is the read, not the copy.
Consent granularity. The Exchange's consent is a scope per data type per study. A patient can consent to "blood glucose" for a study. A patient cannot express "this report, from this laboratory, readable by this notebook until I say otherwise", and cannot revoke in a way that stops a read of bytes that have already been copied into the Exchange.
If laboratory results were pushed into the Exchange as attachments, the Exchange would become the largest and least revocable holder of the patient's genome, which is the opposite of what a patient-consented exchange is for. The Connector therefore publishes references, never bytes.
5. The BioFS Lab Connector
BioFS is GenoBank.io's biological filesystem: every biological dataset (a VCF, a BAM, a DICOM study, a FHIR import, a report derived from any of them) is addressed by a biocid://, registered with its owner, its producing agent and its storage location, and served only through a gate that checks the owner's consent on each request [3]. The Connector is a Data Source and Client for JupyterHealth Exchange built on that filesystem. It works in 4 steps that map onto the Exchange's own objects.
Step 1. Register
A laboratory, or the patient from the laboratory's portal, registers each result file under a biocid of the form biocid://<agent>/<owner>/<type>/<id>/<dataset>. The identifier is bound to the patient's key and names the laboratory that produced the file by its LabNFT, the laboratory's on-chain credential (Section 6), so the registration is signed by a key the registry can verify. The bytes stay encrypted where they are, in the laboratory's storage or the patient's vault, and are never copied into the Exchange.
Step 2. Consent
The patient's consent is a revocable token held by the patient and checked on every read: the BioNFT mechanism of US patents 11,915,808 and 11,984,203 [4, 5], extended by ERC-8356 purpose-bound consent for third parties [6]. The Connector maps that token onto the Exchange's study scopes. A scope such as "tumor sequencing report" is granted and revoked in both systems by 1 signature, and revocation stops future reads of the file itself, not only of its metadata.
Step 3. Publish
The Connector writes FHIR R5 resources into the Exchange through its FHIR API: a DiagnosticReport under the HL7 Genomics Reporting implementation guide for a variant report [7], a DocumentReference for a raw file or an imported record bundle, an ImagingStudy for a DICOM study, and a Consent resource that names the scopes granted. In every case the attachment URL is the gated biocid stream and the laboratory is the performer, identified by its LabNFT serial, so provenance is explicit, verifiable against the registry, and the heavy file is fetched only under license.
Step 4. Analyze and act
A notebook in the JupyterHealth Hub reads the Exchange with jupyterhealth-client and the file with the biofs client, annotates variants, matches trials and renders a tumor-board view. Through the SMART on FHIR provider template the same view opens inside the electronic health record from the patient's chart, and the MCP server lets an agent answer the patient's own questions with cited sources.
sequencing, pathology, ctDNA"] Hosp["Hospital
Patient Access import"] Img["Imaging
DICOM study"] end subgraph Vault["Patient vault (BioFS)"] Reg["biocid registry
owner, agent, location"] Gate["Gated stream
consent checked per read"] end subgraph JHE["JupyterHealth Exchange"] Cons["Consent
scopes granted"] Res["DiagnosticReport · DocumentReference
ImagingStudy"] end subgraph Hub["JupyterHealth Hub"] NB["Notebook
jupyterhealth-client + biofs"] SOF["SMART on FHIR app
opens from the chart"] end Lab --> Reg Hosp --> Reg Img --> Reg Reg -- "publish references" --> Res Reg -- "map scopes" --> Cons Res -- "attachment URL" --> Gate Cons -. "revoke by 1 signature" .-> Gate NB --> Res NB --> Gate SOF --> Res
Text summary (Figure 1) Laboratories, the hospital and imaging write files into the patient's BioFS vault, where each file receives a biocid. The Connector publishes FHIR resources and a Consent into the Exchange; each resource's attachment URL points back at the vault's gated stream. Notebooks in the Hub and a SMART on FHIR app read the resources from the Exchange and the bytes from the gate. One signature revokes the consent, and the gate stops serving.
6. LabNFT: The Laboratory as a Party With a Key
A FHIR DiagnosticReport names its performer as text. Text is a claim, and the Exchange has no way to check it: any client that holds a study token can write "performed by laboratory X". For data that will decide a treatment, the producing laboratory has to be a party with a key, not a string. GenoBank.io has registered laboratories that way since 2021 through the LabNFT [16]: an on-chain certificate of laboratory authority, the genomic counterpart of a TLS certificate for a website [3]. A laboratory applies with its credentials, GenoBank.io reviews them, and the registry mints a non-transferable token bound to the laboratory's wallet with a serial number, a name, a registration time and an active flag. The token cannot be sold or moved; the registry can revoke it; its history stays on chain; and anyone can verify it with a chain query [3]. The laboratories in the pancreatic cancer case are registered this way, each under its own serial [17].
In the Connector the LabNFT does 3 jobs. At registration, the laboratory signs the biocid record with the wallet that holds its LabNFT, so the registry entry carries a verifiable producer rather than a label. At publication, the DiagnosticReport's performer carries an identifier under https://genobank.io/labnft whose value is the LabNFT serial, next to the human-readable name. At reading time, a notebook or a SMART on FHIR app resolves that serial against the registry and learns whether the laboratory existed, was active when the result was signed, and still is. A revoked LabNFT does not erase a result, but it changes how every downstream reader weighs it, in the same way a revoked certificate changes a browser's warning.
Every read through the Connector is answered by 2 credentials that belong to 2 different parties. The LabNFT, held by the laboratory, answers who produced the file. The BioNFT consent, held by the patient, answers whether this reader may open it now. Neither party can forge the other's answer, and the Exchange needs to store neither key: it stores the serial and the biocid, and the chain and the vault gate do the checking.
result file ready"] --> LabKey["Laboratory wallet
holds the LabNFT"] end Patient["Patient wallet
holds the BioNFT"] subgraph Vault["BioFS vault"] direction TB Reg["biocid registry
owner = patient
agent = LabNFT serial"] --> Gate["Gated stream
consent checked per read"] end subgraph Chain["Registry contracts (Sequentia)"] direction TB LabReg["LabNFT registry
credential per laboratory
serial · active · revocable"] CG["ConsentGrant (ERC-8356)
patient's revocable consent"] end subgraph JHE["JupyterHealth Exchange"] direction TB DR["DiagnosticReport
performer = LabNFT serial
attachment = biocid stream"] Cons["Consent
study scopes"] end Reader["Reader
Hub notebook · SMART on FHIR app"] LabKey -- "sign and register" --> Reg LabKey -. "credential checked" .-> LabReg Patient -- "grant or revoke, 1 signature" --> CG CG -. "enforced per read" .-> Gate Reg -- "publish references" --> DR Reg -- "map scopes" --> Cons DR -- "attachment URL" --> Gate Reader -- "read report" --> DR Reader -- "verify performer" --> LabReg Reader -- "fetch bytes" --> Gate
Text summary (Figure 2) A laboratory's sign-out hands the result file to the laboratory wallet, which holds the LabNFT. That wallet signs the file's registration into the BioFS vault, where the biocid record names the patient as owner and the LabNFT serial as producing agent; the registry contract verifies the credential. The Connector publishes references into the Exchange through a practitioner API client: a DiagnosticReport whose performer carries the LabNFT serial and whose attachment URL is the gated stream, plus a Consent mapped from the patient's scopes. The patient grants or revokes with 1 signature on the ConsentGrant contract, which the vault gate enforces on every read. A reader takes the report from the Exchange, verifies the performer against the LabNFT registry, and fetches the bytes from the gate.
This is also what lets a second laboratory add to the same patient's record without a merge step. A germline laboratory and a tumor sequencing laboratory each register and publish under their own LabNFT; the Exchange holds 2 DiagnosticReports with 2 verifiable performers for 1 patient, and a tumor board sees which result came from where. Nothing in the Connector asks one laboratory to trust another's text.
7. Resource Mapping
Table 1 gives the mapping the reference implementation uses. The subject of every resource is the patient, identified by the biowallet address under the system https://genobank.io/biowallet until the Exchange assigns a Patient id, after which the reference points at that Patient. Every resource carries the biocid as an identifier under https://genobank.io/biocid, and every performer or author that is a laboratory carries its LabNFT serial under https://genobank.io/labnft, so a reader can go from any resource to the registry entry, from the entry to the consent that governs it, and from the performer to the credential that vouches for it.
| Vault object | FHIR R5 resource | Key fields | Attachment |
|---|---|---|---|
| Variant report (VCF, annotated variant database) | DiagnosticReport, profile genomics-report | category GE (Genetics); code LOINC 81247-9; performer = producing laboratory with its LabNFT serial as identifier; status final | presentedForm.url = gated biocid stream; content type by file; size in bytes |
| Raw sequencing file (BAM, CRAM, FASTQ) | DocumentReference | type LOINC 51969-4 (genetic analysis report); author = producing laboratory with its LabNFT serial; category = file type | content.attachment.url = gated biocid stream |
| Hospital record import (Patient Access) | DocumentReference | type "Patient Access import (SMART on FHIR)"; author = hospital; description = resource count and types; identifier = import timestamp | FHIR JSON per resource type through the vault's record endpoint |
| DICOM study | ImagingStudy | identifier = Study Instance UID (urn:oid); modality (DICOM DCM codes); series and instance counts; started date | DICOMweb endpoint served from the vault under a session token minted by the patient's signature |
| The grant itself | Consent | status active; category LOINC 59284-0; purposes TREAT and HRESCH; security labels = the Exchange scopes granted | none; policy basis is the vault's consent page |
The route status of each file in the vault (pending, routed on chain, superseded) is carried as an extension under https://genobank.io/fhir/StructureDefinition/consent-route-status, so a reader can distinguish a file whose provenance is anchored from one that is only registered. The bundle is a FHIR transaction: every entry is a POST of its resource type, and a conforming server accepts or rejects it as a whole. The Bundle is tagged under https://genobank.io/jupyterhealth, the Consent names its scopes under https://genobank.io/jupyterhealth/scope, and a hospital import is identified under https://genobank.io/epic-import. Each of these URIs resolves to a page that defines it.
Two consequences follow from the mapping. A tumor variant report and a germline report from different laboratories appear in the same Exchange study as 2 DiagnosticReports with 2 performers, which is exactly the provenance a tumor board needs and exactly what a merged PDF loses. And because the Observation layer of the Genomics Reporting guide (1 Observation per variant, tumor mutational burden, microsatellite status) is a refinement of the same DiagnosticReport, a laboratory can start by publishing the report with its file and add per-variant Observations later without changing the consent or the identifiers.
8. Revocation That Reaches the Bytes
The Exchange already lets a patient withdraw a scope, which stops new uploads and hides Observations from queries. For data that live inside the Exchange, that is the end of the story: whatever was already read remains wherever it was read to. For data that live behind a biocid, withdrawal has a second effect. The gated stream checks the patient's consent token on every request, so a revoked consent stops the next read of the file wherever the request comes from, including a notebook that still holds the URL.
Text summary (Figure 3) The patient signs a consent at the vault and publishes the Consent and the report into the Exchange. A notebook finds the report in the Exchange and fetches the bytes from the vault gate, which serves them while the consent is valid. The patient revokes with 1 signature and withdraws the scope in the Exchange. The next fetch from the same notebook is refused.
Erasure follows the same path. The Exchange keeps FHIR metadata, which the patient can delete there. The file itself has 1 location, the vault, and deleting it there removes the only copy the Connector ever referenced. This is the property a base64 attachment cannot offer: after a copy is inside the Exchange, erasure depends on every reader's cooperation, and after a reference is inside the Exchange, erasure depends on 1 party, the patient.
Revocation stops future reads. It does not retrieve bytes that a notebook already loaded into memory or wrote to disk, and it does not delete a derived result that a researcher computed while the consent stood. Those are governed by the study's terms and by the Exchange's retention policy, not by the token. The Connector makes the boundary visible instead of pretending it is not there.
9. Reference Implementation
A first version of the Connector runs in the GenoBank.io patient dashboard as the section "JupyterHealth", deployed on 8 November 2026 [8]. It reads the patient's vault through the existing dashboard services: hospital imports from the Patient Access importer, genomic files from the biorouter asset inventory (filtered to files that carry a biocid and a genomic type: VCF, BAM, CRAM, FASTQ, index files and annotated variant databases), and imaging studies from the imaging service. The patient selects items from the 3 lists, previews the FHIR R5 transaction Bundle, downloads it, or posts it to an Exchange whose URL, FHIR path, study id and access token the patient enters; those credentials stay in the browser and never reach a GenoBank.io server.
The performer of each DiagnosticReport is taken from the producing agent recorded on the biocid; resolving that agent to its LabNFT serial and writing the serial into performer.identifier is wired in the mapping and pending in the dashboard build, which today writes the laboratory's name. On the operator's vault the section reads 17 hospital imports (the latest holding 28,109 FHIR resources across 37 resource types), 526 genomic files with a biocid and 7 imaging studies. Selecting 1 of each produces a Bundle of 4 entries, Consent, DocumentReference, DiagnosticReport and ImagingStudy, 7,232 bytes long, with no file bytes inside it: the DiagnosticReport names the producing laboratory as performer and its presentedForm.url is the gated stream of the file's biocid.
| Component | Where | What it does |
|---|---|---|
Service jupyterHealthService.js | genobank.io, consent/biofile/services/ | Loads the 3 sources; builds each resource and the transaction Bundle; stores the Exchange configuration locally; tests the connection against {fhir}/metadata; posts the Bundle with a bearer token. |
View jupyterHealthView.js | genobank.io, consent/biofile/components/views/ | The 4-step strip, the connection panel, the 3 lists with selection and a filter, preview, download and publish. |
| Vault gate | genobank.app, biorouter stream | Serves a biocid's bytes only after checking the owner's consent for the requester; the URL every attachment points at. |
| Source | github.com/Genobank/genobank.io | Public under the repository's license; BioFS itself under AGPL-3.0-or-later at github.com/Genobank/biofs-cli. |
The mapping of Section 7 is implementable from the data a patient already holds, without a new upload, a new consent form or a new copy of any file. The bundle is valid FHIR R5 JSON that any conforming server can accept as a transaction. What remains is the receiving side.
10. Deployment Paths
Patient side
A patient enrolled in an Exchange study receives an invitation link. The access token obtained from that link is pasted into the Connector's connection panel together with the Exchange URL and the study id; the patient selects the results to share and publishes. Where the Exchange does not allow the dashboard's origin to call it from a browser, the patient downloads the Bundle and posts it from the Hub with jupyterhealth-client, which the Connector's own message explains.
Laboratory side
A laboratory holding a LabNFT registers as a Practitioner API client of the Exchange, which uses the client credentials grant [1], and runs the Connector as a BioFS verb at the moment a result is signed out: register the file, publish the DiagnosticReport and the Consent to the studies the patient has joined, and record the Exchange's response against the biocid. The laboratory never handles the patient's token; it handles its own client credentials and the biocid, and the vault gate enforces the patient's consent when a reader fetches the file.
Hub and chart
A notebook in the JupyterHealth Hub lists the study's DiagnosticReports, follows each presentedForm.url through the biofs client (which signs the request with the researcher's key so the gate can check the grant), and runs annotation and trial matching on the file. The SMART on FHIR provider template launches the same notebook's dashboard from the patient's chart, so a clinician at the tumor board sees the laboratory results and the Exchange's wearable data in 1 view with the provenance of each.
# Hub notebook sketch (Python)
from jupyterhealth_client import JupyterHealthClient
import subprocess, json
jhe = JupyterHealthClient() # Exchange credentials from the Hub
reports = jhe.list_fhir("DiagnosticReport", study_id=20001)
for r in reports:
url = r["presentedForm"][0]["url"] # the gated biocid stream
biocid = r["identifier"][0]["value"] # biocid://<agent>/<owner>/<type>/<id>/<dataset>
subprocess.run(["biofs", "view", biocid, "--out", "work/"], check=True)
# annotate, match trials, render the tumor-board view
11. Evaluation
The primary endpoint is access latency: the interval between a laboratory generating an actionable result and its availability to the patient in the Exchange in usable form, read from system logs. In the single case above it fell from weeks to hours, which shows the direction and nothing about the size, so a first evaluation measures it across a cohort. Secondary endpoints, all measurable from the Exchange and the Connector, are listed in Table 2.
| Endpoint | Measure | First-year target |
|---|---|---|
| Laboratories writing to the Exchange | Count of distinct performers in published DiagnosticReports | 4: a tumor sequencing laboratory, a germline laboratory, a ctDNA provider, a pathology service |
| Coverage | Share of a patient's laboratory results reachable from 1 consented view | Reported per patient |
| Time to tumor board | Result timestamp to the first tumor-board read of the report | Reported per result |
| Trials surfaced | Trials identified before the referral completes | Reported per patient |
| Revocations honored | Reads attempted after revocation that were refused, over reads attempted | 100% |
| Comprehension | Patient understanding of their results, with the instruments consent research already uses [9, 10] | Reported; the result a patient can question is the point of bringing it home |
Because GenoBank.io builds the components, the evaluation should be run by someone else, with the outcome data held by an independent custodian. A 12-month success is a working Connector in a JupyterHealth deployment with 1 patient's real pancreatic cancer data under that patient's consent, 4 laboratory data sources, a SMART on FHIR tumor-board view, and published endpoints.
12. Limitations
- No receiving Exchange yet. The reference implementation builds and posts a valid Bundle, and its connection test runs against a server's CapabilityStatement, but no public Exchange has been configured to accept it. The Exchange's FHIR API as documented today stores Observations with inline attachments; accepting DiagnosticReports whose attachments are external URLs may need a small change on the Exchange side, which this paper proposes as a contribution to the JupyterHealth project rather than assumes.
- Browser limits. A browser can only call an Exchange that allows the dashboard's origin. The download-then-post route exists for that reason, and the laboratory-side verb does not depend on a browser at all.
- Revocation is prospective. Section 8 states what a revoked token stops and what it does not. Bytes already read and results already derived are governed by the study's terms.
- Per-variant Observations are not yet published. The implementation publishes the report and the file. The Genomics Reporting guide's Observation profiles for individual variants, tumor mutational burden and microsatellite status are the next layer and change neither the consent nor the identifiers.
- One vault, one operator. The counts in Section 9 come from 1 vault. They show that the mapping runs on real data; they say nothing about scale, and the evaluation of Section 11 is designed to.
- What a LabNFT attests. A LabNFT attests that a laboratory was reviewed, registered and not revoked. It does not attest that a given result is correct, that the laboratory's accreditation is current, or that the file was not altered after signing; the first 2 belong to the laboratory's regulators and the third to the content commitment on the biocid. The registry is issued by GenoBank.io today; an issuer model in which accrediting bodies mint LabNFTs is future work.
- Patent scope. The consent mechanism is covered by US patents 11,915,808 and 11,984,203. The Connector, BioFS and this specification are open tools; the patents cover the commercial issuance of biosample and biodata tokens, and this paper does not widen them.
13. Data Protection
The GDPR classifies genetic data and data concerning health as special categories of personal data (Articles 4(13), 4(15) and 9(1)), and pseudonymized data remain personal data (Recital 26). The laboratory results, imaging studies, hospital imports and FHIR resources derived from them that this paper describes are treated here as personal data. Every read of a file through the Connector rests on the patient's explicit consent (Article 9(2)(a)), which the patient can withdraw at any time by revoking the token (Article 7(3)), and the gated stream enforces that withdrawal on the next read. Because the file has 1 location, the patient's or the laboratory's vault, deleting it there is designed to let the right to erasure (Article 17(1)(b)) apply to the only copy the Connector referenced; the FHIR metadata kept by the Exchange is deleted there, and bytes a reader copied while the consent stood are governed by the study's terms, as Section 8 states.
The Health Insurance Portability and Accountability Act (HIPAA) Privacy Rule binds covered entities and their business associates (45 C.F.R. § 160.103). GenoBank.io, which operates the vault and the dashboard, is not a covered entity; a laboratory or a hospital that writes to the vault may be one, and its obligations do not change because the patient holds a copy. De-identification follows 45 C.F.R. § 164.514(b), which allows 2 routes: expert determination, or the removal of 18 listed identifiers; because a genome is itself an identifier, genomic data rest on expert determination, and nothing the Connector publishes is de-identified. HIPAA and the GDPR are the design benchmarks for the consent, erasure and provenance properties described here, and this paper makes no claim of compliance with either.
14. Conclusion
JupyterHealth Exchange gives patients and researchers a consented place to meet. The BioFS Lab Connector lets the results that most decide a patient's treatment, the ones laboratories produce, arrive there without being copied, under a consent the patient can withdraw with 1 signature, and with the laboratory's name on every report. The mapping is implementable today from data patients already hold, the reference implementation is live, and the remaining work is on the receiving side and in a laboratory's sign-out workflow. A result that reaches the patient's own analysis environment in hours, with its provenance intact and its license revocable, is a different object from a PDF in a portal. The Connector is a proposal to make it the normal one.
15. References
- JupyterHealth. JupyterHealth Exchange, README (entities, Observations as base64 valueAttachment, Clients and grant types, demonstration data sources). GitHub, read 8 November 2026. https://github.com/jupyterhealth/jupyterhealth-exchange
- JupyterHealth. Software documentation: Exchange, Hub, jupyterhealth-client, SMART on FHIR provider template, MCP. https://jupyterhealth.github.io/software-documentation/
- Uribe, D. BioFS Protocol. GenoBank.io whitepaper. https://genobank.io/whitepapers/biofs-protocol/
- United States Patent 11,915,808 B1. Issued 27 February 2024.
- United States Patent 11,984,203 B1. Issued 14 May 2024.
- Uribe, D. ERC-8356: Purpose-Bound Third-Party Data Consent. ethereum/ERCs pull request 1921, 2026. https://github.com/ethereum/ERCs/pull/1921; discussion: Ethereum Magicians thread 29217, https://ethereum-magicians.org/t/erc-8356-purpose-bound-third-party-data-consent/29217; whitepaper: https://genobank.io/whitepapers/erc-8356-purpose-bound-consent/
- HL7 International. Genomics Reporting Implementation Guide (FHIR). https://hl7.org/fhir/uv/genomics-reporting/
- GenoBank.io. JupyterHealth section of the patient dashboard, source files jupyterHealthService.js and jupyterHealthView.js, 8 November 2026. https://github.com/Genobank/genobank.io
- Tam, N. T. et al. Participants' understanding of informed consent in clinical trials over three decades: systematic review and meta-analysis. Bulletin of the World Health Organization 93, 186 to 198H (2015). doi:10.2471/BLT.14.141390
- Glaser, J. et al. Interventions to improve patient comprehension in informed consent for medical and surgical procedures: an updated systematic review. Medical Decision Making 40, 119 to 143 (2020). doi:10.1177/0272989X19896348
- 45 C.F.R. § 164.524, Access of individuals to protected health information; 45 C.F.R. § 160.103; 45 C.F.R. § 164.514(b). Electronic Code of Federal Regulations.
- Office of the National Coordinator for Health Information Technology. 21st Century Cures Act: Interoperability, Information Blocking, and the ONC Health IT Certification Program, final rule. 85 Fed. Reg. 25642 (1 May 2020).
- Regulation (EU) 2016/679 (General Data Protection Regulation), Articles 4(13), 4(15), 7(3), 9(1), 9(2)(a), 17(1)(b) and Recital 26. Official Journal of the European Union L 119.
- HL7 International. FHIR R5: DiagnosticReport, DocumentReference, ImagingStudy, Consent, Bundle. https://hl7.org/fhir/R5/
- Edge Medicine. Edge Medicine Innovation Challenge, UC Berkeley and UCSF. https://edgemedicine.org/innovate
- GenoBank.io. LabNFTs: decentralized IDs for certified labs. https://genobank.io/labnfts.html
- Uribe, D. Patient-Owned Digital Twin. GenoBank.io whitepaper (the laboratories of the case registered as LabNFTs with their permittee serials). https://genobank.io/whitepapers/patient-owned-digital-twin/