@moldesk/registry 0.0.1 → 0.0.2

package/dist/models/diffdock/manifest.yaml

@@ -0,0 +1,219 @@
+schemaVersion: 1
+name: diffdock
+displayName: DiffDock-L
+modelVersion: "1.1"
+adapterVersion: 0.2.0
+description: Blind small-molecule docking against a protein, returning ranked poses and confidence (not binding affinity).
+category: docking
+status: planned
+license: MIT
+homepage: https://github.com/gcorso/DiffDock
+source:
+  repository: https://github.com/gcorso/DiffDock
+  # `main` already ships DiffDock-L by default (upstream README: "By default the
+  # repository now runs the new model [DiffDock-L]... use GitHub commit history
+  # to run the original DiffDock model" for legacy v1). Verified live against
+  # upstream on 2026-09-23 via `git ls-remote` (this was HEAD of `main` at that
+  # time) — re-verify before promoting this model past `planned`, since `main`
+  # moves.
+  revision: 85c49b60d3e0b0182a59ee43a34a6d7036981284
+runtimes:
+  # Linux/NVIDIA only. Upstream's pinned dependency stack (torch==1.13.1+cu117
+  # plus matching cu117-built torch-geometric extension wheels) is CUDA/Linux
+  # specific with no Apple Silicon build; there is no genuine CPU-only path
+  # either (upstream exposes no --device/--cpu/--gpu flag — device selection is
+  # its own unconditional `torch.device('cuda' if torch.cuda.is_available() else
+  # 'cpu')`). `nvidiaGpu`/`cuda` are `required`, not `recommended`: this
+  # adapter's verifyInstallation runs a mandatory CUDA probe, matching the
+  # Boltz Linux/CUDA precedent, so a CUDA-less host fails install verification
+  # rather than silently succeeding into a CPU-fallback-capable install.
+  - kind: python
+    # torch==1.13.1+cu117's matching PyTorch Geometric extension wheels
+    # (torch-scatter/torch-cluster/torch-sparse/torch-spline-conv at the exact
+    # pinned +pt113cu117 build) are published on data.pyg.org only up to
+    # cp310 — verified live on 2026-09-23 by listing
+    # https://data.pyg.org/whl/torch-1.13.1+cu117.html: no cp311 build exists
+    # for these packages at this torch+CUDA combination. Python 3.10, not
+    # 3.11, is required for this runtime entry.
+    python: "3.10"
+    installer: uv
+    platforms:
+      - linux-x64
+    # PyTorch's own cu117 build is on a real PEP-503-compatible extra index
+    # (the officially documented `--extra-index-url` pattern) — added
+    # ALONGSIDE default PyPI, never replacing it, so ordinary packages
+    # (pandas, scipy, rdkit, …) still resolve normally. PyTorch Geometric's
+    # CUDA extension wheels (torch-scatter/torch-cluster/torch-sparse/
+    # torch-spline-conv) are published only as a flat wheel-listing page —
+    # genuinely a `--find-links` page, not a PEP-503 index (verified live on
+    # 2026-09-24: the page has no per-package subdirectory structure) —
+    # upstream's own environment.yml uses exactly this split
+    # (`--extra-index-url https://download.pytorch.org/whl/cu117` /
+    # `--find-links https://pytorch-geometric.com/whl/torch-1.13.1+cu117.html`;
+    # findLinks below points at data.pyg.org directly, the canonical host
+    # that URL redirects to, confirmed to serve the identical wheel listing).
+    extraIndexUrls:
+      - https://download.pytorch.org/whl/cu117
+    findLinks:
+      - https://data.pyg.org/whl/torch-1.13.1+cu117.html
+    # Every ABI-sensitive CUDA extension package pinned below also carries a
+    # real `hashes` entry (downloaded and verified byte-for-byte on
+    # 2026-09-24) AND is listed here so `--only-binary <name>` is passed on
+    # every install invocation — install fails closed rather than silently
+    # falling back to a from-source build if wheel resolution ever fails.
+    # torch-geometric is deliberately excluded: it has no published wheel at
+    # all (PyPI only ships an sdist), and it is pure Python with no CUDA/ABI
+    # concern, so building it from source is normal and expected.
+    binaryOnly:
+      - torch
+      - torch-cluster
+      - torch-scatter
+      - torch-sparse
+      - torch-spline-conv
+    nvidiaGpu: required
+    cuda:
+      level: required
+    # Upstream's own environment.yml (not requirements.txt, which omits this
+    # entirely) installs an older `setuptools` via conda BEFORE anything else
+    # (verified live on 2026-09-24). It also keeps `pkg_resources`, which several
+    # of the pinned packages expect, available in the bare uv venv.
+    preInstall:
+      - name: setuptools
+        version: 69.5.1
+    # `openfold` is intentionally NOT installed. Upstream builds it so ESMFold can
+    # predict a structure from a bare sequence (`inference.py --protein_sequence`,
+    # `esm.pretrained.esmfold_v1()`), but compiling its CUDA extension needs a
+    # full CUDA 11.7 toolkit (nvcc) matching torch 1.13.1+cu117, which modern GPU
+    # hosts (CUDA 12.x) do not have and which PyPI does not ship (the cu11 nvcc
+    # wheel has no compiler driver). This adapter only accepts a protein
+    # structure file (`proteinPath`), so that code path is never reached; docking
+    # from a PDB uses only ESM2 embeddings (`esm.pretrained`), which do not need
+    # openfold.
+    requirements:
+      - name: torch
+        version: 1.13.1+cu117
+        hashes:
+          - 14c5c9db09df8cf1b3942a3479c779da6e293a84a162d8a6ac71e2bde30e30c5
+      - name: torch-geometric
+        version: "2.2.0"
+        hashes:
+          - fdb282451fc33270e8e0b81d9aec7b70590363227dab0b1a7cb50a91d7b98e1d
+      - name: torch-cluster
+        version: 1.6.0+pt113cu117
+        hashes:
+          - ee94470e92ec17ec94fdeae19e2c0a7bf1cb15505c8f8c4206388774f6c4886a
+      - name: torch-scatter
+        version: 2.1.0+pt113cu117
+        hashes:
+          - 9e26507e54f0cf7b09fe039c5a5d897f53bbbb991c86d4c27115909411236168
+      - name: torch-sparse
+        version: 0.6.16+pt113cu117
+        hashes:
+          - c23999bc4e24379d8ae807176bb31eb6ce47288fc5e0126141761339b0f07225
+      - name: torch-spline-conv
+        version: 1.2.1+pt113cu117
+        hashes:
+          - cf39e3af57084261afaabb233055f5f0b00df5bba51bd58947112ee4f9a7eb6f
+      # environment.yml pins e3nn==0.5.1 and adds pytorch-lightning==1.9.5,
+      # neither of which matches/exists in requirements.txt (which pins
+      # e3nn==0.5.0 and omits pytorch-lightning entirely) — verified live on
+      # 2026-09-24 that environment.yml is the more carefully maintained,
+      # explicitly-sequenced install recipe (it has ordering-rationale
+      # comments requirements.txt lacks), so its pins are followed here.
+      - name: e3nn
+        version: "0.5.1"
+      - name: pytorch-lightning
+        version: "1.9.5"
+      - name: fair-esm
+        version: "2.0.0"
+        extras:
+          - esmfold
+      - name: rdkit
+        version: 2022.03.3
+      - name: scipy
+        version: "1.12.0"
+      - name: scikit-learn
+        version: "1.1.0"
+      - name: networkx
+        version: 2.8.4
+      - name: pandas
+        version: 1.5.1
+      # Upstream pins prody 2.2.0, which has no wheel for CPython 3.10 and whose C
+      # extension (rtbtools.c) fails to compile on current toolchains. 2.4.1 builds
+      # and imports on 3.10 (verified on Linux x64) and DiffDock only uses it for
+      # PDB parsing/chi angles in datasets/parse_chi.py.
+      - name: prody
+        version: "2.4.1"
+      # Upstream leaves numpy unpinned; unpinned resolves to numpy 2.x, which breaks
+      # the pinned pandas 1.5.1 and torch 1.13.1 builds. 1.23.5 matches that era.
+      - name: numpy
+        version: "1.23.5"
+      - name: pybind11
+        version: 2.11.1
+      - name: torchmetrics
+        version: 0.11.0
+      # Upstream's own requirements.txt/environment.yml pin dllogger unpinned
+      # (`dllogger@git+https://github.com/NVIDIA/dllogger.git`, no @revision) —
+      # a real upstream laxity, not something to carry over. This pins the
+      # exact commit that was dllogger's HEAD when verified on 2026-09-23; a
+      # future revalidation should re-check whether upstream has since pinned
+      # a specific commit of its own to adopt instead.
+      - name: dllogger
+        source: https://github.com/NVIDIA/dllogger
+        revision: 0478734ff7be75adde8d160e04872664d1c62e5f
+# `inference.py` silently downloads `diffdock_models.zip` from a GitHub release
+# on first run when `--model_dir` doesn't already exist
+# (`utils/download.py:download_and_extract`), and separately, every run
+# unconditionally computes ESM2 language-model embeddings
+# (`utils/inference_utils.py`'s `InferenceDataset` is always constructed with
+# `lm_embeddings=True`), which downloads the `esm2_t33_650M_UR50D` checkpoint
+# into torch.hub's cache dir on first use — both are real, verified network
+# fetches into an otherwise uncontrolled location, not just the one obvious
+# weights archive. All three artifacts are pinned here with checksums
+# downloaded and verified byte-for-byte on 2026-09-23, and the adapter always
+# passes `--model_dir`/`--confidence_model_dir` pointing at the pre-populated
+# `diffdock-weights` target plus `TORCH_HOME` pointing at the pre-populated
+# `torch-home` target, so neither download path is ever reached during a real
+# run.
+assets:
+  - id: diffdock-l-weights
+    url: https://github.com/gcorso/DiffDock/releases/download/v1.1/diffdock_models.zip
+    source: https://github.com/gcorso/DiffDock
+    sha256: 5a95b6a1555be47ab1d6f0a8ffd25152f7fe32f5956005bb821e13e7a37d4a3d
+    sizeBytes: 129825226
+    archive: zip
+    target: diffdock-weights
+  - id: esm2-t33-650m-ur50d
+    url: https://dl.fbaipublicfiles.com/fair-esm/models/esm2_t33_650M_UR50D.pt
+    source: https://github.com/facebookresearch/esm
+    license: MIT
+    sha256: ea9d0522b335a8778dea6535a65301f10208dece28cd5865482b0b1fc446168c
+    sizeBytes: 2604537549
+    target: torch-home/hub/checkpoints/esm2_t33_650M_UR50D.pt
+  - id: esm2-t33-650m-ur50d-contact-regression
+    url: https://dl.fbaipublicfiles.com/fair-esm/regression/esm2_t33_650M_UR50D-contact-regression.pt
+    source: https://github.com/facebookresearch/esm
+    license: MIT
+    sha256: 8ffe6edbd4173dc8d45c2cd5cb27d43aad77ec26b4c768200c58ae1f96693575
+    sizeBytes: 3687
+    target: torch-home/hub/checkpoints/esm2_t33_650M_UR50D-contact-regression.pt
+hardware:
+  platforms:
+    - linux-x64
+  nvidiaGpu: required
+  cuda:
+    level: required
+input:
+  formats:
+    - .json
+  required: true
+outputs:
+  - id: top_pose
+    glob: "*/rank1.sdf"
+    required: true
+  - id: ranked_poses
+    glob: "*/rank*_confidence*.sdf"
+    required: true
+  - id: poses_summary
+    glob: "poses_summary.json"
+    required: true

