lawspec 0.7.0 → 0.9.0

package/build.json

@@ -1,26 +1,112 @@
 {
   "version": 1,
   "compilerSources": [
+    "lawspec.cabal",
     "package.yaml",
+    "runtime/LawSpecCodecs.hs",
+    "runtime/LawSpecDataStrategies.hs",
+    "runtime/LawSpecDataStrategies.java",
+    "runtime/LawSpecKotlin.kt",
+    "runtime/LawSpecKotlinCodecs.kt",
+    "runtime/LawSpecKotlinStrategies.kt",
     "runtime/LawSpecRuntime.hs",
     "runtime/LawSpecRuntime.java",
+    "runtime/LawSpecSchema.hs",
+    "runtime/LawSpecSchema.java",
+    "runtime/LawSpecStrategies.kt",
+    "runtime/lawspec_codecs.go",
+    "runtime/lawspec_data_strategies.go",
+    "runtime/lawspec_data_strategies.mjs",
+    "runtime/lawspec_data_strategies.py",
     "runtime/lawspec_runtime.go",
     "runtime/lawspec_runtime.mjs",
     "runtime/lawspec_runtime.py",
+    "runtime/lawspec_runtime.rs",
+    "runtime/lawspec_schema.go",
+    "runtime/lawspec_schema.mjs",
+    "runtime/lawspec_schema.py",
+    "runtime/lawspec_strategies.rs",
+    "runtime/rust/Cargo.lock",
+    "runtime/rust/Cargo.toml",
     "src/LawSpec/Api.hs",
+    "src/LawSpec/Backend.hs",
+    "src/LawSpec/Capabilities.hs",
+    "src/LawSpec/Code/Doc.hs",
+    "src/LawSpec/Code/JavaScript.hs",
+    "src/LawSpec/Common.hs",
     "src/LawSpec/Compile.hs",
+    "src/LawSpec/Core.hs",
+    "src/LawSpec/Core/DefinitionContracts.hs",
+    "src/LawSpec/Core/Definitions.hs",
+    "src/LawSpec/Core/Eval.hs",
+    "src/LawSpec/Core/Expression.hs",
+    "src/LawSpec/Core/Payload.hs",
+    "src/LawSpec/Core/PayloadPlan.hs",
+    "src/LawSpec/Core/RefinementProof.hs",
+    "src/LawSpec/Core/Schema.hs",
+    "src/LawSpec/Core/Semantics.hs",
+    "src/LawSpec/Core/Total.hs",
+    "src/LawSpec/Core/Totality.hs",
+    "src/LawSpec/Core/Types.hs",
+    "src/LawSpec/Core/Validate.hs",
+    "src/LawSpec/Core/Value.hs",
+    "src/LawSpec/CoreEmit.hs",
+    "src/LawSpec/CoreNativeScalarEmit.hs",
+    "src/LawSpec/CoreScalarEmit.hs",
+    "src/LawSpec/Data.hs",
+    "src/LawSpec/DefinitionTotality.hs",
     "src/LawSpec/Domain.hs",
+    "src/LawSpec/Elaboration.hs",
     "src/LawSpec/Emit.hs",
     "src/LawSpec/Eval.hs",
+    "src/LawSpec/Frontend.hs",
     "src/LawSpec/Gen.hs",
+    "src/LawSpec/GoData.hs",
+    "src/LawSpec/GoDefinitions.hs",
+    "src/LawSpec/GoExpr.hs",
+    "src/LawSpec/GoProperties.hs",
+    "src/LawSpec/GoTestHelpers.hs",
+    "src/LawSpec/GoTypeRefs.hs",
+    "src/LawSpec/HaskellData.hs",
+    "src/LawSpec/HaskellDefinitions.hs",
+    "src/LawSpec/HaskellExpr.hs",
+    "src/LawSpec/HaskellProperties.hs",
+    "src/LawSpec/HaskellTestHelpers.hs",
+    "src/LawSpec/HaskellTypeRefs.hs",
+    "src/LawSpec/Inference.hs",
+    "src/LawSpec/JavaData.hs",
+    "src/LawSpec/JavaDefinitions.hs",
+    "src/LawSpec/JavaExpr.hs",
+    "src/LawSpec/JavaProperties.hs",
+    "src/LawSpec/JavaTestHelpers.hs",
+    "src/LawSpec/KotlinData.hs",
+    "src/LawSpec/KotlinDefinitions.hs",
+    "src/LawSpec/KotlinExpr.hs",
+    "src/LawSpec/KotlinProperties.hs",
+    "src/LawSpec/KotlinTestHelpers.hs",
     "src/LawSpec/Model.hs",
-    "src/LawSpec/NativeScalarEmit.hs",
     "src/LawSpec/Parser.hs",
+    "src/LawSpec/PortableGenerator.hs",
+    "src/LawSpec/PortableTestHelpers.hs",
     "src/LawSpec/Prelude.hs",
+    "src/LawSpec/Public.hs",
+    "src/LawSpec/PythonData.hs",
+    "src/LawSpec/PythonDefinitions.hs",
+    "src/LawSpec/PythonExpr.hs",
+    "src/LawSpec/PythonTypes.hs",
     "src/LawSpec/Refinement.hs",
     "src/LawSpec/RuntimeSources.hs",
+    "src/LawSpec/RustData.hs",
+    "src/LawSpec/RustDefinitions.hs",
+    "src/LawSpec/RustEmit.hs",
+    "src/LawSpec/RustExpr.hs",
     "src/LawSpec/Scalar.hs",
-    "src/LawSpec/ScalarEmit.hs",
+    "src/LawSpec/SpecializeDefinitions.hs",
+    "src/LawSpec/Testing.hs",
+    "src/LawSpec/WebData.hs",
+    "src/LawSpec/WebDefinitions.hs",
+    "src/LawSpec/WebExpr.hs",
+    "src/LawSpec/WebTypes.hs",
     "stack.yaml",
     "stack.yaml.lock",
     "tools/embed-runtimes.py",
@@ -30,36 +116,122 @@
     "wasm/lawspec-wasm.cabal"
   ],
   "digests": {
-    "package.yaml": "ca15186d8aa807c58258a4b0fef8fa7d64afaa828f2e71803b4e8741066422fe",
-    "runtime/LawSpecRuntime.hs": "1c3ca22232c64227717d836a57d375d906f748ecde6b79705944a2319ce5064d",
-    "runtime/LawSpecRuntime.java": "5637914bd491f75ad0c75fb19d1bec798164295b7bcf9d23e1549e8ebf780d01",
-    "runtime/lawspec_runtime.go": "62d2041c33760b67db619e0a803501768a505c4dfd9837bca85e158fff81fda9",
-    "runtime/lawspec_runtime.mjs": "7d0abd53fa45dd9828c10ff2ffa7876162e965e7bb4913f4c460af13e06142fa",
-    "runtime/lawspec_runtime.py": "7541353effebd133e50cd00a3f4d8999651c93ba751a6d951164b1f390ce0c15",
-    "src/LawSpec/Api.hs": "f1a283fd3696e8e0dd1bd6240ba636a4c1abe19c6e0ea25d6d80a1af89f762cb",
-    "src/LawSpec/Compile.hs": "a67ee7cb19ebeea644bbf8dbdc0647323a77197b15f8e87fe2227deb6c995b8e",
-    "src/LawSpec/Domain.hs": "8ad50ad3a37aacb3a429c2d7924279e2a3b973204ce3c5c04c634c1b9ada0151",
-    "src/LawSpec/Emit.hs": "0b29d449f762af635bb65e5fcbf1f4cfffb1b91b28db115b08b2309557498693",
-    "src/LawSpec/Eval.hs": "9bdb694352ec4bd7140cdf8ab18045978b7407e93db5b661270160d08e4e9b7d",
-    "src/LawSpec/Gen.hs": "d4b4e5a21f5a2886dcdc98f56f649980d961c0570d9463154bed459844ab66aa",
-    "src/LawSpec/Model.hs": "67cad75f1d344bc2dfc997731c37f68994c6a6b568e03209e5b446484ae54674",
-    "src/LawSpec/NativeScalarEmit.hs": "67f50a7ea381ddada8ecbfc7534917c53f4074f8ce1d4fb6948adb8b7dfb2007",
-    "src/LawSpec/Parser.hs": "b6e5ee4a8c58b0ab2709420460f1fcabe287714f6defc0fab6cf52ccd0c416a5",
+    "lawspec.cabal": "f3372cb64f48514e0e7b16c2ea95636845cdd817b8231e23283b5af8d988fca2",
+    "package.yaml": "6f039e41854347b0443378de9b163e541e7f4b77448c8f620199a60d36bafcca",
+    "runtime/LawSpecCodecs.hs": "90cb1ed15d7ab664a17a054580c849408d77cfd2b2adcb4a3228b05132caeaca",
+    "runtime/LawSpecDataStrategies.hs": "840a316e1a69a862957bbd0f799440fc434240c156a3398e5be6563ecaa70a1b",
+    "runtime/LawSpecDataStrategies.java": "7e87c952ed192bf93a4b40f251a097148b7387ce7d505b5bc893cd9d51af3e65",
+    "runtime/LawSpecKotlin.kt": "0cf3b7de0406155225ccca33ee3dfdf8f0456c47d577f6be8f1265c13df838cb",
+    "runtime/LawSpecKotlinCodecs.kt": "6210f77dbbe24ba2088db48dae5415abf0993fe552fb3a57d29430807efbc297",
+    "runtime/LawSpecKotlinStrategies.kt": "2841edc3595f6d291859cc7edd31ea52093acf86d3542f07575784b01f9de237",
+    "runtime/LawSpecRuntime.hs": "5ced6a6a86a892ae63a544d4c4a4429bf756a730ea786478d820c8070cc96402",
+    "runtime/LawSpecRuntime.java": "c7b7cfc9b7c22b082edee14a52d95ef80ebe01ee56988c22702f629ea24b8a4f",
+    "runtime/LawSpecSchema.hs": "9912d9f525426a598f9c03c29cfc7bacf80218f73c9d537d8c1257bae245aa33",
+    "runtime/LawSpecSchema.java": "885f5f17a9ea1bdb86915dc184aea25b72c3062d6ddb9605530310540b1cc166",
+    "runtime/LawSpecStrategies.kt": "569f7775c0ac44765d05567cbf62d026558ac193c080ca71681ec6ee49c21794",
+    "runtime/lawspec_codecs.go": "abc910b8ea65f503b2df2c236250b5398012fe5eaf30f3e91d968e34c0897c1e",
+    "runtime/lawspec_data_strategies.go": "37aed9e49a286ea74ad9004c85e2ee4e780c99634735f0b40b0233ac24a41443",
+    "runtime/lawspec_data_strategies.mjs": "b39db076de1fc4310633a5271a10b336c56d6b1778c6cd8c2bd937f69e87a97d",
+    "runtime/lawspec_data_strategies.py": "542320b8733dea4cef96efcbc0ed65a949a90ca94b1771b0bee5773d06740e9a",
+    "runtime/lawspec_runtime.go": "af6ef660387b625b3bb5fcd57f06260c821d4f65eda158db44ad12d66e1d70f8",
+    "runtime/lawspec_runtime.mjs": "3b7877c1ee523afba30ed24cd452e2a6126d9e741c7675600e867600d7a73f46",
+    "runtime/lawspec_runtime.py": "2f780bc92762eb1115f734a36cc224ae34504929b4ff0ec506735cfa9e3ab02b",
+    "runtime/lawspec_runtime.rs": "7ae8afaad638a3d9d6973eebc7cd6daecc8012ec57f3f12ff50cca16e23e15b6",
+    "runtime/lawspec_schema.go": "bdfb6f2552bfccf56073d52f7cdbe1d784cba2d956c29762d77df7ad6bba8d67",
+    "runtime/lawspec_schema.mjs": "d204852d89aa862fc980225c111064e7c41bce5873c08063472b3da66190530c",
+    "runtime/lawspec_schema.py": "bf5c719caec1a91c5720be140ceec2cd01a6a2e0cb9a89c7a9bb05fdeecb34e7",
+    "runtime/lawspec_strategies.rs": "74c7b58e5ae119c226cec15b5f12875ba3647e45d4868086543ead6fed3bcc3d",
+    "runtime/rust/Cargo.lock": "dd5a3c0ba85579d13e61040334e9b16866124d2e88754948ec7dd512ade026ca",
+    "runtime/rust/Cargo.toml": "4bd3bb457970bf8f7af8531fc45fd6b605f995594a3ee0f60f7f1aaf765bb8aa",
+    "src/LawSpec/Api.hs": "532960f438214b4ca8a43d8d60777b6086e323f0c54fc7d1bc6bdbf0592ea319",
+    "src/LawSpec/Backend.hs": "03c3b0cd62467ca677c88d29d7b12b2ab505cc0076d93d1f48fbddb0e9bcf133",
+    "src/LawSpec/Capabilities.hs": "e43d4fc3a4481fbb8aa3ff1c3f41f7e7fca5db01bfe256a30162a45d75a00c1c",
+    "src/LawSpec/Code/Doc.hs": "9e3b70f85deb1dcbce385af1d0cd4bea2dfa8a2d806d54745d4bb437406673e5",
+    "src/LawSpec/Code/JavaScript.hs": "77bf27dcc210216e4739f68c4709f556f80130ab83b3b9387ac4a2421e790910",
+    "src/LawSpec/Common.hs": "107612a8aaa787488413acf9c1a56622004d3bff251db89b99928343e6070883",
+    "src/LawSpec/Compile.hs": "0260f0f1dc3d18d2f2e172ab47d603b6e3029ce2948cc0a237ad8277fc64707f",
+    "src/LawSpec/Core.hs": "ec081c49e5ccce95f84ded6073f1d8f30298f061dd8b94437d4b00410c57f27c",
+    "src/LawSpec/Core/DefinitionContracts.hs": "b7f60f038b231187ecf898e585ae1a8fb1fc113bb55bad6d1bb2660350fd969e",
+    "src/LawSpec/Core/Definitions.hs": "52f024fca59661142f70f9aa7dd2cbdb4892e5d3b1ca8079c878c5a1ba667112",
+    "src/LawSpec/Core/Eval.hs": "e1ad8af5b240dd99c3b1126408d2be5f9b42b86ca6189ecd3868680a5119d931",
+    "src/LawSpec/Core/Expression.hs": "84985f4f685126253d3af7b6b605d80d28fc9aa115bd5e2946f989eeb1355224",
+    "src/LawSpec/Core/Payload.hs": "df6a2b250c27c12bb6ac16b84847c52546081d066a3dca7575ed0d743cc13d50",
+    "src/LawSpec/Core/PayloadPlan.hs": "f2a7d2dc58c6a0f79707bdc24773bd3aad3a3b8eea2735a8284b2a9f3a4af4a8",
+    "src/LawSpec/Core/RefinementProof.hs": "c19fc03e68488357a59897ec38ce3d2efd320c35b405b632af17425d6a18447a",
+    "src/LawSpec/Core/Schema.hs": "9a4ec3967803913e6ff43d33e00a1b4b3b8ec0c79dbdbd80ae98101c85bf430f",
+    "src/LawSpec/Core/Semantics.hs": "a9d019433e3b9731f8cd0f65ec0ccc53179824bea58247b72df26760b878c2b6",
+    "src/LawSpec/Core/Total.hs": "95d2b19ba7fbfd033295504d31f786815384003b3b4d370776860b423cf079dd",
+    "src/LawSpec/Core/Totality.hs": "8f5b5d69f4baaba45301899ef568cbe90133943c3771ba78d492424e9725e7a7",
+    "src/LawSpec/Core/Types.hs": "4adf656d17812b68e8bf2d541908c769772cd5bfc9ac7a6c367160a5c40c9212",
+    "src/LawSpec/Core/Validate.hs": "0f045241215e068081d6cd7cf451f0166671bae5fffafda71a2e2320e8014c27",
+    "src/LawSpec/Core/Value.hs": "f2b2e4d82491e184d60b1217922b25c57a06cbbaecb2cb6f31174af50268fbc9",
+    "src/LawSpec/CoreEmit.hs": "868633c03239f12543a357677a273896839a0c044f402477a998b9299557c9cd",
+    "src/LawSpec/CoreNativeScalarEmit.hs": "43f1a22e95539b717a4a9c50b159d6b0b3879278fc90992a40dba4503f614c94",
+    "src/LawSpec/CoreScalarEmit.hs": "485e51dbe3f4dd2f23fb586737364f83e4af98ab532a1462c8b8451fefdb69ed",
+    "src/LawSpec/Data.hs": "9dbeafa120276b114dad790ec69e617f7ad0c632e3c718962f2f7faf8ca327f4",
+    "src/LawSpec/DefinitionTotality.hs": "7671b7efb0cac5d796b074d48b2c10940e5bd0b5df082b926aee694903285efa",
+    "src/LawSpec/Domain.hs": "222d15f0012ae630802238a6d7e1ee78d1e718b599f5ebb5a1ddc4e8d29d68c3",
+    "src/LawSpec/Elaboration.hs": "86e3ef77a977cb1b55985e2939648135acd0c2c015afe76e34e09615d555f53e",
+    "src/LawSpec/Emit.hs": "9f34f5765915a2a12a66a6dca647ddaef9289372956802c6d99cf0cfec447c7a",
+    "src/LawSpec/Eval.hs": "b0872ba8a6974463b32776653c2939826a6be87318c15641401f913f6b139de2",
+    "src/LawSpec/Frontend.hs": "fbf091b9c96f5b5361dbf4f65819634c0f8526ff98550d97c434c0d47af7839e",
+    "src/LawSpec/Gen.hs": "0410d4db3727a7999bc08a581301eb71ab570671e0ebeef7f1570ff76152b0a7",
+    "src/LawSpec/GoData.hs": "813770986acac02846e446e02e72f634b328c2c23c083fd3bfafbe236524e8a2",
+    "src/LawSpec/GoDefinitions.hs": "09e9e4b60cfea893d35589cd18bc8a6099789d81e0f57ae5cb018bd95bd4838b",
+    "src/LawSpec/GoExpr.hs": "da3a7cc0e3d2906886dc44f6b990e72098bb351558bbb31ee335da7382fac58a",
+    "src/LawSpec/GoProperties.hs": "c0bbbba3b6d15b14c28095dd5c6f35d30aa70fd5991fe95d6f6642d0f69b1d42",
+    "src/LawSpec/GoTestHelpers.hs": "dee55ee8505370e932773b8c685f4a1f380129e6f43f8806bf1e82efb99451b1",
+    "src/LawSpec/GoTypeRefs.hs": "7f239f5ac3ac8bd21c8f76c328049f7715d8562ee1382befa0a58abd4f15f726",
+    "src/LawSpec/HaskellData.hs": "125d5b8331d4e0a737f5de2fc28cf01677ba7e275b59238416eafdb9b973c809",
+    "src/LawSpec/HaskellDefinitions.hs": "535a8d644d5ddb98c22fa6bdf34cf2baa787aa1f5b900815c621d0d65ede0f0f",
+    "src/LawSpec/HaskellExpr.hs": "f4144cf2022ef0a3bec6d796ebe7d2f42563e9d25758b9f362cd5545b47e802b",
+    "src/LawSpec/HaskellProperties.hs": "770b5047ec35e99ce186b65f22d913e0e117f33a3103d5382176ccf4ec50393a",
+    "src/LawSpec/HaskellTestHelpers.hs": "51e59b2abc9e85455e3c8e2c6baadb27e5d319081cb730d2ce56be5dc8053897",
+    "src/LawSpec/HaskellTypeRefs.hs": "2225b2a5e2ab3662e7202d23b24f4d6db48353b35ae28df8acd2b92fd2b97574",
+    "src/LawSpec/Inference.hs": "78285145897f03c3c4adc37acf0f490ea779bab3975fb2830628dae3a152fe38",
+    "src/LawSpec/JavaData.hs": "8f5720812a899e02f7d607a7acef133b7aec4a7617e597700a87e436604e0563",
+    "src/LawSpec/JavaDefinitions.hs": "9c0fe11bd4849af09bbe3d941d89ba609a2dabecdc1c8b09b6ddbf69671c8f92",
+    "src/LawSpec/JavaExpr.hs": "6f237b0fc1eabe2d53c160f4cb781f8b77b478383f1a77ca4ccc8f08ac0dbcd0",
+    "src/LawSpec/JavaProperties.hs": "6cacfc6a005ac93a684e94efbfa7f83619d8658a396722b3fc47e533ba04cac1",
+    "src/LawSpec/JavaTestHelpers.hs": "e6f4b9bbb7e5f07ece6ab1845e12aa661e62e8b926680b11454223fc3ec1523d",
+    "src/LawSpec/KotlinData.hs": "338f576204e1f30cc0fdf82c806cbffcfbed3a5dfd1b33ac91cde7d975a28360",
+    "src/LawSpec/KotlinDefinitions.hs": "97d7d407d4bbdb4ce16035d607dbbcb8e3d6f5db513f2123a2c269e3dc6d2b38",
+    "src/LawSpec/KotlinExpr.hs": "20312f0774f1d0832a21a19b93c8103e2791ecd32a827d8e9c4f2b4830a996a0",
+    "src/LawSpec/KotlinProperties.hs": "670a5585a552a2ac91922938a859ca437c32fafd085517bdf2ee169b4d6129c2",
+    "src/LawSpec/KotlinTestHelpers.hs": "74810d65faafc6ed4d64b1fb0596cda4186e586b7144a7441641b798795bc324",
+    "src/LawSpec/Model.hs": "1d7ceb7bd66e3d496eef89eaa86403e6896472317ca9a4be86e0c933a7cce403",
+    "src/LawSpec/Parser.hs": "ad11e8f06371e98f295fae0245edceac8142320f054d0c3cb5600bc72588e17e",
+    "src/LawSpec/PortableGenerator.hs": "69d457e39f539c77fc7a4c08205e75352bbecd9dfdff031a283a39bf44b22d49",
+    "src/LawSpec/PortableTestHelpers.hs": "8ba4d87183c8c11f6ef1ce21c170127335797154f29fb97ad3429f032a167fd3",
     "src/LawSpec/Prelude.hs": "b1e155c12f58e7c346551a0c65c5d5af76d045b3f1625977ca2a5d1c97cb8c46",
-    "src/LawSpec/Refinement.hs": "060f7bdaaa9cebc17969fa28474e9402cc918ceea0f18cac54050d25010b473c",
-    "src/LawSpec/RuntimeSources.hs": "4a49d98919971bdbe2b9eabda4eb2e7cda643aaa65ef1a4e6892b6da40ee8acd",
-    "src/LawSpec/Scalar.hs": "d89d8233abd893f65bb20d4dabe11066340eb51b982ad6fa7bce04d3e22c3547",
-    "src/LawSpec/ScalarEmit.hs": "e1f05d255db08c8634b6af98fd5d0b938f9a3735f8adf13a952f092a90ee884c",
+    "src/LawSpec/Public.hs": "1b5e6031983cdc81559faea8a9a7e9a7bfab835de90fbf8c89f26844c411563a",
+    "src/LawSpec/PythonData.hs": "07e9bb54a1515f3f4744b7b9bb43633cbdbf07b3f9e35efef511753f97e216d5",
+    "src/LawSpec/PythonDefinitions.hs": "bc7b971be97339f2d9e4962ad98100878266176aeccd2a9dfd014e2db9550bd8",
+    "src/LawSpec/PythonExpr.hs": "23d7d24b5fb4efff9cb63d38c02a93d95744ec79b4565daf1412088fc7c4ba59",
+    "src/LawSpec/PythonTypes.hs": "ef928bfeb4324eb6e53c99cae247cc2fa84816075d81de4589d14abaa326656a",
+    "src/LawSpec/Refinement.hs": "8058a9f7e433b4b00ef0966a9ea2be3c91ae93b591ed58a1ffcb792d316193d3",
+    "src/LawSpec/RuntimeSources.hs": "ca453784dd06b7be37568aa142e402fabf9a572d6144766fabf14677d77d95e8",
+    "src/LawSpec/RustData.hs": "08e2c1e2181cbe120362b9fe87881dc78aaa4878c7a7fcec46d1df086b658ae5",
+    "src/LawSpec/RustDefinitions.hs": "5d0328a8b17e0cb5067f65d23f0f2cd2a96b92e4b1c3d6e22b7cb08255697177",
+    "src/LawSpec/RustEmit.hs": "4fbbf0e81627d477fd42db380cd7ff067c4a8641a9e74957d93ba2f3b0dce79b",
+    "src/LawSpec/RustExpr.hs": "04b2ef81417b811c7b98a98acdadab4e588ca8757964a63ba8dc5936c36479e6",
+    "src/LawSpec/Scalar.hs": "52e61fec81a337bb5b35e9e6f501446cf0b18bffa6c6af2ddc5aeac2d6e07131",
+    "src/LawSpec/SpecializeDefinitions.hs": "08f2fe674a5e00d1be396d9edab0dd2c948b7beb12fa99f2a6aba00cbdf01e33",
+    "src/LawSpec/Testing.hs": "db1a427ac2197e447faf2a36eccfe965c58eaa0ba07bc494bf1ba24e4af43ad4",
+    "src/LawSpec/WebData.hs": "d32ed71cc09a5715b6fbaf2c5784afc939e2cb61db4b364f7bed98118fd63899",
+    "src/LawSpec/WebDefinitions.hs": "fd985db70c778c8014b780666ac327018e05260be610fa717b8c5477ba9638b4",
+    "src/LawSpec/WebExpr.hs": "0389dcd5cf7479dd23ef034b1012de6ebd70bf1dc9e3d90981dfb0ba2702596f",
+    "src/LawSpec/WebTypes.hs": "f77ffee1e0c7929964a889fb252c1c5d0977afed94664ffcb0f8770c37b98c70",
     "stack.yaml": "20ccf4d599e355e60b7aa4f814a7cd4299fe2048616cc2e6dbdc22a7bd8cec73",
     "stack.yaml.lock": "ae222b9c81af920c56e50fa4596fa57786e7fa5a7b461390362b2b2ff63818c7",
-    "tools/embed-runtimes.py": "7520956a91f4b4ec8a6ab12078195cf1243c989b388a3f9d0b10a0fa60193bc3",
+    "tools/embed-runtimes.py": "91a05197fc542a65387f3ccf4614a4817c850031eb4b84196c621b8baf344865",
     "wasm/app/Exports.hs": "4ecbdac8faa2449e6fc61b93c82e6278fa14374154f29b4dacf0eef433f06a47",
     "wasm/cabal.project": "021e560afdc5eb4cb7169e7119ecb8f92c9ee170245af909c94b612941bff5cc",
     "wasm/cabal.project.freeze": "733dbed3d2ecccb26e874fd58f136296dad772184deb1658c196b5d54a0814dc",
-    "wasm/lawspec-wasm.cabal": "afdb97eb4a08de190f7533b7be79c6ba11fab9ef30792aca71ef5fb448001106",
-    "npm/core.wasm": "32e3f553dc8346a0d7aac63ad556eacc0e791803b8957f0804a609b883ed0ea8",
+    "wasm/lawspec-wasm.cabal": "61a21f9fc39087839a0df9781d94c9e7ed3dc375316c06e7dac36bd5e67e7f20",
+    "npm/core.wasm": "544ee4b0706f30b73ec6d4d1de1c27da7ebf9838c1dd1b9cff45b7c0393773da",
     "npm/core_jsffi.js": "88d136efe92f7cff5758c8fec8d9b6bbc9707fe37741cebeeb415fe34ce3d72b",
-    "npm/api.mjs": "d6df654600172131ac66a55b86876fc29cde2a76a0a63bbefff3183488a4837b",
-    "npm/index.d.ts": "ec19e731ed33e0d0481345888c73778ae0d3f2db58e4c3310ba684b801e698bc"
+    "npm/api.mjs": "6e25bb1f187d073f56badc1cd66c6c7f779cf68f1c5607d702d775c1c8b8a6dd",
+    "npm/index.d.ts": "d1348a783a116752c8ff2bf31fc29aab107b1452a516bd7b594153e3620cefcd"
   }
 }

