runtime/src/resynthesis/language_catalog.py

"""Frozen broad-language provenance and shared language abilities.

This is catalog construction metadata, not a host-owned runtime router.  The
source snapshot is frozen so checkpoint geometry never changes because a
network service, package installation, or another repository changed.
"""
from __future__ import annotations

import hashlib
import re


LINGUIST_LANGUAGE_SOURCE_SCHEMA = (
    "nnf.resynthesis.github_linguist_language_source.v1"
)
LINGUIST_LANGUAGE_SOURCE_REPOSITORY = (
    "https://github.com/github-linguist/linguist"
)
LINGUIST_LANGUAGE_SOURCE_COMMIT = (
    "e9fe3c9f230cd9220afcd057f75702de4d7700c9"
)
LINGUIST_LANGUAGE_SOURCE_PATH = "lib/linguist/languages.yml"
LINGUIST_LANGUAGE_SOURCE_FILE_SHA256 = (
    "8642e45ad18a62225ec367992d508af916b9caf41ee9b274863621965c4ba794"
)
LINGUIST_LANGUAGE_SOURCE_NAMES_SHA256 = (
    "ec2877045e403b74946bfb03bb49223e3291781d7d7ec1bad0a98ab8e0141624"
)
LINGUIST_LANGUAGE_SOURCE_RECORD_COUNT = 815


def _names(rows: str) -> tuple[str, ...]:
    return tuple(row for row in rows.splitlines() if row)


