@@ -17,6 +17,20 @@ All notable changes to Open Ontologies are documented here.
 
 ### Added
 
+- **OWL 2 functional syntax loads, whatever the file is called.** `src/ofn.rs`
+  reads OFN into exactly the triples the W3C "OWL 2 Mapping to RDF Graphs"
+  assigns it, and every path that reads a file reaches it: `load`, `validate`,
+  `convert`, `lint`, `batch`, `onto_load` with its compile cache,
+  `onto_validate` and `onto_convert`. A document is OFN when its first token is
+  `Prefix(` or `Ontology(`, so the ORE 2015 reasoner-competition corpus, 1,920
+  OFN files published as `.owl` that all died in the RDF/XML parser, now loads,
+  and `.ofn` is accepted by name. A construct the reader does not translate
+  fails the whole document by name, count and first line, never a silent drop.
+  SWRL `DLSafeRule`s become the `swrl:` vocabulary `onto_rules_import` already
+  reads. Checked against OWL API 4.5.29 on 93 ORE files across the `dl`, `el`
+  and `pure_dl` tracks: all 93 agree once seven documented OWL API habits are
+  undone, and none of the seven is a defect in either reader.
+
 - **A named profile hands a client one job's worth of the tool surface** (#263).
   A client aligning two vocabularies has no use for most of what this server
   registers, and every tool it has no use for is one more chance to call the
 
@@ -59,7 +59,7 @@ Claude dynamically decides the next tool call based on what the previous tool re
 | `onto_query` | To verify structure, answer competency questions, explore the ontology |
 | `onto_diff` | To compare against a reference or previous version |
 | `onto_save` | To persist the ontology to a file |
-| `onto_convert` | To convert between formats (Turtle, N-Triples, RDF/XML, N-Quads, TriG) |
+| `onto_convert` | To convert between formats (reads Turtle, N-Triples, RDF/XML, N-Quads, TriG, JSON-LD and OWL 2 functional syntax; writes the first five) |
 | `onto_clear` | To reset the store before loading a different ontology |
 | `onto_marketplace` | To browse and install ontologies: 33 curated W3C/ISO/industry standards plus community packs from the open registry (`community/registry.json`, fetched at runtime; `community=false` for curated/offline only). Curated IDs always win over community IDs |
 | `onto_plugin_list` | To discover installed WASM plugins (community `.wasm` tools in `~/.open-ontologies/plugins` or `./plugins`) and the tools each declares. Requires a build with `--features plugins` |
 
@@ -152,7 +152,7 @@ For aligning two ontologies:
 | `onto_query` | Verify structure, answer competency questions |
 | `onto_diff` | Compare against a reference or previous version |
 | `onto_save` | Persist ontology to a file |
-| `onto_convert` | Convert between formats (Turtle, N-Triples, RDF/XML, N-Quads, TriG) |
+| `onto_convert` | Convert between formats (reads Turtle, N-Triples, RDF/XML, N-Quads, TriG, JSON-LD and OWL 2 functional syntax; writes the first five) |
 | `onto_clear` | Reset the store before loading a different ontology |
 | `onto_pull` | Fetch ontology from a remote URL or SPARQL endpoint |
 | `onto_push` | Push ontology to a SPARQL endpoint |
 
@@ -53,7 +53,7 @@ standards, so the handoff is a file or a SPARQL endpoint:
 
 | Concern | Shared ground |
 |---|---|
-| Serialisation | Turtle, N-Triples, RDF/XML, JSON-LD, TriG |
+| Serialisation | Turtle, N-Triples, RDF/XML, JSON-LD, TriG; OWL 2 functional syntax read |
 | Schema | OWL, RDFS, SKOS |
 | Constraints | SHACL |
 | Provenance | PROV-O (`prov:wasDerivedFrom`) |
 
@@ -104,7 +104,7 @@ it withheld.
 | `onto_coevolve_dependency_graph` | Build the shape→OWL-dependency map for a SHACL document. |
 | `onto_communities` | Detect communities in the loaded entity graph and return a SKELETON per community: size, top members by degree, internal relations, and the bridges connecting it to other communities. |
 | `onto_conservative_check` | Does adding these axioms change anything the ontology ALREADY said? Reasons base and base+extension to a fixpoint under one rule table and reports closure(base ∪ extension) minus closure(base), restricted to triples every name of which the base already used. |
