v0.10.0 - Runtime Environment and Development Kit Release

OpenSysML 0.10.0

0.10.0 is the first minor release of the OpenSysML REDK — the Runtime Environment and Development
Kit, the second generation of OpenMBEE's Model Development Kit (MDK2), expanded and updated for
SysML v2; the Cameo plugin is now OpenSysML MDK. It is cut from main and carries everything that
landed on develop after 0.9.2 — some 250 pull requests, 75 additions, 64 changes and 118 fixes;
full detail per change is in
CHANGELOG.md § 0.10.0.

The headlines: exact arithmetic (unbounded Integers, exact Rationals, across every client); -migrate
as the verb for SysML v1 models, with -portable and -strict output that loads in a tool shipping
only the standard library; action, state-machine, interconnection, case and mixed diagrams with
links back to the source, timelines and message sequences; -import of CSV/TSV/JSON data into feature
values; -compile over Strings, enumerations, records, closures and function values; -self-check
over the SysMLValidation library; a combined sysml-wasm module; a Jupyter kernel with JupyterLab 4
highlighting; every client (Go, Python, Node, Java, Rust, Julia, MATLAB/Octave) reaching the whole
service surface, with install scripts and agent skills for each; and the documentation site at
https://runtime.opensysml.org/.

The wire is additive: three new RPCs (Migrate, RenderView, ExportGraphs) and new optional
fields and capabilities (rational_values, export_graphs, verification arguments); buf breaking
against the 0.9.2 api/proto reports nothing. A service without a capability says so and refuses
what it cannot carry. The notation accepted by 0.9.2 is accepted by 0.10.0 with the exceptions under
Upgrading.

Upgrading