package/dist/models/ligandmpnn/manifest.yaml

@@ -0,0 +1,67 @@
+schemaVersion: 1
+name: ligandmpnn
+displayName: LigandMPNN
+modelVersion: 0.1.2
+adapterVersion: 0.1.0
+description: Protein sequence design for protein-ligand and multimer systems (Dauparas et al. 2023).
+category: sequence-design
+status: beta
+license: MIT
+homepage: https://github.com/dauparas/LigandMPNN
+source:
+  repository: https://github.com/dauparas/LigandMPNN
+  revision: 26ec57ac976ade5379920dbd43c7f97a91cf82de
+runtimes:
+  - kind: python
+    python: "3.11"
+    installer: uv
+    requirements:
+      - name: biopython
+        version: "1.79"
+      - name: filelock
+        version: 3.13.1
+      - name: fsspec
+        version: 2024.3.1
+      - name: Jinja2
+        version: 3.1.3
+      - name: MarkupSafe
+        version: 2.1.5
+      - name: ml-collections
+        version: 0.1.1
+      - name: dm-tree
+        version: 0.1.8
+      - name: torch
+        version: 2.2.1
+      - name: numpy
+        version: "1.23.5"
+      - name: prody
+        version: 2.4.1
+      - name: pyparsing
+        version: 3.1.1
+      - name: scipy
+        version: 1.12.0
+      # prody 2.4.1 imports `pkg_resources` at import time; a bare uv venv has no
+      # setuptools, and setuptools >= 81 no longer ships pkg_resources.
+      - name: setuptools
+        version: 69.5.1
+assets:
+  - id: ligandmpnn-checkpoint
+    url: https://files.ipd.uw.edu/pub/ligandmpnn/ligandmpnn_v_32_010_25.pt
+    source: LigandMPNN upstream model parameter distribution
+    license: MIT
+    sha256: 161cd264061fda9680cbb940255522ae42f2966c552d045d87913d9452a80970
+    target: model_params/ligandmpnn_v_32_010_25.pt
+    sizeBytes: 10541943
+    archive: none
+hardware:
+  platforms:
+    - darwin-arm64
+    - linux-x64
+input:
+  formats:
+    - .pdb
+  required: true
+outputs:
+  - id: sequences
+    glob: "seqs/*.fa"
+    required: true

