OSLC-OP is working on publishing an OASIS multi-part specification:
OSLC Systems Modeling Language Version 2.0. Part 1: Specification
OSLC Systems Modeling Language Version 2.0. Part 2: Vocabulary
OSLC Systems Modeling Language Version 2.0. Part 3: Constraints
OSLC Systems Modeling Language Version 2.0. Part 4: Machine Readable Vocabulary Terms
OSLC Systems Modeling Language Version 2.0. Part 4: Machine Readable Constraints
This is the same as other OSLC servers and RDF vocabularies, and that Systems Modeling Application Programming Interface (API) and Services can reference these documents instead of directly including copies in the OMG specification zip file. The vocabulary and constraints would also be published on open-services.net and accessed using the namespace URL.

The Part 1: Specification describes the conformance clauses an OSLC SysML server meets. It references OMG Systems Modeling Language. https://www.omg.org/spec/SysML/ for all information on SysML. It is a standard for an OSLC server supporting SysML, with vocabulary terms providing an RDF representation of the normative OMG SysML v2 XMI.

See file:///Users/jamsden/Developer/OSLC/oslc-op/oslc-specs/specs/am/architecture-management-spec.html which is a similar specification following the same pattern.

I expect to have a draft project specification published by OASIS soon.

the standard should specify how the commits (and previousCommit(s) ) are transverse to get all the elements

Two Branches can have the same head (Commit) … need multiplicity change
for example to start them off with the same set of elements

This is perhaps not an issue and may require no action other than acknowledging that it is being done, and isn’t formally following KerML semantics.

If this is not acceptable, then we can generate the OSLC SysML v2 vocabulary to import and specialize KerML. That would add some additional work and redundancy, but could be done.

If this is adopted, then there is no reason for the OSLC 3.0 API to define the KerML vocabulary and constraints, hence the reason it is not include in #1 above.

This namespace will be published at http://open-services.net/ns and will provide content negotiation for tools to be able to access the vocabulary and constraints in various RDF resource representations.

All OSLC domain specifications use an open-services.net namespace, e.g., http://open-services.net/ns/am#. The same namespace is used for vocabulary terms and shapes for consistency, and to support navigation to specific sections in the vocabulary and constraints documents for elements of the namespace. The namespaces URLs also provide machine readable access to the RDF resources for use by tools.

RDF namespaces can include version identifiers, but for OSLC integration standards, the OSLC-OP recommends against inclusion of version identifiers as that introduces integration incompatibilities as the standards evolve.

The section OSLC 3.0 API section in Systems Modeling Application Programming Interface (API) and Services will need to be updated to refer to the correct namespace.

since DataIdentity is in the scope of the whole project, one can have multiple Branches where this DataIdentity is created in different Commits in different branches... and deleted in different Commits in different Branches...

so these cannot be associated with the DataIdentity... DataVersion's commit is where that information must be stored...

one could however have an operation that takes a project and branch and DataIdentity... and computes the Creation and Deletion Times from this

not sure one needs scope here... how would it work?... needs documentation in the spec about its use and an example

does the standard want to deal with locking on versioning systems?

says in the standard "Branches are immutable", no they are mutable... can change the head subsequently

Data Version record is associated with up to one (0..1) Data Identity record, this is wrong it is multiplicity of 1

need OCL to specify... previousCommits must be in the same project as the Commit

Data does not need to be further refined in the standard (i.e. no need for Relationship and operations like getRelationshipsByRelatedElements)... these could be there for operations that specifically deal with KerML models...
I would suggest if doing that there should be two sections to this standard or possibly two standards... one that deals with
versioning... the other that is specific to the serialized model

I have a reworked model at https://material.elparazim.com/SysMLv2API/

"usage is the set of Project Usage records representing all other Projects being used by the given Project"… this does not work, need a particular commit for this

What does project usage mean?... I am presuming this comes from Cameo kind of idea about ProjectUsage... but what in this spec does it mean and what can one surmise about it

currently in the spec a ProjectUsage refers to a project that is also local on the system (Server)...
there needs to be a way to reference a project (external) on another server...

I have a reworked model at https://material.elparazim.com/SysMLv2API/

Head on Branch should be multiplicity 0..1 ... when Branch is first created there is no commit

Projects may have multiple DataVersions… change Multiplicity

There should be a navigation between DataVersion to DataIdentity... presumably DataVersion knows about DataIdentity but not vice-versa

Two Tags should be able to be on the same Commit… need multiplicity change

Would suggest OCL for ProjectUsage and CommitReference constraints

