@jsonspecs/decimal 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## [1.0.0] - 2026-07-20
+
+- Added decimal grammar parser for string-only decimal values.
+- Added check and predicate operators for validation, scale, precision, numeric
+  equality, comparisons, inclusive ranges, and field-to-field comparisons.
+- Added contract, profile, pack API, integration, and package smoke tests.
+- Added trusted publishing release workflow.

package/COMPATIBILITY.md

@@ -0,0 +1,28 @@
+# Compatibility Policy
+
+`@jsonspecs/decimal` follows SemVer.
+
+## Breaking Changes
+
+A major version is required for:
+
+- changing accepted decimal grammar;
+- accepting JavaScript numbers as decimal values;
+- changing any operator name or required rule parameter;
+- changing `value_field` naming for field-to-field operators;
+- changing check or predicate status semantics for missing, invalid, or
+  misconfigured inputs;
+- adding rounding or coercion to existing operators;
+- raising the minimum supported `jsonspecs` peer range.
+
+## Non-Breaking Changes
+
+A minor version may add new operators or optional parameters that preserve v1
+behavior. A patch version may fix implementation bugs, metadata, tests,
+packaging, or documentation without changing documented semantics.
+
+## Runtime Contract
+
+The package intentionally has no runtime dependencies. Source files under
+`src/**` must stay deterministic, synchronous, and portable under the package
+profile test.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jsonspecs contributors
+
+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,94 @@
+# @jsonspecs/decimal
+
+[![Release](https://github.com/jsonspecs/decimal/actions/workflows/release.yml/badge.svg)](https://github.com/jsonspecs/decimal/actions/workflows/release.yml)
+[![npm](https://img.shields.io/npm/v/@jsonspecs/decimal)](https://www.npmjs.com/package/@jsonspecs/decimal)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Node 20+](https://img.shields.io/badge/Node-20%2B-green)](https://nodejs.org/)
+
+Decimal string operator pack for `jsonspecs` financial validations.
+
+The pack validates and compares decimal values represented as strings. It never
+accepts JavaScript numbers as decimal input because a number may already have
+lost scale or precision before an operator sees it.
+
+## Installation
+
+```bash
+npm install @jsonspecs/decimal jsonspecs
+```
+
+## Usage
+
+```js
+const { createEngine, Operators } = require("jsonspecs");
+const decimal = require("@jsonspecs/decimal");
+
+const engine = createEngine({
+  operators: {
+    check: { ...Operators.check, ...decimal.check },
+    predicate: { ...Operators.predicate, ...decimal.predicate },
+  },
+});
+```
+
+## Decimal Grammar
+
+Accepted decimal values are strings matching:
+
+```text
+^-?\d+(\.\d+)?$
+```
+
+Allowed: `"12500.50"`, `"-0.01"`, `"007"`.
+
+Rejected: `"+5"`, `"1e3"`, `".5"`, `"5."`, `"12 500"`, `"Infinity"`,
+`""`, and every JavaScript number value.
+
+## Operators
+
+All operators are available as both checks and predicates.
+
+| Operator | Parameters | Semantics |
+| --- | --- | --- |
+| `decimal_valid` | `field` | Field value is a string matching the decimal grammar. |
+| `decimal_scale` | `field`, one of `max` or `exact` | Fractional digit count is `<= max` or `== exact`; `"10.5"` and `"10.50"` differ. |
+| `decimal_precision` | `field`, `max` | BigDecimal-style unscaled precision without leading zeroes. |
+| `decimal_equals` | `field`, `value` | Numeric equality; `"10.50"` equals `"10.5"`. |
+| `decimal_greater_than` | `field`, `value` | Strict numeric greater-than. |
+| `decimal_less_than` | `field`, `value` | Strict numeric less-than. |
+| `decimal_between` | `field`, `min`, `max` | Inclusive numeric range. |
+| `decimal_field_greater_than_field` | `field`, `value_field` | Field is numerically greater than another field. |
+| `decimal_field_equals_field` | `field`, `value_field` | Field is numerically equal to another field. |
+
+Rule parameter misconfiguration returns `EXCEPTION`. Invalid data returns
+`FAIL` for checks and `FALSE` for predicates. A missing target field returns
+`FAIL` for checks and `UNDEFINED` for predicates.
+
+## Currency Dictionaries
+
+Use core `in_dictionary` for currency allow-lists instead of a custom operator:
+
+```json
+{
+  "id": "currency_codes",
+  "type": "dictionary",
+  "entries": ["RUB", "USD", "EUR"]
+}
+```
+
+## Roadmap
+
+Not included in v1:
+
+- `money_sum_equals`: requires wildcard materialization semantics outside this
+  primitive pack.
+- `decimal_multiple_of`: no confirmed demand for v1.
+- `currency_allowed`: use core `in_dictionary`.
+- `money_valid`: compose from `decimal_valid`, `decimal_scale`, and dictionary
+  checks.
+
+## Release
+
+Publishing is handled by `.github/workflows/release.yml` on tags matching `v*`.
+Before pushing the first release tag, configure npm trusted publishing for
+`@jsonspecs/decimal` in this GitHub repository.

package/SPEC_RU.md

@@ -0,0 +1,94 @@
+# @jsonspecs/decimal: спецификация операторов
+
+Пак содержит универсальные финансовые decimal-примитивы для `jsonspecs`.
+
+## 1. Decimal-строка
+
+Единственная валидная форма decimal-значения:
+
+```text
+^-?\d+(\.\d+)?$
+```
+
+Знак `+` не допускается. Экспонента не допускается. Формы `.5` и `5.` не
+допускаются. Ведущие нули допускаются: `"007.50"` валидно.
+
+Пак принимает только строки. Значение поля типа `number` возвращает `FAIL` в
+check-операторах и `FALSE` в predicate-операторах. Причина: `number` мог
+потерять scale и точность до запуска правил, а принятие такого значения
+легализовало бы проблему, которую пакет устраняет.
+
+Внутренний parser: `src/parser/decimal.js`. Сравнение выполняется через
+выравнивание scale добавлением нулей справа и сравнение `BigInt`. Округления в
+паке нет.
+
+## 2. Общая граница ошибок
+
+Мисконфигурация правила является ошибкой автора правила и возвращает
+`EXCEPTION`: отсутствующий обязательный параметр, параметр неверного типа,
+невалидная decimal-строка в параметре правила, одновременно заданные `max` и
+`exact`, а также `min > max` в `decimal_between`.
+
+Невалидные данные возвращают `FAIL` для check и `FALSE` для predicate.
+Отсутствующее поле данных возвращает `FAIL` для check и `UNDEFINED` для
+predicate.
+
+## 3. Операторы
+
+### `decimal_valid`
+
+Параметры: `field`.
+
+Значение поля должно быть строкой по грамматике раздела 1.
+
+### `decimal_scale`
+
+Параметры: `field` и ровно один из `max` или `exact`.
+
+`max` и `exact` должны быть неотрицательными целыми числами. Scale равен числу
+знаков после точки в исходной строке. `"10.5"` имеет scale 1, `"10.50"` имеет
+scale 2.
+
+### `decimal_precision`
+
+Параметры: `field`, `max`.
+
+`max` должен быть положительным целым числом. Precision считается по семантике
+BigDecimal: число цифр unscaled value без ведущих нулей. Если все цифры равны
+нулю, precision равен 1. Примеры: `"0.50"` -> 2, `"12500.50"` -> 7.
+
+### `decimal_equals`
+
+Параметры: `field`, `value`.
+
+`value` должен быть decimal-строкой. Сравнение численное: `"10.50"` равно
+`"10.5"`.
+
+### `decimal_greater_than` / `decimal_less_than`
+
+Параметры: `field`, `value`.
+
+Строгие численные сравнения с decimal-строкой из `value`.
+
+### `decimal_between`
+
+Параметры: `field`, `min`, `max`.
+
+Обе границы включены. `min` и `max` должны быть decimal-строками. Если
+`min > max`, оператор возвращает `EXCEPTION`.
+
+### `decimal_field_greater_than_field` / `decimal_field_equals_field`
+
+Параметры: `field`, `value_field`.
+
+Имя второго поля зеркалит контракт ядровых `field_*_field` операторов:
+используется `value_field`. Оба значения данных должны быть строками по
+decimal-грамматике, иначе результат `FAIL` для check и `FALSE` для predicate.
+
+## 4. Не входит в v1
+
+`money_sum_equals` не включён, потому что требует отдельной семантики
+материализации wildcard. `decimal_multiple_of` не включён из-за отсутствия
+подтверждённого спроса для v1. `currency_allowed` должен выражаться ядровым
+`in_dictionary`. `money_valid` собирается правилами из `decimal_valid`,
+`decimal_scale` и словаря валют.

package/index.d.ts

@@ -0,0 +1,4 @@
+import type { OperatorPack } from "jsonspecs";
+
+declare const pack: OperatorPack;
+export = pack;

package/index.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const pkg = require("./package.json");
+const decimal = require("./src/parser/decimal");
+
+const checkDecimalValid = require("./src/check/decimal_valid");
+const checkDecimalScale = require("./src/check/decimal_scale");
+const checkDecimalPrecision = require("./src/check/decimal_precision");
+const checkDecimalEquals = require("./src/check/decimal_equals");
+const checkDecimalGreaterThan = require("./src/check/decimal_greater_than");
+const checkDecimalLessThan = require("./src/check/decimal_less_than");
+const checkDecimalBetween = require("./src/check/decimal_between");
+const checkDecimalFieldGreaterThanField = require("./src/check/decimal_field_greater_than_field");
+const checkDecimalFieldEqualsField = require("./src/check/decimal_field_equals_field");
+
+const predicateDecimalValid = require("./src/predicate/decimal_valid");
+const predicateDecimalScale = require("./src/predicate/decimal_scale");
+const predicateDecimalPrecision = require("./src/predicate/decimal_precision");
+const predicateDecimalEquals = require("./src/predicate/decimal_equals");
+const predicateDecimalGreaterThan = require("./src/predicate/decimal_greater_than");
+const predicateDecimalLessThan = require("./src/predicate/decimal_less_than");
+const predicateDecimalBetween = require("./src/predicate/decimal_between");
+const predicateDecimalFieldGreaterThanField = require("./src/predicate/decimal_field_greater_than_field");
+const predicateDecimalFieldEqualsField = require("./src/predicate/decimal_field_equals_field");
+
+function deepFreeze(value, seen = new Set()) {
+  if (!value || (typeof value !== "object" && typeof value !== "function")) {
+    return value;
+  }
+  if (seen.has(value)) return value;
+  seen.add(value);
+  for (const key of Reflect.ownKeys(value)) {
+    deepFreeze(value[key], seen);
+  }
+  return Object.freeze(value);
+}
+
+const check = {
+  decimal_valid: bind(checkDecimalValid),
+  decimal_scale: bind(checkDecimalScale),
+  decimal_precision: bind(checkDecimalPrecision),
+  decimal_equals: bind(checkDecimalEquals),
+  decimal_greater_than: bind(checkDecimalGreaterThan),
+  decimal_less_than: bind(checkDecimalLessThan),
+  decimal_between: bind(checkDecimalBetween),
+  decimal_field_greater_than_field: bind(checkDecimalFieldGreaterThanField),
+  decimal_field_equals_field: bind(checkDecimalFieldEqualsField),
+};
+
+const predicate = {
+  decimal_valid: bind(predicateDecimalValid),
+  decimal_scale: bind(predicateDecimalScale),
+  decimal_precision: bind(predicateDecimalPrecision),
+  decimal_equals: bind(predicateDecimalEquals),
+  decimal_greater_than: bind(predicateDecimalGreaterThan),
+  decimal_less_than: bind(predicateDecimalLessThan),
+  decimal_between: bind(predicateDecimalBetween),
+  decimal_field_greater_than_field: bind(predicateDecimalFieldGreaterThanField),
+  decimal_field_equals_field: bind(predicateDecimalFieldEqualsField),
+};
+
+const meta = {
+  pack: "@jsonspecs/decimal",
+  version: pkg.version,
+  operators: {
+    decimal_valid: {
+      title: "decimal string is valid",
+      description: "Field is a string matching the canonical decimal grammar.",
+      template: "{field} is a valid decimal string",
+    },
+    decimal_scale: {
+      title: "decimal scale is allowed",
+      description: "Field has either no more than max fractional digits or exactly exact fractional digits.",
+      template: "{field} has the required decimal scale",
+    },
+    decimal_precision: {
+      title: "decimal precision is allowed",
+      description: "Field precision does not exceed max using BigDecimal-style unscaled precision.",
+      template: "{field} precision is at most {max}",
+    },
+    decimal_equals: {
+      title: "decimal equals value",
+      description: "Field is numerically equal to a decimal rule value.",
+      template: "{field} equals {value}",
+    },
+    decimal_greater_than: {
+      title: "decimal is greater than value",
+      description: "Field is numerically greater than a decimal rule value.",
+      template: "{field} is greater than {value}",
+    },
+    decimal_less_than: {
+      title: "decimal is less than value",
+      description: "Field is numerically less than a decimal rule value.",
+      template: "{field} is less than {value}",
+    },
+    decimal_between: {
+      title: "decimal is between values",
+      description: "Field is numerically between min and max, inclusive.",
+      template: "{field} is between {min} and {max}",
+    },
+    decimal_field_greater_than_field: {
+      title: "decimal field is greater than field",
+      description: "Field is numerically greater than value_field.",
+      template: "{field} is greater than {value_field}",
+    },
+    decimal_field_equals_field: {
+      title: "decimal field equals field",
+      description: "Field is numerically equal to value_field.",
+      template: "{field} equals {value_field}",
+    },
+  },
+};
+
+function bind(operator) {
+  return (rule, ctx) => operator(rule, ctx, decimal);
+}
+
+module.exports = deepFreeze({ check, predicate, meta });

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@jsonspecs/decimal",
+  "version": "1.0.0",
+  "description": "Decimal string operator pack for jsonspecs financial validations",
+  "type": "commonjs",
+  "main": "index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src/",
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "SPEC_RU.md",
+    "COMPATIBILITY.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test tests/*.test.js",
+    "test:pack": "node scripts/pack-smoke.js",
+    "prepublishOnly": "npm test && npm run test:pack"
+  },
+  "keywords": [
+    "jsonspecs",
+    "jsonspecs-operators",
+    "operator-pack",
+    "rules-engine"
+  ],
+  "author": "jsonspecs contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jsonspecs/decimal.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jsonspecs/decimal/issues"
+  },
+  "homepage": "https://github.com/jsonspecs/decimal#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "jsonspecs": "^2.0.0"
+  },
+  "devDependencies": {
+    "jsonspecs": "^2.3.0"
+  }
+}

