aontu 0.50.0 → 0.51.0

package/dist/val/Decimal.js

@@ -0,0 +1,318 @@
+"use strict";
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decimal = exports.DECIMAL_SCALE_BUDGET = exports.DECIMAL_COEFFICIENT_BUDGET = exports.BIG_LITERAL_RE = void 0;
+exports.decimalOverBudget = decimalOverBudget;
+exports.readBigLiteral = readBigLiteral;
+/*
+ * The exact base-10 decimal value behind the `bigdecimal` leaf, and the
+ * parser for the `0d` literal family that reaches both exact leaves.
+ *
+ * A Decimal is a coefficient and a scale:
+ *
+ *   value = unscaled / 10^scale
+ *
+ * with `unscaled` a native bigint and `scale` a plain integer. Every
+ * operation here is EXACT: aontu's whole numeric operator surface
+ * (`+`, `upper()`, `lower()`, unary minus) is exact, so no rounding
+ * context, precision or rounding mode exists anywhere in this file --
+ * addition aligns scales and adds coefficients, and ceiling/floor is
+ * coefficient arithmetic that never lets a float64 near the value.
+ * Where an exact answer will not fit the budget the answer is refused,
+ * never rounded (see decimalOverBudget).
+ *
+ * D4 -- ONE VALUE, ONE RENDERING. In a unifier canon must be a function
+ * of the value, so scale is presentation and not identity: `0d0.10`,
+ * `0d0.1` and `0d1e-1` are the same lattice point and must render
+ * identically. A Decimal therefore NORMALISES IN ITS CONSTRUCTOR --
+ * every Decimal in existence is in minimal form, which is what makes
+ * `equals` a two-field comparison and `same()` correct without any
+ * pointer identity (D2).
+ *
+ * The minimal form keeps ONE decimal place at the bottom. `0d` names the
+ * numeric FAMILY, not the leaf, so an integral bigdecimal that rendered
+ * as `0d1000` would reparse as a biginteger -- a kind-flipping canon of
+ * exactly the sort R4's `.0` suffix exists to prevent. So `0d1e3` canons
+ * as `0d1000.0`, and scale is never reduced below 1.
+ *
+ * Go mirror (D8): a struct of (coeff *big.Int, scale int32) normalised
+ * by the same rule -- strip trailing zeros while scale > 1, then raise
+ * the scale to 1 when it is lower, zero always at scale 1.
+ */
+// D6 -- THE EXACTNESS BUDGET, enforced at parse.
+//
+// Both halves are needed and the scale half is the load-bearing one: a
+// coefficient-only check never fires for `0d1e1000000000`, whose
+// coefficient is one digit, yet plain-form rendering of that value would
+// have to materialise a gigabyte of zeros (and overflow the Go port's
+// int32 scale field) without any arithmetic having occurred.
+//
+// A literal over either bound is a located error, never a rounded or
+// expanded value: this language does not round, so the only honest
+// answer at the limit is refusal.
+const DECIMAL_COEFFICIENT_BUDGET = 4096;
+exports.DECIMAL_COEFFICIENT_BUDGET = DECIMAL_COEFFICIENT_BUDGET;
+const DECIMAL_SCALE_BUDGET = 4096;
+exports.DECIMAL_SCALE_BUDGET = DECIMAL_SCALE_BUDGET;
+// Powers of ten as bigints, memoised: normalisation of an
+// exponent-bearing literal needs one per parse.
+function pow10(n) {
+    return 10n ** BigInt(n);
+}
+// True when a decimal's SOURCE form is over either budget bound.
+//
+// Every route that builds a Decimal from text must ask this BEFORE
+// constructing one, because normalising an over-budget value is itself
+// the resource event the bound exists to prevent: the constructor folds
+// a negative scale by multiplying the coefficient by 10^-scale, so
+// `1e1000000000` would try to build a billion-digit bigint.
+//
+// Written once and used by both routes -- the `0d` literal and the
+// exact-input API -- because the Go port bounds both (NewBigDecimal
+// shares the literal path's checker) and a TypeScript route that did not
+// would be a silent cross-port divergence as well as a hazard.
+//
+// `scale` may be Infinity or NaN when the exponent digits overflow a JS
+// number; the comparison is written so that either answers "over".
+function overBudget(coeffDigits, scale) {
+    return DECIMAL_COEFFICIENT_BUDGET < coeffDigits ||
+        !(Math.abs(scale) <= DECIMAL_SCALE_BUDGET);
+}
+// The decimal digit count of a coefficient, sign ignored (zero counts as
+// one digit). Only the budget test needs it.
+function coeffDigits(unscaled) {
+    return (unscaled < 0n ? -unscaled : unscaled).toString().length;
+}
+class Decimal {
+    constructor(unscaled, scale) {
+        let u = unscaled;
+        let s = Math.trunc(scale);
+        if (0n === u) {
+            // R2/D5: there is no negative zero here to begin with (a bigint
+            // has one zero), and every zero is the same lattice point, so it
+            // takes the one canonical form `0d0.0`.
+            s = 1;
+        }
+        else {
+            // Strip the trailing zeros that scale-as-presentation would
+            // otherwise smuggle into identity (`0d0.10` -> `0d0.1`)...
+            while (1 < s && 0n === u % 10n) {
+                u /= 10n;
+                s--;
+            }
+            // ...and fold a negative scale (an exponent) back up to the one
+            // decimal place the leaf marker requires (`0d1e3` -> 10000/10^1).
+            if (s < 1) {
+                u *= pow10(1 - s);
+                s = 1;
+            }
+        }
+        this.unscaled = u;
+        this.scale = s;
+    }
+    // Exact numeric equality. Both operands are normalised by
+    // construction, so equal values have equal fields -- this is value
+    // comparison, never object identity (D2).
+    equals(peer) {
+        return this.unscaled === peer.unscaled && this.scale === peer.scale;
+    }
+    // Exact ordering: -1, 0 or 1. Compares on a common scale, so no
+    // float64 ever touches the operands.
+    compare(peer) {
+        let a = this.unscaled;
+        let b = peer.unscaled;
+        if (this.scale < peer.scale) {
+            a *= pow10(peer.scale - this.scale);
+        }
+        else if (peer.scale < this.scale) {
+            b *= pow10(this.scale - peer.scale);
+        }
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+    // Exact negation, keeping the leaf. -0 folds to 0 (D5) because the
+    // normalising constructor sends every zero to the same form.
+    negate() {
+        return new Decimal(-this.unscaled, this.scale);
+    }
+    // D6 -- EXACT ADDITION. Align the scales, add the coefficients. That
+    // is the entire algorithm: there is no rounding mode to consult and no
+    // precision to run out of, which is why `0d0.1 + 0d0.2` is exactly
+    // `0d0.3` here and 0.30000000000000004 in binary64.
+    //
+    // The work is bounded because both operands are within the parse-time
+    // budget, so alignment can inflate a coefficient only by the scale
+    // span. The RESULT, however, can be over budget even when both
+    // operands are inside it (`0d1e4000 + 0d1e-4000` needs 8001
+    // coefficient digits), so every caller must test the result with
+    // decimalOverBudget() and report `decimal_budget` rather than store
+    // it. Refusal is the only honest answer at the limit: rounding to fit
+    // is exactly what this leaf exists to prevent.
+    add(peer) {
+        const scale = this.scale < peer.scale ? peer.scale : this.scale;
+        const a = this.unscaled * pow10(scale - this.scale);
+        const b = peer.unscaled * pow10(scale - peer.scale);
+        return new Decimal(a + b, scale);
+    }
+    // Exact ceiling and floor, for `upper()`/`lower()`. Coefficient
+    // arithmetic only -- Math.ceil of this value would mean rounding it to
+    // binary64 first, which for a leaf that exists to escape binary64 is
+    // no answer at all.
+    //
+    // The leaf is kept (R5 contagion): the result is a bigdecimal whose
+    // value happens to be integral, so it keeps the one decimal place the
+    // family marker requires -- `upper(0d1.1)` is `0d2.0`, not `0d2`.
+    //
+    // Neither can leave the exactness budget: with scale >= 1 the integer
+    // part drops `scale` digits and normalisation adds one back, so the
+    // coefficient never grows. That is why these return a Decimal
+    // directly while add() makes its caller check.
+    ceil() {
+        return new Decimal(this.intPart(1n), 0);
+    }
+    floor() {
+        return new Decimal(this.intPart(-1n), 0);
+    }
+    // The integer part, stepped one in the direction of `dir` when a
+    // remainder of that sign was discarded. bigint division truncates
+    // toward zero and the remainder carries the dividend's sign, so
+    // truncation already IS the floor of a positive and the ceiling of a
+    // negative; only the other half of each case needs the step.
+    intPart(dir) {
+        const p = pow10(this.scale);
+        const q = this.unscaled / p;
+        const r = this.unscaled % p;
+        return 0n !== r && (0n < r) === (0n < dir) ? q + dir : q;
+    }
+    isZero() {
+        return 0n === this.unscaled;
+    }
+    // Plain digits, no `0d` marker: `1000.0`, `-0.1`. Plain form at every
+    // magnitude, never scientific -- the budget is what makes that safe.
+    // This is also the rendering string concatenation will want in Phase 4
+    // (`"q" + 0d0.1` is `"q0.1"`), which is why the marker lives in
+    // `canon()` and not here.
+    toString() {
+        const neg = this.unscaled < 0n;
+        let d = (neg ? -this.unscaled : this.unscaled).toString();
+        if (d.length <= this.scale) {
+            d = '0'.repeat(this.scale - d.length + 1) + d;
+        }
+        const cut = d.length - this.scale;
+        return (neg ? '-' : '') + d.slice(0, cut) + '.' + d.slice(cut);
+    }
+    // Canon rendering: the sign goes BEFORE the marker (`-0d1.5`), because
+    // `0d-1.5` is not a literal this language accepts.
+    canon() {
+        const neg = this.unscaled < 0n;
+        return (neg ? '-0d' : '0d') + (neg ? this.negate() : this).toString();
+    }
+    // Exact-input construction for library consumers (D8). A JS `number`
+    // argument is already rounded before this library could inspect it, so
+    // the exact leaves are reachable only from a bigint or from text.
+    // Accepts `[+-]?digits[.digits][(e|E)[+-]digits]`, with or without the
+    // `0d` marker, and no `_` separators (those are literal syntax).
+    static fromString(src) {
+        const m = /^([-+]?)(?:0[dD])?([0-9]+)(?:\.([0-9]+))?(?:[eE]([-+]?[0-9]+))?$/
+            .exec(src);
+        if (null == m) {
+            throw new Error('not-decimal: ' + src);
+        }
+        const frac = m[3] ?? '';
+        const exp = null == m[4] ? 0 : Number(m[4]);
+        const scale = frac.length - exp;
+        // The same bound the `0d` literal obeys (D6). Without it this API
+        // route reached the resource exhaustion the budget exists to
+        // prevent -- `fromString('1e1000000000')` would normalise by
+        // building a billion-digit coefficient -- and disagreed with the Go
+        // port, whose NewBigDecimal shares the literal path's checker.
+        if (overBudget(m[2].length + frac.length, scale)) {
+            throw new Error('decimal-budget: ' + src);
+        }
+        const unscaled = BigInt(m[2] + frac);
+        return new Decimal('-' === m[1] ? -unscaled : unscaled, scale);
+    }
+}
+exports.Decimal = Decimal;
+// D6 -- THE BUDGET APPLIES TO RESULTS, NOT JUST LITERALS. True when a
+// Decimal produced by arithmetic is over either bound and so must be
+// refused with `decimal_budget`.
+//
+// The test is applied to the NORMAL form -- the representation the value
+// is actually stored and rendered in -- rather than to some minimal
+// re-derived source form. That keeps the rule cheap and mechanical
+// enough for the Go port to mirror exactly (count the coefficient's
+// digits, read the scale), and it bounds precisely the thing the bound
+// exists to bound: the digits plain-form rendering will have to
+// materialise.
+//
+// One consequence is worth naming: a literal is budget-checked on its
+// SOURCE form, so an extreme literal whose normal form is wider than its
+// source (`0d1e4096` -- one written digit, 4098 normalised ones) parses
+// but cannot take part in arithmetic. Both bounds are deliberately far
+// beyond any real document, and the alternative -- re-deriving a minimal
+// form per operation -- only moves the same edge somewhere else
+// (`0d100e4096` has minimal scale -4098, over the bound its source form
+// was under), at the cost of a second normal form that both ports would
+// then have to agree on digit for digit.
+function decimalOverBudget(d) {
+    return overBudget(coeffDigits(d.unscaled), d.scale);
+}
+// D3 -- THE `0d` LITERAL.
+//
+//   0[dD] digits [ . digits ] [ (e|E) [+-] digits ]
+//
+// with single `_` separators between digits, exactly as the landed
+// separator rule allows for ordinary numbers (`[0-9](?:_?[0-9])*` admits
+// `1_000` and refuses `1__0`, `_1`, `1_`).
+//
+// LEAF BY SOURCE, mirroring R1's precedent that the source text and not
+// the value decides the kind: digits only is a biginteger, a `.` or an
+// exponent anywhere makes it a bigdecimal. So `0d5` is a biginteger and
+// `0d1e3` is a bigdecimal whose value happens to be integral.
+//
+// THE SIGN IS NOT PART OF THIS PATTERN, though it is part of the D3
+// grammar: `-0d5` is read as the existing unary-minus prefix applied to
+// `0d5` (see negative-prefix in lang.ts), exactly as `-1.5` already is.
+// Aontu's lexer runs regexp value matchers BEFORE the fixed-token
+// matcher, so a `[-+]?` here would claim the `+` of `0d1 +0d2` as a
+// literal sign and silently turn an addition into an implicit list --
+// while plain `1 +2` stayed an addition. The sign belongs to the same
+// operator for both, which is also what keeps `0d-5` rejected.
+//
+// Kept RE2-compatible (no lookaround, no backreferences) so the Go port
+// can use the byte-identical pattern.
+const BIG_LITERAL_RE = /^0[dD]([0-9](?:_?[0-9])*)(?:\.([0-9](?:_?[0-9])*))?(?:[eE]([-+]?[0-9](?:_?[0-9])*))?/;
+exports.BIG_LITERAL_RE = BIG_LITERAL_RE;
+function stripSep(s) {
+    return -1 === s.indexOf('_') ? s : s.replace(/_/g, '');
+}
+// Read a `0d` literal from the groups of BIG_LITERAL_RE:
+//   1 integer digits, 2 fraction digits, 3 exponent.
+function readBigLiteral(m) {
+    const intd = stripSep(m[1]);
+    const fracd = null == m[2] ? undefined : stripSep(m[2]);
+    const expd = null == m[3] ? undefined : stripSep(m[3]);
+    // Leaf by SOURCE, not by value.
+    if (undefined === fracd && undefined === expd) {
+        return { leaf: 'biginteger', int: BigInt(intd) };
+    }
+    // The exponent is read as a plain number on purpose: a 4000-digit
+    // exponent lands on Infinity, whose absolute value is over budget, so
+    // the refusal below fires without any bigint ever being built.
+    const exp = undefined === expd ? 0 : Number(expd);
+    const fracLen = undefined === fracd ? 0 : fracd.length;
+    const scale = fracLen - exp;
+    // The budget is checked on the SOURCE form, before normalisation:
+    // normalising `0d1e1000000000` is itself the resource event the bound
+    // exists to prevent. Coefficient digits are counted as written
+    // (leading zeros included) so the two ports need not agree on any
+    // cleverer rule.
+    if (overBudget(intd.length + fracLen, scale)) {
+        return { leaf: 'error', code: 'decimal_budget' };
+    }
+    return {
+        leaf: 'bigdecimal',
+        dec: new Decimal(BigInt(intd + (fracd ?? '')), scale),
+    };
+}
+//# sourceMappingURL=Decimal.js.map

package/dist/val/Decimal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decimal.js","sourceRoot":"","sources":["../../src/val/Decimal.ts"],"names":[],"mappings":"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"}

package/dist/val/IntegerVal.d.ts

@@ -3,6 +3,8 @@ import { AontuContext } from '../ctx';
 import { ScalarVal } from './ScalarVal';
 declare class IntegerVal extends ScalarVal {
     isInteger: boolean;
+    get canon(): string;
+    gen(_ctx?: AontuContext): number | bigint;
     constructor(spec: ValSpec, ctx?: AontuContext);
     unify(peer: any, ctx: AontuContext): Val;
 }

package/dist/val/IntegerVal.js

@@ -5,12 +5,84 @@ exports.IntegerVal = void 0;
 const err_1 = require("../err");
 const ScalarVal_1 = require("./ScalarVal");
 const ScalarKindVal_1 = require("./ScalarKindVal");
+const numkind_1 = require("./numkind");
 const utility_1 = require("../utility");
 class IntegerVal extends ScalarVal_1.ScalarVal {
+    // Canon renders the EXACT digits of the value, not JavaScript's
+    // shortest round-tripping form.
+    //
+    // A JS number's toString emits the shortest decimal that parses back
+    // to the same double — at most 17 significant digits — so 2^60 printed
+    // as `1152921504606847000`, a DIFFERENT integer that merely rounds to
+    // the same double, while the Go port printed the true
+    // `1152921504606846976` from its int64. That was the one entry in the
+    // parity ledger (issue #21).
+    //
+    // Neither rendering was "the wrong number" while lossy literals were
+    // still accepted, which is why the ledger deferred to the Phase 6
+    // refusal — but Phase 6 refuses INEXACT literals, and every value in
+    // this window (2^60, 2^63-1024, …) is exactly representable and so is
+    // accepted. The divergence was never about exactness; it was about
+    // rendering. Once the value is exactly what the source asked for,
+    // there IS a right answer, and it is the exact digits.
+    //
+    // BigInt is exact here by construction: an IntegerVal's peg is
+    // integral and inside the int64 window (isIntegerKind, enforced in the
+    // constructor), so the bigint conversion cannot lose anything.
+    get canon() {
+        return (0, numkind_1.integerDigits)(this.peg);
+    }
+    // The same exactness in GENERATED output -- the other half of #21, and
+    // the half canon cannot reach.
+    //
+    // `generate()` returns NATIVE values, and the emitter sees only those:
+    // by the time exactJSON has a JS number it can no longer tell an
+    // integer-kind 2^60 (whose exact digits are the answer) from a
+    // float-kind 1e21 (whose shortest form `1e+21` is the answer, and is
+    // what Go prints too). The kind has to travel WITH the value, so above
+    // the safe-integer range an integer-kind value generates as a `bigint`,
+    // which the emitter already writes as exact digits.
+    //
+    // WHY Number.isSafeInteger IS THE LINE. It is precisely "this double is
+    // an integer that renders its own exact digits": inside the range the
+    // integers are contiguous, so toString round-trips exactly and a
+    // `number` loses nothing. Outside it they are not, and JS itself
+    // declares the value untrustworthy -- so handing back a `number` there
+    // would give a consumer something that prints wrong AND does
+    // arithmetic wrong, silently. A bigint makes both explicit: mixing it
+    // with a number throws rather than quietly rounding.
+    //
+    // The line is deliberately the WELL-KNOWN one rather than the tightest
+    // possible one. Some doubles above the range do still render exactly
+    // (2^54, say), so a predicate of `BigInt(peg).toString() === String(peg)`
+    // would keep marginally more values as `number` -- at the cost of a
+    // contract no consumer could evaluate in their head, and of handing
+    // back unsafe numbers for arithmetic. "Integers up to
+    // Number.MAX_SAFE_INTEGER are numbers; beyond that, bigints" is a rule
+    // that can be stated once and relied on.
+    //
+    // This is a BREAKING change for a consumer reading integers above 2^53
+    // out of generate() -- but those were the values that were already
+    // silently wrong, and a TypeError on `out.x + 1` is the better failure.
+    // Go needs none of this: its integer leaf is an int64, exact across the
+    // whole window, and encoding/json writes its digits.
+    //
+    // The BYTES are unchanged below the line, and the values that cross it
+    // with 17 or fewer significant digits (2^53 itself) serialise the same
+    // either way -- only their runtime type moves, which is why the `gens`
+    // rows cannot see it and ts/test/exactjson.test.ts pins it instead.
+    gen(_ctx) {
+        const peg = this.peg;
+        return Number.isSafeInteger(peg) ? peg : BigInt(peg);
+    }
     constructor(spec, ctx) {
-        if (!Number.isInteger(spec.peg)) {
-            // TODO: use Nil?
-            throw new err_1.AontuError('not-integer: ' + spec.peg);
+        // An IntegerVal must hold a value of *integer kind*: integral AND
+        // within the int64 range, so it can never hold something the Go
+        // port's int64 storage could not (see isIntegerKind). Every
+        // construction site pre-checks with the same helper, so reaching
+        // here is a programming error, not user input — hence a throw.
+        if (!(0, numkind_1.isIntegerKind)(spec.peg)) {
+            throw new err_1.AontuError('not-integer-kind: ' + spec.peg);
         }
         // super({ peg: spec.peg, kind: Integer }, ctx)
         super({ ...spec, kind: ScalarKindVal_1.Integer }, ctx);

package/dist/val/IntegerVal.js.map

@@ -1 +1 @@
-{"version":3,"file":"IntegerVal.js","sourceRoot":"","sources":["../../src/val/IntegerVal.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAWzD,gCAA+C;AAE/C,2CAAuC;AACvC,mDAAyC;AAEzC,wCAImB;AAGnB,MAAM,UAAW,SAAQ,qBAAS;IAGhC,YACE,IAAa,EACb,GAAkB;QAElB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YAChC,iBAAiB;YACjB,MAAM,IAAI,gBAAU,CAAC,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,CAAA;QAClD,CAAC;QACD,+CAA+C;QAC/C,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,uBAAO,EAAE,EAAE,GAAG,CAAC,CAAA;QAXxC,cAAS,GAAG,IAAI,CAAA;IAYhB,CAAC;IAED,KAAK,CAAC,IAAS,EAAE,GAAiB;QAChC,MAAM,EAAE,GAAG,GAAG,CAAC,OAAO,IAAI,IAAA,qBAAW,EAAC,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;QAE9E,IAAI,GAAG,GAAQ,IAAI,CAAA;QAEnB,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;YACjB,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACtB,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,IAAA,YAAE,EAAC,EAAE,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;YAC1E,CAAC;iBACI,IACH,IAAI,CAAC,QAAQ;gBACb,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI;gBACvB,IAAI,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,EACrB,CAAC;gBACD,GAAG,GAAG,IAAI,CAAA;YACZ,CAAC;iBACI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACpB,GAAG,GAAG,IAAI,CAAA;YACZ,CAAC;iBACI,CAAC;gBACJ,GAAG,GAAG,IAAA,gBAAU,EAAC,GAAG,EAAE,SAAS;oBAC7B,CAAE,IAAY,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;YACtE,CAAC;QACH,CAAC;aACI,CAAC;YACJ,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QAC9B,CAAC;QAED,IAAA,sBAAY,EAAC,EAAE,EAAE,GAAG,CAAC,CAAA;QAErB,OAAO,GAAG,CAAA;IACZ,CAAC;CACF;QAIC,UAAU"}
+{"version":3,"file":"IntegerVal.js","sourceRoot":"","sources":["../../src/val/IntegerVal.ts"],"names":[],"mappings":"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"}

package/dist/val/KeyFuncVal.d.ts

@@ -7,7 +7,7 @@ declare class KeyFuncVal extends FuncBaseVal {
     make(_ctx: AontuContext, spec: ValSpec): Val;
     funcname(): string;
     unify(peer: Val, ctx: AontuContext): Val;
-    resolve(_ctx: AontuContext, _args: Val[]): Val;
+    resolve(ctx: AontuContext, _args: Val[]): import("./NilVal").NilVal | Val;
     gen(_ctx: AontuContext): any;
 }
 export { KeyFuncVal, };

package/dist/val/KeyFuncVal.js

@@ -5,6 +5,7 @@ exports.KeyFuncVal = void 0;
 const StringVal_1 = require("../val/StringVal");
 const ConjunctVal_1 = require("../val/ConjunctVal");
 const FuncBaseVal_1 = require("./FuncBaseVal");
+const err_1 = require("../err");
 class KeyFuncVal extends FuncBaseVal_1.FuncBaseVal {
     constructor(spec, ctx) {
         super(spec, ctx);
@@ -45,11 +46,40 @@ class KeyFuncVal extends FuncBaseVal_1.FuncBaseVal {
         }
         return out;
     }
-    resolve(_ctx, _args) {
+    resolve(ctx, _args) {
         let out = this;
         // if (!this.mark.type && !this.mark.hide) {
-        let move = this.peg?.[0]?.peg;
-        move = isNaN(move) ? 1 : +move;
+        //
+        // THE LEVEL MUST BE AN INTEGER, OR ABSENT.
+        //
+        // A level is an index into the path (0 the own key, the default 1 the
+        // parent), so the argument is an integer or it is a mistake. Both
+        // exact integer leaves qualify -- `integer` and `biginteger` -- and
+        // everything else is refused rather than silently meaning "parent",
+        // which is what made a mistyped level undetectable.
+        //
+        // This also removes a crash. The test used to be
+        // `isNaN(move) ? 1 : +move` with the COERCING global isNaN, which is
+        // ToNumber, and ToNumber THROWS for a bigint (a biginteger's peg) and
+        // for the null-prototype object a map's peg is -- neither has a
+        // toString or valueOf to call. The exception escaped into unify's
+        // catch-all and surfaced as an opaque [aontu/internal].
+        const argval = this.peg?.[0];
+        let move = 1;
+        if (null != argval) {
+            if (argval.isInteger) {
+                move = argval.peg;
+            }
+            else if (argval.isBigInteger) {
+                // A level far outside the path simply misses, exactly as an
+                // out-of-range plain integer already does, so Number() here needs
+                // no bound of its own.
+                move = Number(argval.peg);
+            }
+            else {
+                return (0, err_1.makeNilErr)(ctx, 'key_level', this);
+            }
+        }
         const key = this.path[this.path.length - (1 + move)] ?? '';
         // console.log('KEY', this.path, move, key)
         out = new StringVal_1.StringVal({ peg: key });

package/dist/val/KeyFuncVal.js.map

@@ -1 +1 @@
-{"version":3,"file":"KeyFuncVal.js","sourceRoot":"","sources":["../../src/val/KeyFuncVal.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAazD,gDAA4C;AAC5C,oDAAgD;AAIhD,+CAA2C;AAG3C,MAAM,UAAW,SAAQ,yBAAW;IAGlC,YACE,IAAa,EACb,GAAkB;QAElB,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QANlB,cAAS,GAAG,IAAI,CAAA;QAOd,iBAAiB;IACnB,CAAC;IAGD,IAAI,CAAC,IAAkB,EAAE,IAAa;QACpC,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,CAAA;IAC7B,CAAC;IAED,QAAQ;QACN,OAAO,KAAK,CAAA;IACd,CAAC;IAGD,KAAK,CAAC,IAAS,EAAE,GAAiB;QAChC,8FAA8F;QAC9F,IAAI,GAAG,GAAQ,IAAI,CAAA;QAEnB,IAAI,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;YACf,IAAI,CAAC,OAAO,EAAE,CAAA;YAEd,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;gBACxC,yEAAyE;gBACzE,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YACvB,CAAC;iBACI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACpB,GAAG,GAAG,IAAI,CAAA;YACZ,CAAC;iBACI,CAAC;gBACJ,IACE,IAAI,CAAC,SAAS;uBACX,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;uBAC3C,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAC5C,CAAC;oBACD,GAAG,GAAG,IAAI,CAAA;gBACZ,CAAC;qBACI,CAAC;oBACJ,GAAG,GAAG,IAAI,yBAAW,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,CAAA;gBACnD,CAAC;YACH,CAAC;QACH,CAAC;aACI,CAAC;YACJ,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QAC9B,CAAC;QAED,OAAO,GAAG,CAAA;IACZ,CAAC;IAGD,OAAO,CAAC,IAAkB,EAAE,KAAY;QACtC,IAAI,GAAG,GAAQ,IAAI,CAAA;QAEnB,4CAA4C;QAC5C,IAAI,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAA;QAC7B,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;QAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,EAAE,CAAA;QAC1D,2CAA2C;QAE3C,GAAG,GAAG,IAAI,qBAAS,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAA;QACjC,IAAI;QAEJ,OAAO,GAAG,CAAA;IACZ,CAAC;IAGD,GAAG,CAAC,IAAkB;QACpB,OAAO,SAAS,CAAA;IAClB,CAAC;CAEF;QAIC,UAAU"}
+{"version":3,"file":"KeyFuncVal.js","sourceRoot":"","sources":["../../src/val/KeyFuncVal.ts"],"names":[],"mappings":"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"}

package/dist/val/LowerFuncVal.js

@@ -5,6 +5,7 @@ exports.LowerFuncVal = void 0;
 const err_1 = require("../err");
 const ScalarKindVal_1 = require("../val/ScalarKindVal");
 const valutil_1 = require("../val/valutil");
+const Decimal_1 = require("../val/Decimal");
 const FuncBaseVal_1 = require("./FuncBaseVal");
 class LowerFuncVal extends FuncBaseVal_1.FuncBaseVal {
     constructor(spec, ctx) {
@@ -18,13 +19,29 @@ class LowerFuncVal extends FuncBaseVal_1.FuncBaseVal {
         return 'lower';
     }
     resolve(ctx, args) {
-        const oldpeg = args?.[0].peg;
+        // A missing argument (`lower()`) must produce an invalid-arg error
+        // value, as the Go port does — reading .peg off nothing threw a
+        // TypeError that the unifier could only report as an opaque
+        // internal error.
+        const arg = args?.[0];
+        const oldpeg = arg?.peg;
         const peg = 'string' === typeof oldpeg ? oldpeg.toLowerCase() :
             'number' === typeof oldpeg ? Math.floor(oldpeg) :
-                undefined;
+                // The exact leaves take an EXACT floor and keep their kind: a
+                // biginteger is already integral so it is its own floor, and a
+                // bigdecimal floors by coefficient arithmetic. Math.floor is not
+                // an option for either — it would round the value into binary64
+                // first, which is the loss the `0d` leaves exist to refuse.
+                'bigint' === typeof oldpeg ? oldpeg :
+                    oldpeg instanceof Decimal_1.Decimal ? oldpeg.floor() :
+                        undefined;
         const out = this.place(null == peg ?
             (0, err_1.makeNilErr)(ctx, 'invalid-arg', this) :
-            (0, valutil_1.makeScalar)(peg));
+            // The floor keeps the ARGUMENT's kind (lower(2) is an integer 2,
+            // lower(1.9) is a number 1) — the function must not narrow
+            // number to integer, and this also makes the actual result kind
+            // agree with the superior() advertised below.
+            (0, valutil_1.makeScalarLike)(peg, arg));
         return out;
     }
     superior() {

package/dist/val/LowerFuncVal.js.map

@@ -1 +1 @@
-{"version":3,"file":"LowerFuncVal.js","sourceRoot":"","sources":["../../src/val/LowerFuncVal.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAYzD,gCAAmC;AAInC,wDAAoD;AACpD,4CAA2C;AAI3C,+CAA2C;AAG3C,MAAM,YAAa,SAAQ,yBAAW;IAGpC,YACE,IAAa,EACb,GAAkB;QAElB,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QANlB,gBAAW,GAAG,IAAI,CAAA;IAOlB,CAAC;IAGD,IAAI,CAAC,IAAkB,EAAE,IAAa;QACpC,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAA;IAC/B,CAAC;IAED,QAAQ;QACN,OAAO,OAAO,CAAA;IAChB,CAAC;IAGD,OAAO,CAAC,GAA6B,EAAE,IAAW;QAChD,MAAM,MAAM,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAA;QAC5B,MAAM,GAAG,GAAG,QAAQ,KAAK,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;YAC7D,QAAQ,KAAK,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC/C,SAAS,CAAA;QACb,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CACpB,IAAI,IAAI,GAAG,CAAC,CAAC;YACX,IAAA,gBAAU,EAAC,GAAG,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC;YACtC,IAAA,oBAAU,EAAC,GAAG,CAAC,CAClB,CAAA;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAGD,QAAQ;QACN,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAA;QACzB,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC;YACpB,IAAI,CAAC,KAAK,CAAC,IAAI,6BAAa,CAAC;gBAC3B,GAAG,EAAE,GAAG,CAAC,IAAI;aACd,CAAC,CAAC,CAAC,CAAC;YACL,KAAK,CAAC,QAAQ,EAAE,CAAA;IACpB,CAAC;CAEF;QAIC,YAAY"}
+{"version":3,"file":"LowerFuncVal.js","sourceRoot":"","sources":["../../src/val/LowerFuncVal.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAYzD,gCAAmC;AAInC,wDAAoD;AACpD,4CAA+C;AAC/C,4CAAwC;AAIxC,+CAA2C;AAG3C,MAAM,YAAa,SAAQ,yBAAW;IAGpC,YACE,IAAa,EACb,GAAkB;QAElB,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QANlB,gBAAW,GAAG,IAAI,CAAA;IAOlB,CAAC;IAGD,IAAI,CAAC,IAAkB,EAAE,IAAa;QACpC,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAA;IAC/B,CAAC;IAED,QAAQ;QACN,OAAO,OAAO,CAAA;IAChB,CAAC;IAGD,OAAO,CAAC,GAA6B,EAAE,IAAW;QAChD,mEAAmE;QACnE,gEAAgE;QAChE,4DAA4D;QAC5D,kBAAkB;QAClB,MAAM,GAAG,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;QACrB,MAAM,MAAM,GAAG,GAAG,EAAE,GAAG,CAAA;QACvB,MAAM,GAAG,GAAG,QAAQ,KAAK,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;YAC7D,QAAQ,KAAK,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC/C,8DAA8D;gBAC9D,+DAA+D;gBAC/D,iEAAiE;gBACjE,gEAAgE;gBAChE,4DAA4D;gBAC5D,QAAQ,KAAK,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;oBACnC,MAAM,YAAY,iBAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;wBAC1C,SAAS,CAAA;QACjB,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CACpB,IAAI,IAAI,GAAG,CAAC,CAAC;YACX,IAAA,gBAAU,EAAC,GAAG,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC;YACtC,iEAAiE;YACjE,2DAA2D;YAC3D,gEAAgE;YAChE,8CAA8C;YAC9C,IAAA,wBAAc,EAAC,GAAG,EAAE,GAAG,CAAC,CAC3B,CAAA;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAGD,QAAQ;QACN,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAA;QACzB,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC;YACpB,IAAI,CAAC,KAAK,CAAC,IAAI,6BAAa,CAAC;gBAC3B,GAAG,EAAE,GAAG,CAAC,IAAI;aACd,CAAC,CAAC,CAAC,CAAC;YACL,KAAK,CAAC,QAAQ,EAAE,CAAA;IACpB,CAAC;CAEF;QAIC,YAAY"}

package/dist/val/MapVal.js

@@ -9,6 +9,7 @@ const err_1 = require("../err");
 const top_1 = require("./top");
 const ConjunctVal_1 = require("./ConjunctVal");
 const BagVal_1 = require("./BagVal");
+const keyorder_1 = require("../keyorder");
 // Structural snapshots of ref spreads (see MapVal.unify), keyed by the
 // ref's canon + source site rather than object identity: spread
 // application clones templates (and the refs inside them) freely, and a
@@ -316,10 +317,11 @@ class MapVal extends BagVal_1.BagVal {
         return out;
     }
     get canon() {
-        // Keys are emitted alphabetically so the canonical form is
-        // independent of insertion/unification order (and matches the Go
-        // port, whose JSON marshaling also sorts keys).
-        let keys = Object.keys(this.peg).sort();
+        // Keys are emitted in CODE POINT order so the canonical form is
+        // independent of insertion/unification order and matches the Go
+        // port. A bare .sort() is UTF-16 code-unit order, which puts an
+        // astral key ahead of everything in U+E000-U+FFFF -- see cmpCodePoint.
+        let keys = Object.keys(this.peg).sort(keyorder_1.cmpCodePoint);
         return '' +
             // this.errcanon() +
             // (this.mark.type ? '<type>' : '') +