suggestions in model at https://material.elparazim.com/SysMLv2API/

ProjectUsage needs a derived attribute “usedProject”

“created” attribute in Project, CommitReference, Commit should be

... these are not the only ones

I have a reworked model at https://material.elparazim.com/SysMLv2API/

there needs to be a statement in the standard concerning how things are serialized...

I have reworked the model here https://material.elparazim.com/SysMLv2API/ and used two stereotypes...
<<NS>> and <<SID>> which stand for "No Serialization" and "Serialize Id (only)"
I believe this leads to a full understand of what will come when one serializing something from
the APi (also examples are given for this serialization(s))

the standard for functions should be, e.g.

getExternalRelationships(projectId:UUID, branchId:UID[0..1],commitId:UID[0..1]):ExternalRelationship[0..*]

which means if a branchId is missing use the commitId, if commitId is missing then use the head of the branchId if it is there,
otherwise, use the default Branch and its head of the project given
many of the API operations need to be specified this way to be consistent

I have a reworked model at https://material.elparazim.com/SysMLv2API/

Most of the API is over specified… as an example, getExternalRelationship has that you need to give it a Project… but you do not need a Project, you only need a ProjectId… so for this one example…
getExternalRelationships(project:Project,commit:Commit):ExternalRelationship[0..*] should be
getExternalRelationships(projectId:UID,commitId:UID):ExternalRelationship[0..*]

this would follow the Interface Segregation Principle (“no client should be forced to depend on methods it does not use”)… most of the API is over specified in this way

I have a reworked model at https://material.elparazim.com/SysMLv2API/

specification and language need to be

... this will have the same kind of semantics as
Opaque/Expression or Behavior from UML (see fig 8.2 and its description in UML 2.5.1)

Need at least one example of a specification for an ExternalRelationship...

also need to define what it means if the specification is null (i.e. presume this means that one is referring to the entire element, so this is the way one specifies that an element in a model is really a remote element from another model)... this needs to be specified

need to explain in the standard why value is 1..* (presuming because of the "in" operator, but the semantics of that is not specified)

Fig. 7 orderBy should be

Fig. 7 queries (which should be a singular, query) is an associationend… whereas in fig. 5 queries is shown as an attribute (needs to be removed in fig. 5)

1. Fig. 7, Operator and JoinOperator need to be shown as enumerations, with literal compartments

1. Fig 6 visibility is not shown on all the attributes, needs to be consistent
2. Fig 7 visibility is not shown on all the attributes, needs to be consistent

Fig 5 Project, Commit, CommitReference all have created as a attribute, But many of the examples (and some of the text have timestamp).. needs to be consistent… I like “created” as it tells one what the timestamp is for

and deleted as the other timestamp name

would suggest using either MOF or UML to show diagrams and to employ ownership dots... note that KerML is specified this way

there are some multiplicities not shown... since there is no specification in the standard about what modeling language the diagram is in... do not know how to interpret these missing multiplicities... would suggest explicitly showing all multiplicities in the diagram

the models used in the standard have the association ends wrapped so you can't see them... suggest that they be unwrapped and
shown on one line

all the standard modeling languages use the same convention as well as most modeling style guides... and so does KerML...

all attributes and association ends are singular... the fact that they can be plural is taken care of by multiplicity

would suggest this convention be followed

IRI standard is referenced, but that does not give a precise definition of how to use it, especially if one wants to be interoperable among implementations... would suggest...

Standard ProjectI IRI:

://

/projects/

/commits/

the first is for Elements and the second is for externally referenced projects

resourceIdentifier is not needed in the record (although would be interesting)... statements about that in another issue... but remove alias, humanidentifier... and description... for example DataVersion and DataIdentity does not need a description... would suggest creating a NamedRecord where name and description are added into that and have Project, Commit, CommitReference, Query specialize that

it does not specify what language these models are in... UML, SysML, KerML, SysML2, MOF?...
it makes a difference in, e.g., interpreting the multiplicities... I would suggest doing the models in MOF and making everything explicit (e.g. multiplicities)

one needs Unique IDs (UID) but not UUID (Universally Unique ID) for most things in this standard,
and would suggest that Record be changed and that it would have

id : UID

also adding

here... and make Project (which is the only thing I can see that needs a UUID)

Project
id : UUID

there is nothing in this standard specifically about SysML or KerML... which is good... I would suggest that the Scope be rewritten and the standard be called "Versioning" or something like that... there is greater use of this standard inside modeling (i.e. legacy modeling language can use this as well) as well as outside of modeling (i.e. anything that can serialized can use this standard to have versions of that serialization)... so would suggest the Scope be changed to say

