Quality: 123 tests: 123 passed, 0 failed, 0 skipped, 29 of 41 requirements proved, 0 open issues, 0 open tickets. The tests and issues of the library
What of Mizan is still in this package (commons 0032-libraries-by-concern ): the commands that need the whole repository. check.ts holds a repository's spec kit and ontologies, versions.ts and changes.ts are the commands of the release check and the change-control check, libraries.ts reads the manifests of the libraries, newer.ts reports a standard newer than its pin, generate-ontology.ts writes the Turtle of the ontologies and oscal-register.ts the register of proofs as OSCAL. The harness, the rules, the levels, the integrations, the change-control and release rules as plugins, and the trace of requirements are the library mizan (@intellectual-frontiers/mizan), and the ontologies are the library ontology (@intellectual-frontiers/ontology).
Spec: 0001-libraries FR-010
# Entry points# Modules# LimitsWhat the modules of this area do not do, or do only in part, as each module's @limits says.
src/affected.ts
src/affected.ts
It reads sources with a pattern for import, export ... from and import(), which finds every file a source names (and at worst a file that a comment names, which only adds an input); a file that is read by a program through a path it builds at run time is not found, and a dependency that a library has outside commons is not followed. Where Git cannot say what changed, every library is affected.
src/dev.ts
src/dev.ts
It proves less than bun run verify of a library: no specification check, no trace, no packing, no Node 26, no other system than this one. CI runs those on the libraries a push affects. A change of a file that no library reads affects no library, and nothing is run.
src/generate-workflows.ts
src/generate-workflows.ts
It reads manifests and writes files; it does not run a workflow and does not ask GitHub whether it accepts one (tests/commons-workflows-schema.test.ts validates the files against the schema GitHub's tools publish).
Spec: 0001-libraries FR-005
src/libraries.ts
src/libraries.ts
It reads files and writes two; it runs no library's verify (check.ts --all does, 0028-conformance-levels FR-012 ), and it does not read inside a library but its manifest, its package and the files that name its spec kit.
src/license.ts
src/license.ts
It does not fetch anything: the official text is the copy in license/, checked against the SHA-256 its standard records. It does not judge what the hand-written files say beyond the few facts named in Finding .
src/metapackages.ts
src/metapackages.ts
It reads no file and knows no registry. It does not know what is published: a release that has not published a member makes the set refer to a version npm does not hold yet, which the release's order prevents.
src/newer.ts
src/newer.ts
It compares bytes, not versions: a source that changes its prefixes or its date changes the hash, and a person reads the difference. It reads the manifests of one folder.
src/oscal-register.ts
src/oscal-register.ts
It reads which tests name a requirement, never whether they pass (that is the test run's evidence, 0008-test-evidence ), and it counts a proof wherever a proves( call or a // Proves: line is, a fixture string included, as the trace check does. It does not write a POA&M: a gap is a finding of the results.
src/pack-commons.ts
src/pack-commons.ts
It builds from the sources of a checkout and does not publish; the release runs it (bun tools/pack.ts in commons/commons) and the workflow publishes the tarball. It needs the TypeScript compiler of commons/commons (or of the repository's root) installed. A specifier it cannot rewrite or that names no library is a finding, never left as it is.
src/pack-tools.ts
src/pack-tools.ts
It reads the manifests and the imports; it does not install, and it cannot make the lockfile: bun install in the folder does, which the writing form runs where the lockfile lacks a package. The check reads bun.lock as data and compares names and versions.
src/plan.ts
src/plan.ts
It decides nothing about a version, a tag or a release; those are the release's. It cannot say what changed where Git cannot: it plans every library then, and says why.
src/readme.ts
src/readme.ts
It writes one file, README.md, and only between the markers; it does not judge the prose around them (the test of the README does).
src/releasing.ts
src/releasing.ts
The plan reads the tags of this repository, so a clone without its tags plans a first release of everything. It cannot know what a registry holds: the workflow asks it, and skips a version that is there. A work that is not a library (commons/docs) is not released here. The floor of the exports sees the keys of exports and nothing behind them: a changed type, signature or behaviour under an unchanged key is declared by the Impact: of the commit.
src/scan.ts
src/scan.ts
A regular expression literal after a token it cannot tell from a division is read as a division; a source with such a literal that contains a quote may be read wrongly, which the packer's inspection would show as a finding, never as a silent pass.
workflows/model.ts
src/workflows/model.ts
It models what this repository's workflows use: push, pull request, manual and reusable triggers, a job's matrix, permissions, environment, concurrency and the steps of a composite action. It does not model every key GitHub knows; the schema GitHub's tools publish is the check of what is written (tests/commons-workflows-schema.test.ts), and a key the model lacks is added here, where the compiler then asks every workflow about it.
workflows/render.ts
src/workflows/render.ts
It writes and never reads; the parity of a rendering with a file that was written by hand is a comparison of what a YAML reader makes of the two (tests/commons-workflows-schema.test.ts).