package/dist/models/opendde/manifest.yaml

@@ -0,0 +1,169 @@
+schemaVersion: 1
+name: opendde
+displayName: OpenDDE Preview
+modelVersion: 1.1.1
+adapterVersion: 0.1.0
+description: All-atom biomolecular co-folding (proteins, nucleic acids, ligands, ions) from Aureka AI Research — upstream preview release.
+category: structure-prediction
+# Upstream itself labels this a preview ("CLI flags, input/output JSON fields,
+# and released checkpoints may change between versions ... not yet intended for
+# production pipelines"), so this stays `beta` regardless of verification.
+status: beta
+license: Apache-2.0
+homepage: https://github.com/aurekaresearch/OpenDDE
+source:
+  repository: https://github.com/aurekaresearch/OpenDDE
+  # Tag v1.1.1 (annotated tag object 1e986714b6a397d0d812d58ee78e1c7dc8c75cf2
+  # peels to this commit), verified via `git ls-remote --tags` on 2026-09-26.
+  # The PyPI `opendde==1.1.1` wheel pinned below was unpacked and compared
+  # file-by-file against this commit's `opendde/` and `runner/` trees: all 117
+  # files byte-identical, and `opendde/config/model_manifest.json` in both
+  # declares package version 1.1.1.
+  revision: ddfa1df8aff1babf1fddac4247b7d2351bd0ce9f
+adapterVerification:
+  lastVerifiedAt: "2026-09-26T12:31:00.000Z"
+  platforms:
+    - darwin-arm64
+  notes: >-
+    Clean `moldesk install opendde` on an Apple M3 (macOS 26.6.2, Python
+    3.11.16, torch 2.7.1, opendde 1.1.1). verifyInstallation passed: asset
+    sizes and SHA-256, a real MPS tensor op, pinned versions, and CLI flags.
+    `moldesk run opendde examples/opendde/tiny.json` succeeded in 39 s with
+    upstream logging "Selected inference device: mps". Outputs: a parseable
+    mmCIF and confidence JSON, checksummed in run.json. The ligand-file
+    example also passed, with companion staging verified after the source
+    files were deleted. Invalid device/template params were rejected before
+    launch. Linux/CUDA was not run (no NVIDIA hardware), so it is not
+    advertised. Full evidence is in models/opendde/README.md.
+runtimes:
+  # Apple Silicon: native PyPI torch (MPS-enabled macOS arm64 build), no
+  # CUDA/cuEquivariance extra, never the NVIDIA-only Docker image. Upstream
+  # documents `--device mps` on Apple Silicon; the live gate for this entry is
+  # recorded in models/opendde/README.md.
+  - kind: python
+    python: "3.11"
+    installer: uv
+    platforms:
+      - darwin-arm64
+    # Measured on the 2026-09-26 live install: the resulting .venv is 823 MB.
+    # Download is an estimate (compressed wheels, torch alone is 68.6 MB).
+    estimatedDownloadBytes: 300000000
+    estimatedDiskBytes: 865000000
+    requirements:
+      # Exact artifact digest of opendde-1.1.1-py3-none-any.whl from PyPI.
+      - name: opendde
+        version: 1.1.1
+        hashes:
+          - 94b193bd360e017c9cfab08d199ec9333cb2919a49fe1d9270c659c4b2efe544
+      # opendde 1.1.1 itself pins `torch==2.7.1`; this is PyPI's
+      # torch-2.7.1-cp311-none-macosx_11_0_arm64.whl.
+      - name: torch
+        version: 2.7.1
+        hashes:
+          - aea4fc1bf433d12843eb2c6b2204861f43d8364597697074c8d38ae2507f8730
+  # Linux x64 + NVIDIA: upstream's documented `--torch-backend cu126
+  # "opendde[gpu]"` install (cuEquivariance/Triton kernels), expressed through
+  # the closed-enum `torchBackend` field rather than a pip argument fragment.
+  # NOT advertised in `hardware.platforms` below: no NVIDIA hardware was
+  # available to run the CUDA live gate, so a Linux host is rejected by the
+  # compatibility check before this entry is ever selected. Add `linux-x64` to
+  # `hardware.platforms` only after that gate passes (see README).
+  - kind: python
+    python: "3.11"
+    installer: uv
+    platforms:
+      - linux-x64
+    torchBackend: cu126
+    nvidiaGpu: required
+    cuda:
+      level: required
+      minDriverCudaVersion: "12.6"
+    requirements:
+      - name: opendde
+        version: 1.1.1
+        extras:
+          - gpu
+        hashes:
+          - 94b193bd360e017c9cfab08d199ec9333cb2919a49fe1d9270c659c4b2efe544
+      # download.pytorch.org/whl/cu126: torch-2.7.1+cu126-cp311-cp311-manylinux_2_28_x86_64.whl
+      - name: torch
+        version: 2.7.1+cu126
+        hashes:
+          - e1a8465165708c2e2e90786ade8a3e1b1d01eca1f022792cd397caad9d8c21bc
+# `opendde pred` would otherwise download the checkpoint and CCD files into
+# `$OPENDDE_ROOT_DIR` (default `~/.cache/opendde`) on first use. They are pinned
+# here instead to the exact Hugging Face commit upstream's own
+# `opendde/config/model_manifest.json` / `dependency_url.py` name
+# (aurekaresearch/OpenDDE @ eddd563ce96571f784012edd8f045181c8f8627d), with the
+# sizes and SHA-256 digests upstream publishes there — independently confirmed
+# against Hugging Face's X-Linked-Size / X-Linked-ETag for each file on
+# 2026-09-26. The adapter points OPENDDE_ROOT_DIR at `assets/opendde-root`.
+#
+# Deliberately NOT installed:
+# - `opendde_abag.pt` (antibody–antigen checkpoint, 2625271509 bytes, sha256
+#   5cf37441ddef2a2f148b81dd4a218ad274f996fecaf17dec901ab6cf1351713d): the asset
+#   model has no opt-in/optional asset concept, so installing it would force an
+#   extra 2.6 GB on every user.
+# - Template/RNA-MSA search databases (pdb_seqres ~220 MB, Rfam ~220 MB,
+#   RNAcentral ~13 GB, NT-RNA ~75 GB, plus a PDB mmCIF mirror) and the
+#   template-only `obsolete_to_successor.json`/`release_date_cache.json`. The
+#   adapter rejects `use_template=true`, and `use_rna_msa=true` without
+#   precomputed per-chain RNA A3M files, so nothing ever reaches for them.
+assets:
+  - id: opendde-v1-checkpoint
+    url: https://huggingface.co/aurekaresearch/OpenDDE/resolve/eddd563ce96571f784012edd8f045181c8f8627d/opendde.pt
+    source: https://huggingface.co/aurekaresearch/OpenDDE
+    license: Apache-2.0
+    sha256: 7b826620390afad877ee2babc6a4d0df81b94d3a0be030959853d6a7da0807cc
+    sizeBytes: 2625249069
+    target: opendde-root/checkpoint/opendde.pt
+  - id: opendde-ccd-components
+    url: https://huggingface.co/aurekaresearch/OpenDDE/resolve/eddd563ce96571f784012edd8f045181c8f8627d/common/components.cif
+    source: https://huggingface.co/aurekaresearch/OpenDDE
+    sha256: bb31ae5cf6c8bc669924313077cb4231ee5ffefd3a20118cd14f3ec89f8bb6a5
+    sizeBytes: 490777362
+    target: opendde-root/common/components.cif
+  - id: opendde-ccd-rdkit-mols
+    url: https://huggingface.co/aurekaresearch/OpenDDE/resolve/eddd563ce96571f784012edd8f045181c8f8627d/common/components.cif.rdkit_mol.pkl
+    source: https://huggingface.co/aurekaresearch/OpenDDE
+    sha256: d1cfb71f5993a3ebea7c47877022d7f597bbfbaf86e28a4770e957da6c50cd35
+    sizeBytes: 142498117
+    target: opendde-root/common/components.cif.rdkit_mol.pkl
+hardware:
+  platforms:
+    - darwin-arm64
+  # ~3.26 GB of assets plus ~1.5 GB for the managed Python environment.
+  minDiskGb: 6
+input:
+  formats:
+    - .json
+  required: true
+outputs:
+  # Upstream writes <out_dir>/<job_name>/seed_<seed>/predictions/… (verified
+  # against runner/dumper.py and docs/infer_json_format.md at the pinned
+  # revision). Segment-wise globs, so an unrelated .cif/.json elsewhere under
+  # output/ can never satisfy these.
+  - id: structures
+    glob: "*/seed_*/predictions/*_sample_*.cif"
+    required: true
+  - id: confidence
+    glob: "*/seed_*/predictions/*_summary_confidence_sample_*.json"
+    required: true
+  - id: atom_confidence
+    glob: "*/seed_*/predictions/*_full_data_sample_*.json"
+    required: false
+  # Adapter-written PDB copy of each mmCIF (per-atom pLDDT in the B-factor
+  # column, CONECT records for ligand bonds). The mmCIF stays the primary
+  # result; structures legacy PDB can't represent are listed in
+  # moldesk-pdb-export-errors.json instead of failing the run.
+  - id: structures_pdb
+    glob: "*/seed_*/predictions/*_sample_*.pdb"
+    required: false
+  - id: pdb_export_errors
+    glob: "moldesk-pdb-export-errors.json"
+    required: false
+  # Adapter-written copy of the job with companion references rewritten to
+  # their staged paths; only present when the job references files.
+  - id: resolved_job
+    glob: "moldesk-resolved-job.json"
+    required: false