package/src/check/decimal_between.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalBetween(rule, ctx, decimal) {
+  return decimal.checkBetween(rule, ctx);
+};

package/src/check/decimal_equals.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalEquals(rule, ctx, decimal) {
+  return decimal.checkScalarCompare(rule, ctx, "eq");
+};

package/src/check/decimal_field_equals_field.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalFieldEqualsField(rule, ctx, decimal) {
+  return decimal.checkFieldCompare(rule, ctx, "eq");
+};

package/src/check/decimal_field_greater_than_field.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalFieldGreaterThanField(rule, ctx, decimal) {
+  return decimal.checkFieldCompare(rule, ctx, "gt");
+};

package/src/check/decimal_greater_than.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalGreaterThan(rule, ctx, decimal) {
+  return decimal.checkScalarCompare(rule, ctx, "gt");
+};

package/src/check/decimal_less_than.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalLessThan(rule, ctx, decimal) {
+  return decimal.checkScalarCompare(rule, ctx, "lt");
+};

package/src/check/decimal_precision.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalPrecision(rule, ctx, decimal) {
+  return decimal.checkPrecision(rule, ctx);
+};

package/src/check/decimal_scale.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalScale(rule, ctx, decimal) {
+  return decimal.checkScale(rule, ctx);
+};

package/src/check/decimal_valid.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalValid(rule, ctx, decimal) {
+  return decimal.checkValid(rule, ctx);
+};

