lawspec 0.6.0 → 0.8.0

package/REFINEMENTS.md

@@ -0,0 +1,158 @@
+# Refinements and abstract integers (0.8.0)
+
+A refinement restricts a scalar domain with a pure Boolean expression. LawSpec
+checks concrete examples, generates satisfying input tuples, and checks adapter
+contracts during testing. It does not prove that an adapter is correct.
+
+## Exact integers without a storage width
+
+`Integer` is the mathematical integer domain. Integer literals default to it;
+integer addition, subtraction, multiplication, negation, quotient, and remainder
+produce it. Calculations use arbitrary precision internally. `BigInt` remains
+available when a concrete arbitrary-precision adapter representation is wanted.
+
+```lawspec
+unit example.increment
+successor :: (x :: Int8) -> (result :: Integer where result == x + 1)
+```
+
+This signature generates contract tests without a separate law. The maximum
+input, `127`, requires the value `128`. Returning a wrapped `-128` fails.
+`Integer` does not assert which storage width the implementation used.
+
+Abstract integer results accept Python `int` (excluding `bool`), JavaScript or
+TypeScript `bigint` and safe integral `number` values, Java/Kotlin standard signed
+integral wrappers and `BigInteger` through `Number`, and Go signed/unsigned integer
+values or `big.Int` values/pointers through `any`. Floating representations are
+rejected even when their current value is integral. Haskell uses `IntegerValue`:
+
+```haskell
+successor :: Int8 -> IntegerValue
+successor x = integerValue (toInteger x + 1)
+```
+
+`integerValue :: Integral a => a -> IntegerValue` erases the width losslessly.
+Abstract integer arguments use the target's arbitrary-precision integer type.
+Concrete signatures keep their existing checked native mappings.
+
+## Inline and named refinements
+
+Use `where` on a quantified input, function argument, or function result:
+
+```lawspec
+`for all` (x :: Int8) (y :: Int8 where y > Int8.max - x) .
+  add x y = x + y
+```
+
+A predicate can reference its own value and earlier inputs. A function result
+predicate can also reference the function's named arguments. Forward value
+references are errors. `Int8.min` and `Int8.max` denote representation bounds;
+machine-sized bounds use the requested `machineBits` profile.
+
+Named refinements distinguish type parameters from value parameters:
+
+```lawspec
+refinement Between
+  (T :: Type) (minimum :: T) (maximum :: T)
+  requires Ordered T is
+  (value :: T where minimum <= value && value <= maximum)
+end
+
+refinement AdditionOverflows
+  (T :: Type) (left :: T)
+  requires Integer T Bounded T is
+  (right :: T where left + right > T.max)
+end
+
+add :: (x :: Int8)
+    -> (y :: AdditionOverflows Int8 x)
+    -> (result :: Integer where result == x + y)
+```
+
+`(x :: Between Int8 1 10)` applies a refinement. Parenthesize compound arguments,
+for example `Between Int8 (-10) (5 + 5)`. Later value-parameter types can use
+earlier parameters. Value arguments must satisfy their declared domains,
+including refinements. Substitution avoids capturing names from the call site.
+Declarations can appear in any order within a unit; recursive aliases are errors.
+Fixed refinements are the zero-parameter form:
+
+```lawspec
+refinement PositiveInt8 is (value :: Int8 where value > 0) end
+```
+
+Aliases preserve their underlying native representation. They can be nested in
+`Nullable` and `Optional`; inner predicates are checked only for present values.
+Type parameters range over the supported scalar types, including presence types.
+
+`requires Integer T` describes integer capabilities in a generic declaration.
+`Integer` entails `Eq` and `Ordered`. `Ordered` currently covers exact real numbers
+and floats, with the existing IEEE comparisons (including NaN behavior).
+`Bounded` covers fixed and machine-sized integers. Bounds refer to the underlying
+integer representation, rather than a tighter interval inferred from a predicate.
+Capabilities are checked on generic declarations and their specializations.
+
+## Predicate expressions and contracts
+
+Predicates support existing pure arithmetic, comparisons, scalar constructors,
+conversions, and built-in helpers. `&&`, `||`, and `!` short-circuit; comparisons
+bind more tightly than `&&`, which binds more tightly than `||`. Assertion `and`
+continues to combine law conclusions. Exact/inexact mixing still needs an explicit
+conversion, and floating expressions retain their declared precision.
+
+`prelude.length` counts Unicode scalars for Text, code points for CodePointText,
+UTF-16 units for Utf16Text, and octets for Bytes. `prelude.isPresent` and
+`prelude.presentValue` inspect tagged presence values; guard extraction with
+`isPresent` before accessing a possibly absent value.
+
+Adapter calls are forbidden in refinements. Predicate errors such as division by
+zero are reported as failures when evaluated; they are not ordinary rejection of
+an input. Short-circuited branches are not evaluated by generation optimizations.
+
+Every refined function signature creates a standalone property. Calls from other
+laws also check argument preconditions, invoke the adapter once, snapshot its
+result, and check postconditions. Calling a function outside its precondition is
+a test failure, not a discarded example. Ordinary `implies` guards retain their
+existing conditional behavior.
+
+## Dependent generation and shrinking
+
+A quantified law ranges over satisfying tuples. For `AdditionOverflows Int8 x`,
+`x = 0` has no admissible `y`. The generator backtracks to choose another `x`;
+it does not count that dead end as a passing test. Valid pairs satisfy:
+
+```text
+1 <= x <= 127
+128 - x <= y <= 127
+```
+
+The generator derives integer bounds from affine comparisons and conjunctions,
+seeds direct comparison values and boundaries, and checks the complete predicate.
+Predicates outside that analysis use bounded sampling. Small finite base-domain
+products are enumerated exhaustively, retaining only satisfying tuples.
+
+Shrinking checks refinements again and repairs dependent later inputs when an
+earlier value changes. An overflowing counterexample can shrink to `(1, 127)`;
+it cannot shrink to `(0, 127)` because that pair is outside the domain.
+
+Compiler requests and `lawspec.json` accept:
+
+```json
+{
+  "generation": {
+    "cases": 100,
+    "maxAttempts": 10000,
+    "maxShrinks": 1000,
+    "exhaustiveLimit": 4096
+  }
+}
+```
+
+All limits are positive integers. These are the defaults for refinement properties.
+`cases` counts accepted property inputs; explicit examples and boundary fixtures
+are additional checks. Exhausted searches report an error with reproduction
+information. Exhaustion does not prove that the mathematical domain is empty.
+Statically established empty executable domains and invalid examples are rejected.
+
+See [the bundled examples](examples/specs/refinements.lawspec) for overflow,
+abstract integer arguments/results, dependent bounds, optional refinements,
+floating classification, and raw-byte lengths.

