Skip to main content

Versioning and Registry

This section is normative.

The MIND Standard, its modalities, metadata profiles, and event types evolve over time. This section defines how versions are assigned and how the central registry is used.

Specification Version​

Each published edition of this document MUST declare a specification version identifier, for example:

  • MIND-Core-Spec@1.0.0

Containers MAY include this identifier in a spec_version field to signal which edition they target.

Modality, Metadata, and Event Versions​

Modalities, metadata profiles, and event types MUST use semantic versioning (major.minor.patch).

  • Increments to major indicate breaking changes.
  • Increments to minor indicate backward-compatible additions.
  • Increments to patch indicate non-breaking fixes.

Implementations MUST treat unknown major versions as potentially incompatible and MAY reject such data.

Registry Structure​

A machine-readable registry of identifiers MUST be provided, including at minimum:

  • modality_registry.json
  • metadata_registry.json
  • event_registry.json
  • optional extension_registry.json

Each entry MUST record:

  • identifier (namespace, family, name, version)
  • status (stable, experimental, deprecated)
  • owning organization or working group
  • link to normative schema.

Status and Deprecation​

Statuses are used as follows:

  • stable — recommended for general use.
  • experimental — subject to change; not recommended for long-lived datasets.
  • deprecated — supported for backward compatibility; not recommended for new work.

Deprecated identifiers MUST remain valid for at least one major version of the Core Specification following deprecation.

Extensions in the Registry​

Extensions under MIND_EXT and vendor namespaces SHOULD register their identifiers in the central registry when intended for broad use.

The registry MUST NOT grant conflicting identifiers for different owners or purposes.

Summary​

The registry and versioning rules in this section ensure that MIND can evolve while remaining interoperable across implementations.