package/src/parser/decimal.js

@@ -0,0 +1,244 @@
+"use strict";
+
+const DECIMAL_RE = /^-?\d+(?:\.\d+)?$/;
+
+function exception(message) {
+  return { status: "EXCEPTION", error: new Error(message) };
+}
+
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+function requireField(rule) {
+  return typeof rule.field === "string" && rule.field.length > 0;
+}
+
+function requireValueField(rule) {
+  return typeof rule.value_field === "string" && rule.value_field.length > 0;
+}
+
+function parseDecimal(value) {
+  if (typeof value !== "string") return null;
+  if (!DECIMAL_RE.test(value)) return null;
+  const negative = value[0] === "-";
+  const body = negative ? value.slice(1) : value;
+  const dot = body.indexOf(".");
+  const intDigits = dot === -1 ? body : body.slice(0, dot);
+  const fracDigits = dot === -1 ? "" : body.slice(dot + 1);
+  return { negative, intDigits, fracDigits };
+}
+
+function scaleOf(parsed) {
+  return parsed.fracDigits.length;
+}
+
+function precisionOf(parsed) {
+  const unscaled = `${parsed.intDigits}${parsed.fracDigits}`;
+  const trimmed = unscaled.replace(/^0+/, "");
+  return trimmed.length === 0 ? 1 : trimmed.length;
+}
+
+function scaledInteger(parsed, scale) {
+  const digits = `${parsed.intDigits}${parsed.fracDigits.padEnd(scale, "0")}`;
+  const magnitude = BigInt(digits);
+  if (magnitude === 0n) return 0n;
+  return parsed.negative ? -magnitude : magnitude;
+}
+
+function compareParsed(left, right) {
+  const scale = Math.max(left.fracDigits.length, right.fracDigits.length);
+  const a = scaledInteger(left, scale);
+  const b = scaledInteger(right, scale);
+  if (a === b) return 0;
+  return a > b ? 1 : -1;
+}
+
+function statusFromCompare(cmp, op) {
+  if (op === "eq") return cmp === 0;
+  if (op === "gt") return cmp > 0;
+  if (op === "lt") return cmp < 0;
+  return false;
+}
+
+function validateScalarRule(rule, parameter) {
+  if (!requireField(rule)) return exception("field is required");
+  if (!hasOwn(rule, parameter)) return exception(`${parameter} is required`);
+  const parsed = parseDecimal(rule[parameter]);
+  if (!parsed) return exception(`${parameter} must be a decimal string`);
+  return { ok: true, parsed };
+}
+
+function checkValid(rule, ctx) {
+  if (!requireField(rule)) return exception("field is required");
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "FAIL" };
+  return { status: parseDecimal(got.value) ? "OK" : "FAIL", actual: got.value };
+}
+
+function predicateValid(rule, ctx) {
+  if (!requireField(rule)) return exception("field is required");
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "UNDEFINED" };
+  return { status: parseDecimal(got.value) ? "TRUE" : "FALSE" };
+}
+
+function getScaleConfig(rule) {
+  const hasMax = hasOwn(rule, "max");
+  const hasExact = hasOwn(rule, "exact");
+  if (hasMax === hasExact) return exception("exactly one of max or exact is required");
+  const key = hasMax ? "max" : "exact";
+  const value = rule[key];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    return exception(`${key} must be a non-negative integer`);
+  }
+  return { ok: true, key, value };
+}
+
+function checkScale(rule, ctx) {
+  if (!requireField(rule)) return exception("field is required");
+  const config = getScaleConfig(rule);
+  if (!config.ok) return config;
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "FAIL" };
+  const parsed = parseDecimal(got.value);
+  if (!parsed) return { status: "FAIL", actual: got.value };
+  const scale = scaleOf(parsed);
+  const ok = config.key === "max" ? scale <= config.value : scale === config.value;
+  return { status: ok ? "OK" : "FAIL", actual: got.value, meta: { scale } };
+}
+
+function predicateScale(rule, ctx) {
+  if (!requireField(rule)) return exception("field is required");
+  const config = getScaleConfig(rule);
+  if (!config.ok) return config;
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "UNDEFINED" };
+  const parsed = parseDecimal(got.value);
+  if (!parsed) return { status: "FALSE" };
+  const scale = scaleOf(parsed);
+  const ok = config.key === "max" ? scale <= config.value : scale === config.value;
+  return { status: ok ? "TRUE" : "FALSE" };
+}
+
+function checkPrecision(rule, ctx) {
+  if (!requireField(rule)) return exception("field is required");
+  if (typeof rule.max !== "number" || !Number.isInteger(rule.max) || rule.max < 1) {
+    return exception("max must be a positive integer");
+  }
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "FAIL" };
+  const parsed = parseDecimal(got.value);
+  if (!parsed) return { status: "FAIL", actual: got.value };
+  const precision = precisionOf(parsed);
+  return { status: precision <= rule.max ? "OK" : "FAIL", actual: got.value, meta: { precision } };
+}
+
+function predicatePrecision(rule, ctx) {
+  if (!requireField(rule)) return exception("field is required");
+  if (typeof rule.max !== "number" || !Number.isInteger(rule.max) || rule.max < 1) {
+    return exception("max must be a positive integer");
+  }
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "UNDEFINED" };
+  const parsed = parseDecimal(got.value);
+  if (!parsed) return { status: "FALSE" };
+  return { status: precisionOf(parsed) <= rule.max ? "TRUE" : "FALSE" };
+}
+
+function checkScalarCompare(rule, ctx, op) {
+  const config = validateScalarRule(rule, "value");
+  if (!config.ok) return config;
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "FAIL" };
+  const parsed = parseDecimal(got.value);
+  if (!parsed) return { status: "FAIL", actual: got.value };
+  const ok = statusFromCompare(compareParsed(parsed, config.parsed), op);
+  return { status: ok ? "OK" : "FAIL", actual: got.value };
+}
+
+function predicateScalarCompare(rule, ctx, op) {
+  const config = validateScalarRule(rule, "value");
+  if (!config.ok) return config;
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "UNDEFINED" };
+  const parsed = parseDecimal(got.value);
+  if (!parsed) return { status: "FALSE" };
+  const ok = statusFromCompare(compareParsed(parsed, config.parsed), op);
+  return { status: ok ? "TRUE" : "FALSE" };
+}
+
+function checkBetween(rule, ctx) {
+  const minConfig = validateScalarRule(rule, "min");
+  if (!minConfig.ok) return minConfig;
+  if (!hasOwn(rule, "max")) return exception("max is required");
+  const max = parseDecimal(rule.max);
+  if (!max) return exception("max must be a decimal string");
+  if (compareParsed(minConfig.parsed, max) > 0) return exception("min must be less than or equal to max");
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "FAIL" };
+  const parsed = parseDecimal(got.value);
+  if (!parsed) return { status: "FAIL", actual: got.value };
+  const ok = compareParsed(parsed, minConfig.parsed) >= 0 && compareParsed(parsed, max) <= 0;
+  return { status: ok ? "OK" : "FAIL", actual: got.value };
+}
+
+function predicateBetween(rule, ctx) {
+  const minConfig = validateScalarRule(rule, "min");
+  if (!minConfig.ok) return minConfig;
+  if (!hasOwn(rule, "max")) return exception("max is required");
+  const max = parseDecimal(rule.max);
+  if (!max) return exception("max must be a decimal string");
+  if (compareParsed(minConfig.parsed, max) > 0) return exception("min must be less than or equal to max");
+  const got = ctx.get(rule.field);
+  if (!got.ok) return { status: "UNDEFINED" };
+  const parsed = parseDecimal(got.value);
+  if (!parsed) return { status: "FALSE" };
+  const ok = compareParsed(parsed, minConfig.parsed) >= 0 && compareParsed(parsed, max) <= 0;
+  return { status: ok ? "TRUE" : "FALSE" };
+}
+
+function checkFieldCompare(rule, ctx, op) {
+  if (!requireField(rule)) return exception("field is required");
+  if (!requireValueField(rule)) return exception("value_field is required");
+  const left = ctx.get(rule.field);
+  const right = ctx.get(rule.value_field);
+  if (!left.ok || !right.ok) return { status: "FAIL" };
+  const a = parseDecimal(left.value);
+  const b = parseDecimal(right.value);
+  if (!a || !b) return { status: "FAIL", actual: left.value };
+  const ok = statusFromCompare(compareParsed(a, b), op);
+  return { status: ok ? "OK" : "FAIL", actual: left.value };
+}
+
+function predicateFieldCompare(rule, ctx, op) {
+  if (!requireField(rule)) return exception("field is required");
+  if (!requireValueField(rule)) return exception("value_field is required");
+  const left = ctx.get(rule.field);
+  const right = ctx.get(rule.value_field);
+  if (!left.ok || !right.ok) return { status: "UNDEFINED" };
+  const a = parseDecimal(left.value);
+  const b = parseDecimal(right.value);
+  if (!a || !b) return { status: "FALSE" };
+  const ok = statusFromCompare(compareParsed(a, b), op);
+  return { status: ok ? "TRUE" : "FALSE" };
+}
+
+module.exports = {
+  checkBetween,
+  checkFieldCompare,
+  checkPrecision,
+  checkScalarCompare,
+  checkScale,
+  checkValid,
+  compareParsed,
+  parseDecimal,
+  predicateBetween,
+  predicateFieldCompare,
+  predicatePrecision,
+  predicateScalarCompare,
+  predicateScale,
+  predicateValid,
+  precisionOf,
+  scaleOf,
+};