package/RUST.md

@@ -0,0 +1,97 @@
+# Rust backend (0.8)
+
+Rust is the first backend built on LawSpec's typed core and testing plan. The
+compiler remains implemented in Haskell. Rust generation does not parse source
+expressions, infer their types, or expand refinement declarations.
+
+## Project setup
+
+Use Rust 1.85 or later, edition 2024, and Cargo. The generated project pins
+Proptest 1.11.0, num-bigint 0.4.8, num-rational 0.4.2, num-complex 0.4.6, and
+num-traits 0.2.19.
+
+```sh
+lawspec init --target rust
+lawspec doctor
+lawspec generate
+cargo test
+cargo test --release
+```
+
+Adapters are user-owned files under `src/`. LawSpec maintains
+`lawspec_runtime.rs`, module declarations in `lawspec_modules.rs`, and tests
+under `tests/`. The scaffolded `src/lib.rs` includes the generated declarations;
+an existing library can include those declarations explicitly. Generation
+preserves edited adapters and reports required signature updates.
+
+The numeric runtime has no Proptest dependency. Framework support lives in a
+separate generated file, `tests/support/lawspec_strategies.rs`.
+
+## Owned adapter values
+
+Arguments and results are owned Rust values. LawSpec does not add borrowing,
+lifetimes, or pointer operations to its language. Tests clone values where an
+expression needs to use an input more than once.
+
+| LawSpec domain | Rust adapter representation |
+| --- | --- |
+| `Bool` | `bool` |
+| Fixed signed/unsigned integers | `i8`…`i64`, `u8`…`u64` |
+| `IntSize`, `UIntSize`, `UIntPtr` | `isize`, `usize`, `usize` |
+| `BigInt`, `BigUInt` | `BigInt`, `BigUint` |
+| `Integer` input | `BigInt` |
+| `Integer` result | `Integer`, with lossless `From` implementations |
+| `Decimal`, `Rational` | Generated `Decimal`, `BigRational` |
+| `Float32`, `Float64` | `f32`, `f64` |
+| `Complex64`, `Complex128` | `Complex32`, `Complex64` from num-complex |
+| `Char`, `Text` | `char`, `String` |
+| `CodePoint`, `CodePointText` | Generated checked wrappers |
+| `CodeUnit16`, `Utf16Text`, `Bytes` | `u16`, generated UTF-16 wrapper, `Vec<u8>` |
+| `Symbol` | Generated identity type; cloning preserves identity |
+| `Unit`, `Null`, `Undefined` | `()`, distinct generated absence types |
+| `Nullable a`, `Optional a` | Distinct generated enums, including nested presence |
+
+Names such as `Integer` and `Decimal` above are exported by the generated
+`lawspec_runtime` module. Machine-sized native bindings check the requested
+`machineBits` against the executing architecture.
+
+For a declaration such as `successor :: Int8 -> Integer`, an implementation can
+return a wider native integer through the logical result wrapper:
+
+```rust
+use crate::lawspec_runtime as ls;
+
+pub fn successor(value: i8) -> ls::Integer {
+    (i16::from(value) + 1).into()
+}
+```
+
+Exact arithmetic in laws uses arbitrary precision. Passing its result to an
+`i8` adapter parameter performs a checked conversion. A fractional or
+out-of-range value fails with the adapter's context.
+
+`Decimal` stores an arbitrary integer coefficient and exponent. Decimal
+arithmetic is exact; explicit rounding uses the requested scale and ties to
+even. Exact-to-float conversion rounds directly to the requested IEEE precision,
+including subnormal and halfway cases.
+
+## Refinements and generation
+
+Small finite domains are enumerated. Larger domains use native Proptest
+strategies. Integer bounds over earlier inputs become dependent strategies;
+when a prefix has no possible continuation, generation retries the prefix.
+Shrinking recomputes those dependent bounds and retains only valid tuples.
+Refinement evaluation errors fail the test rather than being counted as rejected
+samples. Generation limits prevent an empty or unreachable domain from passing
+vacuously.
+
+Contracts check preconditions, evaluate the adapter once, validate its native
+result, and then check postconditions on that result.
+
+## Custom layouts
+
+`sourceDir` and `testDir` move generated sources and imports together. Set Cargo's
+`[lib] path` to the library entry point under the selected source directory. For
+test directories other than `tests`, register generated test files using Cargo
+`[[test]]` entries. Doctor checks the selected Cargo package, edition, resolved
+dependencies, library directory, and custom test registration.