_PROGRAMMING_NAMES = _names(
    """1C Enterprise
4D
ABAP
ABAP CDS
AGS Script
AIDL
AL
ALGOL
AMPL
ANTLR
APL
ASL
ASP.NET
ATS
ActionScript
Ada
Agda
Aiken
Alloy
Alpine Abuild
AngelScript
Answer Set Programming
Apex
Apollo Guidance Computer
AppleScript
Arc
AspectJ
Assembly
Asymptote
Augeas
AutoHotkey
AutoIt
Awk
B (Formal Method)
B4X
BAML
BASIC
BQN
Ballerina
Batchfile
Beef
Befunge
Berry
BibTeX Style
Bicep
Bison
BitBake
BlitzBasic
BlitzMax
Bluespec
Bluespec BH
Boo
Boogie
Brainfuck
BrighterScript
Brightscript
C
C#
C++
C2hs Haskell
C3
CAP CDS
CLIPS
CMake
COBOL
CQL
CUE
CWeb
Cadence
Cairo
Cairo Zero
CameLIGO
Cangjie
Cap'n Proto
Carbon
CartoCSS
Ceylon
Chapel
Charity
ChucK
Circom
Cirru
Clarion
Clarity
Classic ASP
Clean
Click
Clojure
Clue
CodeQL
CoffeeScript
ColdFusion
ColdFusion CFC
Common Lisp
Common Workflow Language
Component Pascal
Cool
Crystal
Csound
Csound Document
Csound Score
Cuda
Curry
Cycript
Cypher
Cython
D
DIGITAL Command Language
DM
DTrace
Dafny
Dart
Daslang
DataWeave
DenizenScript
Dhall
Dockerfile
Dogescript
Dune
Dylan
E
ECL
ECLiPSe
EQ
Earthly
EdgeQL
Eiffel
Elixir
Elm
Elvish
Elvish Transcript
Emacs Lisp
EmberScript
Erlang
Euphoria
F#
F*
FIRRTL
FLUX
Factor
Fancy
Fantom
Faust
Fennel
Filebench WML
Filterscript
Flix
Fluent
Forth
Fortran
Fortran Free Form
FreeBASIC
FreeMarker
Frege
Futhark
G-code
GAML
GAMS
GAP
GCC Machine Description
GDB
GDScript
GDShader
GLSL
GSC
Game Maker Language
Genero 4gl
Genie
Genshi
Gentoo Ebuild
Gentoo Eclass
Gherkin
Gleam
Glimmer JS
Glimmer TS
Glyph
Gnuplot
Go
Golo
Gosu
Grace
Grammatical Framework
Groovy
Groovy Server Pages
HCL
HIP
HLSL
Hack
Harbour
Hare
Haskell
Haxe
HiveQL
HolyC
Hurl
Hy
HyPhy
IDL
IGOR Pro
IL Assembly
ISPC
Idris
ImageJ Macro
Imba
Inform 7
Ink
Inno Setup
Io
Ioke
Isabelle
Isabelle ROOT
J
JCL
JFlex
JSONiq
Jac
Jai
Janet
Jasmin
Java
Java Server Pages
Java Template Engine
JavaScript
JavaScript+ERB
JetBrains MPS
Jison
Jison Lex
Jolie
Jsonnet
Julia
Julia REPL
Just
KCL
KFramework
KRL
Kaitai Struct
KakouneScript
KerboScript
KoLmafia ASH
Koka
Kotlin
LFE
LLVM
LOLCODE
LSL
LabVIEW
Lambdapi
Langium
Lasso
Lean
Lean 4
Leo
Lex
LigoLANG
LilyPond
Limbo
Linear Programming
Linker Script
Liquidsoap
Literate Agda
Literate CoffeeScript
Literate Haskell
LiveCode Script
LiveScript
Logos
Logtalk
LookML
LoomScript
Lua
Luau
M
M4
M4Sugar
MATLAB
MAXScript
MLIR
MQL4
MQL5
MUF
Macaulay2
Makefile
Mako
Mathematical Programming System
Max
MeTTa
Mercury
Meson
Metal
MiniD
MiniZinc
Mint
Mirah
Modelica
Modula-2
Modula-3
Module Management System
Mojo
Monkey
Monkey C
Moocode
MoonBit
MoonScript
Motoko
Motorola 68K Assembly
Move
Myghty
NASL
NCL
NMODL
NSIS
NWScript
Nasal
Nearley
Nemerle
NetLinx
NetLinx+ERB
NetLogo
NewLisp
Nextflow
Nickel
Nim
Nit
Nix
Noir
Nu
NumPy
Nushell
OCaml
OMNeT++ MSG
OMNeT++ NED
Oberon
ObjectScript
Objective-C
Objective-C++
Objective-J
Odin
Omgrofl
Opa
Opal
Open Policy Agent
OpenCL
OpenEdge ABL
OpenQASM
OpenRC runscript
OpenSCAD
OverPy
OverpassQL
Ox
Oxygene
Oz
P4
PDDL
PEG.js
PHP
PLSQL
PLpgSQL
POV-Ray SDL
Pact
Pan
Papyrus
Parrot
Parrot Assembly
Parrot Internal Representation
Pascal
Pawn
Pep8
Perl
PicoLisp
PigLatin
Pike
Pkl
PogoScript
Polar
Pony
Portugol
Power Query
PowerBuilder
PowerShell
Praat
Pro*C
Processing
Procfile
Prolog
Promela
Propeller Spin
Puppet
PureBasic
PureScript
Pyret
Python
Python console
Q#
QML
QMake
Qt Script
Quake
QuakeC
QuickBASIC
Quint
R
RAScript
REALbasic
REXX
RPC
RPGLE
Racket
Ragel
Raku
Rascal
ReScript
Reason
ReasonLIGO
Rebol
Red
Redcode
Redscript
Ren'Py
RenderScript
Rez
Ring
RobotFramework
Roc
Rocq Prover
Rouge
RouterOS Script
Ruby
Rust
SAS
SMT
SQF
SQLPL
SWIG
Sage
Sail
SaltStack
Scala
Scenic
Scheme
Scilab
Self
ShaderLab
Shell
ShellSession
Shen
Sieve
Singularity
Slang
Slash
Slice
SmPL
Smali
Smalltalk
Smarty
Smithy
Snakemake
Solidity
SourcePawn
Squirrel
Stan
Standard ML
Starlark
Stata
SuperCollider
SurrealQL
Sway
Swift
SystemVerilog
TI Program
TL-Verilog
TLA
TSQL
TSX
TXL
Tact
Talon
Tcl
Tcsh
Teal
Terra
Thrift
Toit
Tree-sitter Query
Turing
TypeScript
TypeSpec
Typst
Unified Parallel C
Unix Assembly
Uno
UnrealScript
Untyped Plutus Core
UrWeb
V
VBA
VBScript
VCL
VHDL
Vala
Verilog
Vim Script
Visual Basic .NET
Visual Basic 6.0
Volt
Vyper
WDL
WGSL
WebAssembly
WebIDL
Whiley
Witcher Script
Wolfram Language
Wollok
Wren
X10
XC
XProc
XQuery
XS
XSLT
Xmake
Xojo
Xonsh
Xtend
YARA
Yacc
Yul
ZAP
ZIL
Zeek
ZenScript
Zephir
Zig
Zimpl
eC
fish
hoon
jq
mIRC Script
mcfunction
mupad
nesC
ooc
q
sed
wisp
xBase"""
)