-| `onto_convert` | Convert an RDF file between formats: turtle, ntriples, rdfxml, nquads, trig |
+| `onto_convert` | Convert an ontology file to turtle, ntriples, rdfxml, nquads or trig. |
 | `onto_cq_run` | Run a batch of competency questions (CQs) against the loaded ontology (#29). |
 | `onto_cq_verdicts_list` | List all stored verdicts for a CQ id, most-recent first. |
 | `onto_crosswalk` | Look up clinical crosswalk mappings for a code and system (ICD10, SNOMED, MeSH). |
@@ -141,7 +141,7 @@ it withheld.
 | `onto_lineage` | Get the compact lineage log for the current or specified session. |
 | `onto_lint` | Check an ontology for quality issues: missing labels, comments, domains, ranges |
 | `onto_lint_feedback` | Accept or dismiss a lint issue to improve future lint runs. |
-| `onto_load` | Load an RDF file or inline Turtle content into the in-memory ontology store. |
+| `onto_load` | Load an ontology file or inline Turtle content into the in-memory ontology store. |
 | `onto_lock` | Lock IRIs to prevent removal during plan/apply. |
 | `onto_map` | Generate a mapping config by inspecting a data file's schema against the currently loaded ontology. |
 | `onto_marketplace` | Browse and install ontologies from the curated catalogue of 33 W3C/ISO/industry standards plus the open community-pack registry (community/registry.json, fetched at runtime; override with OPEN_ONTOLOGIES_COMMUNITY_REGISTRY). |
 
@@ -102,7 +102,7 @@ When embeddings exist, `onto_align` automatically uses them as a 7th alignment s
 | `onto_query` | Verify structure, answer competency questions |
 | `onto_diff` | Compare against a reference or previous version |
 | `onto_save` | Persist the active ontology to a file |
-| `onto_convert` | Convert between Turtle, N-Triples, RDF/XML, N-Quads, TriG |
+| `onto_convert` | Convert between formats (reads Turtle, N-Triples, RDF/XML, N-Quads, TriG, JSON-LD and OWL 2 functional syntax; writes the first five) |
 | `onto_clear` | Reset the in-memory store |
 | `onto_pull` | Fetch ontology from a remote URL or SPARQL endpoint |
 | `onto_push` | Push triples to a SPARQL endpoint |
 
@@ -7,6 +7,14 @@ use oxigraph::model::*;
 use oxigraph::sparql::{QueryResults, SparqlEvaluator};
 use oxigraph::store::Store;
 
+/// How a document is serialised: one of the RDF formats Oxigraph parses, or
+/// OWL 2 functional syntax, which is not RDF and is read by [`crate::ofn`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SourceFormat {
+    Rdf(RdfFormat),
+    OwlFunctional,
+}
+
 /// What a parse produced. `statements` counts parser events; `triples` counts
 /// distinct triples, which is the size of the resulting graph. They differ
 /// whenever the source repeats a statement.