• defer <event>; is removed; the pseudostate keywords are deprecated. The defer state member,
  an OpenSysML extension SysML v2 has no counterpart for, is a defer-notation-removed parse error in
  either conformance mode, pointing at the standard encoding (an ordered buffer, a keeping accept loop
  marked MigrationMetadata::DeferredKeeper, an exit flush); defer is an ordinary name again. The
  choice, junction, history, shallow history, deep history and defer keywords still parse
  but warn nonstandard-notation (an error under -strict) naming the StateMachines library
  spelling (#StateMachines::choice state …), with a quick-fix that rewrites and imports. The SysML
  v1 migrator writes the library spellings.
• Arithmetic is exact. Integers are unbounded (2**70 is 1180591620717411303424, no
  arithmetic overflow); a decimal literal is the exact Rational it spells (0.1 + 0.2 == 0.3 is
  true, 1 / 3 is 1/3). Code comparing against rounded binary64 results, or goldens holding them,
  will see the difference; Real stays binary64. gRPC carries them as Value.rational_value and
  Quantity.rational_magnitude under the rational_values capability.
• A SysML v1 model is migrated, not converted. sysml Model.mdzip -convert sysml exits
  non-zero and names -migrate; -migrate is its own verb, with -portable (one self-contained
  file), -strict (no OpenSysML library references, apart from the deferred-signal
  MigrationMetadata::Deferred* annotations) and -migration-results. Migration output
  changed shape in many places — object flows as succession flows, operation calls and send/accept
  actions, parameter sets, value-specification multiplicities, untyped properties following the
  tool's kind marker, use-case diagrams as connections — and the report says where a run stops on a
  construct the tool simulated and v2 cannot run as written. Goldens pinned to 0.9.2 output need
  refreshing.
• Diagnostics that moved. An assume/require outside a requirement or case body and a
  one-ended first <node>; outside an action body are parse errors, not warnings; imports that make
  a namespace's memberships indistinguishable are reported; an end feature that may vary in time is
  read-only (SysML v2 §8.4.2.2); a multiplicity bound is a literal or a feature name; a standalone
  @M about x; annotates x. Subactions no succession orders are now performed, unordered, instead
  of refused; a signal nothing of its object takes is discarded, not held for a later state.
• Bundled extension libraries are library package, not standard library package
  (DiagramLayout, IdentityMetadata, MigrationMetadata, SysMLValidation); RDF export no longer
  writes sysml:isStandard true for them, and the pilot's warning about them goes away.
• Clients. strictConformance is the parse option and strict its deprecated alias (passing both
  with different values is refused); action and state execution return typed results instead of raw
  dictionaries; a dead service is ServiceUnavailableError; the MATLAB client's
  opensysml.symbol(model, id) is opensysml.getSymbol(model, id); Julia's strict=true raises
  ModelError and strict_conformance=true requests strict conformance; OPENSYSML_SERVICE names
  an external service, otherwise a private one is started.
• Names and places. The Go project is the OpenSysML REDK, the Cameo plugin OpenSysML MDK; the
  documentation site is https://runtime.opensysml.org/ (the old URLs forward) and publishes from
  develop; the standard SysML v2 API client is its own package; a program that only creates a
  REPL session no longer links the translators, protobuf or the network stack (replext/all
  restores them).

Execution, verification and analysis

• Actions. Values pass through forks, joins and merges; several succession flows may leave one
  action, and a succession may lead to a succession flow; an action definition that specializes
  another performs the inherited steps, successions, flows and statements, with redefinition,
  multiplicities, gates and pin bindings honoured; assert constraints a succession orders are
  checked when the flow reaches them; terminate inside a loop names its own loop; for <s> in steps declares and traces its variable; first a if g then b; is a TransitionUsage.
• State machines. Entry actions, transitions out of a named entry action, entry routes that
  terminate the machine; a deferred signal in the standard buffer / accept-loop / exit-flush encoding
  (the PSSM referee and the migrator share the lowering); fill.isActive reads whether a state usage
  is active (StateActivity library); change triggers observe every completed write; junctions
  without an enabled route no longer consume events. The service, every client and the browser
  engine return state-machine execution traces.
• Verification. A constraint or requirement with in parameters is verified with positional
  arguments or named_arguments; statements in a constraint body run as steps of the check before
  its conditions; a satisfaction is decided through the requirements it requires by reference;
  -self-check applies the SysMLValidation library and -self-check-package any package's
  constraint defs.
• Exploration and the model checker reach every order of a body's unordered statements and the
  interleavings inside concurrent bodies; executors due at one instant interleave move by move
  under explore, check, replay and seeded schedules; traces and witnesses name loop, if and
  other statement nodes by what they do; %check-* and -check-* set properties, divergence
  features, inputs, assumptions, witnesses and bounds.
• Compiled models. sysml -compile compiles Strings, enumerations, mixed numeric sequences,
  run-time function values and closures, records and record-feature access, with step budgets;
  calcs pass Integers, Rationals, Reals and Booleans in three words. The lowered graph of an action
  or state machine is a public artifact (-graphs, %graphs, ExportGraphs).
• Data. -import/%import set feature values from CSV, TSV, JSON and JSON Lines
  (-import-map, -import-as, -import-dry-run), with a data-import demo; table views export as
  CSV and TSV; === over sequences is element-wise identity; a printed String reads back as itself.
• A model piped or redirected into sysml is read byte for byte: a literal TAB no longer reaches the
  line editor's completer (which panicked), and CRLF line endings parse as single lines.

Diagrams and documents

• Action views draw an action's parameters as pins and its bindings as edges; interconnection
  diagrams show ports on their nodes and connect edges to them; case and mixed diagrams; a
  GeneralView draws the requirement, definition and usage, and package graphs its filters select;
  filtered GridViews render as relationship matrices; a tree rendering draws the relationships
  between the elements it shows; recorded runs render as timelines and message sequences; rendered
  elements link to their source (-render-link); D2 joins Mermaid, PlantUML and Graphviz as a
  rendering form, and Mermaid output preserves far more detail.
• sysml model.sysml -list documents|views|diagrams|pseudo-views|all names what a model declares;
  machine-readable view rendering is exposed through gRPC (RenderView) and every client; the
  in-browser engine renders declared views and targeted pseudo-views.
• Diagram pictures refuse active SVG content and non-data URL schemes (security); diagrams pack a
  container's unconnected children into rows and keep siblings in declaration order; moved nodes
  route at right angles around the other boxes (libavoid is bundled in the VS Code diagram panel).

SysML v1 migration

• -migrate writes activities the action executor performs: object flows as succession flows,
  operation calls on the object the target pin holds, send object and send signal actions addressed
  to their target, accept nodes as AcceptActionUsage, variables and variable actions, buffer nodes,
  ReduceAction, RaiseExceptionAction, ReadSelfAction results bound to this, structural
  feature reads and writes on the object they are given, parameter sets, xor/implies expression
  trees, uml:Expression else guards, interaction uses, state invariants, and owned rules as
  assertions.
• -portable makes one self-contained file; -strict output loads in the pilot implementation,
  referring to no OpenSysML library beyond the deferred-signal annotations; the service migrates with a Migrate RPC and every client
  migrates (Go MigrateFile/MigrateSource, Python opensysml.migrate(), …).
• A SysML v1 to v2 transformation census records what each construct becomes; the migration report
  says where a run will stop on a construct the tool simulated; migrated comments resolve their
  cross-references; a migrated parametric diagram of MagicDraw's Monte Carlo pattern draws again.
• A migrated action usage a part definition owns writes the part's features when it is performed on
  a part declared in another file, so the migration guide's %action Plant::fill plant walkthrough
  runs as shown.

Interchange and the model API

• Load API element-form JSON files directly; convert to a compact form of API JSON, or only some
  documents of a model, over the service; each document of a model has its own root Namespace in
  the element form.
• The REPL and the Jupyter kernel read and write a SysML v2 API repository (%load/%publish with
  the OMG pilot kernel's four commits model); the standard SysML v2 API client is its own package;
  a bearer token is never paged on to another host.
• RDF: relationships written as notation (:, :>, :>>, ::>, =>, ~, conjugates, …) are
  exported as the metamodel has them; connector ends and feature-chain targets are reflected;
  include <ref>; is a ReferenceSubsetting; a transition's guard is owned through a
  TransitionFeatureMembership; the default [1..1] multiplicity follows the usage metaclass.
• The spec-vs-pilot gap register records where the pinned pilot's own source departs from the
  specification; the two SI magnetic dipole moment units are typed by the quantity they measure.

Clients, editors and the browser

• Go, Python, Node/TypeScript, Java, Rust, Julia, MATLAB/Octave reach the service surface:
  the Node client covers the whole service and connects to sysml-wasm without a service; the Rust
  client reaches every RPC through a typed API and recovers from a dead private service; the Java
  client gains the Python client's newer surface; Julia and MATLAB were expanded with model
  inspection, analysis, document queries and chainable source edits. Task-oriented guides per client;
  agent skills for every client and for modeling (packaging/agent-skills/).
• Jupyter. sysml-jupyter-kernel (pip install jupyter-opensysml-kernel) runs cells through the
  REPL session and ships SysML highlighting for JupyterLab 4 and Notebook 7; %load reads notebooks.
• Browser. sysml-wasm combines the execution and validation JSON-RPC surfaces in one module,
  published as @openmbee/opensysml-wasm; the CLI page of the documentation site runs the real
  REPL in the browser with guided walkthroughs, and the landing page's state machine can be edited
  and debugged there.
• Editors. OpenSysML MDK runs inside MDK's DocGen documents; sysml-lsp answers its first
  request promptly on a multi-file workspace and names its real version; ParseSources names the
  documents an edit reached; a production sysml build without the optional features.

Packaging

• Linux amd64/arm64, macOS amd64/arm64 and Windows amd64 archives, sysml-grpc binaries with
  .sha256 sidecars, SHA256SUMS.txt with its cosign bundle and SLSA provenance, the Python wheel
  and sdist, the Jupyter kernel wheels, the combined WebAssembly module, and the npm, crates.io and
  Maven packages are built by the release workflow from tag v0.10.0; the wheel, sdist, crate, npm
  tarball and jar pin this release's service digests. Published: opensysml 0.10.0 and
  jupyter-opensysml-kernel 0.10.0 on PyPI, @openmbee/opensysml 0.10.0 on npm, opensysml 0.10.0
  on crates.io. The Java client is not on Maven Central for this release; install it from a
  checkout of the tag as java-api.md
  describes.
• New: curl -fsSL https://opensysml.org/install.sh | sh and
  irm https://opensysml.org/install.ps1 | iex install the matching release on any supported
  platform (--tools / -Tools take sysml, sysml-lsp, sysml-grpc, sysml-jupyter-kernel or
  all in both scripts); the documentation site's Downloads page lists every artifact and package-manager route;
  nightly snapshots of the Python and Node clients publish from the same commit as the binaries.
• macOS binaries are not Developer ID signed or notarized;
  macos-distribution.md
  gives the workarounds. Windows binaries are unsigned; SmartScreen warns on first launch.

Verification

The pre-tag gate of docs/project/releasing.md on the release commit (Go 1.25, Linux amd64):
gofmt -l . empty, go build ./..., go vet ./..., golangci-lint and gosec clean, the full
race suite with the OMG training corpus, the three pilot corpora, the pilot library XMI and the PSSM
suite required and the RDF round-trip ratchet unmoved, the stdlib snapshot and conformance gates,
the extension-library pin check, the Python client's 1459 tests, buf breaking against the 0.9.2
schema with no breaking change, the documentation id, link and figure checks, mkdocs --strict
and python3 scripts/changelog.py check clean. The CircleCI release rehearsal on the release
commit passed end to end — the five race shards, binaries, Python and Jupyter distributions,
release artifacts, the GitHub release, digest pin, PyPI/npm/crates/Maven/Jupyter publish rehearsals
and the zero-config smoke — and the merged main passes the SonarCloud quality gate (new-code
coverage 80.9%, overall 86.3%, no open bug or vulnerability). Every change in the range merged
through the pull-request CI on develop and, for the release branch, through the full pull-request
CI against main.