_DATA_NAMES = _names(
    """2-Dimensional Array
ABNF
ASN.1
Adblock Filter List
Adobe Font Metrics
Altium Designer
Ant Build System
ApacheConf
Avro IDL
Browserslist
BuildStream
C-ObjDump
CIL
CODEOWNERS
COLLADA
CSON
CSV
Cabal Config
Caddyfile
Checksums
Cloud Firestore Security Rules
CoNLL-U
Cpp-ObjDump
Cue Sheet
Cylc
D-ObjDump
DNS Zone
Darcs Patch
Debian Package Control File
Diff
DirectX 3D File
Dotenv
E-mail
EBNF
Eagle
Easybuild
Ecere Projects
EditorConfig
Edje Data Collection
FIGlet Font
FlatBuffers
Formatted
GEDCOM
GN
Gemfile.lock
Gerber Image
Git Attributes
Git Commit
Git Config
Git Revision List
Glyph Bitmap Distribution Format
Go Checksums
Go Module
Go Workspace
Godot Resource
Gradle
Gradle Kotlin DSL
Graph Modeling Language
GraphQL
Graphviz (DOT)
GtkRC
HAProxy
HOCON
HTTP
HXML
Hosts File
INI
IRC log
Ignore List
JAR Manifest
JSON
JSON with Comments
JSON5
JSONLD
Java Properties
Jest Snapshot
KDL
KiCad Layout
KiCad Legacy Layout
KiCad Schematic
Kickstart
Kusto
LTspice Symbol
Lark
Linux Kernel Module
M3U
Maven POM
Microsoft Developer Studio Project
Microsoft Visual Studio Solution
MiniYAML
MiniZinc Data
NEON
NL
NPM Config
Nginx
Ninja
OASv2-json
OASv2-yaml
OASv3-json
OASv3-yaml
ObjDump
Object Data Instance Notation
OpenAPI Specification v2
OpenAPI Specification v3
OpenStep Property List
OpenType Feature File
Option List
Pickle
Pip Requirements
PlantUML
Prisma
Proguard
Protocol Buffer
Protocol Buffer Text Format
Public Key
Pure Data
Python traceback
RBS
RON
ROS Interface
RPM Spec
Raw token data
Readline Config
Record Jar
Redirect Rules
Regular Expression
Robots Exclusion Rules
SELinux Policy
SPARQL
SQL
SSH Config
STAR
STL
STON
SVG
ShellCheck Config
Simple File Verification
Soong
SpiceDB Schema
Spline Font Database
SubRip Text
Survex data
TMDL
TOML
TSPLIB data
TSV
TextGrid
TextMate Properties
Tor Config
Turtle
Type Language
Unity3D Asset
Valve Data Format
Wavefront Material
Wavefront Object
Web Ontology Language
WebAssembly Interface Type
WebVTT
Wget Config
Win32 Message File
Windows Registry Entries
World of Warcraft Addon Data
X BitMap
X Font Directory Index
X PixMap
XCompose
XML
XML Property List
XPages
YAML
YANG
Zmodel
cURL Config
crontab
desktop
dircolors
edn
iCalendar
nanorc
pkg-config
vCard"""
)

