sysml 0.1.0__py3-none-win_amd64.whl

sysml/library.py

@@ -0,0 +1,151 @@
+"""The KerML and SysML standard library, in the two forms the backends read.
+
+`standard_library()` is the directory of the library's models that a platform wheel carries, for the
+SysML Toolkit backend: ``Model.from_toolkit("model.sysml", library_dir=standard_library())``.
+
+`standard_library_json()` is the same library as full-form interchange JSON, for the payload backend
+(`PayloadLibrary`). It is too large for a wheel: the first call downloads ``sysml_library-<version>.zip``
+from this version's GitHub release, checks it against the SHA-256 that GitHub states for that file,
+and keeps the JSON in the user's cache, where later calls find it. Nothing is downloaded unless the
+function is called. ``SYSML_LIBRARY_JSON`` names a copy of the JSON to use instead, for machines
+without access to GitHub.
+
+Both are the library of the SysML v2 release the SDK was built with, licensed under the Eclipse
+Public License 2.0, not the SDK's Apache-2.0: see the LICENSE and NOTICE beside them.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import shutil
+import sys
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+from .base import SdkError
+
+REPOSITORY = "Open-MBEE/sysml-sdk"
+JSON_VARIABLE = "SYSML_LIBRARY_JSON"
+CACHE_VARIABLE = "SYSML_CACHE_DIR"
+_PACKAGE = Path(__file__).resolve().parent
+_TIMEOUT = 60
+
+
+class LibraryUnavailable(SdkError):
+    """The standard library is not at hand: this installation does not carry it, or it could not be
+    downloaded and checked."""
+
+
+def standard_library() -> Path:
+    """The directory of the standard library models a platform wheel carries, to pass as
+    `library_dir`. The source distribution and a repository checkout carry none."""
+    directory = _PACKAGE / "stdlib"
+    if not directory.is_dir() or next((p for p in directory.rglob("*") if p.suffix in (".kerml", ".sysml")),
+                                      None) is None:
+        raise LibraryUnavailable(
+            "this installation of the SDK carries no standard library models (only the platform "
+            "wheels do); pass the sysml.library directory of sysml_library-<version>.zip from "
+            f"https://github.com/{REPOSITORY}/releases as library_dir")
+    return directory
+
+
+def standard_library_json(*, version: str | None = None, cache_dir: str | os.PathLike | None = None) -> Path:
+    """The standard library as full-form JSON, for `PayloadLibrary`: the file ``SYSML_LIBRARY_JSON``
+    names, else the copy in the cache (``cache_dir``, else ``SYSML_CACHE_DIR``, else the user's cache
+    directory), downloaded from the GitHub release of ``version`` (default: this SDK's) on the first
+    call and checked against the SHA-256 GitHub states for it."""
+    named = os.environ.get(JSON_VARIABLE)
+    if named:
+        if not Path(named).is_file():
+            raise LibraryUnavailable(f"{JSON_VARIABLE} names {named}, which is not a file")
+        return Path(named)
+    version = version or _version()
+    stem = f"sysml_library-{version}"
+    target = Path(cache_dir) if cache_dir is not None else _cache_root()
+    target = target / stem
+    found = target / "sysml.library.full.json"
+    if found.is_file():
+        return found
+
+    page = f"https://github.com/{REPOSITORY}/releases/tag/v{version}"
+    by_hand = (f"download {stem}.zip from {page}, unpack it, and set {JSON_VARIABLE} to the "
+               "sysml.library.full.json it holds")
+    try:
+        release = _get_json(f"https://api.github.com/repos/{REPOSITORY}/releases/tags/v{version}")
+    except (OSError, ValueError) as e:
+        raise LibraryUnavailable(f"cannot read the release v{version} of {REPOSITORY} ({e}); {by_hand}") from e
+    asset = next((a for a in release.get("assets", []) if a.get("name") == f"{stem}.zip"), None)
+    if asset is None:
+        raise LibraryUnavailable(f"the release v{version} of {REPOSITORY} has no {stem}.zip ({page})")
+    digest = asset.get("digest") or ""
+    if not digest.startswith("sha256:"):
+        raise LibraryUnavailable(f"GitHub states no SHA-256 for {stem}.zip, so it is not downloaded; {by_hand}")
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(dir=target.parent) as work:
+        archive = Path(work) / f"{stem}.zip"
+        try:
+            sha256 = _download(asset["browser_download_url"], archive)
+        except OSError as e:
+            raise LibraryUnavailable(f"cannot download {asset['browser_download_url']} ({e}); {by_hand}") from e
+        if sha256 != digest.removeprefix("sha256:"):
+            raise LibraryUnavailable(f"{stem}.zip does not match the SHA-256 GitHub states for it "
+                                     f"({sha256}, not {digest.removeprefix('sha256:')}); nothing was kept")
+        try:
+            with zipfile.ZipFile(archive) as z:
+                for name in ("sysml.library.full.json", "LICENSE", "NOTICE", "README.txt"):
+                    z.extract(f"{stem}/{name}", work)
+        except (KeyError, zipfile.BadZipFile) as e:
+            raise LibraryUnavailable(f"{stem}.zip is not the archive the SDK expects ({e}); {by_hand}") from e
+        if target.exists():
+            shutil.rmtree(target)  # a copy left incomplete by an earlier call
+        os.replace(Path(work) / stem, target)
+    return found
+
+
+def _version() -> str:
+    """This SDK's version: its installed metadata, else (in a repository checkout) pyproject.toml's."""
+    from importlib import metadata
+    try:
+        return metadata.version(__package__)
+    except metadata.PackageNotFoundError:
+        pyproject = _PACKAGE.parent.parent / "pyproject.toml"
+        m = re.search(r'^version = "([^"]+)"', pyproject.read_text(encoding="utf-8"), re.M)
+        if m is None:
+            raise LibraryUnavailable("cannot tell this SDK's version; pass version=")
+        return m.group(1)
+
+
+def _cache_root() -> Path:
+    if os.environ.get(CACHE_VARIABLE):
+        return Path(os.environ[CACHE_VARIABLE])
+    if sys.platform == "win32":
+        return Path(os.environ.get("LOCALAPPDATA") or Path.home() / "AppData" / "Local") / "sysml" / "Cache"
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Caches" / "sysml"
+    return Path(os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache") / "sysml"
+
+
+def _request(url: str, accept: str) -> urllib.request.Request:
+    return urllib.request.Request(url, headers={"User-Agent": f"{__package__}-sdk", "Accept": accept})
+
+
+def _get_json(url: str) -> dict:
+    with urllib.request.urlopen(_request(url, "application/vnd.github+json"), timeout=_TIMEOUT) as response:
+        return json.load(response)
+
+
+def _download(url: str, path: Path) -> str:
+    """Write the file at `url` to `path`; its SHA-256, as hex."""
+    h = hashlib.sha256()
+    with urllib.request.urlopen(_request(url, "application/octet-stream"), timeout=_TIMEOUT) as response, \
+            open(path, "wb") as out:
+        while chunk := response.read(1 << 20):
+            h.update(chunk)
+            out.write(chunk)
+    return h.hexdigest()

sysml/stdlib/Domain Libraries/Analysis/.meta.json

@@ -0,0 +1,10 @@
+{
+  "index": {
+    "AnalysisTooling": "AnalysisTooling.sysml",
+    "SampledFunctions": "SampledFunctions.sysml",
+    "StateSpaceRepresentation": "StateSpaceRepresentation.sysml",
+    "TradeStudies": "TradeStudies.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+}

sysml/stdlib/Domain Libraries/Analysis/.project.json

@@ -0,0 +1,27 @@
+{
+  "name": "SysML Analysis Library",
+  "description": "Standard analysis domain library for the Systems Modeling Language (SysML)",
+  "version": "2.1.0-dev.20260501",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.1.0-dev.20260501"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.1.0-dev.20260501"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.1.0-dev.20260501"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
+      "versionConstraint": "2.1.0-dev.20260501"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Quantities-and-Units-Domain-Library.kpar",
+      "versionConstraint": "2.1.0-dev.20260501"
+    }
+  ]
+}

sysml/stdlib/Domain Libraries/Analysis/AnalysisTooling.sysml

@@ -0,0 +1,34 @@
+standard library package AnalysisTooling {
+	doc
+	/*
+	 * This package contains definitions for metadata annotations related
+	 * to analysis tool integration.
+	 */
+
+	private import ScalarValues::*;
+	
+	metadata def ToolExecution {
+		doc
+		/*
+		 * ToolExecution metadata identifies an external analysis tool to be
+		 * used to implement the annotated action.
+		 */
+	
+		attribute toolName : String;
+		attribute uri : String;
+	}
+	
+	metadata def ToolVariable {
+		doc
+		/*
+		 * ToolVariable metadata is used in the context of an action that has
+		 * been annotated with ToolExecution metadata. It is used to annotate
+		 * a parameter or other feature of the action with the name of the
+		 * variable in the tool that is to correspond to the annotated
+		 * feature.
+		 */
+	
+		attribute name : String;
+	}
+	
+}

sysml/stdlib/Domain Libraries/Analysis/SampledFunctions.sysml

@@ -0,0 +1,119 @@
+standard library package SampledFunctions {
+	doc
+	/*
+	 * This package provides a library model of discretely sampled mathematical functions.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::Positive;
+	private import Collections::KeyValuePair;
+	private import Collections::OrderedMap;
+	private import SequenceFunctions::size;
+	private import ControlFunctions::forAll;
+	private import ControlFunctions::collect;
+	private import ControlFunctions::select;
+	
+    attribute def SamplePair :> KeyValuePair {
+		doc
+		/*
+		 * SamplePair is a key-value pair of a domain-value and a range-value, used as a sample element in SampledFunction.
+		 */
+	
+        attribute domainValue :>> key;
+        attribute rangeValue :>> val;
+    }
+
+	attribute def SampledFunction :> OrderedMap {
+		doc
+		/*
+	     * SampledFunction is a variable-size, ordered collection of 'SamplePair' elements that represents a generic, discretely sampled, 
+	     * uni-variate or multi-variate mathematical function. The function must be montonic, either strictly increasing or strictly
+	     * decreasing.
+	     * 
+	     * It maps discrete domain values to discrete range values.
+	     * The domain of the function is represented by the sequence of 'domainValue' of each 'SamplePair' in 'samples', and 
+	     * the range of the function is represented by the sequence of 'rangeValue' of each 'SamplePair' in 'samples'.
+	     */
+	
+		attribute samples: SamplePair[0..*] ordered :>> elements;
+		
+		assert constraint {
+			// Note: Assumes the functions '<' and '>' are defined for the domain type.
+			(1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) < samples.domainValue#(i+1)) } or  // Strictly increasing
+            (1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) > samples.domainValue#(i+1)) }     // Strictly decreasing
+		}
+	}
+	
+	calc def Domain { 
+		doc
+		/* 
+		 * Domain returns the sequence of the domainValues of all samples in a SampledFunction.
+		 */
+		 
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.domainValue;
+	}
+	
+	calc def Range { 
+		doc
+		/* 
+		 * Range returns the sequence of the rangeValues of all samples in a SampledFunction.
+		 */
+			
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.rangeValue;
+	}
+	
+	calc def Sample {
+		doc
+		/* 
+		 * Sample returns a SampledFunction that samples a given calculation over a sequence of domainValues.
+		 */
+		 
+		in calc calculation { in x; }
+		in attribute domainValues [0..*];
+		return sampling = new SampledFunction (
+			samples = domainValues->collect { in x; new SamplePair(x, calculation(x)) }
+		);
+	}
+	
+	calc def Interpolate {
+		doc
+		/*
+		 * An Interpolate calculation returns an interpolated range value from a given SampledFunction for a given domain value.
+		 * If the input domain value is outside the bounds of the domainValues of the SampleFunction, null is returned.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		return attribute result;
+	}
+		
+	calc interpolateLinear : Interpolate {
+		doc
+		/*
+		 * interpolateLinear is an Interpolate calculation assuming a linear functional form between SamplePairs.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		
+		private attribute domainValues = Domain(fn);
+		private attribute index : Positive[0..1] =
+			(1..size(domainValues))->select { in i : Positive; domainValues#(i) <= value }#(1);
+			
+		private calc def Linear {
+			in attribute lowerSample : SamplePair;
+			in attribute upperSample : SamplePair;
+			in attribute value;
+			private attribute f = (value - lowerSample.domainValue) / (lowerSample.domainValue - upperSample.domainValue);
+			return result = upperSample.rangeValue + f * (lowerSample.rangeValue - upperSample.rangeValue);				
+		}
+		
+		return result [0..1] =
+			if index == null or index == size(domainValues)? null
+			else if domainValues#(index) < domainValues#(index+1)? Linear(fn.samples#(index), fn.samples#(index+1), value)
+			else Linear(fn.samples#(index+1), fn.samples#(index), value);
+	}
+	
+}

sysml/stdlib/Domain Libraries/Analysis/StateSpaceRepresentation.sysml

@@ -0,0 +1,143 @@
+standard library package StateSpaceRepresentation {
+	doc
+	/*
+	 * This package provides a model of the foundational state-space system representation, 
+	 * commonly used in control systems.
+	 */
+
+    private import ISQ::DurationValue;
+    private import Quantities::VectorQuantityValue;
+    private import VectorCalculations::*;
+
+    abstract attribute def StateSpace :> VectorQuantityValue;
+    abstract attribute def Input :> VectorQuantityValue;
+    abstract attribute def Output :> VectorQuantityValue;
+
+    abstract calc def GetNextState { 
+    	in input: Input; 
+    	in stateSpace: StateSpace; 
+    	in timeStep: DurationValue; 
+    	return : StateSpace;
+    }
+    abstract calc def GetOutput {
+    	in input: Input; 
+    	in stateSpace: StateSpace;
+    	return : Output;
+	}
+	
+     abstract action def StateSpaceEventDef {
+    	doc
+    	/*
+    	 * Events to be received.
+    	 */
+    }
+    action def ZeroCrossingEventDef :> StateSpaceEventDef;
+
+    item def StateSpaceItem {
+    	doc
+    	/*
+    	 * Item for SSR connection
+    	 */
+    }
+
+    abstract action def StateSpaceDynamics {
+	    doc
+	    /*
+	     * StateSpaceDynamics is the simplest form of State Space Representation,
+	     * and nextState directly computes the stateSpace of the next timestep. 
+	     */
+    
+        in attribute input: Input;
+
+        abstract calc getNextState: GetNextState;
+        abstract calc getOutput: GetOutput;
+        attribute stateSpace: StateSpace;
+
+        out attribute output: Output = getOutput(input, stateSpace);
+    }
+
+    abstract attribute def StateDerivative :> VectorQuantityValue {
+	    doc
+	    /*
+	     * The definition of the time derivative of StateSpace, which means dx/dt, where x is StateSpace
+	     */
+    
+        ref stateSpace: StateSpace;
+        constraint { stateSpace.order == order }
+    }
+
+    abstract calc def GetDerivative {
+	    doc
+	    /*
+	     * Computes the time derivative of stateSpace, which corresponds dx/dt = f(u, x), where u is input and x is stateSpace.
+	     */
+	    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateDerivative;
+	}
+	
+    abstract calc def Integrate {
+	    doc
+	    /*
+	     * Integrates stateSpace to compute the next stateSpace, which corresponds to x + int dx/dt dt.
+	     * Its actual implementation should be given by a solver. 
+	     */
+    
+        in getDerivative: GetDerivative;
+        in input: Input;
+        in initialState: StateSpace;
+        in timeInterval: DurationValue;
+        return result: StateSpace;
+	}
+	
+    abstract action def ContinuousStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * ContinuousStateSpaceDynamics represents continuous behavior.
+	     * derivative needs to return a time derivative of stateSpace, i.e. dx/dt.
+	     */
+    
+        abstract calc getDerivative: GetDerivative;
+        calc :>> getNextState: GetNextState {
+            /* We compute nextState by Integrate defined above by giving derivative calc. */
+            calc integrate: Integrate {
+                in getDerivative = ContinuousStateSpaceDynamics::getDerivative;
+                in input = GetNextState::input;
+                in initialState = GetNextState::stateSpace;
+                in timeInterval = GetNextState::timeStep;
+           }
+           return result = integrate.result;
+        }
+
+        event occurrence zeroCrossingEvents[0..*] : ZeroCrossingEventDef {
+        	/* ContinuousStateSpaceDynamics may cause zero crossings anomaly. */ 
+        }
+    }
+
+    abstract calc def GetDifference {
+    	doc
+	    /*
+	     * Computes difference of stateSpace by one timestep, that is x(k+1) - x(k),
+	     * where k is the timestep number. 
+	     */
+    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateSpace;
+	}
+	
+    abstract action def DiscreteStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * DiscreteStateSpaceDynamics represents discrete behavior.
+	     * differences needs to return difference of the stateSpace for each timestep.
+	     */
+    
+        abstract calc getDifference: GetDifference;
+        calc :>> getNextState: GetNextState {
+            attribute diff: StateSpace = getDifference(input, stateSpace);
+            return result = stateSpace + diff;
+        }
+    }
+}

sysml/stdlib/Domain Libraries/Analysis/TradeStudies.sysml

@@ -0,0 +1,171 @@
+standard library package TradeStudies {
+	doc
+	/*
+	 * This package provides a simple framework for defining trade-off study analysis cases.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::*;
+	private import ScalarFunctions::*;
+	private import ControlFunctions::*;
+	
+	abstract calc def EvaluationFunction {
+		doc
+		/*
+		 * An EvaluationFunction is a calculation that evaluates a TradeStudy alternative,
+		 * producing a ScalarValue that can be comparted with the evaluation of other
+		 * alternatives.
+		 */
+	
+		in ref alternative : Anything {
+			doc
+			/*
+			 * The alternative to be evaluated.
+			 */
+		} 
+		
+		return attribute result : ScalarValue[1] {
+			doc
+			/*
+			 * A ScalarValue representing the evaluation of the given alternative.
+			 */
+		} 
+	}
+	
+	abstract requirement def TradeStudyObjective {
+		doc
+		/*
+		 * A TradeStudyObjective is the base definition for the objective of a TradeStudy.
+		 * The requirement is to choose from a given set of alternatives the selectedAlternative
+		 * for that has the best evaluation according to a given EvaluationFunction. What
+		 * value is considered "best" is not defined in the abstract base definition but must be
+		 * computed in any concrete specialization.
+		 */
+	
+		subject selectedAlternative : Anything {
+			doc
+			/*
+			 * The alternative that should be selected, as evaluated using the given 
+			 * ObjectiveFunction.
+			 */
+		}
+		
+		in ref alternatives : Anything[1..*] {
+			doc
+			/*
+			 * The alternatives being considered in the TradeStudy for which this TradeStudyObjective 
+			 * is the objective.
+			 */
+		}
+		
+		in calc eval : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used in evaluating the given alternatives.
+			 */
+		}
+		
+		attribute best : ScalarValue {
+			doc
+			/*
+			 * Out of the evaluation results of all the given alternatives, the one that is considered 
+			 * "best", in the sense that it is the value the selectedAlternative should have. This 
+			 * value must be computed in any concrete specialization of TradeStudyObjective.
+			 */
+		}
+				
+		require constraint { eval(selectedAlternative) == best }
+	}
+	
+	requirement def MinimizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MinimizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the minimum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+		 
+		attribute :>> best = alternatives->minimize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the minimum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	requirement def MaximizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MaximizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the maximum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+	
+		attribute :>> best = alternatives->maximize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the maximum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	abstract analysis def TradeStudy {
+		doc
+		/*
+		 * A TradeStudy is an analysis case whose subject is a set of alternatives
+		 * (at least one) and whose result is a selection of one of those alternatives.
+		 * The alternatives are evaluated based on a given ObjectiveFunction and the
+		 * selection is made such that it satisfies the objective of the TradeStudy
+		 * (which must be a TradeStudyObjective).
+		 */
+	
+		subject studyAlternatives : Anything[1..*] {
+			doc
+			/*
+			 * The set of alternatives being considered in this TradeStudy. 
+			 * 
+			 * In a TradeStudy usage, bind this feature to the actual collection of
+			 * alternatives to be considered.
+			 */
+		}
+		
+		abstract calc evaluationFunction : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used to evaluate the alternatives.
+			 * 
+			 * In a TradeStudy usage, redefine this feature to provide the desired
+			 * calculation (or bind it to a calculation usage that does so).
+			 */
+		}
+		
+		objective tradeStudyObjective : TradeStudyObjective {
+			doc
+			/*
+			 * The objective of this TradeStudy.
+			 * 
+			 * Redefine this feature to give it a definition that is a concrete
+			 * specialization of TradeStudyObjective. That can either be one of the
+			 * specializations provided in this package, or a more specific user-
+			 * defined one.
+			 */
+		
+            subject :>> selectedAlternative;
+			in ref :>> alternatives = studyAlternatives;
+			in calc :>> eval = evaluationFunction;
+		}
+		
+		return selectedAlternative : Anything = studyAlternatives->selectOne {in ref a {
+			doc
+			/*
+			 * The alternative selected by this TradeStudy, which is the one that meets the
+			 * requirement of the tradeStudyObjective.
+			 */
+		} tradeStudyObjective(selectedAlternative = a)};
+	}
+	
+}

sysml/stdlib/Domain Libraries/Cause and Effect/.meta.json

@@ -0,0 +1,8 @@
+{
+  "index": {
+    "CausationConnections": "CausationConnections.sysml",
+    "CauseAndEffect": "CauseAndEffect.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+}

sysml/stdlib/Domain Libraries/Cause and Effect/.project.json

@@ -0,0 +1,23 @@
+{
+  "name": "SysML Cause and Effect Library",
+  "description": "Standard cause-and-effect domain library for the Systems Modeling Language (SysML)",
+  "version": "2.1.0-dev.20260501",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.1.0-dev.20260501"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.1.0-dev.20260501"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.1.0-dev.20260501"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
+      "versionConstraint": "2.1.0-dev.20260501"
+    }
+  ]
+}