package/compatibility.json

@@ -2,37 +2,120 @@
   "version": 1,
   "targets": {
     "java": {
-      "java": ["25", "26"],
-      "jetCheck": ["0.3.0", "0.3.1"],
-      "junit-jupiter": ["5.14.0", "5.15.0"]
+      "java": [
+        "25",
+        "26"
+      ],
+      "jetCheck": [
+        "0.3.0",
+        "0.3.1"
+      ],
+      "junit-jupiter": [
+        "5.14.0",
+        "5.15.0"
+      ]
     },
     "python": {
-      "python": ["3.13", "3.15"],
-      "pytest": ["8.4.0", "8.5.0"],
-      "hypothesis": ["6.135.26", "7"]
+      "python": [
+        "3.13",
+        "3.15"
+      ],
+      "pytest": [
+        "8.4.0",
+        "8.5.0"
+      ],
+      "hypothesis": [
+        "6.135.26",
+        "7"
+      ]
     },
     "javascript": {
-      "fast-check": ["4", "5"]
+      "fast-check": [
+        "4",
+        "5"
+      ]
     },
     "typescript": {
-      "fast-check": ["4", "5"],
-      "typescript": ["5.9", "5.10"],
-      "@types/node": ["22", "23"]
+      "fast-check": [
+        "4",
+        "5"
+      ],
+      "typescript": [
+        "5.9",
+        "5.10"
+      ],
+      "@types/node": [
+        "22",
+        "23"
+      ]
     },
     "go": {
-      "go": ["1.22", "1.27"],
-      "rapid": ["1.2.0", "1.2.1"]
+      "go": [
+        "1.22",
+        "1.27"
+      ],
+      "rapid": [
+        "1.2.0",
+        "1.2.1"
+      ]
     },
     "haskell": {
-      "hspec": ["2.11", "2.12"],
-      "hedgehog": ["1.5", "1.6"],
-      "hspec-hedgehog": ["0.3.0.0", "0.3.0.1"],
-      "ghc": ["9.10", "9.11"]
+      "hspec": [
+        "2.11",
+        "2.12"
+      ],
+      "hedgehog": [
+        "1.5",
+        "1.6"
+      ],
+      "hspec-hedgehog": [
+        "0.3.0.0",
+        "0.3.0.1"
+      ],
+      "ghc": [
+        "9.10",
+        "9.11"
+      ]
     },
     "kotlin": {
-      "java": ["25", "26"],
-      "gradle": ["9.1", "9.4"],
-      "kotlin": ["2.3.21", "2.3.22"]
+      "java": [
+        "25",
+        "26"
+      ],
+      "gradle": [
+        "9.1",
+        "9.4"
+      ],
+      "kotlin": [
+        "2.3.21",
+        "2.3.22"
+      ]
+    },
+    "rust": {
+      "rust": [
+        "1.85",
+        "2"
+      ],
+      "proptest": [
+        "1.11.0",
+        "1.11.1"
+      ],
+      "num-bigint": [
+        "0.4.8",
+        "0.4.9"
+      ],
+      "num-rational": [
+        "0.4.2",
+        "0.4.3"
+      ],
+      "num-complex": [
+        "0.4.6",
+        "0.4.7"
+      ],
+      "num-traits": [
+        "0.2.19",
+        "0.2.20"
+      ]
     }
   }
 }