_MARKUP_NAMES = _names(
    """API Blueprint
Antlers
Astro
BibTeX
Bikeshed
Blade
Blueprint
Bru
CSS
Closure Templates
Cooklang
D2
EJS
Ecmarkup
Edge
Genero per
Go Template
HTML
HTML+ECR
HTML+EEX
HTML+ERB
HTML+PHP
HTML+Razor
Haml
Handlebars
Jinja
Jupyter Notebook
Kit
Latte
Less
Liquid
MDX
MTML
Marko
Mask
Mermaid
Mustache
Nunjucks
Pic
PostCSS
PostScript
Pug
RAML
RUNOFF
Rich Text Format
Riot
Roff
Roff Manpage
SCSS
SRecode Template
Sass
Scaml
Slim
Slint
StringTemplate
Stylus
SugarSS
Svelte
TeX
Tea
Terraform Template
Twig
Velocity Template Language
Vento
Vim Snippet
Vue
YASnippet
kvlang
mdsvex
templ"""
)

_PROSE_NAMES = _names(
    """AsciiDoc
Creole
Gemini
Gettext Catalog
Markdown
Muse
Org
Pod
Pod 6
RDoc
RMarkdown
Sweave
Texinfo
Text
Textile
Vim Help File
Wikitext
reStructuredText"""
)

LINGUIST_LANGUAGE_NAMES_BY_TYPE: tuple[
    tuple[str, tuple[str, ...]],
    ...,
] = (
    ("programming", _PROGRAMMING_NAMES),
    ("data", _DATA_NAMES),
    ("markup", _MARKUP_NAMES),
    ("prose", _PROSE_NAMES),
)
LINGUIST_LANGUAGE_SOURCE_TYPE_COUNTS = tuple(
    (source_type, len(names))
    for source_type, names in LINGUIST_LANGUAGE_NAMES_BY_TYPE
)
LINGUIST_LANGUAGE_SOURCE_RECORDS = tuple(
    (name, source_type)
    for source_type, names in LINGUIST_LANGUAGE_NAMES_BY_TYPE
    for name in names
)

# These aliases preserve established Resynthesis dimensions when Linguist uses
# a long name, renamed language, or multiple concrete OpenAPI encodings.
_SOURCE_PACK_ID_ALIASES: tuple[tuple[str, str], ...] = (
    ("Cap'n Proto", "language_capnproto"),
    ("Common Workflow Language", "language_cwl"),
    ("LLVM", "language_llvm_ir"),
    ("M", "language_mumps"),
    ("Makefile", "language_make"),
    ("OASv2-json", "language_openapi"),
    ("OASv2-yaml", "language_openapi"),
    ("OASv3-json", "language_openapi"),
    ("OASv3-yaml", "language_openapi"),
    ("Open Policy Agent", "language_rego"),
    ("OpenAPI Specification v2", "language_openapi"),
    ("OpenAPI Specification v3", "language_openapi"),
    ("Protocol Buffer", "language_protobuf"),
    ("Reason", "language_reasonml"),
    ("Rocq Prover", "language_coq"),
    ("SMT", "language_smtlib"),
    ("Sage", "language_sagemath"),
    ("Standard ML", "language_sml"),
    ("TLA", "language_tla_plus"),
    ("TeX", "language_latex"),
    ("Unified Parallel C", "language_upc"),
    ("Visual Basic .NET", "language_vbnet"),
    ("Visual Basic 6.0", "language_visual_basic"),
    ("Wolfram Language", "language_wolfram"),
)
_SOURCE_PACK_ID_ALIAS_BY_NAME = dict(_SOURCE_PACK_ID_ALIASES)


def linguist_language_pack_id(source_name: str) -> str:
    """Return the frozen canonical NoNE family ID for one source language."""

    alias = _SOURCE_PACK_ID_ALIAS_BY_NAME.get(source_name)
    if alias is not None:
        return alias
    normalized = (
        source_name.casefold()
        .replace("c++", "cpp")
        .replace("c#", "csharp")
        .replace("f#", "fsharp")
        .replace("f*", "fstar")
        .replace("q#", "qsharp")
    )
    slug = re.sub(r"_+", "_", re.sub(r"[^a-z0-9]+", "_", normalized))
    return f"language_{slug.strip('_')}"