package/dist/models/proteinmpnn/manifest.yaml

@@ -0,0 +1,43 @@
+schemaVersion: 1
+name: proteinmpnn
+displayName: ProteinMPNN
+modelVersion: v_48_020
+adapterVersion: 0.1.0
+description: Structure-conditioned protein sequence design (Dauparas et al., Science 2022).
+category: sequence-design
+status: beta
+license: MIT
+homepage: https://github.com/dauparas/ProteinMPNN
+source:
+  repository: https://github.com/dauparas/ProteinMPNN
+  revision: 8907e6671bfbfc92303b5f79c4b5e6ce47cdef57
+runtimes:
+  - kind: python
+    python: "3.11"
+    installer: uv
+    requirements:
+      - name: torch
+        version: 2.2.1
+      - name: numpy
+        version: 1.26.4
+assets:
+  - id: proteinmpnn-checkpoint
+    url: https://raw.githubusercontent.com/dauparas/ProteinMPNN/8907e6671bfbfc92303b5f79c4b5e6ce47cdef57/vanilla_model_weights/v_48_020.pt
+    source: ProteinMPNN pinned source revision
+    license: MIT
+    sha256: c9cb4a671d79604111231f8dbfc7c590e06f1197453b7a6854ac6661a642f5bd
+    target: vanilla_model_weights/v_48_020.pt
+    sizeBytes: 6681301
+    archive: none
+hardware:
+  platforms:
+    - darwin-arm64
+    - linux-x64
+input:
+  formats:
+    - .pdb
+  required: true
+outputs:
+  - id: sequences
+    glob: "seqs/*.fa"
+    required: true