"The purpose of this standard is to specify the Versioning Application Programming Interface (API) and Services that provide standard services to access, navigate, and operate on serialized elements and in particular can be used for modeling languages."

The goal of this issue is to develop conformance test suite for the Query endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/queries/

5. DELETE /projects/

/queries/

/results
7. GET /projects/

/queries/query-results
Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Tag endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/tags/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Query endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/queries/

5. DELETE /projects/

/queries/

/results
7. GET /projects/

/queries/query-results
Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Tag endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/tags/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Diff and Merge endpoints in the REST/HTTP PSM. This includes the following endpoints:
1. GET /projects/

/branches/

/merge
Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Meta endpoints in the REST/HTTP PSM. This includes the following endpoints:
1. GET /meta/datatypes
2. GET /meta/datatypes/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Diff and Merge endpoints in the REST/HTTP PSM. This includes the following endpoints:
1. GET /projects/

/branches/

/merge
Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Meta endpoints in the REST/HTTP PSM. This includes the following endpoints:
1. GET /meta/datatypes
2. GET /meta/datatypes/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The spec says: "DataVersion.identity should be populated with the DataIdentity that will be deleted in the new commit. When a DataIdentity is deleted in a commit, all its versions (DataVersion) are also deleted,"

This sounds wrong - presumably DataVersions referenced by earlier Commits need to be maintained. This does seem to be the way that the reference implementation behaves.

The goal of this issue is to develop conformance test suite for the Element and Relationship endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/commits/

/roots
4. GET /projects/

/commits/

/elements/

/relationships

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Branch endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/branches/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Element and Relationship endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/commits/

/roots
4. GET /projects/

/commits/

/elements/

/relationships

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Branch endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/branches/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

Description - The goal of this issue is to develop conformance test suite for the Commit endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/commits/

/changes
5. GET /projects/

/commits/

/changes/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

Description - The goal of this issue is to develop conformance test suite for Project endpoints in the REST/HTTP PSM. This includes the following endpoints:
1. GET /projects
2. POST /projects
3. GET /projects/

5. DELETE /projects/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

Description - The goal of this issue is to develop conformance test suite for the Commit endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/commits/

/changes
5. GET /projects/

/commits/

/changes/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

Description - The goal of this issue is to develop conformance test suite for Project endpoints in the REST/HTTP PSM. This includes the following endpoints:
1. GET /projects
2. POST /projects
3. GET /projects/

5. DELETE /projects/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The API PIM specification has a Record entity with humanIdentifier attribute. Commit entity inherits from Record, therefore it is expected for humanIdentifier attribute to exist in Commit entity as well. This is not the case at the moment when looking at the API JSON schema.

humanIdentifier is crucial for tool vendors to be able to relate commit UUIDs to version identifiers that are specific to the different versioning schemas used by different tool vendors.

Since OSLC vocabulary gets generated automatically from SysML2 metamodel, it would make sense for it to include typing hierarchy (eSuperTypes of eClassifiers --> rdfs:subClassOf statements) which would make the vocabulary more semantically “rich” and enable some RDFS reasoning on top of it.

The API PIM specification has a Record entity with humanIdentifier attribute. Commit entity inherits from Record, therefore it is expected for humanIdentifier attribute to exist in Commit entity as well. This is not the case at the moment when looking at the API JSON schema.

humanIdentifier is crucial for tool vendors to be able to relate commit UUIDs to version identifiers that are specific to the different versioning schemas used by different tool vendors.

Since OSLC vocabulary gets generated automatically from SysML2 metamodel, it would make sense for it to include typing hierarchy (eSuperTypes of eClassifiers --> rdfs:subClassOf statements) which would make the vocabulary more semantically “rich” and enable some RDFS reasoning on top of it.

OSLC API Resource Shapes and Vocabulary (both for KerML and SysML2) get automatically generated from respective Ecore metamodels, which leads to OCL expressions ending up as part of documentation in <rdfs:comment> properties. This makes the generated vocabularies and shapes super ugly and hard to read, e.g.:

<rdf:Description rdf:about="https://www.omg.org/spec/SysML/20230201/vocab#Expression">
    <rdfs:comment>&lt;p&gt;An Expression is a Step that is typed by a Function. An Expression that also has a Function as its &lt;code&gt;featuringType&lt;/code&gt; is a computational step within that Function. An Expression always has a single &lt;code&gt;result&lt;/code&gt; parameter, which redefines the &lt;code&gt;result&lt;/code&gt; parameter of its defining &lt;code&gt;function&lt;/code&gt;. This allows Expressions to be interconnected in tree structures, in which inputs to each Expression in the tree are determined as the results of other Expressions in the tree.&lt;/p&gt;