LINGUIST_LANGUAGE_SOURCE_PACK_RECORDS = tuple(
    (linguist_language_pack_id(name), name, source_type)
    for name, source_type in LINGUIST_LANGUAGE_SOURCE_RECORDS
)
LINGUIST_LANGUAGE_SOURCE_PACK_IDS = tuple(
    family_id
    for family_id, _name, _source_type in (
        LINGUIST_LANGUAGE_SOURCE_PACK_RECORDS
    )
)
LINGUIST_LANGUAGE_UNIQUE_SOURCE_PACK_IDS = tuple(
    dict.fromkeys(LINGUIST_LANGUAGE_SOURCE_PACK_IDS)
)
LINGUIST_LANGUAGE_SOURCE_PACK_IDS_SHA256 = hashlib.sha256(
    "\n".join(LINGUIST_LANGUAGE_SOURCE_PACK_IDS).encode("utf-8")
).hexdigest()

# This ordered prefix is the last model-emitted native language graph that was
# preserved in the immutable full-corpus build receipt before a staging copy
# replaced the canonical source.  It is catalog identity, not a trained-
# capability claim.  Keeping the digest beside the rows makes another partial
# source replacement fail at import instead of silently shrinking checkpoint
# geometry.
NATIVE_LANGUAGE_PACK_PREFIX_SCHEMA = (
    "nnf.resynthesis.native_language_pack_prefix.v1"
)
NATIVE_LANGUAGE_PACK_PREFIX_IDS = _names(
    """language_python
language_go
language_java
language_ruby
language_php
language_dotnet
language_native
language_c
language_cpp
language_rust
language_csharp
language_fsharp
language_visual_basic
language_javascript
language_typescript
language_swift
language_objective_c
language_kotlin
language_scala
language_dart
language_lua
language_perl
language_r
language_julia
language_matlab
language_sas
language_sql
language_html
language_css
language_graphql
language_bash
language_powershell
language_haskell
language_ocaml
language_clojure
language_elixir
language_erlang
language_scheme
language_common_lisp
language_prolog
language_groovy
language_fortran
language_assembly
language_cuda
language_opencl
language_webassembly
language_zig
language_nim
language_apex
language_verilog
language_systemverilog
language_vhdl
language_cobol
language_ada
language_pascal
language_tcl
language_solidity
language_move
language_hcl
language_nix
language_abap
language_actionscript
language_apl
language_awk
language_ballerina
language_basic
language_chapel
language_clojurescript
language_coffeescript
language_coldfusion
language_coq
language_crystal
language_cython
language_d
language_delphi
language_eiffel
language_elm
language_factor
language_fennel
language_fish
language_forth
language_gdscript
language_gleam
language_glsl
language_hack
language_html_css
language_idris
language_jsonnet
language_k
language_labview
language_latex
language_lean
language_less
language_llvm_ir
language_logo
language_make
language_mlir
language_mojo
language_mumps
language_openscad
language_oz
language_plsql
language_pony
language_protobuf
language_purescript
language_qml
language_racket
language_raku
language_reasonml
language_rego
language_roc
language_scratch
language_scss
language_shell
language_sml
language_sparql
language_stata
language_stylus
language_terraform
language_toml
language_typst
language_v
language_vala
language_vbnet
language_wasm
language_wgsl
language_wolfram
language_xml
language_xslt
language_yaml
language_zeek
language_agda
language_alloy
language_ansible
language_arm_assembly
language_asyncapi
language_bicep
language_cairo
language_capnproto
language_circom
language_cmake
language_cue
language_cwl
language_dhall
language_dockerfile
language_flatbuffers
language_gnu_m4
language_isabelle
language_jq
language_jsonata
language_mermaid
language_meson
language_mips_assembly
language_nextflow
language_ninja
language_noir
language_openapi
language_pkl
language_plantuml
language_postscript
language_puppet
language_riscv_assembly
language_smtlib
language_snakemake
language_svelte
language_thrift
language_tla_plus
language_tsx
language_vue
language_vyper
language_wdl
language_x86_assembly
language_yang
language_smiles
language_smarts
language_smirks
language_selfies
language_group_selfies
language_bigsmiles
language_inchi
language_cml
language_cif
language_mmcif
language_pdb_format
language_molfile_sdf
language_rxnfile
language_xdl_chemistry
language_lammps_input
language_gromacs_topology
language_openmm_xml
language_gaussian_input
language_orca_input
language_cp2k_input
language_quantum_espresso_input
language_vasp_poscar
language_amber_topology
language_charmm_input
language_sbml
language_cellml
language_sedml
language_antimony
language_bngl
language_kappa_biology
language_biopax
language_neuroml
language_sbol
language_libsbgn
language_pharmml
language_nmtran
language_mlxtran
language_fhirpath
language_cql_clinical
language_fhir_shorthand
language_arden_syntax
language_gello
language_aql_openehr
language_cdisc_odm
language_cdisc_define_xml
language_bids
language_nwb
language_adql
language_stan
language_bugs
language_jags
language_webppl
language_church
language_anglican
language_turing_julia
language_gen_julia
language_pymc
language_ampl
language_gams
language_minizinc
language_flatzinc
language_jump_julia
language_essence
language_zimpl
language_modelica
language_octave
language_scilab
language_maple
language_maxima
language_gap
language_form
language_sagemath
language_triton
language_halide
language_taichi
language_tvm_relay
language_sycl
language_hip
language_openacc
language_openmp
language_upc
language_upcxx
language_x10
language_ispc
language_ptx
language_spirv
language_openqasm
language_openpulse
language_qir
language_qsharp
language_quil
language_quil_t
language_cqasm
language_netqasm
language_braket_ir
language_silq
language_acl2
language_dafny
language_fstar
language_mizar
language_metamath
language_pvs
language_whyml
language_boogie
language_hol
language_z_notation
language_nf_core
language_galaxy_workflow
language_autoprotocol
language_opentrons
language_sila2
language_antha
language_urdf
language_sdf_robotics
language_xacro
language_ros_launch
language_netcdf_cdl
language_hdf5_ddl
language_gmsh_geo
language_abaqus_input
language_ansys_apdl
language_fenics_ufl
language_openfoam_dictionary
language_geant4_macro
language_epics_db"""
)
NATIVE_LANGUAGE_PACK_PREFIX_IDS_SHA256 = hashlib.sha256(
    "\n".join(NATIVE_LANGUAGE_PACK_PREFIX_IDS).encode("utf-8")
).hexdigest()
_NATIVE_LANGUAGE_PACK_PREFIX_ID_SET = frozenset(
    NATIVE_LANGUAGE_PACK_PREFIX_IDS
)
BROAD_LANGUAGE_PACK_IDS = (
    NATIVE_LANGUAGE_PACK_PREFIX_IDS
    + tuple(
        family_id
        for family_id in LINGUIST_LANGUAGE_UNIQUE_SOURCE_PACK_IDS
        if family_id not in _NATIVE_LANGUAGE_PACK_PREFIX_ID_SET
    )
)
BROAD_LANGUAGE_PACK_IDS_SHA256 = hashlib.sha256(
    "\n".join(BROAD_LANGUAGE_PACK_IDS).encode("utf-8")
).hexdigest()