package/dist/runtime-selection.d.ts

@@ -0,0 +1,24 @@
+import type { ModelManifestV1, PlatformId, PythonRuntimeSpec, RuntimeSpec, SourceSpec } from "./schema.js";
+/**
+ * Maps the running process's OS/arch to a manifest `PlatformId`. Returns `undefined`
+ * for any host outside the two platforms MoleculeDesk v0.1 supports — callers must
+ * treat that as "no platform id", not throw here, since a legacy runtime entry with
+ * no `platforms` field must still resolve on hosts outside this enum (matching the
+ * pre-existing behavior of installs that never checked platform at all).
+ */
+export declare function detectHostPlatformId(platform?: string, arch?: string): PlatformId | undefined;
+/**
+ * Resolves exactly one python runtime entry from `runtimes` for the given host
+ * platform. An entry with no `platforms` field matches every platform (legacy,
+ * single-runtime manifests such as ProteinMPNN/LigandMPNN); an entry with a
+ * `platforms` field matches only when it includes `platform`.
+ *
+ * Fails closed:
+ * - zero matches -> `RUNTIME_PLATFORM_UNSUPPORTED`
+ * - more than one match -> `RUNTIME_SELECTION_AMBIGUOUS` (a manifest-authoring bug —
+ *   two runtime entries must never both claim the same host platform).
+ */
+export declare function selectPythonRuntime(runtimes: readonly RuntimeSpec[], platform: PlatformId | undefined): PythonRuntimeSpec;
+/** The effective source for an already-selected python runtime entry: its own
+ * per-entry override when present, otherwise the manifest-level `source`. */
+export declare function effectiveRuntimeSource(manifest: Pick<ModelManifestV1, "source">, runtime: Pick<PythonRuntimeSpec, "source">): SourceSpec | undefined;

