IF Commons GitHub

How works are versioned

0026Draft

0026-works-versioning · owner if · domain commons · part of 0003-mizan

The vocabulary

FR-001checkpartly run

Intellectual Frontiers Releases MUST be a typed ontology in commons/ontology/ifr/ (namespace https://www.intellectualfrontiers.com/ontology/ifr#, prefix ifr:), written as typed values like ifccm and ifqs (0012-ontology), published through commons/libraries/src/generate-ontology.ts in every form the others are (Turtle, OWL functional syntax, RDF/XML, SHACL shapes, JSON Schema, SKOS code lists, SQL code-list tables, SSSOM mappings, an HTML view and an entry in the DCAT catalog), and Mizan's check MUST know its terms so that a specification may name ifr: terms and no others.

Enforced (check): .github: cd commons/ontology && bun test suite/ — ifr-ontology.test.ts: the ontology is typed values in commons/ontology/ifr with the namespace ifr#, every file it generates exists and is current (Turtle, OWL, RDF/XML, SHACL, JSON Schema, SKOS, SQL, SSSOM, HTML, the DCAT catalog entry), the generated OWL is read by ROBOT in CI, and a specification naming an ifr: term the ontology lacks is found

Tests: skipped: suite/ifr-ontology.test.ts the generated OWL functional syntax is read by ROBOT without an error, where ROBOT and Jav; passed: suite/ifr-ontology.test.ts the ontology is typed values under its own namespace, well formed, and every form the gene

FR-002checkpassing

Every class and every class of a code list of the ontology MUST have one mz:OntologyTerm record of the standard it rests on or of why none is adopted (0018-standards-first FR-003), and a class of no standard MUST be unaligned, with what was examined and the day it was added, from which its Decision is due within 90 days.

Enforced (check): .github: cd commons/ontology && bun test suite/ — ifr-ontology.test.ts: every class and code-list class has exactly one audit record, the audit's rules find nothing within the 90 days, and the classes of no standard are unaligned with what was examined and the day they were added

Tests: passed: suite/ifr-ontology.test.ts every class and code-list class has one record of its basis, the audit's rules find nothin

FR-003checkpassing

The ontology MUST keep apart the five things a version number is too often asked to carry: the identity of a work (ifr:Work: a slug and an IRI), a state of its content (ifr:Expression), a rendition of that state (ifr:Manifestation: a PDF, an EPUB, a print run), a version or an edition (ifr:version, ifr:Edition) and a release (ifr:Release: a version that was published, named by a tag and immutable); a work has expressions (ifr:hasExpression) and releases (ifr:hasRelease), an expression has renditions (ifr:hasRendition), a release realizes an expression (ifr:realizes), and a rendition has no version of its own.

Enforced (check): .github: cd commons/ontology && bun test suite/ — ifr-ontology.test.ts: Work, Expression, Manifestation, Release and Edition are distinct classes joined by hasExpression, hasRelease, hasRendition and realizes, with the domains and ranges the requirement names, and a manifestation has no version property

Tests: passed: suite/ifr-ontology.test.ts identity, state, rendition, version and release are different classes, joined by the prope

FR-004checkpassing

The ontology MUST hold three code lists with these keys: ifr:VersionScheme (SemVer, CommitDateEdition, SnapshotDate, IntegerRevision, NoVersion), ifr:WorkKind (Software, Library, CommandLineInterface, Ontology, Schema, Prose, Data, ControlledDocument, Specification) and ifr:Impact (Major, Minor, Patch), each class with the properties the tools branch on.

Enforced (check): .github: cd commons/ontology && bun test suite/ — ifr-ontology.test.ts: the three code lists have exactly the keys the requirement names, in that order, and each individual is of its class

Tests: passed: suite/ifr-ontology.test.ts the three code lists have the keys the specification names, and each individual is of its

Cited by: Subject profiles

FR-005checkpassing

Each ifr:WorkKind MUST use exactly one ifr:VersionScheme (ifr:usesScheme): SemVer for Software, Library, CommandLineInterface, Ontology and Schema; CommitDateEdition for Prose; SnapshotDate for Data, which also carries a SemVer for its schema (ifr:companionScheme); IntegerRevision for ControlledDocument; NoVersion for Specification; and no other kind MUST have a companion scheme.

Enforced (check): .github: cd commons/ontology && bun test suite/ — ifr-ontology.test.ts: each work kind uses the scheme the requirement names, only Data has a companion scheme (SemVer), and the specification and the ontology agree on the nine kinds

Proved by: mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-pure.test.ts the tool's kinds, schemes, impacts and companion scheme are the ontology's, and each schem; passed: suite/ifr-ontology.test.ts each kind of work uses exactly one scheme, and only data carries a companion SemVer for it

Cited by: Mizan, versions/scheme, ifr/ifr

FR-006checkpassing

Each ifr:VersionScheme that has versions MUST carry the pattern its versions match (ifr:versionPattern) and how two of them are ordered (ifr:precedenceRule): Semantic Versioning 2.0.0 for SemVer (build metadata after + is not part of precedence), YYYY.MM.DD-<commit8> for CommitDateEdition, YYYY-MM-DD for SnapshotDate and a whole number from 1 for IntegerRevision; and NoVersion MUST have no pattern; the kind of a work decides its scheme and a pattern never does, since a commit-date edition is also syntactically a Semantic Version (2026.11.17 with the pre-release 1a2b3c4d).

Enforced (check): .github: cd commons/ontology && bun test suite/ — ifr-ontology.test.ts: the pattern of each scheme accepts the versions it should and rejects the ones it should not, the patterns hold no backslash, NoVersion has none, and every ontology of commons has a version that matches the SemVer pattern

Proved by: mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-pure.test.ts the tool's kinds, schemes, impacts and companion scheme are the ontology's, and each schem; passed: suite/ifr-ontology.test.ts each scheme's pattern accepts the versions it should and rejects the ones it should not

Cited by: Mizan, versions/scheme, ifr/ifr

Identity and the release record

FR-007checkpassing

The identity of a work, its slug and its IRI, and the position of a volume in the work it is part of, MUST never change; the check MUST find a change of any of the three between the base and the head as versions/identity-changed, and a work that is renamed or renumbered MUST be a new work whose record names the one it replaces.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: a changed slug, IRI or position is versions/identity-changed, a renamed work is a new work that names the one it replaces (replaces), and a work moved to another folder is the same work

Proved by: mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-pure.test.ts a changed slug, IRI or position is versions/identity-changed, a renamed work is a new work

Cited by: Mizan, versions/judge, versions/rules

FR-008checkpassing

A work MUST have a typed record, the file <work>/release.ts, whose only export is release, an object literal of data that a program reads as data and never runs (as 0020-ifccm reads a harness's declaration, so that a version from Git reads like the present one): slug (lower-case letters, digits and hyphens; the prefix of its tags), kind (the name of an ifr:WorkKind), title, authors (a list of objects with a name), and version (written by the scheme of its kind; absent for a Specification); and it MAY carry iri, partOf (the slug of the work it is part of), position, identifier (a DOI or an ISBN), repository, exclude (paths of the folder that are not the work's files), paths (paths of the repository outside the folder that are also the work's files, FR-039), snapshot (digest, schemaVersion and, where the schema's files are named, schemaPaths, for data), replaces (the slug of the work it replaces, FR-007), approval (for a controlled document, FR-013), retention (FR-027), retired (FR-028) and migratedFrom (FR-037); a decoder MUST check it, an unknown field or a wrong type MUST be a finding that names the file and the field, and a tool MUST write it through a template and never by a hand edit.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the record decodes as data and never runs (an expression and a second export are refused), an unknown field and a wrong type name the field, a kind's own rules hold (no version on a specification, a snapshot only on data), and the one template writes a layout that reads back

Proved by: mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-pure.test.ts the record decodes as data and never runs, an unknown field and a wrong type are findings

Cited by: Mizan, versions/record, ifr/ifr, Ontology, Commons libraries, Libraries by concern

FR-009checkpassing

A work MUST be a folder that holds a release.ts; the files of the work MUST be every file tracked by Git under that folder except the files of a work nested in it, the folder's release.ts and CITATION.cff, and the paths its record names in exclude, and, besides, every file tracked under a path its record names in paths (FR-039); and every judgement of a version MUST be scoped to those files and to no others (path-scoped).

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the files of a work are the tracked files under its folder less nested works, its record, CITATION.cff and exclude, and a deleted file is still the work's; versions-git.test.ts: a change only under exclude is no finding in a real repository

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts check against the merge base: a version grows at the release, so a change of a work's file; passed: suite/versions-pure.test.ts a change only under a path the record excludes is no finding, and a nested work is judged ; passed: suite/versions-pure.test.ts a work is a folder with a release.ts and its files are the tracked files under it except n

Cited by: Mizan, versions/judge, versions/works

The scheme of each kind

FR-010checkpassing

WHERE a work is of the kind Software, Library, CommandLineInterface, Ontology or Schema, its version MUST be a Semantic Version 2.0.0 compared by its precedence (a pre-release before its release, build metadata ignored), the build metadata +<commit12> MUST NOT appear in its record, its tag or a comparison and MAY appear in the version an artifact displays, and a version that does not grow by precedence MUST be a finding.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: Semantic Version precedence with build metadata refused in a record and ignored in a comparison, a pre-release before its release, a version that went back or did not grow is versions/not-grown; versions-git.test.ts: the check on a real branch

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts check against the merge base: a version grows at the release, so a change of a work's file; passed: suite/versions-pure.test.ts versions compare by the scheme: precedence with build ignored, an edition by day then hist; passed: suite/versions-pure.test.ts a work whose files changed and whose version did not grow is versions/not-grown, a grown v

Cited by: Mizan, versions/scheme

FR-011checkpassing

WHERE a work is of the kind Prose, its version MUST be the commit-date edition YYYY.MM.DD-<commit8>: the committer date in UTC of the commit the edition is made at, and the first eight characters of that commit's object name, never the clock; the edition MUST be a commit that is in the history of the head and not before the base's edition, and an edition grows where its date is later or its date is the same and its commit is a descendant of the base's edition commit.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the edition's day is its commit's UTC day, its commit is in the head's history, it grows by a later day or a descendant commit on the same day; versions-git.test.ts: bump writes the UTC day of a commit made at 23:30 in New York and its first eight characters

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts bump by the kind: an edition takes the commit's UTC day and its first eight characters, da; passed: suite/versions-pure.test.ts versions compare by the scheme: precedence with build ignored, an edition by day then hist; passed: suite/versions-pure.test.ts the commit-date edition takes the commit's UTC day, is in the history of the head, and gro

FR-012checkpassing

WHERE a work is of the kind Data, its version MUST be the snapshot date YYYY-MM-DD and the record's snapshot MUST carry the SHA-256 of the snapshot and a Semantic Version for its schema; the snapshot date MUST be strictly later than the base's, its digest MUST differ, and the schema's version MUST grow by precedence wherever the schema's files changed.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: a later snapshot date, another digest and a schema version that grew where the schema's files changed; versions-git.test.ts: bump reads the SHA-256 of the snapshot file

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts bump by the kind: an edition takes the commit's UTC day and its first eight characters, da; passed: suite/versions-pure.test.ts versions compare by the scheme: precedence with build ignored, an edition by day then hist; passed: suite/versions-pure.test.ts data needs a later snapshot date and another digest, and a schema version that grew where

FR-013checkpassing

WHERE a work is of the kind ControlledDocument, its version MUST be an integer revision that is strictly greater than the base's, and the record MUST carry an approval of that revision (approval: approvedBy, a person, role, on, a day, and decision, the identifier of the mz:Decision); the person MUST be data in the record and never inferred, and a revision with no approval MUST be a finding that is never a warning.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: an integer revision that grew, the approval record, versions/approval-missing as a gate-phase finding of the plugin; versions-git.test.ts: bump removes the approval of a new revision until it is recorded, and the check finds it

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts bump by the kind: an edition takes the commit's UTC day and its first eight characters, da; passed: suite/versions-pure.test.ts versions compare by the scheme: precedence with build ignored, an edition by day then hist; passed: suite/versions-pure.test.ts a revision is an integer that grew and has its approval (a finding that gates), and a spec

Cited by: Mizan, versions/record, versions/rules

FR-014checkpassing

A work of the kind Specification MUST have no version: its record MUST NOT carry version, a requirement identifier of it MUST never be renumbered, its revision is the commit, and a tool MUST NOT judge, bump, tag or cite a version of it.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: a specification's record that carries a version is refused and a specification has no version to grow; versions-git.test.ts: bump, tag, cite and notes refuse a specification with exit 2 and write nothing

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts bump by the kind: an edition takes the commit's UTC day and its first eight characters, da; passed: suite/versions-pure.test.ts a revision is an integer that grew and has its approval (a finding that gates), and a spec

Cited by: Mizan, versions/judge, versions/scheme

FR-015checkpartly run

An ontology and a schema of commons MUST use Semantic Versioning: owl:versionInfo MUST be a Semantic Version and owl:versionIRI MUST be the ontology's IRI, a / and that version, and commons' own ontologies (Mizan's, ifccm, ifqs, ifr and the packaging ontology) MUST be at 1.0.0 where the integer 1 was, with the DCAT catalog's dcat:version, the generated files and every test reading them in step.

Enforced (check): .github: cd commons/ontology && bun test suite/ — ontology-versions.test.ts: owl:versionInfo of Mizan's, ifccm, ifqs, ifr and the packaging ontology is a Semantic Version, owl:versionIRI is the ontology IRI, a slash and that version, the generated Turtle and the DCAT catalog carry them, and rdflib reads the version IRI back where Python is present

Proved by: ontology/suite/ontology-versions.test.ts

Tests: skipped: suite/ontology-versions.test.ts an independent reader (rdflib) reads the version IRI of each ontology back, where Python w; passed: suite/ontology-versions.test.ts every ontology of commons is at the Semantic Version 1.0.0 and its version IRI is its IRI,; passed: suite/ontology-versions.test.ts the generated Turtle names the Semantic Version and its version IRI, and the DCAT catalog

Cited by: The ontology in TypeScript

FR-016noneno test run

The version of an ontology or a schema MUST be raised by the impact of the capability that changes it: major where a term is removed or renamed or its range narrows, minor where a term is added, patch where only wording changes; the tool that compares the terms of two versions to check that impact is later.

Enforced (none): Planned, owner decision 2026-11-17: the comparison of the terms of two versions of an ontology or a schema with the declared impact is later, like the API-surface diff; the rule of impact is stated here and not yet checked

Releases

FR-017checkpassing

A published version MUST name its commit (the full object name) and its Git tree hash, MUST be immutable, and MUST NOT be replaced by another commit under the same version: a correction is a new version, and the one it corrects stays.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: a ledger entry names the commit and tree of its tag; versions-git.test.ts: tag writes the commit and tree hash in the message, and a tag moved to another commit is versions/tag-moved

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts tag creates the annotated tag <slug>-v<version> at the head with the commit, tree, scheme ; passed: suite/versions-git.test.ts the ledger from real tags is deterministic, and against an earlier ledger a tag that moved; passed: suite/versions-pure.test.ts the ledger is derived from the tags: each release with its commit, tree, signature and day

Cited by: Mizan, versions/git, versions/ledger

FR-018checkpassing

A release MUST be a signed annotated Git tag named <slug>-v<version> (in a repository of many works, one tag per work, with commons' tags <library>-v<version>, and ifc-docs-v0.1.0 of the work that Docs replaces, keeping the scheme); versions tag <work> MUST create the annotated tag at the head, MUST sign it where Git signing is configured and MUST say so where it is not, MUST refuse a tag that exists, a work whose record has an uncommitted change and a version that is not greater than the work's last tag, and MUST write the tag's message with the commit, the tree hash, the scheme and the evidence tier.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-git.test.ts: tag makes the annotated tag <slug>-v<version> at the head with commit, tree, scheme and tier in its message, says where it is not signed, signs with an ssh-keygen key where Git is set to (git tag -v verifies), refuses a tag that exists, an uncommitted record and a version not greater than the last tag

Proved by: mizan/suite/versions-git.test.ts

Tests: passed: suite/versions-git.test.ts tag creates the annotated tag <slug>-v<version> at the head with the commit, tree, scheme ; passed: suite/versions-git.test.ts where Git is set to sign with an SSH key, tag makes a signed annotated tag that git verifi

FR-019checkpassing

The ledger of releases MUST be derived from the tags and MUST never be written by hand: versions ledger [<work>] MUST read the annotated tags of the form <slug>-v<version> and print, for each, the work, the version, the commit, the tree hash, whether the tag is signed and the day of the commit, in order by the work's scheme, as text or, with --json, as a deterministic JSON document.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the ledger from tags in the order of the scheme, deterministic as text and JSON whatever the order read; versions-git.test.ts: ledger and ledger --json from real tags, twice the same document, signed or not

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts where Git is set to sign with an SSH key, tag makes a signed annotated tag that git verifi; passed: suite/versions-git.test.ts the ledger from real tags is deterministic, and against an earlier ledger a tag that moved; passed: suite/versions-pure.test.ts the ledger is derived from the tags: each release with its commit, tree, signature and day

FR-020checkpassing

The ledger MUST find as versions/ledger-order a tag whose version is not greater than that of a tag of the same work whose commit is an ancestor of its own; MUST find as versions/tag-moved and versions/tag-removed a tag whose commit or tree differs from, or is absent from, an earlier ledger given with --against FILE (a --json output kept earlier) unless the record's retired names the version (FR-028); and MUST compare versions only within one scheme (FR-037).

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: versions/ledger-order, versions/tag-moved and versions/tag-removed against an earlier ledger, retired excuses, comparison only within one scheme; versions-git.test.ts: the same with real tags moved, deleted and out of order, and --against FILE

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts the ledger from real tags is deterministic, and against an earlier ledger a tag that moved; passed: suite/versions-pure.test.ts a tag not greater than one of its own history is versions/ledger-order, a tag that moved o

Cited by: Mizan, versions/ledger, versions/rules

FR-021checkpassing

A version MUST be raised by the capability that changes the work (0020-ifccm) with the impact it declares: a commit's message MAY carry a line Impact: major, Impact: minor or Impact: patch (a Git trailer on a line of its own), and versions bump <work> --impact major|minor|patch MUST write the next version into the record by the scheme of its kind (for SemVer: major raises the first number and zeroes the others, minor raises the second and zeroes the third, patch raises the third), while --impact auto MUST take the greatest of the impacts of the commits since the work's last tag that touch its files and MUST exit with 2 where there is none.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the Impact line is read from a message (the greatest wins, a quoted line is not read); versions-git.test.ts: bump major, minor and patch, and auto from the commits since the last tag that touch the work, exit 2 and no write where none states one

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts bump writes the next version by the impact: auto takes the greatest Impact line of the com; passed: suite/versions-pure.test.ts the impact is read from an Impact line (the greatest wins), and the notes group the Closes

Cited by: changes/commit-message, Mizan, versions/notes, ifr/ifr, governance/ids, Repoctl library, commit and doctor, Intellectual Frontiers Capabilities Configuration Management

FR-022checkpassing

A version grows at the release, and a push does not need it to: versions check [--base REV] MUST compare each work's record at the head with the base (the merge base with REV, which is origin/main unless given, or the head's first parent where the head is REV), and MUST report as versions/not-grown a work whose version is lower than the base's by its scheme (a version never goes back; a snapshot that is taken again with the digest unchanged, and a schema whose files changed under a version that did not grow, are found as before), as versions/record-invalid a record that does not decode, and as versions/scheme-mismatch a version that does not match the pattern of its kind's scheme; it MUST NOT report a work whose files changed and whose version did not (the release raises it: FR-041). The judgement of files changed since a base is the release's, over the tags (FR-041).

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: versions/not-grown for a version that went back, versions/record-invalid and versions/scheme-mismatch over two trees; versions-git.test.ts: check against the merge base and against the head's first parent on a real repository, a change with no growth is no finding

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts bump writes the next version by the impact: auto takes the greatest Impact line of the com; passed: suite/versions-git.test.ts check against the merge base: a version grows at the release, so a change of a work's file; passed: suite/versions-pure.test.ts a work whose files changed and whose version did not grow is versions/not-grown, a grown v

Cited by: Libraries, releasing, versions, Mizan, versions/judge, versions/rules

FR-023checkpassing

Release notes MUST be generated from the capabilities closed since the last tag, so that the change log and the trace chain (0020-ifccm) are one thing: versions notes <work> [--from TAG] MUST print deterministic Markdown that lists, for each Closes #N line (read with the commit-message reader of 0020-ifccm) of the commits that touch the work's files since its last tag, the issue number, the subject of the commit and its first seven characters, grouped by the commit's impact (major, minor, patch, then not stated) and ordered by issue number, and MUST say how many commits closed no capability.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the notes' exact Markdown, grouped by impact and ordered by issue number, and the count of commits that closed none; versions-git.test.ts: notes from real commits since the last tag, deterministic

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts notes from real commits: each Closes line of the commits that touch the work since its las; passed: suite/versions-pure.test.ts the impact is read from an Impact line (the greatest wins), and the notes group the Closes

Cited by: Mizan, versions/notes

FR-024checkpassing

Every work that is released MUST have a citation file: versions cite <work> MUST write CITATION.cff in the work's folder, deterministically from the record (the Citation File Format 1.2.0: cff-version, message, title, version, date-released as the day of the release's commit, authors, repository-code and, only where the record carries identifier, identifiers), and --check MUST exit 1 without writing where the file is not what the record makes.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: CITATION.cff from the record, deterministic; versions-git.test.ts: cite writes it with the day of the release's commit, --check exits 1 where it differs, and the file is not the work's own

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts cite writes CITATION.cff from the record with the day of the release's commit, --check exi; passed: suite/versions-pure.test.ts CITATION.cff is made deterministically from the record, and the identifier is written only

Cited by: Mizan, versions/cite, versions/git

FR-025noneno test run

Every release MUST carry its provenance (a SLSA provenance attestation in the in-toto format), its software bill of materials (SPDX 3) and the SHA-256 checksums of its artifacts, each recorded by its digest on the release (ifr:provenance, ifr:sbom, ifr:checksum); the release workflow that makes them is a later piece and MUST NOT be claimed before it is built.

Enforced (none): Planned, owner decision 2026-11-17: the release workflow that generates the SLSA provenance, the SPDX 3 software bill of materials and the checksums of a release is not built; only the recorded fields exist in the ontology

FR-026checkpassing

Every release MUST record the evidence tier it was released on (ifr:releasedOnTier, an ifqs:QualityTier judged by quality tier), and WHERE a harness declares a regulated domain, versions tag MUST refuse to release unless the tier judged is at least the tier the harness's declaration names (a field releaseTier of the declaration of 0020-ifccm, taken as an argument with the judgement of the tier), and MUST refuse a regulated harness whose declaration names none.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the gate refuses a regulated harness with no releaseTier, no tier judged or a lower tier, and the declaration reads the field compatibly; versions-git.test.ts: tag refuses and makes no tag, and records the tier on the release that passes

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts a regulated harness releases only on the tier it declares: tag refuses with no releaseTier; passed: suite/versions-pure.test.ts a regulated harness releases only on the tier it declares: it is refused with no releaseTi

Cited by: Mizan, versions/gate

FR-027checkpassing

The digests and the metadata of every published version MUST be kept forever; the bytes of a version MAY be deleted only after a retention period the record states (retention, an ISO 8601 duration such as P10Y, from the release's day); the identifier of a version MUST always resolve, and WHERE its bytes are gone it MUST resolve to a tombstone (ifr:Tombstone: the metadata, the digest kept and the day the bytes were removed, in the record's retired entry for that version).

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the retention period and the tombstone of a retired version are read from the record, and bytes removed before the period ends are versions/retention-early

Proved by: mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-pure.test.ts a retired version, its replacement and its tombstone are read from the record, and bytes r

Cited by: Mizan, versions/ledger, versions/record, versions/rules

FR-028checkpassing

A retired or archived version MUST be recorded, never silently removed: the record's retired MUST name the version (version), the day it was retired (on), the version that replaces it (ifr:replaces, ifr:isReplacedBy) where there is one and the day it was archived where it was, and a tag of the ledger that is gone and that retired does not name MUST be a finding.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: a retired version, its replacement and archive day are in the ledger; versions-git.test.ts: a tag gone is found against an earlier ledger unless the record's retired names it

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts the ledger from real tags is deterministic, and against an earlier ledger a tag that moved; passed: suite/versions-pure.test.ts a retired version, its replacement and its tombstone are read from the record, and bytes r

Cited by: Mizan, versions/ledger, versions/record, versions/rules

FR-029checkpassing

A DOI MUST be opt-in per work: a work MAY carry identifier in its record, and versions cite MUST write it into CITATION.cff where it is there and MUST NOT write one where it is not; no tool of this specification mints, requires or registers a DOI.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the identifier is written into CITATION.cff only where the record carries one; versions-git.test.ts: cite with and without one

Proved by: mizan/suite/versions-git.test.ts, mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-git.test.ts cite writes CITATION.cff from the record with the day of the release's commit, --check exi; passed: suite/versions-pure.test.ts CITATION.cff is made deterministically from the record, and the identifier is written only

Cited by: Mizan, versions/cite

FR-030noneno test run

WHERE a work is of the kind Library, the check SHOULD compare the exported surface of its API at the base and at the head with the impact the capability declared, and MUST report a removal under a minor or patch impact; this comparison is later and nothing claims it before it is built.

Enforced (none): Planned, owner decision 2026-11-17: the comparison of a library's exported API surface with the declared impact is later; not built

The tool

FR-031checkpassing

The tool MUST be the command commons/libraries/src/versions.ts over the pure library commons/mizan/src/versions/ and a thin host layer (the library reads no clock and no environment, and takes Git facts and the day as arguments), with the commands check, bump, tag, notes, cite and ledger (FR-018 to FR-024); it MUST exit with 0 where it did what was asked and found nothing, 1 where it found something or cite --check finds the file different, 2 for a usage error (an unknown command, option or work, a work of no version) and 3 where the environment cannot do it, and MUST say not_run with its reason where Git is absent, the directory is no repository or the base cannot be found, and MUST NOT write a record as a result of a run that was not run.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-git.test.ts: the six commands, exit 0, 1, 2 and 3, not_run with its reason for a directory that is no repository, a base that is not there and a shallow clone, nothing written by a run that did not run, on plain Git, as a program on this runtime (Bun, and Node 26 under node --test)

Proved by: mizan/suite/versions-git.test.ts

Tests: passed: suite/versions-git.test.ts bump by the kind: an edition takes the commit's UTC day and its first eight characters, da; passed: suite/versions-git.test.ts check against the merge base: a version grows at the release, so a change of a work's file; passed: suite/versions-git.test.ts the command runs as a program on this runtime: 0 for nothing found, 1 for a finding, 2 for; passed: suite/versions-git.test.ts a directory that is no repository, a base that is not there and a shallow clone with no ba

Cited by: Mizan, versions/git

FR-032checkpassing

Mizan's harness check MUST run a rule plugin of the tool for what a folder can judge offline: that every release.ts under the root decodes, that each version matches the pattern of its kind's scheme, that a Specification has none and that a controlled document's revision has its approval; the comparison with a base is the command's.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: the rule plugin finds a record that does not decode, a version that does not match its scheme, a specification with a version, a controlled document with no approval and a repeated slug, once, for the anchored specification; mizan/check.ts passes the records under the root to holdHarness

Proved by: mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-pure.test.ts holdHarness runs the plugin: a folder whose records are sound passes, a record that does n; passed: suite/versions-pure.test.ts the rule plugin judges every record under a root by itself: it decodes, its version matche

Cited by: Mizan, versions/plugin, versions/scan

FR-033checkpassing

The tool MUST be TypeScript 7 on the runtime of 0005-typescript-practice (Bun by default, Node 26 as the backup, the same code and the same tests), strict, with no any, no non-null !, errors as values (Result), tagged unions and exhaustive switch statements, and no third-party runtime module, and its tests MUST use real temporary Git repositories and real annotated tags, signing with an SSH key made by ssh-keygen where it is present.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts, versions-git.test.ts: the tool is strict TypeScript with no any or non-null assertion (tsc, and the lint of the mizan folder in CI), and its tests use real repositories, real annotated tags and an ssh-keygen key where present

Proved by: mizan/suite/versions-git.test.ts

Tests: passed: suite/versions-git.test.ts the command runs as a program on this runtime: 0 for nothing found, 1 for a finding, 2 for

FR-034checkpassing

Commons' work Docs MUST have the record commons/docs/release.ts (slug docs, replaces: "ifc-docs", the package @intellectual-frontiers/docs), whose version MUST be that of its latest tag, ifc-docs-v0.1.0, or greater where a change has been made since and the owner has not yet tagged it, and whose package.json version MUST equal its record. A work that is retired MUST have no record: its tags stay in the ledger as the history of the work and are not findings, and the work ifc-ts (ifc-ts-v0.1.0 to ifc-ts-v0.4.0) is retired.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-git.test.ts: commons/docs/release.ts decodes, names docs and replaces ifc-docs, carries the version of its package, and the retired work ifc-ts has no record, equal the package.json versions, and the real tags are in the ledger

Proved by: mizan/suite/versions-git.test.ts

Tests: passed: suite/versions-git.test.ts commons' work Docs has a record equal to its tag and to its package.json version, the reti

FR-035checkpassing

The check job of .github/workflows/tests.auto.yml MUST run versions check, offline and path-scoped, and it MUST pass on this repository as it is.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-git.test.ts: the check job of .github/workflows/tests.auto.yml runs versions check with the history fetched, and the ledger of this repository finds nothing

Proved by: mizan/suite/versions-git.test.ts

Tests: passed: suite/versions-git.test.ts commons' work Docs has a record equal to its tag and to its package.json version, the reti

Migration from the schemes in use

FR-036reviewno test run

A harness that adopts this specification MUST map the schemes it uses today to the one scheme of each kind as the table of the Assumptions says, and a reviewer MUST check that no kind of its works keeps two schemes.

Enforced (review): 0026-works-versioning FR-036 — A reviewer checks that a harness that adopts this specification keeps one scheme for each kind of its works and maps its present schemes as the table of the Assumptions says

FR-037checkpassing

WHERE a work changes its scheme, its record MUST name the scheme it came from and the first version of the new scheme (migratedFrom), the versions already tagged MUST stay in the ledger as they were tagged, and a tool MUST compare versions only within one scheme and MUST begin the new scheme at the tag the record names.

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-pure.test.ts: migratedFrom names the scheme it came from and the first version of the new one, the old tags stay in the ledger and are compared only with each other

Proved by: mizan/suite/versions-pure.test.ts

Tests: passed: suite/versions-pure.test.ts a work that changes its scheme names the scheme it came from and the first version of the

Cited by: Mizan, versions/judge, versions/ledger, versions/record

FR-038checkno test run

WHERE a work is not of a Semantic Version scheme, versions bump <work> MUST need no --impact: a commit-date edition takes the head commit (its UTC day and its first eight characters), data takes --snapshot FILE (the SHA-256 of the snapshot) and the day (--day, the clock only where it is not given) and raises the Semantic Version of its schema where --impact is given, and a controlled document's revision goes up by one with its approval removed until --approved-by, --role and --decision record it, never inferred; versions tag MUST take the tier judged by quality tier as --tier and the declaration as --declaration FILE (arguments: the tool imports no part of the quality system), and versions ledger MUST read a tag that is not annotated too and say so (annotated: false), since the first tags of commons are so, and a retired entry MAY carry bytesRemovedOn, the day the bytes were removed (FR-027).

Enforced (check): .github: cd commons/mizan && bun test suite/ — versions-git.test.ts: bump of an edition, of data and of a controlled document needs no impact, tag takes --tier and --declaration, and the ledger reads the commons tags that are not annotated

FR-039checkpassing

A record MAY carry paths, a list of paths of the repository (from its root, with /, a folder or a file) outside the work's own folder, whose tracked files are also the work's, for a work whose files are not all in one folder (a schema kept elsewhere, a document of the repository's top folder): versions check MUST judge a change in them as a change of the work, so that its version MUST grow (FR-022), in the head and the base alike, notes and bump --impact auto MUST count commits that touch them, and a path inside the work's own folder MUST be a finding (versions/record-invalid), since the folder is already the work's (amended 2026-11-18).

Enforced (check): .github: cd commons/mizan && bun test suite/ — mizan-harness-requests.test.ts: paths decode, are written in their place by the template and refused where absolute, with .. or with a backslash; a path inside the work's folder is record-invalid; on a real repository a change only in a named path is versions/not-grown and a bump clears it

Proved by: mizan/suite/mizan-harness-requests.test.ts

Tests: passed: suite/mizan-harness-requests.test.ts a version that went back is found, offline, against any base revision, and the library giv; passed: suite/mizan-harness-requests.test.ts a record's paths decode, are written back in their place, and may not name the work's own

FR-040checkpassing

A consumer MUST be able to run the check offline against any base it has: the package MUST export the command as ./ts/mizan/versions (run(argv, deps) and checkVersions(repo, rev), which gives the findings of versions check as data, judged with the findings, the number of works and what they were judged against, or not_run with its reason, from Git alone and for any revision the repository holds), and ./ts/mizan MUST export readWorks, checkVersions, runVersions and the pure library as versions (amended 2026-11-18).

Enforced (check): .github: cd commons/mizan && bun test suite/ — mizan-harness-requests.test.ts: the package exports versions, check, changes and oscal-register, checkVersions gives the findings as data against any revision of a real repository and not_run with its reason for a directory that is no repository or a missing revision, and readWorks finds the records of a folder

Proved by: mizan/suite/mizan-harness-requests.test.ts

Tests: passed: suite/mizan-harness-requests.test.ts a version that went back is found, offline, against any base revision, and the library giv; passed: suite/mizan-harness-requests.test.ts the package exports the versions command, the check, the register and readWorks, and readW

Cited by: versions

FR-041checkno test run

A version MUST be raised by the release, and not by each push: the release (commons/libraries/src/releasing.ts) MUST raise the version of each work whose files (FR-009, FR-039) changed since its last tag, by the greatest Impact: its commits since that tag state (a patch where none does; the one package commons of single distribution, commons 0036-distribution FR-027, is such a work whose files are those of every library) or, where it is greater, by the floor that the keys of the package's exports ask for (commons 0001-libraries FR-027), a breaking impact (major) raising the minor while the major version is 0 (SemVer 2.0.0 item 4: major version zero is for initial development, and anything may change at any time) and the major from 1.0.0, and each work that imports a work that it raises by at least a patch, and MUST release a version that is not tagged yet as it is, whatever the tags say of earlier versions (a work never tagged, or whose record is ahead of its last tag), unless the registry holds that version with other files, which raises it; a work whose version is tagged and whose files did not change MUST be left alone. The release MUST write the record of what it publishes and tags (commons/generated/release.auto.json), and the tag of a version MUST be made by the workflow that publishes it, never by a person's push (the Git proxy refuses a tag push); the release is specified by commons 0001-libraries FR-013 to FR-015.

Enforced (check): .github: cd commons/libraries && bun test suite/ — releasing.test.ts: a library changed since its tag is raised by its impact, its importers by a patch, a version not tagged yet is released as it is, one tagged and unchanged is left alone, in the order of the imports; the floor of the exports and the breaking impact of a major version of 0: release-floor.test.ts

Cited by: releasing, Libraries, Distribution

Out of scope

  • The tags, signing and the trace chain of changes: 0020-ifccm. The evidence tiers and the quality branch: 0021-ifqs. The workspace that holds the repositories: ergonex, in commons/ergonex/.
  • Minting or registering a DOI, the release workflow that generates provenance and the software bill of materials, and the comparison of an API surface or of an ontology's terms with a declared impact: later (FR-016, FR-025, FR-029, FR-030).
  • Versioning a harness's own products that are not works of this repository's own: the harness applies this specification to them through its own record files.

Edge cases

  • A work whose files changed and whose record did not: no finding of a push; the release raises it, per FR-022 and FR-041.
  • A work whose only changed paths are named in its record's exclude: no finding, and the exclusion is visible in the record, per FR-009.
  • A work never tagged, or whose version is ahead of its last tag: released as it is, per FR-041.
  • A work whose record names paths: ["shared/schema"] and a change only in shared/schema/a.json: the work's change for the release, which raises its version, per FR-039 and FR-041.
  • A record whose paths names its own folder, or a path with .., or an absolute path: a finding that names the file and the path, per FR-008 and FR-039.
  • A consumer that calls checkVersions(repo, rev) in a directory that is no repository, or with a revision it does not have: not_run with the reason, never a pass, per FR-040.
  • A Semantic Version 1.2.3+abc123def456 in a record: refused, as build metadata is not part of a record or a tag, per FR-010.
  • Two editions of a book on the same day: ordered by the history, the later commit is the greater, per FR-011.
  • A snapshot taken twice on one day with another digest: not a new version, the date must be later, per FR-012.
  • A policy revision 7 with no approval: a finding that gates, per FR-013.
  • A specification whose record carries a version: refused, per FR-014.
  • A tag of a retired work, ifc-ts-v0.4.0, moved to another commit: found against an earlier ledger, per FR-020.
  • A tag deleted and not named in retired: found as removed, per FR-028.
  • A bump --impact auto with no commit that states an impact: exit status 2, per FR-021.
  • A regulated harness that declares no release tier: tag refuses, per FR-026.
  • A repository on plain Git with no host: check, bump, tag, notes, cite and ledger read only Git and run, per FR-031.
  • A shallow clone with no base: not_run, with its reason, per FR-031.
  • A commit-date edition read by a Semantic Version pattern: it matches, and is still an edition, as the work's kind says, per FR-006.
  • A work renamed from book-one to book-1: a new work that replaces the old, not a change of slug, per FR-007.

Scenarios

  • Given the ontology of releases, When a specification names ifr:WorkKind and ifr:Impact, Then Mizan's check knows both and finds nothing, and a name the ontology lacks is found (FR-001, FR-004).
  • Given the code list of work kinds, When the scheme of Prose and the scheme of Data are read, Then they are the commit-date edition and the snapshot date, and Data carries a Semantic Version for its schema (FR-005).
  • Given a record of a library at 0.4.0 and a commit that changes its files with Impact: minor, When versions bump <work> --impact auto runs, Then the record says 0.5.0 and the check finds nothing (FR-010, FR-021, FR-022).
  • Given a change to a work's files with no change to its record, When versions check runs against the base, Then the status is 0, and when the record's version is lower than the base's the status is 1 and versions/not-grown names the work (FR-022).
  • Given a book at the commit-date edition 2026.11.10-1a2b3c4d and a later commit, When versions bump <work> runs, Then the record carries the commit's UTC date and its first eight characters, never the clock's (FR-011).
  • Given a specification, When versions bump runs on it, Then the status is 2 and nothing is written (FR-014, FR-031).
  • Given a version that is raised, When versions tag <work> runs where Git signing is configured, Then a signed annotated tag <slug>-v<version> names the commit and the message holds the tree hash and the tier, and where it is not configured the command says the tag is not signed (FR-017, FR-018).
  • Given the tags of a repository, When versions ledger --json runs twice, Then the two documents are the same and each tag appears once with its commit and tree (FR-019).
  • Given tags lib-v1.2.0 and lib-v1.1.0 where the commit of the first is an ancestor of the second's, When the ledger is read, Then versions/ledger-order names the pair (FR-020).
  • Given three closed capabilities since the last tag, When versions notes <work> runs, Then each appears once under its impact, in order of its number, and the same text is printed again (FR-023).
  • Given a record with an identifier, When versions cite runs and then versions cite --check, Then CITATION.cff holds the identifier and the check exits with 0, and with no identifier the file holds none (FR-024, FR-029).
  • Given a harness that declares a regulated domain and a release tier above the tier judged, When versions tag runs, Then it refuses and creates no tag (FR-026).
  • Given a version retired with a replacement, When the ledger is read against an earlier one, Then nothing is found for it, and a tag gone without a retired entry is found (FR-020, FR-028).
  • Given commons' two packages, When versions check runs on this repository, Then it finds nothing, and the records equal the tags and the package.json versions (FR-034, FR-035).
  • Given a library whose record names paths: ["shared"] and a commit that changes only shared/x.ts, When versions check runs against the base, Then versions check finds nothing, and the release raises the work's version because a file of shared changed since its tag (FR-039, FR-041).
  • Given a consumer repository with a base revision it has fetched, When it calls checkVersions(repo, base) from the package, Then it gets the findings as data with no network (FR-040).

Assumptions

  • Standards considered (0018-standards-first): IFLA LRM and FRBR (work, expression, manifestation, item) for the levels of FR-003, whose IRIs are to verify, so the classes rest on schema.org's CreativeWork; schema.org's version, isPartOf, position, identifier and bookEdition; Dublin Core Terms' isVersionOf, replaces and isReplacedBy; PROV-O's wasDerivedFrom and wasRevisionOf; OWL's versionInfo and versionIRI; SPDX 3's software_packageVersion; Semantic Versioning 2.0.0, whose build metadata +<commit12> is not part of precedence; the Citation File Format 1.2.0; SLSA and in-toto for provenance; DOI, DataCite and Zenodo for the opt-in identifier; Git's annotated and signed tags; and, for a controlled document, the document control of ISO 9001:2015 clause 7.5.3 and ISO 13485:2016 clause 4.2.4. Calendar Versioning was considered and not adopted: its date is the clock's, and here it is the commit's. Keep a Changelog and Conventional Commits were considered and not adopted: the notes are generated from the Closes lines and the Impact lines of 0020-ifccm's commits, so that the trace chain is the change log.
  • The mapping from the four schemes the first publishing harness uses today to the one scheme of each kind (FR-036):

    Scheme in useKind of workScheme hereWhat becomes of it
    Semantic Version with +commit12 for softwareSoftware, Library, CommandLineInterfaceSemVerThe record and the tag carry the plain Semantic Version; the commit is its own field of the release (ifr:releaseCommit); +commit12 MAY stay in a displayed version and is never compared
    A UTC minute stamp for books and papersProseCommitDateEditionThe commit's UTC date and the first eight characters of its commit replace the stamp; the stamps already tagged stay in the ledger as they were (FR-037)
    YYYY.MM.DD-<commit8> for a manual setProseCommitDateEditionIt is already the scheme: adopted as written, with the date taken from the commit and never the clock
    An integer book edition and printingProseCommitDateEditionThe integer edition is the label ifr:bookEditionNumber of an edition, as schema.org's bookEdition; the printing is ifr:printing, a property of the print rendition; neither is the version
  • A work's folder can be told from its release.ts alone, and a repository of one work keeps its record at its root; Git's tag namespace is shared by every work of a repository, which is why the slug is the tag's prefix.
  • The record is read as data, as the declaration of 0020-ifccm is, so that a version at the base reads like the present one and nothing is run.
  • A commit's Impact: line is a Git trailer that 0020-ifccm's commit reader does not read yet; the tool reads it itself and 0020-ifccm is not changed by this specification.
  • A harness that declares a regulated domain declares the release tier in the declaration it already keeps (FR-026); the field is added to the declaration's decoder by the tool, compatibly.
  • Retention is the harness's to state: the digests and metadata are kept forever, and a period for the bytes is only ever stated by a record, never assumed.
  • This specification is Draft: the ontology, the migration of commons' ontologies and the mapping are built; the tool, the records of commons' two packages and the check in the workflow are the next piece, and the register says so for each requirement.

Open questions

None.

Key entities

  • Work - a work in its identity, a slug and an IRI that never change (ifr:Work).
  • Expression and Manifestation - a state of a work's content, and a rendition of it (ifr:Expression, ifr:Manifestation).
  • Release and Edition - a version that was published, named by a signed tag; an edition is a release of prose (ifr:Release, ifr:Edition).
  • VersionScheme, WorkKind and Impact - the schemes, the kinds that each use one and the impacts a version is raised by.
  • ReleaseRecord - the typed file <work>/release.ts.
  • ReleaseTag, Retention, Tombstone, ApprovalRecord and Citation - the tag, how long bytes are kept, what resolves where they are gone, the approval of a controlled document and the citation file.

Success criteria

SC-001success criterion

For every work of this repository one command says its version, whether it grew where its files changed and which release it was, and no work has two schemes.

SC-002success criterion

The change log of a release is the list of the capabilities it closed, so that no one writes a change log by hand and none disagrees with the trace chain.

SC-003success criterion

A published version is never changed or silently lost: its commit, its tree and its digest can be found as long as the repository is.

Review & acceptance checklist

  • [x] Every requirement is testable (MUST / MUST NOT), not aspirational
  • [x] No company fact is asserted here
  • [x] Every open item is marked, not silently decided

Cited by

generate-ontology, Libraries, releasing, versions, changes/commit-message, Mizan, versions/cite, versions/gate, versions/git, versions/judge, versions/ledger, versions/mod, versions/notes, versions/plugin, versions/record, versions/rules, versions/scan, versions/scheme, versions/works, ifr/ifr, ifr/mod, Ontology, governance/ids, ansible dialect: layers, AnyFS: layers, apt dialect: layers, Archon layers, Boot plugin: layers, cloud-init dialect: layers, Converge plugin: layers, DNS plugin: layers, Estate: layers, The harness of Mizan, Homebrew dialect: layers, Libraries, mise dialect: layers, Native-pinned layers, opentofu dialect: layers, The shared kit of the dialects that drive a package manager for Archon (commons archon 0004-archon-dialects) and Toolchain (commons toolchain 0003-toolchain-logical): it is a library in the layers of Kanon, and the dialects of Homebrew, apt, WinGet and mise are packages of their own that hold only the data of a manager. Kanon lets a dialect reach its host and no other member of the family, so the code the dialects share lives in a library that is no member., Archon tool plugin: layers, Toolchain layers, WinGet dialect: layers, Repoctl library, commit and doctor, The ontology in TypeScript, Intellectual Frontiers Capabilities Configuration Management, Commons libraries, Conformance levels, Subject profiles, Libraries by concern, Archon, Distribution

Titles, headings, exports, tables, columns and requirements. Esc closes.