LANGUAGE_ABILITY_SET_SCHEMA = "nnf.resynthesis.language_ability_set.v1"
LANGUAGE_ABILITY_AXES: tuple[tuple[str, str], ...] = (
    ("syntax_parse", "lex, parse, and recover concrete syntax"),
    ("grammar_parser_generation", "author and validate grammars and parsers"),
    ("formatter_roundtrip", "format without semantic loss and round-trip forms"),
    ("lint_static_analysis", "lint and perform static defect analysis"),
    ("semantic_analysis", "resolve names, scope, effects, and semantics"),
    ("type_contract_check", "check types, contracts, invariants, and schemas"),
    ("compile_link", "compile, link, and diagnose toolchain failures"),
    ("compiler_ir_lowering", "lower and inspect compiler intermediate forms"),
    ("interpret_execute", "interpret or execute with environment grounding"),
    ("build_dependency_resolution", "build and resolve dependency graphs"),
    ("package_release", "package, version, sign, and publish artifacts"),
    ("unit_integration_test", "design and run unit and integration tests"),
    ("property_fuzz_test", "property-test, fuzz, and minimize counterexamples"),
    ("bug_reproduction_minimization", "reproduce and minimize reported failures"),
    ("failure_triage_root_cause", "triage evidence and isolate root causes"),
    ("debug_trace", "debug state and trace execution across boundaries"),
    ("profile_optimize", "profile and optimize time, memory, and I/O"),
    ("performance_portability", "preserve performance across target platforms"),
    ("concurrency_memory_model", "reason about concurrency and memory ordering"),
    ("security_taint_audit", "audit trust boundaries, taint, and unsafe behavior"),
    ("vulnerability_disclosure_remediation", "prepare disclosure and remediation"),
    ("supply_chain_reproducibility", "verify dependencies and reproducible builds"),
    ("ffi_cross_language_interop", "bridge ABIs, FFI, and foreign runtimes"),
    ("protocol_network_interop", "implement and validate network protocols"),
    ("refactor_migrate", "refactor and migrate while preserving behavior"),
    ("legacy_modernization", "understand and modernize legacy systems"),
    ("patch_review_validation", "draft, review, test, and validate patches"),
    ("code_generation_drafting", "draft implementation before committed action"),
    ("documentation_examples", "write accurate documentation and examples"),
    ("localization_text_processing", "process text, encodings, and localization"),
    ("api_schema_compatibility", "evolve APIs and schemas compatibly"),
    ("query_data_model", "reason over queries, indexes, and data models"),
    ("database_transaction_consistency", "preserve transaction consistency"),
    ("serialization_exchange", "validate serialization and exchange formats"),
    ("markup_render_accessibility", "render markup with accessibility checks"),
    ("config_policy_validation", "validate configuration and policy languages"),
    ("formal_proof_model_check", "prove properties and model-check state spaces"),
    ("binary_reverse_engineering", "inspect binary and disassembly representations"),
    ("numerical_stability_units", "validate precision, units, and dimensions"),
    ("probabilistic_inference_optimization", "validate inference and optimization"),
    ("chemical_structure_reaction_validation", "validate chemical structures and reactions"),
    ("systems_biology_simulation", "validate mechanistic biology simulations"),
    ("clinical_regulatory_validation", "validate clinical and regulatory logic"),
    ("workflow_provenance_orchestration", "orchestrate reproducible workflows"),
    ("laboratory_robotics_control", "validate laboratory and robot control"),
    ("scientific_data_mesh_geometry", "validate scientific arrays, meshes, and geometry"),
    ("simulation_boundary_conditions", "validate simulator inputs and boundaries"),
    ("accelerator_parallel_lowering", "lower and verify parallel accelerator kernels"),
    ("hardware_hdl_verification", "simulate and verify digital hardware"),
    ("quantum_circuit_pulse_validation", "validate circuits, pulses, and quantum IR"),
    ("data_visualization_reporting", "produce reproducible scientific reports"),
    ("provenance_evidence_uncertainty", "preserve provenance and explicit uncertainty"),
    ("deployment_observability_operations", "deploy and operate observable systems"),
)
LANGUAGE_ABILITY_AXIS_IDS = tuple(
    ability_id for ability_id, _description in LANGUAGE_ABILITY_AXES
)
LANGUAGE_ABILITY_AXIS_IDS_SHA256 = hashlib.sha256(
    "\n".join(LANGUAGE_ABILITY_AXIS_IDS).encode("utf-8")
).hexdigest()