package/api.mjs

@@ -2,5 +2,5 @@
 import { loadCore } from './launcher.mjs';
 export async function createCompiler() {
   const call = await loadCore();
-  return { check: (input) => call({ ...input, method: 'check' }), expand: (input) => call({ ...input, method: 'expand' }), planGeneration: (input) => call({ ...input, method: 'planGeneration' }) };
+  return { check: (input) => call({ schemaVersion: 3, ...input, method: 'check' }), expand: (input) => call({ schemaVersion: 3, ...input, method: 'expand' }), planGeneration: (input) => call({ schemaVersion: 3, ...input, method: 'planGeneration' }) };
 }

package/bin/lawspec.mjs

@@ -4,6 +4,7 @@ import path from "node:path";
 import { createCompiler } from "../api.mjs";
 import { targets, templates, commands, setup } from "../templates.mjs";
 import { generateExamples } from "../examples-command.mjs";
+import { showScalar } from "../scalars.mjs";
 import { doctor } from "../doctor.mjs";
 import {
   readOptional,
@@ -18,7 +19,7 @@ const options = {};
 const positional = [];
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
-  if (["--target", "--project", "--config", "--output"].includes(arg)) {
+  if (["--target", "--project", "--config", "--output", "--machine-bits"].includes(arg)) {
     if (!args[i + 1] || args[i + 1].startsWith("--"))
       throw new Error(`Missing value for ${arg}`);
     options[arg.slice(2)] = args[++i];
@@ -103,6 +104,7 @@ async function init() {
     throw new Error("Target is already configured");
   await mkdir(root, { recursive: true });
   const buildFiles = [
+    "Cargo.toml",
     "pom.xml",
     "pyproject.toml",
     "package.json",
@@ -138,6 +140,7 @@ async function init() {
       await readFile(new URL("../starter.lawspec", import.meta.url), "utf8"),
       true,
     );
+  if (options.machineBits !== undefined) config.machineBits = options.machineBits;
   config.targets.push({
     language,
     root: path.relative(configRoot, root) || ".",
@@ -151,47 +154,32 @@ async function init() {
     `Configured ${language}. ${hasBuild ? "Existing build files preserved." : "Created missing project build files."}\n${setup[language]}\nNext: lawspec doctor, then lawspec generate.`,
   );
 }
-function showExpression(expr) {
-  const value = expr.contents;
-  if (expr.tag === "Var") return value;
-  if (
-    expr.tag === "Number" ||
-    expr.tag === "StringLit" ||
-    expr.tag === "BoolLit"
-  )
-    return JSON.stringify(value);
-  if (expr.tag === "Apply")
-    return `${showExpression(value[0])} (${showExpression(value[1])})`;
-  return `(${showExpression(value[0])} . ${showExpression(value[1])})`;
+function showAssertion(assertion) {
+  if (assertion.kind === "equal") return `${assertion.left.text} = ${assertion.right.text}`;
+  if (assertion.kind === "implies") return `${assertion.guard.text} implies ${showAssertion(assertion.body)}`;
+  return assertion.items.map(showAssertion).join(" and ");
 }
 function explainExamples(law) {
-  return law.original.examples
-    .map(
-      (ex) =>
-        `\nexample ${JSON.stringify(ex.exampleName)}\n` +
-        ex.bindings
-          .map(([n, v]) => `  ${n} = ${JSON.stringify(v)}`)
-          .join("\n") +
-        "\n" +
-        ex.expectations
-          .map(
-            (e) =>
-              `  expect ${showExpression(e.actual)} = ${JSON.stringify(e.expected)}`,
-          )
-          .join("\n"),
-    )
-    .join("\n");
+  return law.examples.map(ex =>
+    `\nexample ${JSON.stringify(ex.name)}\n` +
+    ex.bindings.map(b => `  ${b.name} = ${showScalar(b.value)}`).join("\n") + "\n" +
+    ex.expectations.map(e => `  expect ${showAssertion(e)}`).join("\n")
+  ).join("\n");
 }
 async function main() {
+  if (options['machine-bits'] !== undefined) {
+    options.machineBits = Number(options['machine-bits']);
+    if (![32,64].includes(options.machineBits)) throw new Error('machineBits must be 32 or 64');
+  }
   if (!verb || ["help", "--help", "-h"].includes(verb)) {
     output(
-      "LawSpec 0.6.0\nUsage: lawspec init --target <language> [--project <directory>]\n       lawspec check | doctor | explain <unit>::<law> | generate\n       lawspec examples [--target <language>] [--output example_artifacts]\nOptions: --config <path>, --target <language>, --json\nGeneration: --dry-run, --check\nTargets: " +
+      "LawSpec 0.8.0\nUsage: lawspec init --target <language> [--project <directory>]\n       lawspec check | doctor | explain <unit>::<law> | generate\n       lawspec examples [--target <language>] [--output example_artifacts]\nOptions: --config <path>, --target <language>, --machine-bits <32|64>, --json\nGeneration: --dry-run, --check\nTargets: " +
         targets.join(", "),
     );
     return;
   }
   if (verb === "--version") {
-    output("0.6.0");
+    output("0.8.0");
     return;
   }
   if (positional.length > (verb === "explain" ? 1 : 0))
@@ -256,14 +244,15 @@ async function main() {
     if (reports.some((r) => !r.ok)) process.exitCode = 1;
     return;
   }
-  const input = { sources: await sources(config) };
+  if (config.machineBits !== undefined && ![32, 64].includes(config.machineBits)) throw new Error("machineBits must be 32 or 64");
+  const input = { sources: await sources(config), generation: config.generation, machineBits: options.machineBits ?? config.machineBits ?? 64 };
   const compiler = await createCompiler();
   if (verb === "check") {
     const result = diagnostics(await compiler.check(input));
     output(
       options.json
         ? result
-        : `Checked ${result.laws.length} executable law(s).`,
+        : `Checked ${result.laws.length} law(s).`,
     );
     return;
   }
@@ -274,7 +263,7 @@ async function main() {
       .filter(
         ({ e }) => !positional[0] || `${e.owner}::${e.name}` === positional[0],
       );
-    if (!indices.length) throw new Error("No matching executable law");
+    if (!indices.length) throw new Error("No matching law");
     output(
       options.json
         ? indices.map(({ e, i }) => ({ ...e, expansion: result.expansions[i] }))
@@ -302,7 +291,7 @@ async function main() {
       ).files,
     );
   const reports = await Promise.all(
-    selected.map((t, i) => doctor(t, roots[i])),
+    selected.map((t, i) => doctor(t, roots[i], artifacts[i])),
   );
   const failed = reports.filter((r) => !r.ok);
   if (failed.length)

package/build.json

@@ -2,38 +2,94 @@
   "version": 1,
   "compilerSources": [
     "package.yaml",
+    "runtime/LawSpecRuntime.hs",
+    "runtime/LawSpecRuntime.java",
+    "runtime/lawspec_runtime.go",
+    "runtime/lawspec_runtime.mjs",
+    "runtime/lawspec_runtime.py",
+    "runtime/lawspec_runtime.rs",
+    "runtime/lawspec_strategies.rs",
+    "runtime/rust/Cargo.lock",
+    "runtime/rust/Cargo.toml",
     "src/LawSpec/Api.hs",
+    "src/LawSpec/Backend.hs",
+    "src/LawSpec/Common.hs",
     "src/LawSpec/Compile.hs",
+    "src/LawSpec/Core.hs",
+    "src/LawSpec/Core/Eval.hs",
+    "src/LawSpec/Core/Semantics.hs",
+    "src/LawSpec/Core/Validate.hs",
+    "src/LawSpec/CoreEmit.hs",
+    "src/LawSpec/CoreNativeScalarEmit.hs",
+    "src/LawSpec/CoreScalarEmit.hs",
+    "src/LawSpec/Domain.hs",
     "src/LawSpec/Emit.hs",
+    "src/LawSpec/Eval.hs",
+    "src/LawSpec/Frontend.hs",
     "src/LawSpec/Gen.hs",
     "src/LawSpec/Model.hs",
     "src/LawSpec/Parser.hs",
     "src/LawSpec/Prelude.hs",
+    "src/LawSpec/Public.hs",
+    "src/LawSpec/Refinement.hs",
+    "src/LawSpec/RuntimeSources.hs",
+    "src/LawSpec/RustEmit.hs",
+    "src/LawSpec/Scalar.hs",
+    "src/LawSpec/Testing.hs",
     "stack.yaml",
     "stack.yaml.lock",
+    "tools/embed-runtimes.py",
     "wasm/app/Exports.hs",
     "wasm/cabal.project",
     "wasm/cabal.project.freeze",
     "wasm/lawspec-wasm.cabal"
   ],
   "digests": {
-    "package.yaml": "25d79d741039fe21e1164d789fdf4f698f135df7e4c96c82560e4f7efe8fbdf9",
-    "src/LawSpec/Api.hs": "00b1e4bc81231ebd387f10652463904084ebf9c3c4486fd2c2217a6d4dbfc157",
-    "src/LawSpec/Compile.hs": "64aa042ce2f0f460d691ea43fa27bf75576a49a6e852a068f62a2cf5a28e81b7",
-    "src/LawSpec/Emit.hs": "85ab85d789c4e2c98703e2768075cb1c0bed42b987c45b5060b9a9df56e8d291",
-    "src/LawSpec/Gen.hs": "c596e411790a47cb15b2945d391b9909cbec1972bf6e502ed8c069db2c67e991",
-    "src/LawSpec/Model.hs": "549f553d1cc5d65c804a5acfac0cc06e63ff10eb80674893e32fcd3c0a71a5b3",
-    "src/LawSpec/Parser.hs": "ae7c5ad29871b99441db2dae10548afafb2ae4931dd1a62208ca0f5e3545002c",
+    "package.yaml": "90923d07cf41977f62a201faf26667ae4fd76de84c6f25ce47917ac92a6a1f4b",
+    "runtime/LawSpecRuntime.hs": "1c3ca22232c64227717d836a57d375d906f748ecde6b79705944a2319ce5064d",
+    "runtime/LawSpecRuntime.java": "5637914bd491f75ad0c75fb19d1bec798164295b7bcf9d23e1549e8ebf780d01",
+    "runtime/lawspec_runtime.go": "62d2041c33760b67db619e0a803501768a505c4dfd9837bca85e158fff81fda9",
+    "runtime/lawspec_runtime.mjs": "7d0abd53fa45dd9828c10ff2ffa7876162e965e7bb4913f4c460af13e06142fa",
+    "runtime/lawspec_runtime.py": "7541353effebd133e50cd00a3f4d8999651c93ba751a6d951164b1f390ce0c15",
+    "runtime/lawspec_runtime.rs": "bf9cf5fa546346a59c85248936395fe11946974ce0bad053aeeaf4e26b6a829d",
+    "runtime/lawspec_strategies.rs": "a5dcee400574a69a5d2aa066bb8959e366728b3f21a578de84f50feadadf6641",
+    "runtime/rust/Cargo.lock": "91533e20939436e117c0f09ded695a8a05a86e79efc29fe4b4b93ad8ef1771c8",
+    "runtime/rust/Cargo.toml": "7ec66cf82dcc73a4a0b4a44d6048b6c3a340897c488aaaace9e8d4bac90b5e0a",
+    "src/LawSpec/Api.hs": "4810c05d53e370daf7520b9116c34997b7b4ba9c8d3f1a349e2afdb7b1424552",
+    "src/LawSpec/Backend.hs": "15ba04b69739e3891f73757d9cdc0a29acca6b7f7e067fd11d83d718474d0f20",
+    "src/LawSpec/Common.hs": "baa849dad0cc6227af334fdc7488389df50c0fe3a74a2ba1d84eb60c6b6edd6e",
+    "src/LawSpec/Compile.hs": "6c8bcea938f2ec3f83afb348c5ca932d96ce070f4e916fc9233a3a02ffcc89f2",
+    "src/LawSpec/Core.hs": "27ce2bb1274485cc190e10f8520118d5b381c90ac4ab6343223c46fb3cd10869",
+    "src/LawSpec/Core/Eval.hs": "87bf2acfdfff1431f1358947044c0474df40b5bc601076f5e5051e089f1d2fa4",
+    "src/LawSpec/Core/Semantics.hs": "a9d019433e3b9731f8cd0f65ec0ccc53179824bea58247b72df26760b878c2b6",
+    "src/LawSpec/Core/Validate.hs": "bd67926c872e190279f3758ad57b45c0f80d5be8381cedc8ac56a5b88b115201",
+    "src/LawSpec/CoreEmit.hs": "7ba225a262372f61edd6fe2ba0f2dbade44dfa2f767cdbcdd3f4c323eb5e9e7b",
+    "src/LawSpec/CoreNativeScalarEmit.hs": "f20382952f5854605ae617609c1ff9f5627e5acb134417cf3a67b97054844acb",
+    "src/LawSpec/CoreScalarEmit.hs": "db564e0cb07c69dee63b7dcb9cd524c30d4e7d658264d72f834adcc9fa05899d",
+    "src/LawSpec/Domain.hs": "8ad50ad3a37aacb3a429c2d7924279e2a3b973204ce3c5c04c634c1b9ada0151",
+    "src/LawSpec/Emit.hs": "9f34f5765915a2a12a66a6dca647ddaef9289372956802c6d99cf0cfec447c7a",
+    "src/LawSpec/Eval.hs": "bbaa50d3febee690c3b09ceb3f2592964cdb458dd1b4c38b6ec68a80f3e077ea",
+    "src/LawSpec/Frontend.hs": "b483732416f23960f0f03c30079a6db3ba630cf013b38fd6beede08b186585b8",
+    "src/LawSpec/Gen.hs": "f0a153e05fb0599a7cb2303dd62a269b2561738466c7211efc1927af2d5604b0",
+    "src/LawSpec/Model.hs": "75cedd730b8e8f7bff2dd39cfe3c1ed8f64e74471f6231248474957df446328f",
+    "src/LawSpec/Parser.hs": "e64356888d78f02572ff8c0a39b782248dd6a4bb9f0b1e30900f9dc12c3cd946",
     "src/LawSpec/Prelude.hs": "b1e155c12f58e7c346551a0c65c5d5af76d045b3f1625977ca2a5d1c97cb8c46",
+    "src/LawSpec/Public.hs": "eec6c9684b3c5cb42fa882f89460104856cb02f963822b66d9b9583dc011dfeb",
+    "src/LawSpec/Refinement.hs": "9902897edc0a803c2d440cf6d5a1d44e524f94b7384ea55a6f9dcd16dbfa8957",
+    "src/LawSpec/RuntimeSources.hs": "69dadd138bb784eaebd74869d03e30079e6d73e1724179794d8ec32be178e171",
+    "src/LawSpec/RustEmit.hs": "702652cc590c5db148f35d2e591d90e45270eee47e78c31772749943509aafe7",
+    "src/LawSpec/Scalar.hs": "2907d94b72e66584b762b5ab33da64adb26f9bf84b885151ef408dc3de1a440d",
+    "src/LawSpec/Testing.hs": "a5dc1c15a45539bb72d1c7cb24cbd04888bbb8ef2f066c829654c3bdbf32c609",
     "stack.yaml": "20ccf4d599e355e60b7aa4f814a7cd4299fe2048616cc2e6dbdc22a7bd8cec73",
     "stack.yaml.lock": "ae222b9c81af920c56e50fa4596fa57786e7fa5a7b461390362b2b2ff63818c7",
+    "tools/embed-runtimes.py": "26dda6ecf944ac065d10165d84ecdf44f134945fabbd48492a67d2495b5faba4",
     "wasm/app/Exports.hs": "4ecbdac8faa2449e6fc61b93c82e6278fa14374154f29b4dacf0eef433f06a47",
     "wasm/cabal.project": "021e560afdc5eb4cb7169e7119ecb8f92c9ee170245af909c94b612941bff5cc",
     "wasm/cabal.project.freeze": "733dbed3d2ecccb26e874fd58f136296dad772184deb1658c196b5d54a0814dc",
-    "wasm/lawspec-wasm.cabal": "d0d9c395b96de75264d5dc62f7995f02b285aebc696a2cf603a62b4e280f9132",
-    "npm/core.wasm": "e90e71610ca9f58a1b1e88d65f593c74d2a5b09347a4b47802bd771c954b7e42",
+    "wasm/lawspec-wasm.cabal": "22590b2a6fcd384ef8957bd179e04a055e90535f7eaaa2b5ac3d314fd0b686ed",
+    "npm/core.wasm": "09efa9e767c3d33e718a8a0909cdf23b24d158813570cc610f56e72d37a59fa3",
     "npm/core_jsffi.js": "88d136efe92f7cff5758c8fec8d9b6bbc9707fe37741cebeeb415fe34ce3d72b",
-    "npm/api.mjs": "d6df654600172131ac66a55b86876fc29cde2a76a0a63bbefff3183488a4837b",
-    "npm/index.d.ts": "628016928dc71dc735d59d15ccde45500d9a4133e3b20c8d3c21cb9c65ccb604"
+    "npm/api.mjs": "7415fc057ea5f4da68f9d255ce862152d6bc45d6b0053d44f61f9110911ac64b",
+    "npm/index.d.ts": "d19ecaea0be4ca01c8667a76e1bcfe758fd200d728ef67a44ad14e1b1dd15b72"
   }
 }

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"
+      ]
     }
   }
 }