mons-rules 0.2.0 → 0.2.1

package/README.md

@@ -1,10 +1,8 @@
 # Mons rules engine
 
-The Mons rules engine is implemented in strict TypeScript and distributed as the
-dependency-free `mons-rules` npm package. Its single ES module works in browser
-bundles, Web Workers, Node.js, and Firebase Cloud Functions.
-
-The module exposes 23 named game APIs with matching TypeScript declarations.
+`mons-rules` is the dependency-free TypeScript rules engine for Super Metal Mons.
+Its single ES module works in browsers, Web Workers, Node.js, and Firebase Cloud
+Functions.
 
 ```ts
 import { GameVariant, MonsGameModel } from "mons-rules";
@@ -19,81 +17,35 @@ const { GameVariant, MonsGameModel } = require("mons-rules");
 const game = MonsGameModel.new(GameVariant.Classic);
 ```
 
-## Migrating from the legacy packages
-
-Replace either legacy dependency with `mons-rules` and update the module specifier:
-
-```diff
--import * as Mons from "mons-web";
-+import * as Mons from "mons-rules";
-```
-
-```diff
--const Mons = require("mons-rust");
-+const Mons = require("mons-rules");
-```
-
-The module has no default initializer or `initSync` export. Remove the default
-import and initialization call; named imports are ready to use immediately. The
-generated `InitInput`, `SyncInitInput`, and `InitOutput` TypeScript types are removed
-with those loaders.
-
-```diff
--import initMonsWeb, { MonsGameModel } from "mons-web";
--await initMonsWeb();
-+import { MonsGameModel } from "mons-rules";
-```
-
-The named API is otherwise preserved, including enum values, FEN formats, model
-classes, event ordering, random automoves, and smart-automove preferences.
-
-Incoming strings retain the previous runtime normalization: unpaired UTF-16
-surrogates become U+FFFD before parsing or echoing. One intentional error-policy
-change applies to malformed data: native `RuntimeError("unreachable")` traps from
-invalid UTF-8 slice boundaries or genuine board/location bounds failures are
-deterministic TypeScript `RangeError`s. Wrapped location indices that resolve inside
-the board remain compatible aliases.
-
-Published JavaScript targets ES2020 and uses the Web-standard
-`globalThis.performance` and `globalThis.crypto` APIs in every runtime. Node.js 22.13
-through 22.x, or Node.js 24 or newer, is required for Node consumers, repository
-development, and release tooling. These versions support loading the same ES module
-through either `import` or `require`.
+Published JavaScript targets ES2020 and uses the Web-standard `performance` and
+`crypto` globals. Node.js 22.13 through 22.x, or Node.js 24 or newer, is required for
+Node consumers and repository tooling.
 
 ## Validation
 
-Install the workspace with Node.js 22.13 through 22.x, or Node.js 24 or newer, and
-run the standard checks:
+Install dependencies and run the complete local gate:
 
 ```sh
 npm ci --engine-strict
-npm run format:check
-npm run lint
-npm run typecheck
-npm run build
-npm test
-npm run test:automove-parity
+npm run check
 ```
 
-Run `./scripts/run-rules-tests.sh` with no options to replay the deterministic
-compressed stream of 699,994 canonical unique rules transitions recovered from
-699,999 historical raw fixtures. The command validates and streams the corpus without
-unpacking or rewriting it.
+The check streams and replays 699,994 canonical rules transitions without unpacking
+the compressed corpus. It also validates 89 public API edge cases, 39 deterministic
+automove decisions, and 1,527 complete real-player games containing 25,185 turns and
+169,480 inputs across all 12 variants.
 
 Run `node ./scripts/check-complete-games.cjs` to validate the immutable public corpus
-of 1,527 complete real-player games. Run `npm run test:complete-games` to replay all
-25,185 turns and 169,480 inputs through the TypeScript engine across all 12 variants.
+without replaying it. Run `npm run test:complete-games` for the full engine replay.
 
 ## Release
 
-Run `./publish.sh --check-only` to execute the complete validation, build the
-`mons-rules` tarball, verify its ES module through browser and Node consumers, and
-perform an npm dry run without publishing. Publishing is an explicit release
-operation: run `./publish.sh` from a clean worktree to release `mons-rules` to the
-`latest` tag.
+Run `npm run bump` to increment the patch version in `package.json` and
+`package-lock.json`, then commit the release change. Run
+`npm run publish -- --check-only` to validate the unpublished version and perform an
+npm dry run. Run `npm run publish` from a clean worktree to publish that version to
+`latest`.
 
-A real publish acquires the transient `mons-npm-publish-lock` tag on `origin`, or on
-the shared remote named by `MONS_PUBLISH_LOCK_REMOTE`. All publishers must use this
-script and the same remote for the lock to serialize releases across hosts. If a
-process terminates without releasing the tag, the script prints inspection and
-lease-protected stale-lock recovery commands.
+A real publish uses the transient `mons-npm-publish-lock` tag on `origin`, or the
+shared remote named by `MONS_PUBLISH_LOCK_REMOTE`, to serialize releases across
+hosts. The script prints lease-protected recovery instructions if cleanup fails.