LANGUAGE_ABILITY_IDS_BY_SOURCE_TYPE: tuple[
    tuple[str, tuple[str, ...]],
    ...,
] = (
    (
        "programming",
        (
            "syntax_parse",
            "grammar_parser_generation",
            "formatter_roundtrip",
            "lint_static_analysis",
            "semantic_analysis",
            "type_contract_check",
            "compile_link",
            "compiler_ir_lowering",
            "interpret_execute",
            "build_dependency_resolution",
            "package_release",
            "unit_integration_test",
            "property_fuzz_test",
            "bug_reproduction_minimization",
            "failure_triage_root_cause",
            "debug_trace",
            "profile_optimize",
            "performance_portability",
            "concurrency_memory_model",
            "security_taint_audit",
            "binary_reverse_engineering",
            "vulnerability_disclosure_remediation",
            "supply_chain_reproducibility",
            "ffi_cross_language_interop",
            "protocol_network_interop",
            "refactor_migrate",
            "legacy_modernization",
            "patch_review_validation",
            "code_generation_drafting",
            "documentation_examples",
            "api_schema_compatibility",
            "provenance_evidence_uncertainty",
            "deployment_observability_operations",
        ),
    ),
    (
        "data",
        (
            "syntax_parse",
            "grammar_parser_generation",
            "formatter_roundtrip",
            "lint_static_analysis",
            "type_contract_check",
            "property_fuzz_test",
            "bug_reproduction_minimization",
            "failure_triage_root_cause",
            "security_taint_audit",
            "patch_review_validation",
            "documentation_examples",
            "api_schema_compatibility",
            "query_data_model",
            "database_transaction_consistency",
            "serialization_exchange",
            "config_policy_validation",
            "provenance_evidence_uncertainty",
        ),
    ),
    (
        "markup",
        (
            "syntax_parse",
            "grammar_parser_generation",
            "formatter_roundtrip",
            "lint_static_analysis",
            "semantic_analysis",
            "type_contract_check",
            "unit_integration_test",
            "property_fuzz_test",
            "bug_reproduction_minimization",
            "patch_review_validation",
            "documentation_examples",
            "localization_text_processing",
            "api_schema_compatibility",
            "serialization_exchange",
            "markup_render_accessibility",
            "provenance_evidence_uncertainty",
        ),
    ),
    (
        "prose",
        (
            "syntax_parse",
            "formatter_roundtrip",
            "lint_static_analysis",
            "bug_reproduction_minimization",
            "patch_review_validation",
            "code_generation_drafting",
            "documentation_examples",
            "localization_text_processing",
            "data_visualization_reporting",
            "provenance_evidence_uncertainty",
        ),
    ),
)