package/doctor.mjs

@@ -67,14 +67,14 @@ async function installed(req, name) {
     dir = parent;
   }
 }
-export async function doctor(target, root) {
+export async function doctor(target, root, plannedArtifacts = []) {
   const name = target.language;
   const defaults =
     name === "java"
       ? ["src/main/java", "src/test/java"]
       : name === "kotlin"
         ? ["src/main/kotlin", "src/test/kotlin"]
-        : ["src", name === "python" ? "tests" : "test"];
+        : ["src", ["python", "rust"].includes(name) ? "tests" : "test"];
   const sourceDir = target.sourceDir ?? defaults[0];
   const testDir = target.testDir ?? defaults[1];
   try {
@@ -257,6 +257,8 @@ export async function doctor(target, root) {
         "The Stack profile requires one package per target root",
       );
       const cabal = await readFile(path.join(root, cabals[0]), "utf8");
+      const components = cabal.split(/^(?:library(?:[ \t]+\S+)?|test-suite[ \t]+\S+)[ \t]*\n/m).slice(1).map(s => s.split(/\n(?=\S)/)[0]);
+      requireThat(components.some(s => s.includes(sourceDir) && ['text','bytestring'].every(dep => new RegExp(`(?:^|[\\s,])${dep}(?=[\\s,<>=]|$)`).test(s))), "The component compiling generated source must directly depend on text and bytestring");
       const suites = cabal
         .split(/^test-suite\s+/m)
         .slice(1)
@@ -355,6 +357,33 @@ export async function doctor(target, root) {
         ),
         "The JUnit Jupiter test engine must be on the test classpath",
       );
+    } else if (name === "rust") {
+      const compiler = target.rustc || "rustc";
+      const cargo = target.cargo || "cargo";
+      versions.rust = (await run(compiler, ["--version"], root)).match(/^rustc (\d+\.\d+\.\d+)/)?.[1];
+      requireThat(versions.rust && compare(versions.rust, "1.85.0") >= 0, "Rust 1.85+ is required");
+      const data = JSON.parse(await run(cargo, ["metadata", "--format-version", "1"], root));
+      const pkg = data.packages.find(p => path.resolve(p.manifest_path) === path.join(root, "Cargo.toml"));
+      requireThat(pkg, "Select a Cargo package directory containing Cargo.toml");
+      requireThat(pkg.edition === "2024", "Cargo package must use edition 2024");
+      const node = data.resolve.nodes.find(n => n.id === pkg.id);
+      for (const dep of ["proptest", "num-bigint", "num-rational", "num-complex", "num-traits"]) {
+        const reference = node.deps.find(d => d.name === dep.replaceAll("-", "_"));
+        versions[dep] = data.packages.find(p => p.id === reference?.pkg)?.version;
+        requireThat(versions[dep], `Missing direct Cargo dependency: ${dep}`);
+      }
+      const manifest = await readFile(path.join(root, "Cargo.toml"), "utf8");
+      requireThat(!/harness\s*=\s*false/.test(manifest), "Rust generated tests require the standard Cargo test harness");
+      const testRoot = path.resolve(root, testDir);
+      const expectedTests = plannedArtifacts.length
+        ? plannedArtifacts.filter(f => f.placement === "test" && f.path.endsWith("_lawspec.rs")).map(f => path.resolve(root, f.path))
+        : (await readdir(testRoot).catch(error => {if(error.code === "ENOENT") return []; throw error;})).filter(n => n.endsWith("_lawspec.rs")).map(n => path.join(testRoot,n));
+      if (testDir !== "tests" || /autotests\s*=\s*false/.test(manifest)) {
+        const registered = new Set(pkg.targets.filter(t => t.kind.includes("test") && t.test).map(t => path.resolve(t.src_path)));
+        requireThat(expectedTests.length ? expectedTests.every(file => registered.has(file)) : [...registered].some(file => file.startsWith(testRoot + path.sep)), "Register every generated Rust test file with Cargo [[test]] entries for this custom layout");
+      }
+      const library = pkg.targets.find(t => t.kind.includes("lib"));
+      requireThat(!library || path.dirname(path.resolve(library.src_path)) === path.resolve(root, sourceDir), "Cargo library path must match the configured sourceDir");
     } else if (name === "kotlin") {
       const command =
         target.gradle ||

package/examples/specs/algebra.lawspec

@@ -1,13 +1,13 @@
 unit example.algebra
 
--- Int32 arithmetic in this example wraps modulo 2^32 on every target.
-add           :: Int32 -> Int32 -> Int32
-multiply      :: Int32 -> Int32 -> Int32
-negateValue   :: Int32 -> Int32
-maximumValue  :: Int32 -> Int32 -> Int32
-subtractValue :: Int32 -> Int32 -> Int32
-divideLeft    :: Int32 -> Int32 -> Int32
-divideRight   :: Int32 -> Int32 -> Int32
+-- Integer denotes mathematical integers. Adapter results must remain exact.
+add           :: Integer -> Integer -> Integer
+multiply      :: Integer -> Integer -> Integer
+negateValue   :: Integer -> Integer
+maximumValue  :: Integer -> Integer -> Integer
+subtractValue :: Integer -> Integer -> Integer
+divideLeft    :: Integer -> Integer -> Integer
+divideRight   :: Integer -> Integer -> Integer
 
 law `addition is commutative` is
   definition is
@@ -20,6 +20,20 @@ law `addition is commutative` is
     expect add x y = 8
     expect add y x = 8
   end
+
+  example `addition exceeds the Int32 maximum without wrapping` is
+    x = 2147483647
+    y = 1
+    expect add x y = 2147483648
+    expect add y x = 2147483648
+  end
+
+  example `addition remains exact beyond machine and safe-number bounds` is
+    x = 18446744073709551615
+    y = 2
+    expect add x y = 18446744073709551617
+    expect add y x = 18446744073709551617
+  end
 end
 
 law `addition is associative` is
@@ -116,6 +130,14 @@ law `multiplication distributes over addition left` is
     expect multiply x (add y z) = 36
     expect add (multiply x y) (multiply x z) = 36
   end
+
+  example `multiplication preserves products outside Int32` is
+    x = 2147483647
+    y = 2147483647
+    z = 1
+    expect multiply x y = 4611686014132420609
+    expect multiply x (add y z) = 4611686016279904256
+  end
 end
 
 law `multiplication distributes over addition right` is
@@ -251,4 +273,10 @@ law `negation is an involution` is
     expect negateValue x = 3
     expect negateValue (negateValue x) = -3
   end
+
+  example `negating the Int32 minimum produces a positive integer` is
+    x = -2147483648
+    expect negateValue x = 2147483648
+    expect negateValue (negateValue x) = -2147483648
+  end
 end

package/examples/specs/collections.lawspec

@@ -0,0 +1,67 @@
+unit example.collections
+
+reverse :: List Int32 -> List Int32
+sort :: List Int32 -> List Int32
+sorted :: List Int32 -> Bool
+permutation :: List Int32 -> List Int32 -> Bool
+echoMaybe :: Maybe (Maybe Bool) -> Maybe (Maybe Bool)
+echoEither :: Either (List Int32) (Maybe Bool) -> Either (List Int32) (Maybe Bool)
+echoNested :: List (Maybe (Either CodeUnit16 Bytes)) -> List (Maybe (Either CodeUnit16 Bytes))
+
+law `list involution` (f :: List a -> List a) requires Eq a is
+  definition is `involution` f end
+end
+
+law `reverse twice restores the list` is
+  definition is `list involution` reverse end
+  example `ordered input` is
+    x = [3, 1, 2]
+    expect reverse x = [2, 1, 3]
+  end
+  example `empty input` is x = [] expect reverse x = [] end
+end
+
+law `sorting is idempotent` is
+  definition is `idempotent` sort end
+  example `duplicates` is x = [3, 1, 3] expect sort x = [1, 3, 3] end
+end
+
+law `sort produces sorted output` is
+  definition is `for all` (xs :: List Int32) . sorted (sort xs) end
+end
+
+law `sort preserves length` is
+  definition is `for all` (xs :: List Int32) . prelude.length (sort xs) = prelude.length xs end
+end
+
+law `sort preserves elements` is
+  definition is `for all` (xs :: List Int32) . permutation (sort xs) xs end
+end
+
+law `nonempty reversal preserves length` is
+  definition is
+    `for all` (xs :: List Int32 where prelude.length xs > 0) .
+      prelude.length (reverse xs) = prelude.length xs
+  end
+end
+
+law `Maybe preserves nested absence` is
+  definition is `for all` (x :: Maybe (Maybe Bool)) . echoMaybe x = x end
+  example `outer absence` is x = Nothing expect echoMaybe x = Nothing end
+  example `inner absence` is x = Just Nothing expect echoMaybe x = Just Nothing end
+  example `present` is x = Just (Just true) expect echoMaybe x = Just (Just true) end
+end
+
+law `Either preserves branches` is
+  definition is `for all` (x :: Either (List Int32) (Maybe Bool)) . echoEither x = x end
+  example `left list` is x = Left [3, 1, 3] expect echoEither x = Left [3, 1, 3] end
+  example `right absence` is x = Right Nothing expect echoEither x = Right Nothing end
+end
+
+law `nested raw values survive` is
+  definition is `for all` (xs :: List (Maybe (Either CodeUnit16 Bytes))) . echoNested xs = xs end
+  example `surrogate and octets` is
+    xs = [Nothing, Just (Left codeUnit16(55296)), Just (Right bytes([0, 255]))]
+    expect echoNested xs = [Nothing, Just (Left codeUnit16(55296)), Just (Right bytes([0, 255]))]
+  end
+end

package/examples/specs/currying.lawspec

@@ -1,6 +1,6 @@
 unit example.currying
 
-sumFour :: Int32 -> Int32 -> Int32 -> Int32 -> Int32
+sumFour :: Integer -> Integer -> Integer -> Integer -> Integer
 format  :: Text -> Bool -> Int32 -> Text -> Text
 referenceFormat :: Text -> Bool -> Int32 -> Text -> Text
 trim    :: Text -> Text