fair-metadata-integration 0.1.0__tar.gz

fair_metadata_integration-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NL-BioImaging
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fair_metadata_integration-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: fair-metadata-integration
+Version: 0.1.0
+Summary: Integrate and package all metadata into RO-Crate, linking to other metadata files
+Author-email: Joost de Folter <folterj@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NL-BioImaging/fair-metadata-integration
+Project-URL: Repository, https://github.com/NL-BioImaging/fair-metadata-integration
+Keywords: RO-Crate,FAIR,metadata,bioimaging,OME-Zarr
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rocrate>=0.15.1
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# fair-metadata-integration
+
+Integrate and package all metadata into RO-Crate, linking to other metadata files.
+
+Given a [Bilayers](https://github.com/bilayer-containers/bilayers) workflow
+specification and the image data an analysis consumed and produced, this package
+writes a [Workflow RO-Crate](https://w3id.org/workflowhub/workflow-ro-crate/1.0):
+an `ro-crate-metadata.json` describing the run, alongside copies of the files it
+describes.
+
+## Installation
+
+```bash
+pip install fair-metadata-integration
+```
+
+Requires Python 3.12 or newer. [`rocrate`](https://pypi.org/project/rocrate/) is
+installed automatically.
+
+## Usage
+
+```python
+from fair_metadata_integration import create_ro_crate
+
+create_ro_crate(
+    dest_path="crate",
+    workflow_schema_filename="config.yaml",
+    input_path="input.ome.zarr",
+    output_paths=["output.ome.zarr"],
+)
+```
+
+- `dest_path` — directory the crate is written to, created if it does not exist.
+- `workflow_schema_filename` — the Bilayers `config.yaml` describing the workflow.
+- `input_path` — the input image (an OME-Zarr directory or a TIFF file).
+- `output_paths` — the images the workflow produced. Each gets its own parameter.
+
+The source files are copied into the crate, so `dest_path` ends up
+self-contained:
+
+```
+crate/
+├── config.yaml
+├── input.ome.zarr/
+├── output.ome.zarr/
+└── ro-crate-metadata.json
+```
+
+### What the crate contains
+
+The workflow specification is the crate's `mainEntity`, typed as a
+`ComputationalWorkflow`, and the metadata descriptor declares the Workflow
+RO-Crate profile:
+
+```json
+{
+  "@id": "ro-crate-metadata.json",
+  "@type": "CreativeWork",
+  "about": { "@id": "./" },
+  "conformsTo": [
+    { "@id": "https://w3id.org/ro/crate/1.2" },
+    { "@id": "https://w3id.org/workflowhub/workflow-ro-crate/1.0" }
+  ]
+}
+```
+
+The workflow's `programmingLanguage` is a `ComputerLanguage` entity for the
+Bilayers specification, identified by its Zenodo concept DOI
+[`10.5281/zenodo.17652333`](https://doi.org/10.5281/zenodo.17652333), which
+resolves to the latest release of the spec.
+
+Inputs and outputs are modelled as `FormalParameter` entities carrying an
+[EDAM](https://edamontology.org/) format IRI — `format_3915` for Zarr,
+`format_3591` for TIFF. Each image dataset points back at the parameter it
+realises via `exampleOfWork`:
+
+```json
+{
+  "@id": "input.ome.zarr/",
+  "@type": "Dataset",
+  "additionalType": "http://edamontology.org/format_3915",
+  "exampleOfWork": { "@id": "#input" }
+}
+```
+
+The crate's JSON-LD context is extended with terms for describing biological
+imaging metadata — `biosample`, `specimen`, `organism_classification`,
+`preparation_method`, `channel` and others — so those properties can be added to
+the crate's entities.
+
+## Development
+
+```bash
+git clone https://github.com/NL-BioImaging/fair-metadata-integration.git
+cd fair-metadata-integration
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT

fair_metadata_integration-0.1.0/README.md

@@ -0,0 +1,102 @@
+# fair-metadata-integration
+
+Integrate and package all metadata into RO-Crate, linking to other metadata files.
+
+Given a [Bilayers](https://github.com/bilayer-containers/bilayers) workflow
+specification and the image data an analysis consumed and produced, this package
+writes a [Workflow RO-Crate](https://w3id.org/workflowhub/workflow-ro-crate/1.0):
+an `ro-crate-metadata.json` describing the run, alongside copies of the files it
+describes.
+
+## Installation
+
+```bash
+pip install fair-metadata-integration
+```
+
+Requires Python 3.12 or newer. [`rocrate`](https://pypi.org/project/rocrate/) is
+installed automatically.
+
+## Usage
+
+```python
+from fair_metadata_integration import create_ro_crate
+
+create_ro_crate(
+    dest_path="crate",
+    workflow_schema_filename="config.yaml",
+    input_path="input.ome.zarr",
+    output_paths=["output.ome.zarr"],
+)
+```
+
+- `dest_path` — directory the crate is written to, created if it does not exist.
+- `workflow_schema_filename` — the Bilayers `config.yaml` describing the workflow.
+- `input_path` — the input image (an OME-Zarr directory or a TIFF file).
+- `output_paths` — the images the workflow produced. Each gets its own parameter.
+
+The source files are copied into the crate, so `dest_path` ends up
+self-contained:
+
+```
+crate/
+├── config.yaml
+├── input.ome.zarr/
+├── output.ome.zarr/
+└── ro-crate-metadata.json
+```
+
+### What the crate contains
+
+The workflow specification is the crate's `mainEntity`, typed as a
+`ComputationalWorkflow`, and the metadata descriptor declares the Workflow
+RO-Crate profile:
+
+```json
+{
+  "@id": "ro-crate-metadata.json",
+  "@type": "CreativeWork",
+  "about": { "@id": "./" },
+  "conformsTo": [
+    { "@id": "https://w3id.org/ro/crate/1.2" },
+    { "@id": "https://w3id.org/workflowhub/workflow-ro-crate/1.0" }
+  ]
+}
+```
+
+The workflow's `programmingLanguage` is a `ComputerLanguage` entity for the
+Bilayers specification, identified by its Zenodo concept DOI
+[`10.5281/zenodo.17652333`](https://doi.org/10.5281/zenodo.17652333), which
+resolves to the latest release of the spec.
+
+Inputs and outputs are modelled as `FormalParameter` entities carrying an
+[EDAM](https://edamontology.org/) format IRI — `format_3915` for Zarr,
+`format_3591` for TIFF. Each image dataset points back at the parameter it
+realises via `exampleOfWork`:
+
+```json
+{
+  "@id": "input.ome.zarr/",
+  "@type": "Dataset",
+  "additionalType": "http://edamontology.org/format_3915",
+  "exampleOfWork": { "@id": "#input" }
+}
+```
+
+The crate's JSON-LD context is extended with terms for describing biological
+imaging metadata — `biosample`, `specimen`, `organism_classification`,
+`preparation_method`, `channel` and others — so those properties can be added to
+the crate's entities.
+
+## Development
+
+```bash
+git clone https://github.com/NL-BioImaging/fair-metadata-integration.git
+cd fair-metadata-integration
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT

fair_metadata_integration-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fair-metadata-integration"
+version = "0.1.0"
+description = "Integrate and package all metadata into RO-Crate, linking to other metadata files"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [
+    { name = "Joost de Folter", email = "folterj@gmail.com" },
+]
+keywords = ["RO-Crate", "FAIR", "metadata", "bioimaging", "OME-Zarr"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+]
+dependencies = [
+    "rocrate>=0.15.1",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://github.com/NL-BioImaging/fair-metadata-integration"
+Repository = "https://github.com/NL-BioImaging/fair-metadata-integration"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+# -s disables output capture so print() from passing tests is visible
+addopts = "-s"

fair_metadata_integration-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fair_metadata_integration-0.1.0/src/fair_metadata_integration/__init__.py

@@ -0,0 +1,3 @@
+from .metadata_integration import create_ro_crate
+
+__all__ = ["create_ro_crate"]

fair_metadata_integration-0.1.0/src/fair_metadata_integration/metadata_integration.py

@@ -0,0 +1,95 @@
+import os.path
+from rocrate.rocrate import ROCrate
+from rocrate.model import ComputerLanguage, ContextEntity
+
+
+def create_ro_crate(dest_path, workflow_schema_filename, input_path, output_paths=[]):
+    crate = ROCrate()
+
+    crate.metadata.extra_terms = {
+        "organism_classification": "https://schema.org/taxonomicRange",
+        "BioChemEntity": "https://schema.org/BioChemEntity",
+        "channel": "https://www.openmicroscopy.org/Schemas/Documentation/Generated/OME-2016-06/ome_xsd.html#Channel",
+        "obo": "http://purl.obolibrary.org/obo/",
+        "FBcv": "http://ontobee.org/ontology/FBcv/",
+        "acquisiton_method": {
+            "@reverse": "https://schema.org/result",
+            "@type": "@id",
+        },
+        "biological_entity": "https://schema.org/about",
+        "biosample": "http://purl.obolibrary.org/obo/OBI_0002648",
+        "preparation_method": "https://www.wikidata.org/wiki/Property:P1537",
+        "specimen": "http://purl.obolibrary.org/obo/HSO_0000308",
+    }
+
+    output_entities = []
+    for image_path in output_paths:
+        rel_path = os.path.basename(image_path.rstrip('\\/'))
+        output_entities.append(crate.add_dataset(
+            source=image_path, dest_path=rel_path,
+            properties=get_additional_filetype_property(image_path)))
+
+    input_entity = crate.add_dataset(source=input_path,
+                                     dest_path=os.path.basename(input_path.rstrip('\\/')),
+                                     properties=get_additional_filetype_property(input_path))
+
+    # main=True sets the root dataset's mainEntity and declares the Workflow RO-Crate
+    # profile in conformsTo (on the metadata descriptor for rocrate < 0.16, on the
+    # root dataset for rocrate >= 0.16).
+    workflow = crate.add_workflow(source=workflow_schema_filename,
+                                  dest_path=os.path.basename(workflow_schema_filename),
+                                  main=True, lang=get_bilayers_language(crate))
+
+    # The Workflow RO-Crate profile ranges input/output over FormalParameter rather
+    # than over the data entities themselves; each data entity is linked back to its
+    # parameter with exampleOfWork.
+    workflow['input'] = [add_formal_parameter(crate, input_entity, 'input')]
+    if output_entities:
+        workflow['output'] = [
+            add_formal_parameter(crate, entity, 'output' if i == 0 else f'output_{i + 1}')
+            for i, entity in enumerate(output_entities)
+        ]
+
+    crate.write(dest_path)
+    return crate
+
+
+def get_additional_filetype_property(path):
+    ext = os.path.splitext(path)[1]
+    ref = None
+    if '.zar' in ext:
+        ref = 'http://edamontology.org/format_3915'
+    elif '.tif' in ext:
+        ref = 'http://edamontology.org/format_3591'
+    if ref:
+        return {'additionalType': ref}
+    return None
+
+
+def get_bilayers_language(crate):
+    """Return the ComputerLanguage entity for a bilayers workflow specification.
+
+    Identified by the Zenodo concept DOI, which is version-independent and
+    resolves to the latest release of the specification.
+    """
+    return crate.add(ComputerLanguage(
+        crate,
+        identifier='https://doi.org/10.5281/zenodo.17652333',
+        properties={
+            'name': 'Bilayers',
+            'alternateName': 'Bilayers workflow specification',
+            'identifier': {'@id': 'https://doi.org/10.5281/zenodo.17652333'},
+            'url': {'@id': 'https://github.com/bilayer-containers/bilayers'},
+        },
+    ))
+
+
+def add_formal_parameter(crate, data_entity, name):
+    """Add a FormalParameter describing *data_entity* and link the two together."""
+    properties = {'@type': 'FormalParameter', 'name': name}
+    format_ref = data_entity.get('additionalType')
+    if format_ref:
+        properties['format'] = {'@id': format_ref}
+    parameter = crate.add(ContextEntity(crate, f'#{name}', properties))
+    data_entity['exampleOfWork'] = parameter
+    return parameter

fair_metadata_integration-0.1.0/src/fair_metadata_integration.egg-info/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: fair-metadata-integration
+Version: 0.1.0
+Summary: Integrate and package all metadata into RO-Crate, linking to other metadata files
+Author-email: Joost de Folter <folterj@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NL-BioImaging/fair-metadata-integration
+Project-URL: Repository, https://github.com/NL-BioImaging/fair-metadata-integration
+Keywords: RO-Crate,FAIR,metadata,bioimaging,OME-Zarr
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rocrate>=0.15.1
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# fair-metadata-integration
+
+Integrate and package all metadata into RO-Crate, linking to other metadata files.
+
+Given a [Bilayers](https://github.com/bilayer-containers/bilayers) workflow
+specification and the image data an analysis consumed and produced, this package
+writes a [Workflow RO-Crate](https://w3id.org/workflowhub/workflow-ro-crate/1.0):
+an `ro-crate-metadata.json` describing the run, alongside copies of the files it
+describes.
+
+## Installation
+
+```bash
+pip install fair-metadata-integration
+```
+
+Requires Python 3.12 or newer. [`rocrate`](https://pypi.org/project/rocrate/) is
+installed automatically.
+
+## Usage
+
+```python
+from fair_metadata_integration import create_ro_crate
+
+create_ro_crate(
+    dest_path="crate",
+    workflow_schema_filename="config.yaml",
+    input_path="input.ome.zarr",
+    output_paths=["output.ome.zarr"],
+)
+```
+
+- `dest_path` — directory the crate is written to, created if it does not exist.
+- `workflow_schema_filename` — the Bilayers `config.yaml` describing the workflow.
+- `input_path` — the input image (an OME-Zarr directory or a TIFF file).
+- `output_paths` — the images the workflow produced. Each gets its own parameter.
+
+The source files are copied into the crate, so `dest_path` ends up
+self-contained:
+
+```
+crate/
+├── config.yaml
+├── input.ome.zarr/
+├── output.ome.zarr/
+└── ro-crate-metadata.json
+```
+
+### What the crate contains
+
+The workflow specification is the crate's `mainEntity`, typed as a
+`ComputationalWorkflow`, and the metadata descriptor declares the Workflow
+RO-Crate profile:
+
+```json
+{
+  "@id": "ro-crate-metadata.json",
+  "@type": "CreativeWork",
+  "about": { "@id": "./" },
+  "conformsTo": [
+    { "@id": "https://w3id.org/ro/crate/1.2" },
+    { "@id": "https://w3id.org/workflowhub/workflow-ro-crate/1.0" }
+  ]
+}
+```
+
+The workflow's `programmingLanguage` is a `ComputerLanguage` entity for the
+Bilayers specification, identified by its Zenodo concept DOI
+[`10.5281/zenodo.17652333`](https://doi.org/10.5281/zenodo.17652333), which
+resolves to the latest release of the spec.
+
+Inputs and outputs are modelled as `FormalParameter` entities carrying an
+[EDAM](https://edamontology.org/) format IRI — `format_3915` for Zarr,
+`format_3591` for TIFF. Each image dataset points back at the parameter it
+realises via `exampleOfWork`:
+
+```json
+{
+  "@id": "input.ome.zarr/",
+  "@type": "Dataset",
+  "additionalType": "http://edamontology.org/format_3915",
+  "exampleOfWork": { "@id": "#input" }
+}
+```
+
+The crate's JSON-LD context is extended with terms for describing biological
+imaging metadata — `biosample`, `specimen`, `organism_classification`,
+`preparation_method`, `channel` and others — so those properties can be added to
+the crate's entities.
+
+## Development
+
+```bash
+git clone https://github.com/NL-BioImaging/fair-metadata-integration.git
+cd fair-metadata-integration
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT

fair_metadata_integration-0.1.0/src/fair_metadata_integration.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/fair_metadata_integration/__init__.py
+src/fair_metadata_integration/metadata_integration.py
+src/fair_metadata_integration.egg-info/PKG-INFO
+src/fair_metadata_integration.egg-info/SOURCES.txt
+src/fair_metadata_integration.egg-info/dependency_links.txt
+src/fair_metadata_integration.egg-info/requires.txt
+src/fair_metadata_integration.egg-info/top_level.txt
+tests/test_metadata_integration.py

fair_metadata_integration-0.1.0/src/fair_metadata_integration.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fair_metadata_integration-0.1.0/src/fair_metadata_integration.egg-info/requires.txt

@@ -0,0 +1,4 @@
+rocrate>=0.15.1
+
+[test]
+pytest>=7.0

fair_metadata_integration-0.1.0/src/fair_metadata_integration.egg-info/top_level.txt

@@ -0,0 +1 @@
+fair_metadata_integration

fair_metadata_integration-0.1.0/tests/test_metadata_integration.py

@@ -0,0 +1,246 @@
+import json
+import os
+from pathlib import Path
+import pytest
+
+from fair_metadata_integration.metadata_integration import create_ro_crate
+
+
+BILAYERS_CONFIG = """\
+citations:
+  - name: "Empanada"
+    doi: "10.1083/jcb.202208005"
+    license: "Apache-2.0"
+    description: "Panoptic segmentation of organelles in volume electron microscopy"
+
+docker_image:
+  org: "czii"
+  name: "empanada-napari"
+  tag: "latest"
+  platform: "linux/amd64"
+
+algorithm_folder_name: "empanada_inference"
+
+exec_function:
+  name: "generate_cli_command"
+  cli_command: "python -m empanada.inference"
+  hidden_args: []
+
+inputs:
+  - name: input_image
+    type: image
+    cli_tag: "--image"
+    cli_order: 1
+
+outputs:
+  - name: segmentation
+    type: image
+    cli_tag: "--output"
+    cli_order: 2
+
+parameters:
+  - name: model
+    type: string
+    cli_tag: "--model"
+    default: "MitoNet_v1_mini"
+
+display_only: []
+"""
+
+
+def make_bilayers_config(path: Path) -> Path:
+    """Write a minimal bilayers config.yaml to *path* and return it."""
+    config = path / "config.yaml"
+    config.write_text(BILAYERS_CONFIG)
+    return config
+
+
+def make_ome_zarr_dirs(path: Path) -> tuple[Path, Path]:
+    """Create input/output ome-zarr directories under *path* and return them."""
+    input_zarr = path / "input.ome.zarr"
+    output_zarr = path / "output.ome.zarr"
+    # Nested content, so tests can check the whole tree is copied into the crate.
+    (input_zarr / "0").mkdir(parents=True)
+    (input_zarr / ".zattrs").write_text('{"multiscales": []}')
+    (input_zarr / "0" / "0.0.0").write_bytes(b"\x01\x02\x03")
+    output_zarr.mkdir()
+    (output_zarr / ".zattrs").write_text('{"segmentation": true}')
+    return input_zarr, output_zarr
+
+
+class TestCreateRoCrate:
+    @pytest.fixture()
+    def bilayers_config(self, tmp_path: Path) -> Path:
+        return make_bilayers_config(tmp_path)
+
+    @pytest.fixture()
+    def ome_zarr_dirs(self, tmp_path: Path) -> tuple[Path, Path]:
+        return make_ome_zarr_dirs(tmp_path)
+    
+    def test_create_ro_crate(self, tmp_path, bilayers_config, ome_zarr_dirs):
+        """create_ro_crate writes a valid RO-Crate with all expected entities."""
+        input_zarr, output_zarr = ome_zarr_dirs
+        dest = tmp_path / "crate"
+        dest.mkdir()
+
+        create_ro_crate(
+            dest_path=str(dest),
+            workflow_schema_filename=str(bilayers_config),
+            input_path=str(input_zarr),
+            output_paths=[str(output_zarr)],
+        )
+
+        assert (dest / "ro-crate-metadata.json").exists()
+
+        metadata = json.loads((dest / "ro-crate-metadata.json").read_text())
+        print("\n--- ro-crate-metadata.json ---")
+        print(json.dumps(metadata, indent=2))
+
+        ids = self._read_ids(dest)
+        # rocrate normalises paths to forward-slashes with a trailing '/'.
+        assert any(eid == "output.ome.zarr/" for eid in ids), (
+            f"Output zarr not found in crate entities: {ids}"
+        )
+        # Entities must live inside the crate root, never above it.
+        assert not any(eid.startswith("../") for eid in ids), (
+            f"Crate contains entities outside the crate root: {ids}"
+        )
+        assert any("config.yaml" in eid for eid in ids), (
+            f"Bilayers config.yaml not found in crate entities: {ids}"
+        )
+
+    def test_workflow_ro_crate_profile(self, tmp_path, bilayers_config, ome_zarr_dirs):
+        """The crate declares the Workflow RO-Crate profile correctly."""
+        input_zarr, output_zarr = ome_zarr_dirs
+        dest = tmp_path / "crate"
+        dest.mkdir()
+
+        create_ro_crate(
+            dest_path=str(dest),
+            workflow_schema_filename=str(bilayers_config),
+            input_path=str(input_zarr),
+            output_paths=[str(output_zarr)],
+        )
+
+        entities = self._read_entities(dest)
+
+        # The crate must declare the Workflow RO-Crate profile. rocrate < 0.16
+        # (RO-Crate 1.1) lists it on the metadata descriptor; rocrate >= 0.16
+        # (RO-Crate 1.2+) lists it on the root dataset.
+        conforms_to = set()
+        for entity_id in ("ro-crate-metadata.json", "./"):
+            refs = entities[entity_id].get("conformsTo", [])
+            if isinstance(refs, dict):
+                refs = [refs]
+            conforms_to.update(ref["@id"] for ref in refs)
+        assert any(
+            uri.startswith("https://w3id.org/workflowhub/workflow-ro-crate/")
+            for uri in conforms_to
+        ), conforms_to
+
+        # The root dataset must point at the workflow as its main entity.
+        assert entities["./"]["mainEntity"] == {"@id": "config.yaml"}
+
+        workflow = entities["config.yaml"]
+        assert "ComputationalWorkflow" in workflow["@type"]
+
+        # input/output must reference FormalParameter entities, not the datasets.
+        for prop in ("input", "output"):
+            for ref in workflow[prop]:
+                assert entities[ref["@id"]]["@type"] == "FormalParameter", (
+                    f"workflow {prop} '{ref['@id']}' is not a FormalParameter"
+                )
+
+        # Each dataset links back to the parameter it is an example of.
+        assert entities["input.ome.zarr/"]["exampleOfWork"] == {"@id": "#input"}
+        assert entities["output.ome.zarr/"]["exampleOfWork"] == {"@id": "#output"}
+
+        # The language must describe bilayers, not CWL, and must be identified by
+        # a resolvable persistent identifier rather than an invented one.
+        lang = entities[workflow["programmingLanguage"]["@id"]]
+        assert lang["@type"] == "ComputerLanguage"
+        assert lang["name"] == "Bilayers"
+        assert lang["@id"] == "https://doi.org/10.5281/zenodo.17652333"
+
+    def test_payload_files_are_copied_into_crate(self, tmp_path, bilayers_config, ome_zarr_dirs):
+        """Every entity in the crate is backed by a file that is actually there."""
+        input_zarr, output_zarr = ome_zarr_dirs
+        dest = tmp_path / "crate"
+        dest.mkdir()
+
+        create_ro_crate(
+            dest_path=str(dest),
+            workflow_schema_filename=str(bilayers_config),
+            input_path=str(input_zarr),
+            output_paths=[str(output_zarr)],
+        )
+
+        assert (dest / "config.yaml").read_text() == BILAYERS_CONFIG
+        # The zarr directories are copied whole, nested chunks included.
+        assert (dest / "input.ome.zarr" / ".zattrs").exists()
+        assert (dest / "input.ome.zarr" / "0" / "0.0.0").read_bytes() == b"\x01\x02\x03"
+        assert (dest / "output.ome.zarr" / ".zattrs").exists()
+
+        # No entity may describe a file that is missing from the crate.
+        for eid in self._read_ids(dest):
+            if eid.startswith("#") or eid.startswith("http") or eid == "./":
+                continue
+            assert (dest / eid).exists(), f"entity '{eid}' has no file in the crate"
+
+    def test_multiple_outputs_get_distinct_parameters(self, tmp_path, bilayers_config):
+        """Each output dataset gets its own FormalParameter."""
+        input_zarr = tmp_path / "input.ome.zarr"
+        input_zarr.mkdir()
+        outputs = []
+        for name in ("a.ome.zarr", "b.ome.zarr"):
+            out = tmp_path / name
+            out.mkdir()
+            outputs.append(str(out))
+        dest = tmp_path / "crate"
+        dest.mkdir()
+
+        create_ro_crate(
+            dest_path=str(dest),
+            workflow_schema_filename=str(bilayers_config),
+            input_path=str(input_zarr),
+            output_paths=outputs,
+        )
+
+        entities = self._read_entities(dest)
+        output_ids = [ref["@id"] for ref in entities["config.yaml"]["output"]]
+        assert output_ids == ["#output", "#output_2"]
+        assert entities["a.ome.zarr/"]["exampleOfWork"] == {"@id": "#output"}
+        assert entities["b.ome.zarr/"]["exampleOfWork"] == {"@id": "#output_2"}
+
+    @staticmethod
+    def _read_entities(dest: Path) -> dict:
+        metadata = json.loads((dest / "ro-crate-metadata.json").read_text())
+        return {entity["@id"]: entity for entity in metadata["@graph"]}
+
+    @staticmethod
+    def _read_ids(dest: Path) -> set[str]:
+        metadata = json.loads((dest / "ro-crate-metadata.json").read_text())
+        return {entity["@id"] for entity in metadata["@graph"]}
+
+
+if __name__ == "__main__":
+    import pprint
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_path = Path(tmp)
+
+        bilayers_config = make_bilayers_config(tmp_path)
+        input_zarr, output_zarr = make_ome_zarr_dirs(tmp_path)
+        dest = tmp_path / "crate"
+        dest.mkdir()
+
+        create_ro_crate(
+            dest_path=str(dest),
+            workflow_schema_filename=str(bilayers_config),
+            input_path=str(input_zarr),
+            output_paths=[str(output_zarr)],
+        )
+
+        metadata = json.loads((dest / "ro-crate-metadata.json").read_text())
+        pprint.pprint(metadata)