metanum 2.0.1 → 2.0.3

package/metanum.js

@@ -228,6 +228,38 @@
     return Math.log10(Number(str.substring(0, LONG_STRING_MIN_LENGTH))) + (str.length - LONG_STRING_MIN_LENGTH);
   };
 
+  // Canonical form of a value with 0 < |v| < 1: the library stores it as the
+  // RECIPROCAL with sign 2 (0<v<1) / -2 (-1<v<0) — the same encoding the
+  // underflow path below already produced, now applied to the WHOLE sub-unit
+  // range so that `MetaNum(0.5).sign === 2` and every operation result in that
+  // range carries it too (README: sign 2 / -2 == 0~1 / -1~0).
+  //
+  // _skipCanon lets rec() produce the reciprocal of a sub-unit value (2 for 0.5)
+  // without this rule turning it straight back into a small value.
+  var _skipCanon = 0;
+  function canonicalizeSubUnit(x) {
+    if (_skipCanon) return x;
+    if (x.layer !== 0 || x.array.length !== 1) return x;
+    var r = x.array[0];
+    if (x.sign !== 1 && x.sign !== -1) return x;   // already reciprocal-encoded
+    if (r.length === 1) {
+      var v = r[0];
+      if (!(typeof v === 'number') || !isFinite(v) || v <= 0 || v >= 1) return x;
+      r[0] = 1 / v;
+      x.sign = x.sign === -1 ? -2 : 2;
+      return x;
+    }
+    if (r.length === 2 && r[1] === 1) {
+      // 10^e with a negative exponent is sub-unit: store 10^(-e) as reciprocal
+      var e = r[0];
+      if (!(typeof e === 'number') || !isFinite(e) || e >= 0) return x;
+      r[0] = -e;
+      x.sign = x.sign === -1 ? -2 : 2;
+      return x;
+    }
+    return x;
+  }
+
   P.normalize = function () {
     var b;
     var x = this;
@@ -469,6 +501,40 @@
     return x;
   };
 
+  // Apply the sub-unit canonical form to a public result (constructor input or
+  // the result of a basic arithmetic op).  Deliberately NOT part of normalize():
+  // normalize runs on every internal intermediate, and the engine's own
+  // transcendentals (log10 → 0.301, slog, gamma, hyper-op levels) plus hardy's
+  // coefficient arrays read r0 structurally, so canonicalizing there broke
+  // them.  See canonicalizeSubUnit above.
+  function canonicalizeResult(x) {
+    if (x instanceof MetaNum) canonicalizeSubUnit(x);
+    return x;
+  }
+
+  // Constructor that never applies the sub-unit canonical form.  Engine
+  // internals build values that are consumed STRUCTURALLY (r0 read as a
+  // magnitude, sign tested for -1): the transcendentals' own results
+  // (log10(2) = 0.301, slog, gamma, pent_log) and hardy's fractional
+  // coefficients.  Canonicalizing those changed r0[0] from 0.301 to 3.32 and
+  // silently corrupted every consumer.
+  function rawMetaNum(v) {
+    _skipCanon++;
+    try { return new MetaNum(v); } finally { _skipCanon--; }
+  }
+
+  // Run fn with the sub-unit canonical form suppressed.  Applied to the engine
+  // functions that CONSUME sub-unit magnitudes structurally (gamma's series,
+  // slog's log10 chain, the layeradd/pentate inverse paths): they read r0 as a
+  // plain magnitude, so a canonicalized intermediate (log10(2) → r0 [3.32]
+  // instead of [0.301]) silently produced garbage.  The PRODUCERS (log10, ln,
+  // exp, root, the constructor, add/sub/mul/div) stay canonicalized, so the
+  // public contract the user asked for still holds.
+  function rawBody(fn, self, args) {
+    _skipCanon++;
+    try { return fn.apply(self, args || []); } finally { _skipCanon--; }
+  }
+
   var standardizeMessageSent = false;
   P.standardize = function () {
     if (!standardizeMessageSent) console.warn(metaNumError + "'standardize' method is being deprecated in favor of 'normalize' and will be removed in the future!"), standardizeMessageSent = true;
@@ -501,6 +567,19 @@
     if (this.array[0] && isNaN(this.array[0][0])) return NaN;
     if (other.array[0] && isNaN(other.array[0][0])) return NaN;
 
+    // Plain finite numerics (any sign, including the sub-unit encoding 2/-2)
+    // compare as real numbers.  The structural path below reads r0 as the
+    // magnitude and only inverts at the very end, so a sign-2 value like 0.2
+    // (stored as r0 = [5]) used to compare as 5 — every `lt`/`gt`/`eq` against a
+    // sub-unit value was wrong.
+    var tNum = plainNumericValue(this);
+    var oNum = plainNumericValue(other);
+    if (tNum !== null && oNum !== null) {
+      if (tNum < oNum) return -1;
+      if (tNum > oNum) return 1;
+      return 0;
+    }
+
     var tInf = this.array[0] && this.array[0][0] === Infinity;
     var oInf = other.array[0] && other.array[0][0] === Infinity;
 
@@ -796,6 +875,30 @@
     return x.sign === 2 || x.sign === -2;
   }
 