package/dist/runtime-selection.js

@@ -0,0 +1,54 @@
+import { MoldeskError } from "./errors.js";
+/**
+ * Maps the running process's OS/arch to a manifest `PlatformId`. Returns `undefined`
+ * for any host outside the two platforms MoleculeDesk v0.1 supports — callers must
+ * treat that as "no platform id", not throw here, since a legacy runtime entry with
+ * no `platforms` field must still resolve on hosts outside this enum (matching the
+ * pre-existing behavior of installs that never checked platform at all).
+ */
+export function detectHostPlatformId(platform = process.platform, arch = process.arch) {
+    if (platform === "darwin" && arch === "arm64")
+        return "darwin-arm64";
+    if (platform === "linux" && arch === "x64")
+        return "linux-x64";
+    return undefined;
+}
+/**
+ * Resolves exactly one python runtime entry from `runtimes` for the given host
+ * platform. An entry with no `platforms` field matches every platform (legacy,
+ * single-runtime manifests such as ProteinMPNN/LigandMPNN); an entry with a
+ * `platforms` field matches only when it includes `platform`.
+ *
+ * Fails closed:
+ * - zero matches -> `RUNTIME_PLATFORM_UNSUPPORTED`
+ * - more than one match -> `RUNTIME_SELECTION_AMBIGUOUS` (a manifest-authoring bug —
+ *   two runtime entries must never both claim the same host platform).
+ */
+export function selectPythonRuntime(runtimes, platform) {
+    const pythonRuntimes = runtimes.filter((r) => r.kind === "python");
+    const matches = pythonRuntimes.filter((r) => r.platforms === undefined || (platform !== undefined && r.platforms.includes(platform)));
+    if (matches.length === 0) {
+        throw new MoldeskError({
+            code: "RUNTIME_PLATFORM_UNSUPPORTED",
+            message: platform
+                ? `No python runtime entry supports platform ${platform}.`
+                : "No python runtime entry supports this host platform.",
+            remediation: "Run on darwin-arm64 or linux-x64, or pick a model whose runtimes[] declares this platform.",
+            details: { platform, candidateCount: pythonRuntimes.length },
+        });
+    }
+    if (matches.length > 1) {
+        throw new MoldeskError({
+            code: "RUNTIME_SELECTION_AMBIGUOUS",
+            message: `${matches.length} python runtime entries match platform ${platform ?? "this host"}; a manifest must declare at most one match per platform.`,
+            remediation: "Fix the manifest so no two runtime entries' `platforms` (or absence thereof) overlap for the same host platform.",
+            details: { platform, matchCount: matches.length },
+        });
+    }
+    return matches[0];
+}
+/** The effective source for an already-selected python runtime entry: its own
+ * per-entry override when present, otherwise the manifest-level `source`. */
+export function effectiveRuntimeSource(manifest, runtime) {
+    return runtime.source ?? manifest.source;
+}