@@ -299,23 +307,42 @@ impl GraphStore {
 
     fn load_file_mode(&self, path: &str, replace: bool) -> anyhow::Result<usize> {
         let content = std::fs::read_to_string(path)?;
-        let format = Self::detect_format_sniffed(path, &content);
-        let reader = Cursor::new(content.as_bytes());
-
-        // A document's own location is its default base, per RFC 3986. Without
-        // it, any file using relative IRIs fails to parse at all, which is
-        // most published RDF/XML: LUBM's generated data would not load a
-        // single triple before this.
-        let base = Self::file_base_iri(path);
         // All or nothing: see load_turtle (issue #93).
-        let mut parser = RdfParser::from_format(format);
-        if let Some(base) = base {
-            parser = parser.with_base_iri(base)?;
-        }
-        let quads: Vec<_> = parser.for_reader(reader).collect::<Result<_, _>>()?;
+        let quads = Self::parse_document(path, &content)?;
         self.store_parsed_quads(&quads, replace)
     }
 
+    /// Parse a whole document, whatever it is serialised as, into quads.
+    ///
+    /// Every path that reads a FILE goes through here (`load_file`,
+    /// `replace_file`, `validate_file`, `content_as_turtle`), so a format this
+    /// engine learns to read is learned once and reaches the CLI, `batch`, the
+    /// MCP tools and the compile cache together. Before the OWL functional
+    /// syntax reader existed each of those called the RDF parser directly, and
+    /// adding a format meant finding all of them.
+    fn parse_document(path: &str, content: &str) -> anyhow::Result<Vec<Quad>> {
+        match Self::detect_source_format(path, content) {
+            SourceFormat::OwlFunctional => Ok(crate::ofn::parse(content)?
+                .into_iter()
+                .map(|t| t.in_graph(GraphName::DefaultGraph))
+                .collect()),
+            SourceFormat::Rdf(format) => {
+                // A document's own location is its default base, per RFC 3986.
+                // Without it, any file using relative IRIs fails to parse at
+                // all, which is most published RDF/XML: LUBM's generated data
+                // would not load a single triple before this. OFN needs none:
+                // its grammar admits only absolute IRIs.
+                let mut parser = RdfParser::from_format(format);
+                if let Some(base) = Self::file_base_iri(path) {
+                    parser = parser.with_base_iri(base)?;
+                }
+                Ok(parser
+                    .for_reader(Cursor::new(content.as_bytes()))
+                    .collect::<Result<_, _>>()?)
+            }
+        }
+    }
+
     fn store_parsed_quads(&self, quads: &[Quad], replace: bool) -> anyhow::Result<usize> {
         let before = if replace {
             0
@@ -361,8 +388,8 @@ impl GraphStore {
 
     /// As `read_as_turtle`, for content already in hand (stdin, for instance).
     pub fn content_as_turtle(path_hint: &str, content: String) -> anyhow::Result<String> {
-        let format = Self::detect_format_sniffed(path_hint, &content);
-        if format == RdfFormat::Turtle {
+        let format = Self::detect_source_format(path_hint, &content);
+        if format == SourceFormat::Rdf(RdfFormat::Turtle) {
             if let Some(base) = Self::file_base_iri(path_hint) {
                 // Keep the default base on the first source line so downstream
                 // parsers report the document's original line numbers. A later
@@ -374,14 +401,7 @@ impl GraphStore {
         let store = Self::new();
         {
             let inner = &store.store;
-            let base = Self::file_base_iri(path_hint);
-            let mut parser = RdfParser::from_format(format);
-            if let Some(base) = base {
-                parser = parser.with_base_iri(base)?;
-            }
-            let quads: Vec<_> = parser
-                .for_reader(Cursor::new(content.as_bytes()))
-                .collect::<Result<_, _>>()?;
+            let quads = Self::parse_document(path_hint, &content)?;
             for quad in &quads {
                 inner.insert(quad)?;
             }
@@ -391,13 +411,35 @@ impl GraphStore {
 
     pub fn validate_file(path: &str) -> anyhow::Result<ValidationCounts> {
         let content = std::fs::read_to_string(path)?;
-        let format = Self::detect_format_sniffed(path, &content);
-        let reader = Cursor::new(content.as_bytes());
-        let mut parser = RdfParser::from_format(format);
-        if let Some(base) = Self::file_base_iri(path) {
-            parser = parser.with_base_iri(base)?;
+        if let SourceFormat::Rdf(format) = Self::detect_source_format(path, &content) {
+            let reader = Cursor::new(content.as_bytes());
+            let mut parser = RdfParser::from_format(format);
+            if let Some(base) = Self::file_base_iri(path) {
+                parser = parser.with_base_iri(base)?;
+            }
+            return Self::count_parsed(parser.for_reader(reader));
+        }
+        Self::count_ofn(&content)
+    }
+
+    /// Validate text handed over without a file name: the CLI's `validate -`
+    /// and `onto_validate` with `inline: true`. Both used to go straight to
+    /// the Turtle parser, which is right for everything they were written for
+    /// and wrong for an OWL functional-syntax document, which no Turtle parser
+    /// can read. With no extension to go on, the content decides.
+    pub fn validate_text(content: &str) -> anyhow::Result<ValidationCounts> {
+        if crate::ofn::looks_like_ofn(content) {
+            return Self::count_ofn(content);
         }
-        Self::count_parsed(parser.for_reader(reader))
+        Self::validate_turtle(content)
+    }
+
+    fn count_ofn(content: &str) -> anyhow::Result<ValidationCounts> {
+        Self::count_parsed(
+            crate::ofn::parse(content)?
+                .into_iter()
+                .map(|t| Ok::<_, oxigraph::io::RdfParseError>(t.in_graph(GraphName::DefaultGraph))),
+        )
     }
 
     /// A local document's default base is its encoded file URL. Building this
@@ -1275,6 +1317,24 @@ impl GraphStore {
         Ok(out)
     }
 
+    /// The serialisation of a document, deciding between the RDF formats
+    /// Oxigraph parses and the one this crate parses itself.
+    ///
+    /// OWL functional syntax wins on content before anything else is
+    /// consulted, because the extension it most often travels under is `.owl`,
+    /// and `.owl` means RDF/XML to [`Self::detect_format`]. The ORE 2015
+    /// reasoner-competition corpus is 1,920 such files and every one of them
+    /// reached the RDF/XML parser and died on its first line. `.ofn` is the
+    /// one extension that names the syntax, so it is honoured even when the
+    /// content does not sniff, which sends a malformed `.ofn` file to the
+    /// reader that can say what is wrong with it.
+    fn detect_source_format(path: &str, content: &str) -> SourceFormat {
+        if crate::ofn::looks_like_ofn(content) || path.to_ascii_lowercase().ends_with(".ofn") {
+            return SourceFormat::OwlFunctional;
+        }
+        SourceFormat::Rdf(Self::detect_format_sniffed(path, content))
+    }
+
     fn detect_format(path: &str) -> RdfFormat {
         if path.ends_with(".ttl") || path.ends_with(".turtle") {
             RdfFormat::Turtle
 
@@ -5,15 +5,17 @@ use serde::Deserialize;
 
 #[derive(Deserialize, JsonSchema)]
 pub struct OntoValidateInput {
-    /// Path to an RDF file OR inline Turtle content
+    /// Path to an ontology file (any format onto_load reads, OWL functional
+    /// syntax included) OR inline Turtle or OWL functional-syntax content
     pub input: String,
     /// If true, treat input as inline content rather than a file path
     pub inline: Option<bool>,
 }
 
 #[derive(Deserialize, JsonSchema)]
 pub struct OntoConvertInput {
-    /// Path to source RDF file
+    /// Path to the source file: any format onto_load reads, OWL functional
+    /// syntax included
     pub path: String,
     /// Target format: turtle, ntriples, rdfxml, nquads, trig
     pub to: String,
@@ -23,7 +25,8 @@ pub struct OntoConvertInput {
 
 #[derive(Deserialize, JsonSchema)]
 pub struct OntoLoadInput {
-    /// Path to RDF file, OR inline Turtle/RDF content
+    /// Path to an ontology file: Turtle, N-Triples, RDF/XML, N-Quads, TriG,
+    /// JSON-LD or OWL 2 functional syntax
     pub path: Option<String>,
     /// Inline Turtle content to load (alternative to path)
     pub turtle: Option<String>,
 
@@ -79,6 +79,9 @@ pub mod marketplace;
 /// answered, on rmcp 1.4.0 and on 1.8.0 alike.
 pub mod mcp_handshake;
 pub mod monitor;
+/// OWL 2 Functional-Style Syntax read into the RDF graph the W3C mapping
+/// assigns it, so `.ofn` files and the OFN-under-`.owl` corpora load.
+pub mod ofn;
 pub mod ontology;
 pub mod ossie;
 pub mod plan;
 
@@ -2553,7 +2553,7 @@ async fn async_main() -> anyhow::Result<()> {
             let result = if input == "-" {
                 let mut buf = String::new();
                 std::io::Read::read_to_string(&mut std::io::stdin(), &mut buf)?;
-                GraphStore::validate_turtle(&buf)
+                GraphStore::validate_text(&buf)
             } else {
                 GraphStore::validate_file(&input)
             };