isModelLevelEvaluable = modelLevelEvaluable(Set(Element){})
specializesFromLibrary("Performances::evaluations")
owningMembership &lt;&gt; null and 
owningMembership.oclIsKindOf(FeatureValue) implies
    let featureWithValue : Feature = 
        owningMembership.oclAsType(FeatureValue).featureWithValue in
    featuringType = featureWithValue.featuringType
ownedMembership.selectByKind(ResultExpressionMembership)-&gt;
    forAll(mem | ownedFeature.selectByKind(BindingConnector)-&gt;
        exists(binding |
            binding.relatedFeature-&gt;includes(result) and
            binding.relatedFeature-&gt;includes(mem.ownedResultExpression.result)))</rdfs:comment>

Prior OSLC artifact generation we need to figure out how to distinguish between normative documentation of metamodel objects (eClassifiers and eOperations) vs their OCL expressions in the original Ecore files.

OSLC API Resource Shapes and Vocabulary (both for KerML and SysML2) get automatically generated from respective Ecore metamodels, which leads to OCL expressions ending up as part of documentation in <rdfs:comment> properties. This makes the generated vocabularies and shapes super ugly and hard to read, e.g.:

<rdf:Description rdf:about="https://www.omg.org/spec/SysML/20230201/vocab#Expression">
    <rdfs:comment>&lt;p&gt;An Expression is a Step that is typed by a Function. An Expression that also has a Function as its &lt;code&gt;featuringType&lt;/code&gt; is a computational step within that Function. An Expression always has a single &lt;code&gt;result&lt;/code&gt; parameter, which redefines the &lt;code&gt;result&lt;/code&gt; parameter of its defining &lt;code&gt;function&lt;/code&gt;. This allows Expressions to be interconnected in tree structures, in which inputs to each Expression in the tree are determined as the results of other Expressions in the tree.&lt;/p&gt;

isModelLevelEvaluable = modelLevelEvaluable(Set(Element){})
specializesFromLibrary("Performances::evaluations")
owningMembership &lt;&gt; null and 
owningMembership.oclIsKindOf(FeatureValue) implies
    let featureWithValue : Feature = 
        owningMembership.oclAsType(FeatureValue).featureWithValue in
    featuringType = featureWithValue.featuringType
ownedMembership.selectByKind(ResultExpressionMembership)-&gt;
    forAll(mem | ownedFeature.selectByKind(BindingConnector)-&gt;
        exists(binding |
            binding.relatedFeature-&gt;includes(result) and
            binding.relatedFeature-&gt;includes(mem.ownedResultExpression.result)))</rdfs:comment>

Prior OSLC artifact generation we need to figure out how to distinguish between normative documentation of metamodel objects (eClassifiers and eOperations) vs their OCL expressions in the original Ecore files.

it is unclear if queryConformace implies derivedProperties conformance. In other words, does the query service provider need to support derived properties or not.

it is unclear if queryConformace implies derivedProperties conformance. In other words, does the query service provider need to support derived properties or not.

The POST projects/

/commits endpoint in the OpenAPI spec for REST/HTTP PSM includes examples for creating elements (ElementCommitRequest), relationships (RelationshipCommitRequest), project usages (ProjectUsageCommitRequest), and others. See the attached screenshot. There is also an example (DeleteCommitRequest) that shows the commit request body when elements are to be deleted.

It will help to add specific examples (as below) that provide details of Commit.change when elements are to be created, updated, or deleted.

• ElementCreateCommitRequest
• ElementUpdateCommitRequest
• ElementDeleteCommitRequest

The POST projects/

/commits endpoint in the OpenAPI spec for REST/HTTP PSM includes examples for creating elements (ElementCommitRequest), relationships (RelationshipCommitRequest), project usages (ProjectUsageCommitRequest), and others. See the attached screenshot. There is also an example (DeleteCommitRequest) that shows the commit request body when elements are to be deleted.

It will help to add specific examples (as below) that provide details of Commit.change when elements are to be created, updated, or deleted.

• ElementCreateCommitRequest
• ElementUpdateCommitRequest
• ElementDeleteCommitRequest

In section 7.1.2 - the Data Versioning API Model, versionedData is a derived relationship. The spec does not specify what/how it is derived from.

In section 7.1.2 - the Data Versioning API Model, versionedData is a derived relationship. The spec does not specify what/how it is derived from.