_source_names = tuple(name for name, _source_type in LINGUIST_LANGUAGE_SOURCE_RECORDS)
if (
    len(_source_names) != LINGUIST_LANGUAGE_SOURCE_RECORD_COUNT
    or len(_source_names) != len(set(_source_names))
    or hashlib.sha256(
        "\n".join(sorted(_source_names)).encode("utf-8")
    ).hexdigest()
    != LINGUIST_LANGUAGE_SOURCE_NAMES_SHA256
    or set(LINGUIST_LANGUAGE_SOURCE_PACK_IDS)
    != set(LINGUIST_LANGUAGE_UNIQUE_SOURCE_PACK_IDS)
    or len(NATIVE_LANGUAGE_PACK_PREFIX_IDS) != 298
    or len(NATIVE_LANGUAGE_PACK_PREFIX_IDS)
    != len(set(NATIVE_LANGUAGE_PACK_PREFIX_IDS))
    or NATIVE_LANGUAGE_PACK_PREFIX_IDS_SHA256
    != "11ee56c6ef37fb2ced4bc95959cbd1f4eccbb8b1c04aa6143bdb95aefb6b5cfc"
    or len(BROAD_LANGUAGE_PACK_IDS) != 936
    or len(BROAD_LANGUAGE_PACK_IDS) != len(set(BROAD_LANGUAGE_PACK_IDS))
    or BROAD_LANGUAGE_PACK_IDS[: len(NATIVE_LANGUAGE_PACK_PREFIX_IDS)]
    != NATIVE_LANGUAGE_PACK_PREFIX_IDS
    or BROAD_LANGUAGE_PACK_IDS_SHA256
    != "dfd7e29914ff5764539d36db1882b14356127d1048d2c1e2a20e80c87662a1d8"
    or len(LANGUAGE_ABILITY_AXIS_IDS)
    != len(set(LANGUAGE_ABILITY_AXIS_IDS))
):
    raise RuntimeError("frozen broad-language catalog provenance is invalid")