lawspec 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 brain-fuel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,240 @@
+# LawSpec
+
+**State the law once. Check it everywhere.**
+
+LawSpec 0.1 compiles reusable laws into native property tests, executable examples,
+and implementation adapters. The compiler is Haskell, distributed as prebuilt
+WebAssembly with a Node CLI and an asynchronous, typed JavaScript API.
+
+## Install and try it
+
+The checkout includes the npm package in `npm/`. Build an installable archive:
+
+```sh
+npm pack ./npm
+npm install --save-dev ./lawspec-0.1.0.tgz
+```
+
+No Haskell toolchain is needed to install or run the npm package. Node 22+ and the
+selected target's build tools are required. The reference platforms are macOS
+and Linux. This checkout has not been published to the npm registry.
+
+From an empty application directory, use the installed `lawspec` command:
+
+```sh
+lawspec init --target javascript
+npm install
+lawspec check
+lawspec explain 'example.atoi_codec::itoa and then atoi yields a'
+lawspec doctor
+lawspec generate
+```
+
+Implement `src/example/atoi_codec.mjs`, then run `npm test`:
+
+```javascript
+export function itoa(value) { return String(value); }
+export function atoi(value) { return Number(value); }
+```
+
+The starter adapters intentionally throw until implemented. Generated tests
+include the supplied examples, signed 32-bit boundary cases, and randomized
+properties with the selected framework's shrinking and failure reporting.
+
+## Targets
+
+| Target | Build setup | Test libraries | Test command |
+| --- | --- | --- | --- |
+| `java` | Maven, JDK 25, release 25 | JetCheck 0.3.0, JUnit Jupiter 5.14.x | `mvn test` |
+| `python` | Python 3.13 or 3.14, pyproject | pytest 8.4.x, Hypothesis 6.135.26+ (6.x) | `python -m pytest` |
+| `javascript` | Node 22+, npm, ESM | fast-check 4.x, node:test | `npm test` |
+| `typescript` | Node 22+, npm, TypeScript 5.9.x, ESM | fast-check 4.x, node:test | `npm test` |
+| `go` | Go modules, Go 1.22–1.26 | Rapid 1.2.0, testing | `go test ./...` |
+| `haskell` | Stack, GHC 9.10, LTS 24.58 | Hspec 2.11, Hedgehog 1.5, hspec-hedgehog 0.3 | `stack test` |
+| `kotlin` | JDK/JVM 25, Gradle 9.1–9.3, Kotlin 2.3.21 | Kotest 5.9.1 | `gradle test` |
+
+Java 25 and Python 3.13 are the minimum baselines. New JVM releases are admitted
+through compatibility profiles after testing; v0.1's current JVM profile certifies
+25. Python templates declare `requires-python = ">=3.13"` and runtime checks
+currently recognize 3.13 and 3.14. Kotlin templates pin Gradle's supported build
+configuration to Kotlin 2.3.21 and target JVM 25.
+
+`npm/compatibility.json` records inclusive minimum/exclusive maximum dependency
+bounds. Unknown, prerelease, missing, and incompatible versions fail preflight.
+Build-tool probes inspect resolved dependencies, compiler settings, source roots,
+and runner configuration. Unverifiable custom filtering/configuration is rejected
+with setup instructions. Build tools may populate their normal caches while
+resolving dependencies; LawSpec does not run dependency installers during generation.
+
+## Existing projects and configuration
+
+`init` creates `lawspec.json` and a starter specification. It creates build
+files only when no existing build setup is detected. Existing build files are
+preserved, and setup instructions describe the changes you need to make yourself.
+
+```json
+{
+  "version": 1,
+  "sources": ["laws"],
+  "targets": [
+    {"language": "java", "root": "java"},
+    {"language": "python", "root": "python", "python": ".venv/bin/python"},
+    {"language": "haskell", "root": "haskell"}
+  ]
+}
+```
+
+Source entries are files or directories, relative to the configuration file.
+Directories are scanned for `.lawspec` files. Every target has its own project
+root. Use `init --target python --project python` to add a target; `--config`
+selects a different configuration file. Targets can override `sourceDir` and
+`testDir` with relative paths. Configure the native build to include those paths
+before generation. Go's source and test directories must be the same.
+
+Defaults are `src`/`test` for JS, TS and Haskell; `src`/`tests` for Python;
+`src/main/java`/`src/test/java` for Java; the corresponding Kotlin directories;
+and unit-based package directories at the Go project root. Python accepts a
+`python` interpreter override; Java accepts `maven`; Kotlin accepts `gradle` and
+otherwise uses a local `gradlew` or `gradle` on PATH.
+
+For Python, create and select a 3.13+ virtual environment and install the printed
+test dependencies. For Stack, run `stack build --test --no-run-tests` once before
+`doctor`; this resolves the snapshot and generates the Cabal description through
+Hpack. Doctor uses that existing description without rewriting it. Test discovery
+uses `test/Spec.hs` with `hspec-discover`.
+
+Commands:
+
+- `check`: parse, resolve, type-check and expand laws without target dependencies.
+- `explain [unit::law]`: display expansion steps and inherited example inputs.
+- `doctor`: inspect selected native environments and print corrective instructions.
+- `generate`: check environments, validate every output, then write artifacts.
+- `generate --dry-run`: show proposed file operations without applying them.
+- `generate --check`: fail when generated files need updating, without writing.
+
+Use `--target <language>` to select a configured language, and `--json` for
+machine-readable check, explanation, doctor and generation output. Generation
+fails before writing if any selected target is incompatible or any output
+conflicts with file ownership.
+
+## Language slice
+
+```lawspec
+unit example.atoi_codec
+
+itoa :: Int32 -> Text
+atoi :: Text -> Int32
+
+law `round trip` is
+  definition is
+    `left inverse` atoi itoa
+  end
+  description is
+    "applying {itoa} and then {atoi} recovers the original integer"
+  end
+  example `negative` is
+    x = -42
+  end
+end
+```
+
+The implicit prelude defines `left inverse` and `round trip identity is preserved`.
+A law may reference a local reusable law or a prelude law. The compiler performs
+capture-avoiding expansion and specializes types; it does not recognize codec
+function names specially. `explain` shows the final property:
+
+```text
+for all (x :: Int32) . atoi (itoa (x)) = x
+```
+
+Reusable laws can declare typed unary function parameters and `requires Eq a`.
+Definitions support law application, function application/composition, universal
+quantification, integer literals and equality. Function signatures use `Int32`
+and `Text`; generic variables are supported in reusable laws. v0.1 generates
+quantified `Int32` inputs, including multiple inputs. `Text` can be an intermediate
+or compared result. Functions are synchronous and unary.
+
+Examples refer to the expanded input names, including names inherited from the
+prelude. Bind every input exactly once. Ambiguous names and out-of-range values
+are errors. Descriptions and rationales use `{function}` references; `{{` and `}}`
+produce literal braces. Metadata blocks follow the order shown in `scratch.md`:
+definition, optional description, optional rationale, examples, optional references.
+`--` starts a line comment. Names that cannot be emitted portably are diagnosed.
+
+Additional primitives, external law packages, cross-unit imports beyond the
+prelude, async functions, direct existing-symbol binding and browser hosting are
+outside this release.
+
+## Ownership
+
+Implementation adapters are created once and belong to you. Implement them or
+have them delegate to existing application functions. Regeneration never rewrites
+them. If the required adapter contract changes, generation prints the new stub
+shape for you to apply manually.
+
+Generated tests are tracked in `.lawspec/generated.json` with content hashes.
+Commit that manifest alongside generated tests. LawSpec refuses to overwrite
+unowned files or edited generated files, even if an unowned file has matching
+contents. Obsolete tests are deleted only when they still match their recorded
+hash. User adapters remain. Output paths cannot traverse outside a target root
+or pass through symlinks. Writes use temporary files and atomic replacement;
+concurrent edits detected during preflight abort generation.
+
+## JavaScript API
+
+```javascript
+import { createCompiler } from 'lawspec';
+
+const compiler = await createCompiler();
+const result = await compiler.planGeneration({
+  sources: [{ path: 'codec.lawspec', content: sourceText }],
+  target: 'python'
+});
+if (result.diagnostics.length) console.error(result.diagnostics);
+else console.log(result.files);
+```
+
+`check`, `expand`, and `planGeneration` are asynchronous and share structured
+source/diagnostic types. `planGeneration` returns proposed paths, contents and
+ownership; it does not inspect a host environment or write files. The CLI applies
+compatibility and ownership checks. TypeScript declarations ship in the package.
+The same compiler instance supports repeated and concurrent requests, serialized
+by the JS shim.
+
+## Build and verify
+
+```sh
+stack test
+# With wasm32-wasi-cabal and wasm32-wasi-ghc installed:
+tools/wasm.sh
+node --test npm/test/*.test.mjs
+node tools/parity.mjs
+node tools/build-integrity.mjs
+node tools/package-smoke.mjs
+```
+
+Stack is the native development tool. The WASM build uses GHC's wasm32-wasi backend
+and Cabal, following Rice's Tax. `tools/wasm.sh` reads `~/.ghc-wasm/env` when present.
+The current artifact was built using GHC WASM 9.14.1.20260731; WASM dependencies
+are frozen in `wasm/cabal.project.freeze`. Install the cross compiler through
+[ghc-wasm-meta](https://gitlab.haskell.org/haskell-wasm/ghc-wasm-meta).
+
+Haskell's export table generates the JS API and `.d.ts` files. The build records
+compiler-source and artifact hashes in `npm/build.json`; CI rejects stale WASM
+or hand-edited generated wrappers. The npm archive is a self-contained consumer
+artifact, with no install-time compilation or download hook.
+
+For all seven native integrations, install their build tools, then:
+
+```sh
+# Set LAWSPEC_GRADLE to a Gradle 9.3.0 executable if it is not on PATH.
+node tools/bootstrap-integration.mjs
+node tools/integration.mjs
+```
+
+These scripts use isolated `.integration/` projects. Bootstrap installs the pinned
+test dependencies; integration verifies that correct adapters pass, broken adapters
+fail, regeneration preserves implementations, and generation leaves build files
+unchanged. Arguments select individual targets. `LAWSPEC_PYTHON=3.14` selects the
+additional Python reference environment. CI also exercises Node 22/24/26 and packs
+and installs the npm archive. Registry publication is a separate release action.

package/api.mjs

@@ -0,0 +1,6 @@
+// Generated from LawSpec.Gen. Do not edit.
+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' }) };
+}