The beta spec should provide details on deleting a project that has commits with data.

ProjectService in the PIM includes an operation "deleteProject" to delete a project. An equivalent endpoint is available in the REST/HTTP PSM (DELETE /projects/

).

However the specification should provide details, including recommended practices on what happens to the contents of a project and project usages when a project is deleted.

Note that authorization (permissions) are outside the scope of the specification but related to this action.

The goal of this task is to develop conformance test cases for the OSLC PSM of the Systems Modeling API and Services. Annex A of the specification includes Conformance Test Suite for the PIM of the API & Services. API & Services Providers and Consumers will generally conform to the individual PSMs, even though PIM-level conformance is allowed. See Section 2 (Conformance) for details. Hence, the specification should provide a Conformance Test Suite for the OSLC PSM.

The beta spec should provide details on deleting a project that has commits with data.

ProjectService in the PIM includes an operation "deleteProject" to delete a project. An equivalent endpoint is available in the REST/HTTP PSM (DELETE /projects/

).

However the specification should provide details, including recommended practices on what happens to the contents of a project and project usages when a project is deleted.

Note that authorization (permissions) are outside the scope of the specification but related to this action.

The goal of this task is to develop conformance test cases for the OSLC PSM of the Systems Modeling API and Services. Annex A of the specification includes Conformance Test Suite for the PIM of the API & Services. API & Services Providers and Consumers will generally conform to the individual PSMs, even though PIM-level conformance is allowed. See Section 2 (Conformance) for details. Hence, the specification should provide a Conformance Test Suite for the OSLC PSM.

In the PIM, ProjectDataVersioningService.diffCommits(...) operation returns a set of differences between two commits (baseCommit and compareCommit). This includes elements added, updated, or deleted in the compareCommit compared to the baseCommit.
The set of differences returned from the diffCommits operations can be large, even though served using pagination.
In many scenarios, consumers of the API may only be interested in specific types of changes, e.g. elements added, or updated, or deleted.
Can we add an additional argument to the diffCommits operation that returns a filtered set of differences based on a change type versus all the differences.

In the PIM, ProjectDataVersioningService.getCommitChange(...) operation returns a set of changes in a given commit compared to the previous commit(s). This includes elements added, updated, or deleted in the given commit. The set of changes returned from the getCommitChange(...) operations can be large, even though served using pagination. In many scenarios, consumers of the API may only be interested in specific types of changes, e.g. elements added, or updated, or deleted.
Can we add an additional argument to the getCommitChange(...) operation that returns a filtered set of changes based on a change type versus all the changes?

The query is only described using abstract syntax. While most of the API REST commands are fairly straightforward, it is not the case for query. There needs to be a BNF production that specifies the concrete syntax for query, which is the string that would be passed in the body of the post command

The goal of this task is to develop conformance test cases for the REST/HTTP PSM of the Systems Modeling API and Services.
Annex A of the specification includes Conformance Test Suite for the PIM of the API & Services.
API & Services Providers and Consumers will generally conform to the individual PSMs, even though PIM-level conformance is allowed. See Section 2 (Conformance) for details. Hence, the specification should provide a Conformance Test Suite for the REST/HTTP PSM.

In the Project Data Versioning PIM (Sec 7.1.2, Fig. 5), the relationship between DataVersion and its payload Data is inconsistent with the representation of deletion in Commits.

As per page 71, Commit::change "is the set of DataVersion records representing Data that is created, updated, or deleted in the
Commit". This implies that Data being deleted by the Commit must be expressed as a DataVersion object somehow.

The approach followed by the JSON/RPC PSM is that the DataVersion has an identity that identifies the Data, but the payload is null. However, in the PIM, the multiplicity of DataVersion::payload does not allow it to be null. So seemingly the PIM cannot actually express a Commit that deletes things.

In the API PIM, under ElementNavigationService, there's a getElements service which is dedicated for dumping the entire model content at a given commit.

This is an overkill for a use case when only part of the model content (e.g. a package) is required to do analysis (or any other task) on.

While theoretical a workaround could be used via getRelationshipsByRelatedElement by retrieving all of the owned elements under specified owner, this would result in gazillion separate calls and would not be efficient under slower networks.

Proposal - introduce a new service getOwnedElements with an ability to collect all of the owned elements recursively under specified root or enrich getElements with optional arguments allowing to achieve the same.

Currently state machines GBNF allows for inclusion of control nodes:
fork, join, merge, final
They are not currently supported by SysML v2 state semantics and concrete syntax and need to be removed