+  // The plain r0 magnitude as the engine's own numeric routines expect it:
+  // for a sub-unit value (sign 2/-2) r0 holds the RECIPROCAL, so unwrap it.
+  // Use this wherever a function does `isSimple(x) ? x.array[0][0] : …` to feed
+  // a float routine — otherwise 0.5 (r0 [2]) is read as 2.
+  function magnitudeOf(x) {
+    if (!isSmall(x)) return x.array[0][0];
+    return 1 / x.array[0][0];
+  }
+
+  // Real value of a plain finite numeric MetaNum, or null when the value is
+  // structured (layer > 0, ordinal rows, E/power-tower r0) and must go through
+  // the structural comparison.  sign 2/-2 is the sub-unit encoding: r0 holds
+  // the reciprocal, so the value is 1/r0 (negated for -2).
+  function plainNumericValue(x) {
+    if (x.layer !== 0 || x.array.length !== 1) return null;
+    var r0 = x.array[0];
+    if (r0.length !== 1) return null;
+    var v = r0[0];
+    if (typeof v !== 'number' || !isFinite(v) || v === 0) return null;
+    if (x.sign === 2) return 1 / v;
+    if (x.sign === -2) return -1 / v;
+    return x.sign === -1 ? -v : v;
+  }
+
   function isNumeric(x) {
     return x.layer === 0 && x.array.length === 1 &&
            x.array[0].length === 1 && isFinite(x.array[0][0]);
@@ -1011,9 +1114,11 @@
     var domMul = layerDominant(x, other);
     if (domMul !== null) return domMul.clone().normalize();
 
-    if (isSimple(x) && isSimple(other) && !isSmall(x) && !isSmall(other)) {
-      var nx = x.array[0][0];
-      var ny = other.array[0][0];
+    if (isSimple(x) && isSimple(other)) {
+      // magnitudeOf: sub-unit operands (sign 2/-2) store the reciprocal, so
+      // read the real values — otherwise 0.5·0.5 multiplied 2·2 = 4.
+      var nx = magnitudeOf(x);
+      var ny = magnitudeOf(other);
       var n = nx * ny;
       if (isFinite(n) && n !== 0 && Math.abs(n) <= MAX_SAFE_INTEGER) {
         if (Math.abs(n) < 1) return new MetaNum(1 / Math.abs(n)).rec();
@@ -1066,9 +1171,11 @@
     }
 
     if (x.eq(MetaNum.ZERO)) return MetaNum.ZERO.clone();
-    if (isSimple(x) && isSimple(other) && !isSmall(x) && !isSmall(other)) {
-      var nx = x.array[0][0];
-      var ny = other.array[0][0];
+    if (isSimple(x) && isSimple(other)) {
+      // magnitudeOf: sub-unit operands store the reciprocal — 0.5 / 0.25 must
+      // read 0.5 and 0.25, not 2 and 4.
+      var nx = magnitudeOf(x);
+      var ny = magnitudeOf(other);
       var n = nx / ny;
       if (isFinite(n) && n !== 0 && Math.abs(n) <= MAX_SAFE_INTEGER) {
         if (Math.abs(n) < 1) return new MetaNum(1 / Math.abs(n)).rec();
@@ -1111,7 +1218,10 @@
     var x = this.clone();
     // Toggle between large and small: 1↔2, -1↔-2
     x.sign = x.sign === 1 ? 2 : x.sign === 2 ? 1 : x.sign === -1 ? -2 : -1;
-    return x.normalize();
+    // _skipCanon: the reciprocal of a sub-unit value is a NORMAL value (rec(0.5)
+    // = 2) — canonicalizeSubUnit would otherwise flip it straight back.
+    _skipCanon++;
+    try { return x.normalize(); } finally { _skipCanon--; }
   };
   Q.reciprocate = Q.rec = function (x) {
     return new MetaNum(x).rec();
@@ -1202,7 +1312,11 @@
       if (other.mod(2).eq(MetaNum.ONE)) return x.abs().root(other).neg();
       return MetaNum.NaN.clone();
     }
-    if (isNumeric(x) && isNumeric(other)) return new MetaNum(Math.pow(x.array[0][0], 1 / other.array[0][0]));
+    if (isNumeric(x) && isNumeric(other)) {
+      // magnitudeOf: a sub-unit x (sign 2) stores the reciprocal in r0, so
+      // sqrt(0.25) must read 0.25, not the stored 4 (which gave 2).
+      return new MetaNum(Math.pow(magnitudeOf(x), 1 / magnitudeOf(other)));
+    }
     // Handle E^m format (iterated exponentiation levels)
     if (x.layer === 0 && x.array.length === 1 && x.array[0].length > 1 && isNumeric(other)) {
       var r0 = x.array[0];
@@ -1260,19 +1374,11 @@
   P.generalLogarithm = P.log10 = function () {
     if (this.isNaN() || this.sign === -1 || this.sign === -2) return MetaNum.NaN.clone();
     if (this.isInfinite()) return this;
-    if (isSmall(this)) {
-      // Small value: log10 is negative of what it would be for the normal value
-      var n = this.clone();
-      n.sign = 1; // Convert to normal positive for computation
-      var result = n.log10();
-      // Result should be negative (because log10 of a small number is negative)
-      // Need to handle this carefully - after conversion, the result is the magnitude
-      // which we need to negate
-      return result.neg();
-    }
     if (this.eq(MetaNum.ZERO)) return MetaNum.NEGATIVE_INFINITY.clone();
     if (isNumeric(this)) {
-      var lv = Math.log10(this.array[0][0]);
+      // magnitudeOf: a sub-unit operand stores the reciprocal in r0, so
+      // log10(0.5) must read 0.5, not the stored 2.
+      var lv = Math.log10(magnitudeOf(this));
       if (Number.isFinite(lv)) return new MetaNum(lv);
     }
     if (this.layer === 0 && this.array.length === 1 && this.array[0].length > 1) {
@@ -1298,7 +1404,7 @@
     if (x.eq(MetaNum.ZERO)) return MetaNum.NEGATIVE_INFINITY.clone();
     if (x.eq(MetaNum.ONE)) return MetaNum.ZERO.clone();
     if (isNumeric(x) && isNumeric(base)) {
-      var lv = Math.log(x.array[0][0]) / Math.log(base.array[0][0]);
+      var lv = Math.log(magnitudeOf(x)) / Math.log(magnitudeOf(base));
       if (Number.isFinite(lv)) return new MetaNum(lv);
     }
     return x.log10().div(base.log10());
@@ -1308,11 +1414,14 @@
   };
 
   P.naturalLogarithm = P.ln = function () {
-    if (this.isNaN() || this.sign === -1 || this.sign === -2) return MetaNum.NaN.clone();
+    if (this.sign === -1 || this.sign === -2) return MetaNum.NaN.clone();
+    if (this.isNaN()) return MetaNum.NaN.clone();
     if (this.eq(MetaNum.ZERO)) return MetaNum.NEGATIVE_INFINITY.clone();
     if (this.isInfinite()) return this;
     if (isNumeric(this)) {
-      var lv = Math.log(this.array[0][0]);
+      // magnitudeOf: a sub-unit operand stores the reciprocal in r0, so
+      // ln(0.5) must read 0.5, not the stored 2.
+      var lv = Math.log(magnitudeOf(this));
       if (Number.isFinite(lv)) return new MetaNum(lv);
     }
     return this.log10().div(new MetaNum(Math.LOG10E));
@@ -1354,7 +1463,7 @@
     if (this.sign === -1 || this.sign === -2) return MetaNum.NaN.clone();
     if (this.isNaN() || this.isInfinite()) return this.clone();
     if (isSimple(this)) {
-      var n = this.array[0][0];
+      var n = magnitudeOf(this);   // sub-unit r0 holds the reciprocal
       if (Number.isInteger(n) && n >= 0 && n <= 100) {
         var f = 1;
         for (var i = 2; i < n; i++) f *= i;
@@ -1377,7 +1486,7 @@
     if (this.isNaN() || this.isInfinite()) return this;
     if (this.sign === -1 || this.sign === -2) return this.abs().fact().neg();
     if (isSimple(this)) {
-      var n = this.array[0][0];
+      var n = magnitudeOf(this);   // sub-unit r0 holds the reciprocal
       if (Number.isInteger(n) && n >= 0 && n <= 20) {
         var f = 1;
         for (var i = 2; i <= n; i++) f *= i;
@@ -1415,7 +1524,7 @@
       if (this.gt(MetaNum.E_MAX_SAFE_INTEGER)) return d_lambertw(this, tol, principal);
       if (isNumeric(this)) {
         try {
-          return new MetaNum(f_lambertw(this.array[0][0], tol, principal));
+          return new MetaNum(f_lambertw(magnitudeOf(this), tol, principal));
         } catch (e) {
           return MetaNum.NaN.clone();
         }
@@ -1428,7 +1537,8 @@
       if (this.abs().gt(MetaNum.E_MAX_SAFE_INTEGER)) return d_lambertw(this, tol, principal);
       if (isNumeric(this)) {
         try {
-          return new MetaNum(f_lambertw(this.sign * this.array[0][0], tol, principal));
+          return new MetaNum(f_lambertw(
+            (this.sign === -2 ? -1 : this.sign) * magnitudeOf(this.abs()), tol, principal));
         } catch (e) {
           return MetaNum.NaN.clone();
         }
@@ -1594,7 +1704,7 @@
     if (this.eq(MetaNum.ZERO)) return MetaNum.ZERO.clone();
     if (this.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (isSimple(this)) {
-      var v = this.array[0][0];
+      var v = magnitudeOf(this);
       if (v > 0 && v < 1) return new MetaNum(v);
       try {
         var w = f_lambertw(Math.log(v));
@@ -2063,9 +2173,21 @@
           if (other.eq(MetaNum.ONE)) return self.clone();
           if (frac.eq(MetaNum.ZERO)) return self.arrow(nLev)(other);
           var target = self.arrow(nLev)(other);
-          var theta0 = target.hyper_log(self)(nLev.add(MetaNum.ONE));
+          var lev1 = nLev.add(MetaNum.ONE);
+          var theta0 = hyperAnchorReal(self, lev1, target);
+          if (theta0 === null) theta0 = target.hyper_log(self)(lev1);
+          if (theta0.isNaN() || !(theta0.gt(MetaNum.ZERO))) theta0 = MetaNum.ONE.clone();
           var theta = theta0.mul(other.div(theta0).pow(frac));
-          return self.arrow(nLev.add(MetaNum.ONE))(theta);
+          var res = self.arrow(lev1)(theta);
+          if (hasFractionOutsideR00(res)) {
+            // levels that diagonalize into ordinal rows would keep the
+            // interpolated argument as a fractional row count — fall back to the
+            // integer argument so the "only array[0][0] is fractional" contract
+            // holds (floor is exact again at f = 1, where θ = y)
+            var ti = Math.max(1, Math.floor(theta.toNumber()));
+            if (isFinite(ti)) res = self.arrow(lev1)(new MetaNum(ti));
+          }
+          return res;
         };
       }
       return function () { return MetaNum.NaN.clone(); };
@@ -2393,6 +2515,29 @@
     return hi;
   }
 
+  // Continuous inverse used as the interpolation ANCHOR of a fractional level:
+  // the real c with a{b}c = d, searched by bisection on doubles (arrow()
+  // evaluates fractional arguments).  hyperBisect only searches integers and
+  // therefore overshoots (θ0 = 2 where the true value is 1.0414), which makes
+  // the geometric interpolation θ = θ0·(y/θ0)^f run BACKWARDS (y/θ0 < 1) and
+  // breaks the monotonicity of x{y}y — arrow(10,1.5,1.5) came out smaller than
+  // arrow(10,1.1,1.1).  Returns null when d cannot be bracketed.
+  function hyperAnchorReal(a, b, d) {
+    try {
+      var lo = 0, hi = 1, it = 0;
+      while (it++ < 60 && a.arrow(b)(new MetaNum(hi)).lt(d)) { lo = hi; hi = hi * 2; }
+      if (!isFinite(hi) || hi > 1e15) return null;
+      for (var k = 0; k < 80; k++) {
+        var mid = (lo + hi) / 2;
+        if (a.arrow(b)(new MetaNum(mid)).lt(d)) lo = mid; else hi = mid;
+      }
+      var r = new MetaNum((lo + hi) / 2);
+      return r.isNaN() ? null : r;
+    } catch (e) {
+      return null;
+    }
+  }
+
   P.hyper_log = function (a) {
     var d = this.clone();
     a = new MetaNum(a);
@@ -2814,6 +2959,22 @@
     for (var j = 0; j < keep.length; j++) arr.push(keep[j]);
   }
 
+  // Layer marker WITHOUT the standard-form rewrites.  hardy's tower rule needs
+  // the layer to track the input's 10^ levels one-for-one — the standard
+  // de-layer ((b) above) would fold a finite-bracket marker (e.g. the
+  // layer-2 [[3086.036,9×8]] of eee10) down one layer and change the number
+  // the rule is about.  Same shape as _layerMarker, minus the rewrites.
+  Q._rawLayerMarker = function (r0, layer, rows) {
+    var v = new MetaNum(0);
+    v.sign = 1;
+    v.layer = layer > 0 ? layer : 0;
+    v.array = [(r0 && r0.length) ? r0.slice() : [0]];
+    for (var i = 0; i < (rows ? rows.length : 0); i++) {
+      if (rows[i] && rows[i].length > 1) v.array.push(rows[i].slice());
+    }
+    return v;
+  };
+
   Q._standardizeLayerValue = function (v) {
     if (!v || v.layer < 1) return v.normalize();
     var L = v.layer;
@@ -2895,12 +3056,16 @@
     var V = V0.clone();
     var i = 0;
     var guard = 0;
-    while (i < iters) {
-      if (++guard > 200) return Q._applyOrdinalRows(V, beta, iters - i);
+    // a fractional argument (yCnt - 1) still means a whole number of
+    // applications, and the rows must carry INTEGER counts — ceil keeps the
+    // step consistent with the expanded path (count = ceil(y)-2)
+    var total = Math.ceil(iters);
+    while (i < total) {
+      if (++guard > 200) return Q._applyOrdinalRows(V, beta, total - i);
       var vCnt = metaFiniteCount(V);
       if (!(vCnt <= MAX_SAFE_INTEGER)) {
         // V is huge: every further application adds one β-row → fast-forward
-        return Q._applyOrdinalRows(V, beta, iters - i);
+        return Q._applyOrdinalRows(V, beta, total - i);
       }
       V = Q._ordinalHyperop(x, V, beta, (depth || 0) + 1);
       i++;
@@ -2975,13 +3140,12 @@
         for (var bi = 2; bi < pred.length; bi++) if ((pred[bi] || 0) > 0) bigLevel = true;
         if (xOkS && bigLevel && ym <= 100000) {
           // successor rule written in the EXPANDED form (the same generator the
-          // integer arguments use): x{α}(m+f) = x{α-1}^m(x^f) means the α-1 row
-          // carries m applications — ceil(y)-2 = m-1 — and the cascade below it
-          // takes its first fundamental sequence at the fractional start value
-          // x^f, which is what interpolates the cascade depth between the two
-          // neighbouring integers (exactly what the finite levels do: 10{3}2.1
-          // starts from 10^0.1).  The base is x{x^f}x when that descent is the
-          // ω one (ω+1 levels), x{x}x otherwise.
+          // integer arguments use): the α-1 row carries the m applications as an
+          // integer count ceil(y)-2 = m-1, and the fraction lives in the cascade
+          // depth — the first fundamental sequence is taken at the fractional
+          // start value x^f (x{α}(m+f) = x{α-1}^m(x^f) — exactly what the finite
+          // levels do: 10{3}2.1 starts from 10^0.1).  Whatever fraction is left
+          // over lands in the base, i.e. in array[0][0].
           return Q._expandedHyperop(x, new MetaNum(ym + 1), cf0,
             Math.pow(xnfS, Number((yFracNum - ym).toPrecision(15))));
         }
@@ -3057,14 +3221,19 @@
   //     into the base x and every row carries x-2 — including for 100 < y ≤ MSI
   //     (h20(10,1000) stays an expanded cascade, not a one-row marker).
   // ---------------------------------------------------------------------------
-  // `fsOpd` is the operand of the FIRST fundamental-sequence step.  The default
-  // is the base x; the fractional successor rule passes the fractional start
-  // value x^f instead (x{α}(m+f) = x{α-1}^m(x^f)), which is what interpolates the
-  // cascade depth between two integers.  baseIdx (returned as `.baseIdx`) is the
-  // index used by the last descent — the finite level the cascade bottoms out at.
+  // Only array[0][0] (the base's value slot) may ever be non-integer — the same
+  // contract as arrow(): every row count and every row coefficient is an integer.
+  // A fractional argument therefore enters in two integer-safe places:
+  //   - the outer count is `yn - 2` with yn = ceil(y) (an integer);
+  //   - the rest of the fraction sits in the CASCADE DEPTH: the first
+  //     fundamental sequence is taken at the fractional start value x^f
+  //     (x{α}(m+f) = x{α-1}^m(x^f)), and any fractional constant term left over
+  //     is carried into the base's finite level index (x{10.16}x), so it ends up
+  //     as the fractional array[0][0] exactly like arrow() does.
+  // `fsOpd` is that fractional start value; `.baseIdx` returns the base index.
   Q._cascadeRows = function (xn, cf, yn, budget, fsOpd) {
     var rows = [];
-    if (!(budget >= 1)) return { rows: rows, baseIdx: xn };
+    if (!(budget >= 1)) return rows;
     var cfs = trimCoeffs((cf || []).slice());
     var opd = Math.min(yn, MAX_SAFE_INTEGER);
     var first = (cfs[0] || 0) > 0;      // successor: the outer count is y-2
@@ -3077,10 +3246,8 @@
       if ((cfs[0] || 0) > 0) {
         var mRaw = cfs[0];
         var m = Math.floor(mRaw);
-        // a fractional constant term (from a fundamental sequence taken at a
-        // fractional index) is not a valid CNF coefficient — keep the integer
-        // part as rows and carry the remainder into the base's finite level
-        // index (x{10.16}x), which is exactly how the ω level interpolates
+        // a fractional constant term is not a valid CNF coefficient: keep the
+        // integer part as rows and carry the remainder to the base
         var mFr = Number((mRaw - m).toPrecision(15));
         if (mFr > 1e-9) fracRem = mFr;
         var beta = trimCoeffs(cfs.slice());
@@ -3091,13 +3258,15 @@
           var j = m - 1 - s;                            // rows β+m-1 … β
           var cnt = (first ? opd : xn) - 2;
           first = false;
-          if (cnt < 1) continue;
+          if (cnt < 1) continue;                        // no application to record
           if (cnt > MAX_SAFE_INTEGER) cnt = MAX_SAFE_INTEGER;
           var ord = beta.slice();
           if (j > 0) ord[0] = (ord[0] || 0) + j;        // β + j
           ord = trimCoeffs(ord);
           if (!coeffsHaveOmegaPart(ord)) continue;      // finite: lives in r0
-          rows.push([cnt].concat(ord));
+          var row = [snapInt(cnt)];
+          for (var oi = 0; oi < ord.length; oi++) row.push(snapInt(ord[oi]));
+          rows.push(row);
         }
         cfs = beta;                                     // continue below β
         opd = Math.min(xn, MAX_SAFE_INTEGER);           // everything below the top
@@ -3127,7 +3296,9 @@
   Q._expandedHyperop = function (x, y, cf, fsOpd) {
     var maxRows = MetaNum.maxRows;
     var xn = Math.floor(metaFiniteCount(x));
-    var yn = Math.floor(metaFiniteCount(y));
+    // ceil: the outer count must stay an integer (only array[0][0] may be
+    // fractional), so the m applications of x{α}(m+f) give ceil(y)-2 = m-1
+    var yn = Math.ceil(metaFiniteCount(y));
     var budget = maxRows - 1;                           // ordinal rows the array holds
     var desc = Q._cascadeRows(xn, cf, yn, budget + 1, fsOpd); // +1 detects truncation
     var truncated = desc.length > budget;
@@ -3153,6 +3324,28 @@
     return result.normalize();
   };
 
+  // Floating-point residue: 2.1e-12 left where the exact value is an integer.
+  // Only array[0][0] may be fractional, so snap everything else.
+  function snapInt(v) {
+    if (!isFinite(v)) return v;
+    var r = Math.round(v);
+    return Math.abs(v - r) < 1e-9 ? r : v;
+  }
+
+  // Does any entry outside array[0][0] carry a fractional part?
+  function hasFractionOutsideR00(v) {
+    if (!v || !v.array) return false;
+    for (var i = 0; i < v.array.length; i++) {
+      var row = v.array[i];
+      for (var j = 0; j < row.length; j++) {
+        if (i === 0 && j === 0) continue;
+        var c = row[j];
+        if (typeof c === "number" && isFinite(c) && c !== Math.floor(c)) return true;
+      }
+    }
+    return false;
+  }
+
   // Any coefficient with a non-zero fractional part?
   function coeffsHaveFraction(coeffs) {
     for (var i = 0; i < coeffs.length; i++) {
@@ -3667,6 +3860,17 @@
         cfw.push(cfac);
         return Q._hyperopFromOrdinal(x, x, cfw);
       }
+      // marker form: ω^m·(x^f) — the count must stay an integer, so write the
+      // fractional part out one level down: ω^m·floor(c) + ω^(m-1)·(x·frac),
+      // the same resolution the CNF levels use
+      if (mf >= MetaNum.maxCols) {
+        var cfFl = Math.floor(cfac), cfFr = cfac - cfFl;
+        var mkRows = [];
+        if (cfFl >= 1) mkRows.push([cfFl, mf]);
+        if (cfFr > 1e-9 && mf >= 2) mkRows.push([Math.max(1, Math.round(xnf * cfFr)), mf - 1]);
+        if (mkRows.length === 0) mkRows.push([1, mf]);
+        return Q._layerMarker([10], 1, mkRows);
+      }
       return Q._layerMarker([10], 1, [[cfac, mf]]);
     }
     // ordinal / out-of-range operand: y plus one ω^ω marker row
@@ -4118,7 +4322,13 @@
     if (yc <= MAX_SAFE_INTEGER) {
       var m = Math.max(2, Math.floor(yc));
       if (m > MAX_SAFE_INTEGER) m = MAX_SAFE_INTEGER;
-      return Q._layerMarker([10], m, [[1, 1]]);
+      // v2.0.2: a fractional height (hardy of anything between 10^^m and
+      // 10^^(m+1)) interpolates through the base argument 10+f instead of being
+      // flat across the whole range — and only array[0][0] stays fractional
+      var marker = Q._layerMarker([10], m, [[1, 1]]);
+      var mf = Number((yc - Math.floor(yc)).toPrecision(15));
+      if (isFinite(mf) && mf > 0) marker.array[0][0] = 10 + mf;  // stays in array[0][0]
+      return marker;
     }
     // ordinal / out-of-range operand: ε₀ caps the library → the MSI ω-tower
     return Q._layerMarker([10], MAX_SAFE_INTEGER, [[1, 1]]);
@@ -4663,7 +4873,7 @@
     if (this.isNaN()) return "NaN";
     if (this.isInfinite()) return "Infinity";
     if (isSimple(this)) {
-      var v = decimalPlaces(this.array[0][0], places);
+      var v = decimalPlaces(magnitudeOf(this), places);   // sub-unit r0 = reciprocal
       if (Number.isFinite(v)) return v.toString();
     }
     return this.toString();
@@ -4679,7 +4889,14 @@
     if (typeof require == 'function') {
       try { formatter = require('./format-metanum.js').format; } catch (e) { formatter = null; }
     }
-    return format(this, precision, small);
+    if (!formatter && typeof format === 'function') formatter = format;   // browser bundle
+    if (!formatter) {
+      // No formatter available (bare browser include): fall back to the plain
+      // decimal expansion rather than throwing ReferenceError.
+      var plain = this.toNumber();
+      return isFinite(plain) ? String(plain) : this.toString();
+    }
+    return formatter(this, precision, small);
   };
 
   P.toExponential = function (places) {
@@ -4711,7 +4928,7 @@
     if (this.isNaN()) return "NaN";
     if (this.isInfinite()) return "Infinity";
     if (isSimple(this)) {
-      var v = this.array[0][0];
+      var v = magnitudeOf(this);   // sub-unit r0 holds the reciprocal
       if (v < 10) return String(v);
       return "E" + Math.log10(v).toFixed(6);
     }
@@ -4937,6 +5154,24 @@
       return x;
     }
 
+    // v2.0.2: "1e10+0.5" / "1e10+11" / "1e16+1e13" — the digit paths (hardy)
+    // need the exact decimal value and the plain float parse reads 0 here.
+    // Split the sum and add the parts exactly; the '+' must not be the e+
+    // exponent marker ("1e+21" keeps its old parsing).
+    if (s.indexOf('+') > 0) {
+      var sumParts = s.split('+');
+      if (sumParts.length === 2 && sumParts[0] !== '' && sumParts[1] !== '' &&
+          !/[eE]$/.test(sumParts[0]) && !/[eE]$/.test(sumParts[1])) {
+        var sumA = Q.fromString(sumParts[0].trim());
+        var sumB = Q.fromString(sumParts[1].trim());
+        if (!sumA.isNaN() && !sumB.isNaN()) {
+          var sumV = sumA.add(sumB);
+          if (negateIt) sumV.sign = -sumV.sign;
+          return sumV;
+        }
+      }
+    }
+
     var layerMatch = s.match(/^\u03C9\^(\d+)\s*/);
     if (layerMatch) {
       x.layer = parseInt(layerMatch[1], 10);
@@ -5773,6 +6008,12 @@
   // deep for inputs like hardy(1e10+20) where n1≈40 makes every ω^j segment
   // take the exact branch: Maximum call stack size exceeded).
   Q._hardyH = function (coeffs, nArg) {
+    // Coefficients are read/written STRUCTURALLY below (c[j] -= 1, c[j-1] = n,
+    // c_j compared against HARDY_EXACT_BOUND) and a fractional coefficient is
+    // the normal case once the running base is 10+f — the sub-unit canonical
+    // form must not rewrite them into reciprocals.
+    _skipCanon++;
+    try {
     function MN(v) { return (v instanceof MetaNum) ? v.clone() : new MetaNum(v || 0); }
     var c = [];
     for (var i0 = 0; i0 < coeffs.length; i0++) c.push(MN(coeffs[i0]));
@@ -5807,6 +6048,19 @@
         n = nWf;
         continue;
       }
+      if (j >= c.length) return n;       // no positive term left (safety net)
+      // A coefficient can turn FRACTIONAL because the fundamental-sequence step
+      // writes the running base n — and n is 10+f for a fractional hardy input
+      // (hardy(1000.5)).  For 0 < c_j < 1 the "-1" step would go negative and
+      // leave no positive term at all, so take the PARTIAL step instead:
+      //   ω^j·f contributes ω^(j-1)·(n·f)   (continuous — f→1 is the full
+      //   ω^(j-1)·n step of the integer recursion, f→0 contributes nothing)
+      var cjN = c[j].toNumber();
+      if (isFinite(cjN) && cjN > 0 && cjN < 1 && j >= 2) {
+        c[j] = MetaNum.ZERO.clone();
+        c[j - 1] = n.mul(new MetaNum(Number(cjN.toPrecision(15))));
+        continue;
+      }
       if (c[j].gt(HARDY_EXACT_BOUND)) {                    // engine collapse
         // H_{β + ω^j·c}(n) ≈ H_β(2{c}j) — evaluate with the OLD c[j]
         var nCol = new MetaNum(2).arrow(j)(c[j]);
@@ -5823,6 +6077,97 @@
     }
     // budget exhausted: keep whatever was accumulated (monotone)
     return n;
+    } finally { _skipCanon--; }
+  };
+
+  // H_{ω^k}(n) for the from-below base of hardy (n ≥ 1e10).
+  //   The exact expansion writes a tower of level k-1 — H_{ω^10}(10) =
+  //   10{9}(11…21), H_{ω^20}(20) = 10{19}(21…22) — so array[0] holds k entries
+  //   and the step-by-step expansion only fits while k ≤ maxCols.  Above that
+  //   the running base turns structured, the coefficients the limit steps write
+  //   from it turn structured too, and every later comparison / collapse becomes
+  //   meaningless: hardy(1e10+11) (k = n1 = 22) collapsed to [[1],[2,20]] — a
+  //   destroyed base with a bogus row — and hardy(1e16+1e13) (k = 28) likewise.
+  //   There the from-below value is taken from the engine instead: 10{k-1}(n+1)
+  //   is exactly the lower bound the exact expansion stays strictly above, so
+  //   hardy stays monotone and keeps its "strictly below the engine" property.
+  Q._hardyOmegaPower = function (n1) {
+    var n1Num = (n1.layer === 0 && n1.array.length === 1 && n1.array[0].length === 1) ? n1.toNumber() : Infinity;
+    if (isFinite(n1Num) && n1Num >= 2) {
+      var kFit = Math.floor(n1Num);
+      if (kFit <= MetaNum.maxCols + 1) {
+        // exact expansion — a fractional base (hardy("1e10+0.5"), n = 10+f)
+        // flows through the fundamental-sequence steps (the partial-step rule
+        // keeps the coefficients sane) and collapses into ONE plain row: the
+        // fractional hyper-operation result, between hardy(1e10) and
+        // hardy(1e10+1)
+        var ec = [];
+        for (var zi = 0; zi < kFit; zi++) ec.push(0);
+        ec.push(1);
+        return Q._hardyH(ec, n1);
+      }
+      // n1 > maxCols+1: the exact tower [c0, (n1-1)×(n1-2)] no longer fits the
+      // array (22 entries for n1 = 22, maxCols = 20).  Keep the TRUNCATED
+      // cascade instead of the engine value 10{n1-1}(n1+1): the tower level
+      // n1-1 over the definitional base — hardy("1e10+11") =
+      // [3086.036…, 21×19] (the user-visible [非整数, 21, 21, …, 21] shape),
+      // strictly above hardy("1e10+10")'s exact [6313063, 19×18] (the level 21
+      // dominates the level 19) and still far below the matching engine
+      // ordinal op 10{ω^ω+ω+1}10.
+      var lv = Math.floor(n1Num) - 1;
+      var depth = Math.min(Math.floor(n1Num) - 2, MetaNum.maxCols - 1);
+      var r0 = Q._hardyBaseR0();
+      var arr = [r0[0]];
+      for (var di = 0; di < depth; di++) arr.push(lv);
+      var out = new MetaNum(0);
+      out.array = [arr];
+      return out.normalize();
+    }
+    // structured / fractional operand: one ω-diagonal row (engine convention)
+    return Q._applyOrdinalRows(n1, [0, 1], 1);
+  };
+
+  // Decimal digit string of a plain number stored as r0 = [v, 1] (= 10^v),
+  // or null when the value is not in that form / has no finite exponent.
+  // Only an actual POWER TOWER is excluded: 10^^k has the same r0 shape but
+  // v ≥ 1e10, so "1e100000" (= 10^100000, v = 100000) is a plain number and
+  // keeps the ordinary digit path — the old guard rejected exponents above
+  // 1e5 and pushed hardy("1e100000") into the tower branch (layer 1).
+  Q._hardyDigitsOfPowForm = function (r0) {
+    if (!r0 || r0.length !== 2 || r0[1] !== 1 || !isFinite(r0[0])) return null;
+    if (r0[0] >= 1e10) return null;                  // power tower → slog branch
+    var exN = Math.floor(r0[0]);
+    if (exN < 0 || exN > 1000000) return null;       // digit string budget
+    var mantN = Math.pow(10, r0[0] - exN);
+    if (!isFinite(mantN)) return null;
+    // the exponent is stored with ~15 significant digits, so the reconstructed
+    // mantissa carries a rounding tail — 2e1000 is stored as 10^1000.301029995664
+    // and 10^0.301029995664 = 1.9999999999999…, which would spell the digits
+    // "19999…9" instead of "2000…0".  Round the mantissa to the digits the
+    // exponent can actually hold before spelling it out.
+    if (mantN > 0) mantN = Number(mantN.toPrecision(12));
+    if (mantN >= 10 - 1e-9) { mantN /= 10; exN += 1; }
+    var digN = String(mantN).replace('.', '');
+    var zeroN = exN - (digN.length - 1);
+    if (zeroN < 0) return null;
+    return digN + '0'.repeat(zeroN);
+  };
+
+  // r0 of the definitional from-below base H_{ω^10}(10) = 10{9}(11…21) — the
+  // base every hardy(n ≥ 1e10) value is built on.
+  Q._hardyBaseR0 = function () {
+    return Q._hardyOmegaPower(MetaNum.TEN.clone()).array[0].slice();
+  };
+
+  // issues.md truncation marker: once the ordinal rows overflow, the engine
+  // collapses the base to [10].  hardy keeps its definitional base instead —
+  // every level above it is carried by the ordinal rows, so the truncation
+  // loses nothing but the unnameable low levels, and the value stays bigger
+  // than the marker base (hardy is monotone across the truncation point).
+  Q._hardyKeepBase = function (v) {
+    var r0 = v.array[0];
+    if (r0 && r0.length === 1 && r0[0] === 10) v.array[0] = Q._hardyBaseR0();
+    return v;
   };
 
   // MetaNum.hardy(n): the Hardy level of n.
@@ -5830,6 +6175,29 @@
   //   coefficients of an ordinal α (hardy(1234) = H_{ω³+ω²·2+ω·3+4}(10)) and
   //   the result is H_α(10).
   Q.hardy = function (n) {
+    // A plain JS number / numeric string keeps its own decimal expansion: from
+    // 1e16 on the library stores the value as 10^v (r0 = [v,1]) and the way
+    // back through the double loses the low digits — hardy(1e16+1e13) =
+    // hardy(10010000000000000) reads back as 10010000000000014, so the digit
+    // path would take 14 instead of 1e13 as the "rest" of the ordinal.
+    var rawNum = (typeof n === 'number') ? n
+      : (typeof n === 'string' ? Number(n) : null);
+    // v2.0.2: "1e10+0.5" / "1e10+11" / "1e16+1e13" — the digit path needs the
+    // exact decimal value, and Number('1e10+0.5') is NaN (the old path read 0 →
+    // hardy(0) = 10 → the [10] base).  Split the sum and add the parts exactly.
+    if (typeof n === 'string' && n.indexOf('+') > 0) {
+      var plusParts = n.split('+');
+      if (plusParts.length === 2 && plusParts[0] !== '' && plusParts[1] !== '' &&
+          !/[eE]$/.test(plusParts[0]) && !/[eE]$/.test(plusParts[1])) {
+        var pvA = new MetaNum(plusParts[0].trim());
+        var pvB = new MetaNum(plusParts[1].trim());
+        if (!pvA.isNaN() && !pvB.isNaN()) {
+          n = pvA.add(pvB);
+          rawNum = null;
+        }
+      }
+    }
+    if (rawNum !== null && !isFinite(rawNum)) rawNum = null;
     n = new MetaNum(n);
     if (n.sign !== 1) {
       throw Error(metaNumError + 'hardy: n must be a non-negative integer');
@@ -5841,9 +6209,23 @@
     //   hardy(10^^MSI) = the MetaNum limit exactly (slog(10^^MSI) = MSI).
     //   Ordinal-row / ε-layer values sit at their own Hardy position
     //   (H_{ω^β}(10) = 10{β}10) and map to themselves.
-    var num = (n.layer === 0 && n.array.length === 1) ? n.toNumber() : Infinity;
+    var num = (rawNum !== null) ? rawNum
+      : ((n.layer === 0 && n.array.length === 1) ? n.toNumber() : Infinity);
+    // r0 = [v, 1] means 10^v — the plain-number form the library uses once a
+    // value leaves the plain-integer range.  Read the decimal expansion off
+    // that mantissa/exponent pair when the double itself is unavailable
+    // (hardy("1.8e308") — beyond Number.MAX_VALUE).
+    var hStr = (rawNum === null && n.layer === 0 && n.array.length === 1)
+      ? Q._hardyDigitsOfPowForm(n.array[0]) : null;
     if (!isFinite(num)) {
       if (n.layer === 0 && n.array.length === 1) {
+        // v2.0.2: a PLAIN number that merely exceeds the double range (hardy
+        // ("1.8e308") — 1.8e308 > Number.MAX_VALUE) is not a power tower, so it
+        // must not fall into the tower branch: read its decimal expansion and
+        // keep the ordinary digit path (hardy(1.8e308) stays layer 0).
+        // (A tower 10^^k has the same shape but v ≥ 1e10, so the size guard
+        // below keeps towers on the slog branch.)
+        if (hStr === null) {
         var hVal = n.slog();
         // a clean power tower shadows to ω^ω^…^ω (k ω's); slog(10^^k) = [[k]]
         // (a plain single number — NOT the structured slog of, say, G600)
@@ -5851,20 +6233,82 @@
           var hNum = hVal.toNumber();
           if (isFinite(hNum) && hNum >= 2 && hNum <= Number.MAX_SAFE_INTEGER) {
             // k ≤ MSI: the tower fits the engine limit (f_ε₀); k > MSI is
-            // beyond ε₀ and the Hardy hierarchy is undefined there → Infinity
-            return MetaNum.TEN.epsilonate(hNum).normalize();
+            // beyond ε₀ and the Hardy hierarchy is undefined there → Infinity.
+            // The ordinal is read off the value itself: V = 10^W gives
+            // α = ω^ord(W), so the result is the ordinary cascade on the
+            // from-below base while the tower height still leaves a readable
+            // exponent (k ≤ 3 — hardy(ee10) = H_{ω^(ω^ω)}(10) = the ω^ω
+            // cascade, layer 0 like iterate(10), not a layer-2 marker).
+            // Above that the level no longer fits into ordinal rows and the
+            // value becomes a layer marker whose layer is ceil(k) - 3:
+            //   ee10 < 10^(1e10+1) < ee20 … eee10  → layer 1
+            //   eee20 … eeee10                     → layer 2, and so on
+            var r0T = n.array[0];
+            // v2.0.2 (issues): clean power towers — EVERY extra 10^ level in
+            // the input raises hardy's layer by ONE, the ordinal rows stay
+            // those of the innermost readable expansion:
+            //   hardy("1e308")   = the layer-0 digit-path cascade (…[8,6,0,3],[8,7,0,3])
+            //   hardy("e1e308")  = the same rows at layer 1
+            //   hardy("ee1e308") = the same rows at layer 2, and so on.
+            // The stored tower r0 = [v, k] is (k-1) further 10^ levels over
+            // 10^v; a layer-L input adds L more levels on top.
+            if (r0T && r0T.length === 2 && r0T[1] >= 1 &&
+                r0T[1] === Math.floor(r0T[1]) &&
+                isFinite(r0T[0]) && r0T[0] >= 10 &&
+                (r0T[1] >= 2 || r0T[0] >= 1e10)) {
+              var towerInner;
+              if (r0T[1] >= 2) {
+                // peel (k-1) levels at once: hardy = layerUp^(k-1)(hardy(10^v))
+                var towerBase = new MetaNum(0);
+                towerBase.sign = 1;
+                towerBase.layer = 0;
+                towerBase.array = [[r0T[0], 1]];
+                towerInner = Q.hardy(towerBase);      // hardy(10^v), layer 0/1
+                return Q._rawLayerMarker(towerInner.array[0],
+                  n.layer + (r0T[1] - 1) + towerInner.layer,
+                  towerInner.array.slice(1));
+              }
+              // single 10^ level over a readable exponent: hardy(10^v) =
+              // layerUp(hardy(v))
+              towerInner = Q.hardy(r0T[0]);
+              return Q._rawLayerMarker(towerInner.array[0], n.layer + 1,
+                towerInner.array.slice(1));
+            }
+            if (hNum <= 3 && r0T && r0T.length === 2 && r0T[1] === 1 &&
+                isFinite(r0T[0]) && r0T[0] >= 10) {
+              return Q._hardyLeading(r0T[0], 1, MetaNum.TEN.clone());
+            }
+            var kc = Math.ceil(hNum - 1e-9);
+            // position inside the band (kc-1, kc]: monotone in the tower height,
+            // kept just below 1 so the layer does not jump at the band edge
+            var kFrac = Math.min(Math.max(hNum - (kc - 1), 0), 0.999999);
+            if (kc <= 4) {
+              // layer 1: 10{ω^y}10 = L1 [[base],[1,y,1]] with y = ω + t, t
+              // growing with the tower height so the band stays monotone —
+              // the base is hardy's definitional from-below base, not the
+              // bare [10] marker (issues: a truncated base keeps
+              // [3086.036,9×8])
+              var tv = Math.max(1, Math.round((hNum - 3) * 1e6));
+              return Q._layerMarker(Q._hardyBaseR0(), 1, [[1, tv, 1]]);
+            }
+            // layer kc-3 ≥ 2: epsilonate(layer+1) carries the fractional tower
+            // height in its base, so the band stays monotone as well
+            // (beyond ~1e15 the fraction is not representable in the exponent)
+            return MetaNum.TEN.epsilonate(
+              kc > 1e15 ? (kc - 2) : (kc - 2 + kFrac)).normalize();
           }
         }
         // layer-0 value beyond a clean 10^^k with k ≤ MSI: finite
         // hyperoperations above tetration (G600, 3{9}3, …) or a tower taller
         // than 10^^MSI exceed the library's ε₀ ceiling → Infinity
         return new MetaNum(Infinity);
+        }
       }
       // ordinal-row / ε-layer / letter-chain values sit at their own Hardy
       // position (H_{ω^β}(10) = 10{β}10): map to themselves
-      return n.clone().normalize();
+      if (hStr === null) return n.clone().normalize();
     }
-    var s = String(num);
+    var s = (hStr !== null) ? hStr : String(num);
     // > 1e20 arrives in scientific notation ('1e+21') — expand to the exact
     // decimal digits so the digit-reading stays monotone (issues.md v2.1:
     // hardy must support > 1e15 inputs)
@@ -5874,6 +6318,17 @@
       var eZeros = Number(eMatch[3]) - eFrac.length;
       if (eZeros > 0) s = eMatch[1] + eFrac + '0'.repeat(eZeros);
     }
+    // v2.0.2: fractional argument.  The ordinal is read from the INTEGER part's
+    // digits while the base argument becomes 10+f, so H stays continuous in n:
+    //   hardy(10.38)  = H_ω(10.38)    = 10.38·2      = 20.76
+    //   hardy(100.1)  = H_{ω²}(10.1)  = 10.1·2^10.1  = 11084.709858935355
+    var hFrac = 0;
+    var hDot = s.indexOf('.');
+    if (hDot >= 0) {
+      hFrac = Number('0.' + s.slice(hDot + 1));
+      s = s.slice(0, hDot);
+    }
+    var hArg = hFrac > 0 ? new MetaNum(10 + hFrac) : MetaNum.TEN.clone();
     if (s.length >= 11) {
       // n ≥ 1e10 (issues.md v2.0): the ordinal is built per definition, then
       // evaluated from below on the engine's own representation:
@@ -5894,41 +6349,62 @@
       var kExp = s.length - 1;
       var dk = s.charCodeAt(0) - 48;
       var restNum = Number(s.slice(1));
-      var n1 = MetaNum.TEN.clone();
-      if (restNum > 0) n1 = Q.hardy(restNum);
-      // from-below base: H_{ω^n1}(n1) — exact for small finite n1, one
-      // ω-diagonal row (engine convention) for huge n1
-      var base;
-      var n1Num = (n1.array.length === 1 && n1.layer === 0) ? n1.toNumber() : Infinity;
-      if (isFinite(n1Num) && n1Num === Math.floor(n1Num) && n1Num >= 2 && n1Num <= 100) {
-        var ec = [];
-        for (var zi = 0; zi < n1Num; zi++) ec.push(0);
-        ec.push(1);
-        base = Q._hardyH(ec, n1);
-      } else {
-        base = Q._applyOrdinalRows(n1, [0, 1], 1);
-      }
+      var n1 = hArg.clone();
+      // the fractional part flows into the rest part too: hardy("1e10+1.5")
+      // = H_{ω^10}(hardy(1.5)) = H_{ω^10}(11.5) — dropping the fraction here
+      // made every 1e10+k.f input behave like 1e10+k
+      if (restNum > 0) n1 = Q.hardy(restNum + hFrac);
+      return Q._hardyLeading(kExp, dk, n1);
+    }
+    if (num < 10) return new MetaNum(10 + num);
+    var coeffs = [];
+    for (var i = s.length - 1; i >= 0; i--) coeffs.push(s.charCodeAt(i) - 48);
+    return Q._hardyH(coeffs, hArg);
+  };
+
+  // The leading term ω^ord(kExp)·dk of hardy's ordinal, evaluated from below
+  // on the already-computed lower part n1 = H_ord(rest)(10).
+  Q._hardyLeading = function (kExp, dk, n1) {
+      // a plain operand still has a single plain number as its whole array[0]
+      var nPlain = (n1.layer === 0 && n1.array.length === 1 && n1.array[0].length === 1);
+      var n1Num = nPlain ? n1.toNumber() : Infinity;
       if (kExp === 10) {
-        return Q._applyOrdinalRows(base, [0, 1], dk - 1).normalize();
-      }
-      // kExp ≥ 11 (ord = ω+c): mirror the engine's own ordinal rows for
-      // 10{ω+c}(9+dk) onto the from-below base — hardy(1e11) keeps
-      // expande(10,10)'s row structure with the strictly smaller
-      // definitional base, so hardy(1e11) < 10{ω+1}10 (issues.md)
+        // H_{ω^ω·dk}(n1): the first ω^ω-segment is H_{ω^n1}(n1) (from below),
+        // every further one adds one ω-row
+        return Q._hardyKeepBase(
+          Q._applyOrdinalRows(Q._hardyOmegaPower(n1), [0, 1], dk - 1)).normalize();
+      }
+      // kExp ≥ 11 (ord = ω+c): β = ord(kExp) and the leading term ω^β·dk is dk
+      // APPLICATIONS of H_{ω^β}, one after the other on the running value:
+      //   hardy(1.1e11) = H_{ω^(ω+1)+ω^ω}(10) = H_{ω^(ω+1)}(H_{ω^ω}(10))
+      //                 = [3086.036,9×8] [1,1,1]          (one row per application)
+      //   hardy(2e11)   = H_{ω^(ω+1)·2}(10) = H_{ω^(ω+1)}(H_{ω^(ω+1)}(10))
+      //                 = [3086.036,9×8] [8,0,1] [1,1,1]
+      //   hardy(1e16+1e13) = H_{ω^(ω+6)}(H_{ω^(ω+3)}(10)) → … [1,6,1]
+      // so an application is a row [1, β] — never a bump of the ω-row count
+      // ([9,0,1] / [16,0,1] conflated dk with the rest-part).  The FIRST
+      // application on a plain operand is still expanded from below: the base
+      // H_{ω^n1}(n1) plus the cascade of 10{β}10 (hardy(1e11) = [3086.036,9×8]
+      // [8,0,1], strictly below 10{ω+1}10 — issues.md).
       var ks = String(kExp);
       var ordCoeffs = [];
       for (var oi = ks.length - 1; oi >= 0; oi--) ordCoeffs.push(ks.charCodeAt(oi) - 48);
-      var mir = Q._hyperopFromOrdinalRaw(MetaNum.TEN.clone(), new MetaNum(9 + dk), ordCoeffs);
-      var out = base.clone();
-      for (var ri = 1; ri < mir.array.length; ri++) {
-        out = Q._applyOrdinalRows(out, mir.array[ri].slice(1), mir.array[ri][0]);
+      var out, extra;
+      if (nPlain && isFinite(n1Num) && n1Num >= 2) {
+        out = Q._hardyOmegaPower(n1);
+        var mir = Q._hyperopFromOrdinalRaw(MetaNum.TEN.clone(), MetaNum.TEN.clone(), ordCoeffs);
+        for (var ri = 1; ri < mir.array.length; ri++) {
+          out = Q._applyOrdinalRows(out, mir.array[ri].slice(1), mir.array[ri][0]);
+        }
+        extra = dk - 1;
+      } else {
+        // structured operand: H_{ω^β} has no room left to expand into, so each
+        // application is one more row [1, β]
+        out = n1.clone();
+        extra = dk;
       }
-      return out.normalize();
-    }
-    if (num < 10) return new MetaNum(10 + num);
-    var coeffs = [];
-    for (var i = s.length - 1; i >= 0; i--) coeffs.push(s.charCodeAt(i) - 48);
-    return Q._hardyH(coeffs, MetaNum.TEN.clone());
+      if (extra > 0) out = Q._applyOrdinalRows(out, ordCoeffs, extra);
+      return Q._hardyKeepBase(out).normalize();
   };
 
   // ==================== BEAF Array Notation ====================
@@ -6118,7 +6594,12 @@
       }
 
       var temp;
+      // Public primitive input: a numeric literal / decimal string in (0,1) or
+      // (-1,0) is stored as the reciprocal with sign 2 / -2.  Array/object input
+      // (engine internals, JSON, parsers) is left exactly as given.
+      var publicInput = false;
       if (typeof input === "number" && input2 === undefined) {
+        publicInput = true;
         temp = objectCreate();
         temp.array = [[Math.abs(input)]];
         temp.sign = input < 0 ? -1 : 1;
@@ -6128,6 +6609,7 @@
       } else if (parsedObject) {
         temp = Q.fromObject(parsedObject);
       } else if (typeof input === "string") {
+        publicInput = true;
         temp = Q.fromString(input);
       } else if (Array.isArray(input)) {
         temp = Q.fromArray(input, input2, input3);
@@ -6136,6 +6618,7 @@
       } else if (typeof input === "object" && input !== null) {
         temp = Q.fromObject(input);
       } else {
+        publicInput = true;
         temp = objectCreate();
         var num = Number(input);
         if (!isNaN(num) && isFinite(num)) {
@@ -6151,6 +6634,7 @@
           temp.sign = num < 0 ? -1 : 1;
         }
       }
+      if (publicInput) canonicalizeSubUnit(temp);
 
       x.array = deepCloneArray(temp.array);
       x.sign = temp.sign;
@@ -6330,6 +6814,63 @@
 
   MetaNum = clone(MetaNum);
   MetaNum = defineConstants(MetaNum);
+
+  // Sub-unit canonical form: run the engine's structural CONSUMERS with it off.
+  // These functions read r0 as a plain magnitude and chain through log10/exp
+  // (whose results are now canonicalized when a user calls them directly), so
+  // without this they saw reciprocals where they expected values — gamma(0.5)
+  // read r0 [2] as 2, slog computed from a 3.32 instead of 0.301, and
+  // layeradd/pentate_log returned garbage.  The PRODUCERS (constructor with a
+  // primitive, add/sub/mul/div, log10, ln, exp, root, neg) stay canonicalized,
+  // so MetaNum(0.5).sign === 2 and arithmetic results in (0,1) carry sign 2.
+  (function () {
+    var rawConsumers = [
+      'gamma', 'lambertw', 'slog', 'layeradd', 'layeradd10',
+      'pentate', 'pentate_log', 'pentate_root', 'ssrt', 'linear_sroot',
+      'hyper_log', 'hyper_root', 'tetrate', 'expande', 'explode',
+      'expandainate', 'expoiter', 'slayer', 'fastest_hypergrow',
+      'logBase', 'mod', 'arrow'
+    ];
+    for (var ri = 0; ri < rawConsumers.length; ri++) {
+      var name = rawConsumers[ri];
+      var fn = P[name];
+      if (typeof fn !== 'function') continue;
+      P[name] = (function (orig) {
+        return function () {
+          _skipCanon++;
+          var out;
+          try { out = orig.apply(this, arguments); }
+          finally { _skipCanon--; }
+          // The hyper-op builders (arrow, tetrate, expande, …) return a
+          // CLOSURE that carries out the real computation — the guard is gone
+          // by then, so the chain ran canonicalized and drifted by an ULP
+          // (4{25}4 → 153.906997547968 instead of …802).  Re-arm around it.
+          if (typeof out === 'function') {
+            return function () {
+              _skipCanon++;
+              try { return out.apply(this, arguments); }
+              finally { _skipCanon--; }
+            };
+          }
+          return out;
+        };
+      })(fn);
+    }
+    // Q-level entry points that drive the same structural machinery
+    var rawStatics = ['BEAF', '_beafRecursive', 'arrow', 'beaf'];
+    for (var si = 0; si < rawStatics.length; si++) {
+      var sfn = Q[rawStatics[si]];
+      if (typeof sfn !== 'function') continue;
+      Q[rawStatics[si]] = (function (orig) {
+        return function () {
+          _skipCanon++;
+          try { return orig.apply(this, arguments); }
+          finally { _skipCanon--; }
+        };
+      })(sfn);
+    }
+  })();
+
   MetaNum['default'] = MetaNum.MetaNum = MetaNum;
 
   if (typeof define == 'function' && define.amd) {