package/bin/lawspec.mjs

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+import { readFile, mkdir, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { createCompiler } from "../api.mjs";
+import { targets, templates, commands, setup } from "../templates.mjs";
+import { doctor } from "../doctor.mjs";
+import {
+  readOptional,
+  planWrites,
+  applyWrites,
+  atomicWrite,
+  safePath,
+} from "../files.mjs";
+const args = process.argv.slice(2);
+const verb = args.shift();
+const options = {};
+const positional = [];
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (["--target", "--project", "--config"].includes(arg)) {
+    if (!args[i + 1] || args[i + 1].startsWith("--"))
+      throw new Error(`Missing value for ${arg}`);
+    options[arg.slice(2)] = args[++i];
+  } else if (["--dry-run", "--check", "--json"].includes(arg))
+    options[arg.slice(2)] = true;
+  else if (arg.startsWith("--")) throw new Error(`Unknown option: ${arg}`);
+  else positional.push(arg);
+}
+const configFile = path.resolve(options.config || "lawspec.json");
+const configRoot = path.dirname(configFile);
+const output = (value) =>
+  console.log(
+    typeof value === "string" ? value : JSON.stringify(value, null, 2),
+  );
+const shellQuote = (value) =>
+  "'" + String(value).replaceAll("'", "'\\''") + "'";
+function testCommand(target, root) {
+  const testDir = target.testDir || "test";
+  let command = commands[target.language];
+  if (target.language === "python")
+    command = `${shellQuote(target.python || "python3")} -m pytest`;
+  if (target.language === "java")
+    command = `${shellQuote(target.maven || "mvn")} test`;
+  if (target.language === "kotlin")
+    command = `${shellQuote(target.gradle || "gradle")} test`;
+  if (target.language === "javascript")
+    command = `node --test ${shellQuote(testDir)}/*.test.mjs`;
+  if (target.language === "typescript")
+    command = `npm exec -- tsc -p tsconfig.json && node --test ${shellQuote("dist/" + testDir)}/*.test.js`;
+  return `(cd ${shellQuote(root)} && ${command})`;
+}
+function diagnostics(result) {
+  if (result.diagnostics?.length)
+    throw Object.assign(
+      new Error(
+        result.diagnostics
+          .map(
+            (d) =>
+              `${d.at ? `${d.at.file}:${d.at.line}:${d.at.column}: ` : ""}${d.code}: ${d.message}`,
+          )
+          .join("\n"),
+      ),
+      { diagnostics: result.diagnostics },
+    );
+  return result;
+}
+async function sources(config) {
+  const files = [];
+  async function visit(file) {
+    const info = await stat(file);
+    if (info.isDirectory())
+      for (const entry of (await readdir(file)).sort())
+        await visit(path.join(file, entry));
+    else if (file.endsWith(".lawspec")) files.push(file);
+  }
+  for (const source of config.sources)
+    await visit(path.resolve(configRoot, source));
+  if (!files.length) throw new Error("No .lawspec source files found");
+  return Promise.all(
+    [...new Set(files)].sort().map(async (file) => ({
+      path: path.relative(configRoot, file).split(path.sep).join("/"),
+      content: await readFile(file, "utf8"),
+    })),
+  );
+}
+async function init() {
+  const language = options.target;
+  if (!targets.includes(language))
+    throw new Error(`Choose --target ${targets.join("|")}`);
+  const root = path.resolve(configRoot, options.project || ".");
+  const current = await readOptional(configFile);
+  const config =
+    current === null
+      ? { version: 1, sources: ["laws"], targets: [] }
+      : JSON.parse(current);
+  if (
+    config.targets.some(
+      (t) =>
+        t.language === language && path.resolve(configRoot, t.root) === root,
+    )
+  )
+    throw new Error("Target is already configured");
+  await mkdir(root, { recursive: true });
+  const buildFiles = [
+    "pom.xml",
+    "pyproject.toml",
+    "package.json",
+    "go.mod",
+    "stack.yaml",
+    "package.yaml",
+    "build.gradle",
+    "build.gradle.kts",
+    "settings.gradle.kts",
+  ];
+  const hasBuild = (await readdir(root)).some(
+    (f) => buildFiles.includes(f) || f.endsWith(".cabal"),
+  );
+  const additions = hasBuild ? {} : templates(language);
+  for (const name of Object.keys(additions)) {
+    const file = await safePath(root, name);
+    if ((await readOptional(file)) !== null)
+      throw new Error(`Will not overwrite ${file}`);
+  }
+  const starter = await safePath(configRoot, "laws/atoi_codec.lawspec");
+  await safePath(configRoot, path.basename(configFile));
+  if (current === null && (await readOptional(starter)) !== null)
+    throw new Error(
+      "Starter specification already exists; create lawspec.json manually to use it",
+    );
+  if (!hasBuild && language !== "go")
+    await mkdir(path.join(root, "src"), { recursive: true });
+  for (const [name, content] of Object.entries(additions))
+    await atomicWrite(path.join(root, name), content, true);
+  if (current === null)
+    await atomicWrite(
+      starter,
+      await readFile(new URL("../starter.lawspec", import.meta.url), "utf8"),
+      true,
+    );
+  config.targets.push({
+    language,
+    root: path.relative(configRoot, root) || ".",
+  });
+  await atomicWrite(
+    configFile,
+    JSON.stringify(config, null, 2) + "\n",
+    current === null,
+  );
+  output(
+    `Configured ${language}. ${hasBuild ? "Existing build files preserved." : "Created missing project build files."}\n${setup[language]}\nNext: lawspec doctor, then lawspec generate.`,
+  );
+}
+async function main() {
+  if (!verb || ["help", "--help", "-h"].includes(verb)) {
+    output(
+      "LawSpec 0.1.0\nUsage: lawspec init --target <language> [--project <directory>]\n       lawspec check | doctor | explain <unit>::<law> | generate\nOptions: --config <path>, --target <language>, --json\nGeneration: --dry-run, --check\nTargets: " +
+        targets.join(", "),
+    );
+    return;
+  }
+  if (verb === "--version") {
+    output("0.1.0");
+    return;
+  }
+  if (positional.length > (verb === "explain" ? 1 : 0))
+    throw new Error(`Unexpected argument: ${positional.join(" ")}`);
+  if (verb === "init") return init();
+  if (!["check", "doctor", "explain", "generate"].includes(verb))
+    throw new Error(`Unknown command: ${verb}`);
+  const config = JSON.parse(await readFile(configFile, "utf8"));
+  if (
+    config.version !== 1 ||
+    !Array.isArray(config.sources) ||
+    !Array.isArray(config.targets)
+  )
+    throw new Error(
+      "Expected lawspec.json version 1 with sources and targets arrays",
+    );
+  const selected = config.targets.filter(
+    (t) => !options.target || t.language === options.target,
+  );
+  if (["doctor", "generate"].includes(verb) && !selected.length)
+    throw new Error("No matching configured target");
+  const roots = selected.map((t) => path.resolve(configRoot, t.root));
+  if (new Set(roots).size !== roots.length)
+    throw new Error("Each configured target needs its own project root");
+  if (verb === "doctor") {
+    const reports = await Promise.all(
+      selected.map((t, i) => doctor(t, roots[i])),
+    );
+    output(
+      options.json
+        ? reports
+        : reports
+            .map(
+              (r) =>
+                `${r.target}: ${r.ok ? "ready" : `${r.message}\n${r.instructions}`}`,
+            )
+            .join("\n"),
+    );
+    if (reports.some((r) => !r.ok)) process.exitCode = 1;
+    return;
+  }
+  const input = { sources: await sources(config) };
+  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).`,
+    );
+    return;
+  }
+  if (verb === "explain") {
+    const result = diagnostics(await compiler.expand(input));
+    const indices = result.laws
+      .map((e, i) => ({ e, i }))
+      .filter(
+        ({ e }) => !positional[0] || `${e.owner}::${e.name}` === positional[0],
+      );
+    if (!indices.length) throw new Error("No matching executable law");
+    output(
+      options.json
+        ? indices.map(({ e, i }) => ({ ...e, expansion: result.expansions[i] }))
+        : indices
+            .map(
+              ({ e, i }) =>
+                `${e.owner}::${e.name}\n${e.trace.join("\n=> ")}\n=> ${result.expansions[i]}`,
+            )
+            .join("\n\n"),
+    );
+    return;
+  }
+  if (options["dry-run"] && options.check)
+    throw new Error("--dry-run and --check are mutually exclusive");
+  const artifacts = [];
+  for (const target of selected)
+    artifacts.push(
+      diagnostics(
+        await compiler.planGeneration({
+          ...input,
+          target: target.language,
+          sourceDir: target.sourceDir,
+          testDir: target.testDir,
+        }),
+      ).files,
+    );
+  const reports = await Promise.all(
+    selected.map((t, i) => doctor(t, roots[i])),
+  );
+  const failed = reports.filter((r) => !r.ok);
+  if (failed.length)
+    throw new Error(
+      failed
+        .map((r) => `${r.target}: ${r.message}\n${r.instructions}`)
+        .join("\n"),
+    );
+  const plans = await Promise.all(
+    artifacts.map((files, i) => planWrites(roots[i], files)),
+  );
+  if (!options["dry-run"] && !options.check) await applyWrites(plans);
+  const summary = plans.map((plan, i) => ({
+    target: selected[i].language,
+    changes: plan.changes.map((c) => ({ action: c.action, path: c.relative })),
+    preservedAdapters: plan.preserved,
+    adapterUpdates: plan.adapterUpdates,
+    test: testCommand(selected[i], roots[i]),
+  }));
+  output(
+    options.json
+      ? summary
+      : summary
+          .map(
+            (r) =>
+              `${r.target}: ${r.changes.length} ${options["dry-run"] || options.check ? "planned" : "applied"} change(s), ${r.preservedAdapters.length} user adapter(s) preserved.${r.adapterUpdates.length ? "\nReview required adapter signatures:\n" + r.adapterUpdates.map((a) => a.path + "\n" + a.requiredAdapter).join("\n") : ""}\nTest: ${r.test}`,
+          )
+          .join("\n"),
+  );
+  if (options.check && plans.some((p) => p.changes.length))
+    process.exitCode = 1;
+}
+main().catch((error) => {
+  if (options.json)
+    output({
+      diagnostics: error.diagnostics || [
+        { code: "cli", message: error.message, at: null },
+      ],
+    });
+  else console.error(`lawspec: ${error.message}`);
+  process.exitCode = 1;
+});

package/build.json

@@ -0,0 +1,39 @@
+{
+  "version": 1,
+  "compilerSources": [
+    "package.yaml",
+    "src/LawSpec/Api.hs",
+    "src/LawSpec/Compile.hs",
+    "src/LawSpec/Emit.hs",
+    "src/LawSpec/Gen.hs",
+    "src/LawSpec/Model.hs",
+    "src/LawSpec/Parser.hs",
+    "src/LawSpec/Prelude.hs",
+    "stack.yaml",
+    "stack.yaml.lock",
+    "wasm/app/Exports.hs",
+    "wasm/cabal.project",
+    "wasm/cabal.project.freeze",
+    "wasm/lawspec-wasm.cabal"
+  ],
+  "digests": {
+    "package.yaml": "cb68fcf21def8f7a880bbab7088208a86fcf313a83fe2c02e18957872cf65c67",
+    "src/LawSpec/Api.hs": "00b1e4bc81231ebd387f10652463904084ebf9c3c4486fd2c2217a6d4dbfc157",
+    "src/LawSpec/Compile.hs": "5ea31f4a66df87ddba2ff0b498d12eea5cbbefb0e10e3bf1c1d2bf4a88f5792e",
+    "src/LawSpec/Emit.hs": "27ba0cafbea8d5a82aac439f4e72f98e003cfdc177f99a902f8d11f033684b8e",
+    "src/LawSpec/Gen.hs": "b283001bc18971ddb2159f2ec7e51ac58aa7e191b52577006140694b09a06987",
+    "src/LawSpec/Model.hs": "8f501e134cd1480261ae8bb9e3df8255efd38a02eb883468c6bc2c342e200970",
+    "src/LawSpec/Parser.hs": "f546502c6eedb0a4ccd30d11e3b017aedf5a7145080ea58cfd34753fd9b509c6",
+    "src/LawSpec/Prelude.hs": "d4b0ae08eab0f30b4b8c819ce360f7cccb1f77d5ea38ded3b88dbb07936b10b6",
+    "stack.yaml": "20ccf4d599e355e60b7aa4f814a7cd4299fe2048616cc2e6dbdc22a7bd8cec73",
+    "stack.yaml.lock": "ae222b9c81af920c56e50fa4596fa57786e7fa5a7b461390362b2b2ff63818c7",
+    "wasm/app/Exports.hs": "4ecbdac8faa2449e6fc61b93c82e6278fa14374154f29b4dacf0eef433f06a47",
+    "wasm/cabal.project": "021e560afdc5eb4cb7169e7119ecb8f92c9ee170245af909c94b612941bff5cc",
+    "wasm/cabal.project.freeze": "733dbed3d2ecccb26e874fd58f136296dad772184deb1658c196b5d54a0814dc",
+    "wasm/lawspec-wasm.cabal": "d11ccf7991e406f0fd26f124c54d6552613b892328f8e22a964e38d03c7d6de4",
+    "npm/core.wasm": "14d88c08f92b10ac2939d6b92bc428b0ee255d56e88890fd46abb1e959a26b2b",
+    "npm/core_jsffi.js": "88d136efe92f7cff5758c8fec8d9b6bbc9707fe37741cebeeb415fe34ce3d72b",
+    "npm/api.mjs": "d6df654600172131ac66a55b86876fc29cde2a76a0a63bbefff3183488a4837b",
+    "npm/index.d.ts": "8003304d88dbb01a07bd3dbdc4d680a193db1ec323c5712b9860e166ca9cc94b"
+  }
+}

package/compatibility.json

@@ -0,0 +1,38 @@
+{
+  "version": 1,
+  "targets": {
+    "java": {
+      "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"]
+    },
+    "javascript": {
+      "fast-check": ["4", "5"]
+    },
+    "typescript": {
+      "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"]
+    },
+    "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"]
+    },
+    "kotlin": {
+      "java": ["25", "26"],
+      "gradle": ["9.1", "9.4"],
+      "kotlin": ["2.3.21", "2.3.22"]
+    }
+  }
+}