package/dist/runtime-selection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime-selection.test.js

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vitest";
+import { MoldeskError } from "./errors.js";
+import { detectHostPlatformId, effectiveRuntimeSource, selectPythonRuntime } from "./runtime-selection.js";
+function pythonRuntime(overrides = {}) {
+    return {
+        kind: "python",
+        python: "3.11",
+        installer: "uv",
+        requirements: [{ name: "torch" }],
+        ...overrides,
+    };
+}
+describe("detectHostPlatformId", () => {
+    it("maps darwin/arm64 to darwin-arm64", () => {
+        expect(detectHostPlatformId("darwin", "arm64")).toBe("darwin-arm64");
+    });
+    it("maps linux/x64 to linux-x64", () => {
+        expect(detectHostPlatformId("linux", "x64")).toBe("linux-x64");
+    });
+    it("returns undefined for unsupported platform/arch combinations", () => {
+        expect(detectHostPlatformId("win32", "x64")).toBeUndefined();
+        expect(detectHostPlatformId("darwin", "x64")).toBeUndefined();
+        expect(detectHostPlatformId("linux", "arm64")).toBeUndefined();
+    });
+});
+describe("selectPythonRuntime", () => {
+    it("resolves a legacy manifest with no platforms field on its one entry, on any platform", () => {
+        const legacy = pythonRuntime();
+        expect(selectPythonRuntime([legacy], "darwin-arm64")).toBe(legacy);
+        expect(selectPythonRuntime([legacy], "linux-x64")).toBe(legacy);
+        expect(selectPythonRuntime([legacy], undefined)).toBe(legacy);
+    });
+    it("resolves a single match among per-platform entries", () => {
+        const darwin = pythonRuntime({ platforms: ["darwin-arm64"] });
+        const linux = pythonRuntime({ platforms: ["linux-x64"] });
+        expect(selectPythonRuntime([darwin, linux], "darwin-arm64")).toBe(darwin);
+        expect(selectPythonRuntime([darwin, linux], "linux-x64")).toBe(linux);
+    });
+    it("fails closed with RUNTIME_PLATFORM_UNSUPPORTED on zero matches", () => {
+        const linuxOnly = pythonRuntime({ platforms: ["linux-x64"] });
+        try {
+            selectPythonRuntime([linuxOnly], "darwin-arm64");
+            expect.unreachable();
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(MoldeskError);
+            expect(error.code).toBe("RUNTIME_PLATFORM_UNSUPPORTED");
+        }
+    });
+    it("fails closed with RUNTIME_PLATFORM_UNSUPPORTED when the host platform is undetected", () => {
+        const linuxOnly = pythonRuntime({ platforms: ["linux-x64"] });
+        expect(() => selectPythonRuntime([linuxOnly], undefined)).toThrowError(MoldeskError);
+    });
+    it("fails closed with RUNTIME_SELECTION_AMBIGUOUS when two entries both match the same platform", () => {
+        const first = pythonRuntime({ platforms: ["darwin-arm64"] });
+        const second = pythonRuntime({ platforms: ["darwin-arm64"], python: "3.12" });
+        try {
+            selectPythonRuntime([first, second], "darwin-arm64");
+            expect.unreachable();
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(MoldeskError);
+            expect(error.code).toBe("RUNTIME_SELECTION_AMBIGUOUS");
+        }
+    });
+    it("ignores non-python runtime entries entirely", () => {
+        const docker = { kind: "docker", image: "x", digest: `sha256:${"a".repeat(64)}`, gpu: "none" };
+        const python = pythonRuntime();
+        expect(selectPythonRuntime([docker, python], "linux-x64")).toBe(python);
+    });
+});
+describe("effectiveRuntimeSource", () => {
+    const manifestSource = { repository: "https://github.com/example/manifest-level", revision: "a".repeat(40) };
+    const entrySource = { repository: "https://github.com/example/entry-level", revision: "b".repeat(40) };
+    it("prefers the per-entry source override when present", () => {
+        expect(effectiveRuntimeSource({ source: manifestSource }, { source: entrySource })).toEqual(entrySource);
+    });
+    it("falls back to the manifest-level source when the entry has none", () => {
+        expect(effectiveRuntimeSource({ source: manifestSource }, {})).toEqual(manifestSource);
+    });
+    it("returns undefined when neither is set", () => {
+        expect(effectiveRuntimeSource({}, {})).toBeUndefined();
+    });
+});