package/src/predicate/decimal_between.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalBetweenPredicate(rule, ctx, decimal) {
+  return decimal.predicateBetween(rule, ctx);
+};

package/src/predicate/decimal_equals.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalEqualsPredicate(rule, ctx, decimal) {
+  return decimal.predicateScalarCompare(rule, ctx, "eq");
+};

package/src/predicate/decimal_field_equals_field.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalFieldEqualsFieldPredicate(rule, ctx, decimal) {
+  return decimal.predicateFieldCompare(rule, ctx, "eq");
+};

package/src/predicate/decimal_field_greater_than_field.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalFieldGreaterThanFieldPredicate(rule, ctx, decimal) {
+  return decimal.predicateFieldCompare(rule, ctx, "gt");
+};

package/src/predicate/decimal_greater_than.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalGreaterThanPredicate(rule, ctx, decimal) {
+  return decimal.predicateScalarCompare(rule, ctx, "gt");
+};

package/src/predicate/decimal_less_than.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalLessThanPredicate(rule, ctx, decimal) {
+  return decimal.predicateScalarCompare(rule, ctx, "lt");
+};

package/src/predicate/decimal_precision.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalPrecisionPredicate(rule, ctx, decimal) {
+  return decimal.predicatePrecision(rule, ctx);
+};

package/src/predicate/decimal_scale.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalScalePredicate(rule, ctx, decimal) {
+  return decimal.predicateScale(rule, ctx);
+};

package/src/predicate/decimal_valid.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function decimalValidPredicate(rule, ctx, decimal) {
+  return decimal.predicateValid(rule, ctx);
+};