metanum 1.4.0 → 2.0.1

package/metanum.js

@@ -1,14 +1,13 @@
-//Author: dlsdl v1.4
-//Support hyper operation >MSI and fix format-metanum bugs
+//Author: dlsdl v2.0
+//v2.0: Add hyper-root & hyper-log, hardy function, fractional hyperoperation inputs, fix BEAF operation level and format
 //Code snippets and templates from OmegaNum.js
 
 ;(function (globalScope) {
   "use strict";
 
   var MetaNum = {
-    maxRows: 100,
-    maxCols: 100,
-    maxArrow: Number.MAX_SAFE_INTEGER,
+    maxRows: 20,
+    maxCols: 20,
     serializeMode: 0,
     debug: 0
   },
@@ -43,13 +42,14 @@
   R.NaN = NaN;
   R.POSITIVE_INFINITY = Infinity;
   R.NEGATIVE_INFINITY = -Infinity;
+  R.infinity = Infinity;              // alias of POSITIVE_INFINITY
   R.E_MAX_SAFE_INTEGER = "E" + MAX_SAFE_INTEGER;
   R.EE_MAX_SAFE_INTEGER = "EE" + MAX_SAFE_INTEGER;
   R.TETRATED_MAX_SAFE_INTEGER = "F" + MAX_SAFE_INTEGER;
   R.PENTATED_MAX_SAFE_INTEGER = "G" + MAX_SAFE_INTEGER;
   R.TRITRI = "[[3638334640023.7783, 7625597484984]]";
   R.GRAHAMS_NUMBER = "[[3638334640023.7783,7625597484984,0,1],[63,0,1]]";
-  R.TERR3 = "[[10],[1,374389,2],[1,374387,2],[1,374385,2],[1,374383,2],[1,374381,2],[1,374379,2],[1,374377,2],[1,374375,2],[1,374373,2],[1,374371,2]]"; //https://www.bilibili.com/video/BV1X94y1n7D1
+  R.TERR3 = "[[10],[1,374389,2],[1,374387,2],[1,374385,2],[1,374383,2],[1,374381,2],[1,374379,2],[1,374377,2],[1,374375,2],[1,374373,2],[1,374371,2]]";
   R.QqQe308 = "QqQe308";
 
   function cmpArr(a, b) {
@@ -352,12 +352,40 @@
       }
 
       if (x.array.length > MetaNum.maxRows) {
-        x.array = x.array.slice(x.array.length - MetaNum.maxRows);
+        // Truncation keeps the base row and the largest maxRows-1 ordinal rows;
+        // only the smallest ordinal rows are sacrificed.  The transient
+        // _ordTrunc flag lets the hyperoperation entry points detect the
+        // overflow and apply the issues.md truncation marker (array[1][0]+1,
+        // array[0] = [10]) — clone() does not copy it.
+        x._ordTrunc = true;
+        x.array = [x.array[0]].concat(x.array.slice(x.array.length - (MetaNum.maxRows - 1)));
         b = true;
       }
 
+      // r0 wider than maxCols: convert the overflow levels (>= maxCols) into
+      // finite-level ordinal rows [count, level] instead of dropping them.
+      // Deferred until the r0 cascade has settled so that high-level counts
+      // can still decompose into lower levels (e.g. "Z10" must fully expand
+      // into its level chain before levels >= maxCols freeze into rows).
+      if (r0.length > MetaNum.maxCols && !b) {
+        var r0Settled = !(r0[0] > MAX_SAFE_INTEGER)
+          && !(r0[1] && r0[0] < MAX_E)
+          && !(!r0[1] && r0.length > 2);
+        if (r0Settled) {
+          var pushedOverflow = false;
+          for (var ov = MetaNum.maxCols; ov < r0.length; ov++) {
+            if (r0[ov] > 0) {
+              x.array.push([r0[ov], ov]);
+              r0[ov] = 0;
+              pushedOverflow = true;
+            }
+          }
+          if (pushedOverflow) b = true;
+        }
+      }
+
       for (var i = 0; i < x.array.length; i++) {
-        if (x.array[i].length > MetaNum.maxCols) {
+        if (i > 0 && x.array[i].length > MetaNum.maxCols) {
           x.array[i] = x.array[i].slice(0, MetaNum.maxCols);
           b = true;
         }
@@ -773,14 +801,6 @@
            x.array[0].length === 1 && isFinite(x.array[0][0]);
   }
 
-  function computeLayer(arr) {
-    // Layer represents ω^ nesting level above the ordinal represented by the array.
-    // For all normal ordinal operations (up to ω^(maxcols-1) level), layer is 0.
-    // Layer 1 = ω^(array ordinal), layer 2 = ω^ω^(array ordinal), etc.
-    // Layer is managed explicitly by layerUp/layerDown, not computed from array.
-    return 0;
-  }
-
   function toNormalizedSign(s) {
     // Map sign=2/-2 to the corresponding normal sign for the array data
     return s === 2 ? 1 : s === -2 ? -1 : s;
@@ -794,7 +814,15 @@
     return new MetaNum([arr]);
   }
 
+  // Threshold values 10{n}val depend only on (n, val) and are only ever used
+  // in read-only comparisons — cache them: rebuilding an r0 of length n+1 on
+  // every arrow call cost ~1.8ms each (several per call, ~70% of the
+  // structured fast path).
+  var hyperLevelSafeCache = {};
   function hyperLevelSafe(n, val) {
+    var key = n + "|" + val;
+    var cached = hyperLevelSafeCache[key];
+    if (cached) return cached;
     var arr = new Array(n + 1);
     for (var i = 0; i <= n; i++) arr[i] = 0;
     arr[0] = val;
@@ -803,6 +831,7 @@
     MetaNum.maxCols = Math.max(oldMaxCols, n + 1);
     var r = new MetaNum([arr]);
     MetaNum.maxCols = oldMaxCols;
+    if (n >= 0 && n <= 100000) hyperLevelSafeCache[key] = r;
     return r;
   }
 
@@ -832,7 +861,6 @@
   // numbers (e.g. 10^16 stored as [[16,1]]) instead of Infinity. This is used
   // by hyperoperation functions (expande/multiexpande/powerexpande) to compute
   // iteration counts `count = y - 2` when y is a large-but-finite MetaNum.
-  //
   // toNumber() returns Infinity whenever r0.length > 1 (E-notation) or the
   // array has ordinal rows, which is too conservative for count extraction:
   // 10^16 is a perfectly finite JS number. We only return Infinity for genuine
@@ -868,6 +896,11 @@
     if (x.isInfinite()) return x;
     if (other.isInfinite()) return other;
 
+    // Layer swallowing: an ω-tower plus a layer-0 value is the tower; two
+    // towers keep the larger one (ordinal addition, same layer).
+    var domAdd = layerDominant(x, other);
+    if (domAdd !== null) return domAdd.clone().normalize();
+
     // For simple numbers, use direct numeric addition
     if (isSimple(x) && isSimple(other)) {
       var directSum = x.toNumber() + other.toNumber();
@@ -973,6 +1006,11 @@
 
     if (x.max(other).gt(MetaNum.EE_MAX_SAFE_INTEGER)) return x.max(other);
 
+    // Layer swallowing: multiplying a tower (layer≥1) by any layer-0 value
+    // leaves the tower unchanged; two towers keep the larger one.
+    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];
@@ -1795,11 +1833,243 @@
     return new MetaNum(x).pentate_root(height);
   };
   
+  // Layer swallowing (README representation L17): a layer≥1 value is a
+  // 10{ω^ω^…}10 tower and dominates every operation with a layer-0 operand
+  // — the result keeps the tower's layer. Returns the dominating MetaNum,
+  // or null when both operands carry the same layer>0.
+  function layerDominant(a, b) {
+    if (a.layer > 0 && b.layer === 0) return a;
+    if (b.layer > 0 && a.layer === 0) return b;
+    if (a.layer > b.layer) return a;
+    if (b.layer > a.layer) return b;
+    return null;
+  }
+
+  // Fast construction of the diagonal chain D(L) = t{L}t for a plain finite
+  // integer base t. The generic successor-rule recursion recomputes the whole
+  // chain at every level (each level re-invokes t{n-1}(t)), which is ~O(n^3)
+  // for plain diagonals (3{99}3 at maxCols=100 took ~5.5s). Unrolling rule 2
+  // once builds the identical normalized array bottom-up:
+  //   D(1) = t{1}t ; D(n+1) = t{n}^{t-1}(t) = t{n}^{t-2}(D(n))
+  // Each t{n}(D(n)) step is the engine's own structured-value fast path, so
+  // the result is array-identical to the recursive evaluation, in O(L^2).
+  function canFastDiagonal(t) {
+    if (t.layer !== 0 || t.array.length !== 1) return false;
+    var n = t.toNumber();
+    if (!isFinite(n) || n < 1 || Math.floor(n) !== n) return false;
+    return (n - 2) <= 1000;
+  }
+  function diagonalChain(t, L) {
+    var repeat = Math.max(Math.floor(t.toNumber()) - 2, 0);
+    var r = t.pow(t); // D(1) = t{1}t
+    for (var n = 1; n < L; n++) {
+      // D(n+1) = t{n}^{repeat}(D(n)) with repeat = t-2.
+      // n=1,2 keep pow/tetr (their own structuralization). For n>=3 every
+      // step is the engine's structured-value fast path verbatim
+      // (0 + D(n), then one count at column n, normalize) — do it directly
+      // instead of re-entering arrow() (whose threshold guards cost ~7ms).
+      for (var k = 0; k < repeat; k++) {
+        if (n >= 3) {
+          var j = MetaNum.ZERO.add(r);
+          if (j.array.length === 1) {
+            while (j.array[0].length <= n) j.array[0].push(0);
+            j.array[0][n] = (j.array[0][n] || 0) + 1;
+          }
+          j.normalize();
+          r = j;
+        } else {
+          r = t.arrow(n)(r);
+        }
+      }
+    }
+    return r;
+  }
+
+  // Convert a structured raw-application COUNT C at finite operation level n
+  // ({n}^C(10)) to the dlsdl Aa-band smooth argument α (v = 10{n+2}(α)),
+  // α ∈ [2,10). A count given canonically as 10{k}(t), t∈[1,10]:
+  //   t = 10 rewrites exactly to α-anchor 2 one level up (10{k}10=10{k+1}2);
+  //   each further level promotion is the geometric smooth-log step
+  //   f → 1 + log10(f) (the same step the low-level polarize produces).
+  // Matches dlsdl rule (iii)-(v): {99}^{10{93}10}(10) = 10{101}(2.001607…).
+  // Raw application COUNT C at operation level n ({n}^C(10)) -> the dlsdl
+  // diagonal-letter smooth argument α in [2,10) with v = 10{n+2}(α).
+  // Start from C=10{level}(t) (polarize: a scalar C starts at level 1 with
+  // t=log10(C)), then each level promotion is the geometric smooth-log step
+  // t → 1+log10(t) (exact t=10 rewrites to the α-anchor 2). The final value
+  // lands in [1,2); the diagonal mantissa is α=1+t (2 at the anchor).
+  function countToDiagonalAlpha(C, n, r0OfC, rowsOfC) {
+    var t, level;
+    if (r0OfC === undefined || r0OfC === null) {
+      t = Math.log10(C); level = 1;
+    } else {
+      // Truncation marker normalization: when rows overflowed the budget the
+      // base was reset to [10] and the LOWEST kept finite row got +1 over the
+      // uniform per-level fill (xCnt). That +1 marks the dropped cascade —
+      // read it as the same count as the next kept row so the count climb
+      // matches the untruncated anchor across configs.
+      var pr0 = r0OfC.slice();
+      var prows = rowsOfC ? rowsOfC.slice() : [];
+      if (pr0[0] === 10 && prows.length > 0) {
+        var li = 0;
+        for (var pi = 1; pi < prows.length; pi++) {
+          if (prows[pi][1] < prows[li][1]) li = pi;
+        }
+        var sortedLv = prows.slice().sort(function (a, b) { return a[1] - b[1]; });
+        var c0v = sortedLv[0][0] || 0;
+        var c1v = sortedLv.length > 1 ? (sortedLv[1][0] || 0) : 0;
+        if (c0v === c1v + 1) {
+          prows[li] = [c1v, prows[li][1]];
+          pr0[0] = 10000000000;
+        }
+      }
+      var pol = polarizeLike(pr0, prows);
+      if (!pol) return null;
+      t = Math.log10(pol.bottom) + pol.repeation;
+      level = pol.arrows + 1; // C = 10{level}(t)
+    }
+    while (level < n + 2) {
+      t = (t >= 9.999999999) ? 2 : 1 + Math.log10(t);
+      level++;
+      if (!(t > 0)) return null;
+    }
+    if (t >= 9.999999999) t = 2;
+    return t < 2 ? 1 + t : (t > 10 ? 10 : t);
+  }
+
+  // Minimal local structural polarize (faithful port of format-metanum's
+  // refPolarize) so the engine need not import the formatter: returns
+  // {bottom, repeation, arrows} for an r0 + finite [count,level] rows chain,
+  // i.e. the value behaves as 10{arrows+1}(log10(bottom)+repeation).
+  function polarizeLike(r0, finiteRows) {
+    var array = [r0[0]];
+    for (var i = 1; i < r0.length; i++) if ((r0[i] || 0) > 0) array.push([i, r0[i], 1, 1]);
+    if (finiteRows) for (i = 0; i < finiteRows.length; i++) {
+      var fr0 = finiteRows[i];
+      if (fr0 && fr0.length === 2 && (fr0[0] || 0) > 0) array.push([fr0[1], fr0[0], 1, 1]);
+    }
+    function arraySort() {
+      array.sort(function (a, b) {
+        if (typeof a == 'number') return
+        else if (a[3] > b[3]) return -1
+        else if (a[3] < b[3]) return 1
+        else if (a[2] == 'x' && b[2] != 'x') return -1
+        else if (a[2] != 'x' && b[2] == 'x') return 1
+        else if (a[2] == 'x' && b[2] == 'x') return -1
+        else if (a[2] > b[2]) return -1
+        else if (a[2] < b[2]) return 1
+        else if (a[0] == 'x' && b[0] != 'x') return -1
+        else if (a[0] != 'x' && b[0] == 'x') return 1
+        else if (a[0] == 'x' && b[0] == 'x') return -1
+        else if (a[0] > b[0]) return -1
+        else if (a[0] < b[0]) return 1
+        else if (a[1] > b[1]) return -1
+        else if (a[1] < b[1]) return 1
+        return -1
+      });
+    }
+    function arrayMerge() {
+      var elemOffset = 0;
+      for (var mi = 0; mi < array.length - 2; ++mi) {
+        if (array[mi][0] == array[mi + 1][0] &&
+            array[mi][2] == array[mi + 1][2] && array[mi][3] == array[mi + 1][3]) {
+          array[mi][1] += array[mi + 1][1]
+          array.splice(mi + 1, 1)
+          --mi
+          elemOffset++
+        }
+      }
+      return elemOffset
+    }
+    arraySort(); arrayMerge();
+    var ptr = array.length - 2
+    var b = function () { return array[array.length - 1] }
+    var c = function (x) { array[array.length - 1] = x }
+    var repeatResult = 500000
+    while (--repeatResult >= 0) {
+      if (b() >= 10) {
+        var a = Math.log10(b())
+        array.push([1, 1, 1, 1]); ptr++; arraySort()
+        var offset = arrayMerge(); ptr -= offset; c(a)
+      } else {
+        if (ptr == 0 && typeof array[ptr + 1] == 'number') break
+        if (ptr != 0 && typeof array[ptr + 1] == 'number' && typeof array[ptr][0] == 'number' &&
+          array[ptr][1] == 1 &&
+          (array[ptr - 1][0] == 'x' || array[ptr - 1][2] > array[ptr][2] || array[ptr - 1][3] > array[ptr][3]) &&
+          array[ptr][0] > 2 && (ptr != 0 || array[ptr - 1][0] == 'x')) {
+          var arrow_count = array[ptr][0]
+          var base = b()
+          var Jx = arrow_count == 3 ? base : arrow_count - 1 + Math.log(base / 2) / Math.log(5)
+          array[ptr][0] = 'x'
+          c(Jx); arraySort(); var off2 = arrayMerge(); ptr -= off2
+        }
+        if (typeof array[ptr + 1] == 'number' && array[ptr][0] == 'x' && b() < 10 && ptr != 0) {
+          var base2 = b()
+          var JRepeation = array[ptr][1]
+          var Kx = JRepeation + Math.log10(base2)
+          array[ptr][1] = 1
+          array[ptr][0] = 1
+          array[ptr][2]++
+          c(Kx); arraySort(); var off3 = arrayMerge(); ptr -= off3
+        }
+        if (((ptr == 0) || ptr != 0) && array[ptr][0] != 'x' && b() < 10) {
+          if (b() == 1 && ptr > 0 && array[ptr - 1][0] > array[ptr][0] && array[ptr][1] == 1) {
+            array[ptr][0] = array[ptr - 1][0]
+          } else {
+            var right = array[ptr][1] + Math.log10(b())
+            array[ptr][0]++
+            array[ptr][1] = 1
+            c(right)
+          }
+          arraySort(); var off4 = arrayMerge(); ptr -= off4
+        }
+      }
+    }
+    if (typeof array[ptr][0] !== 'number' || !isFinite(b())) return null;
+    return { bottom: b(), repeation: array[ptr][1], arrows: array[ptr][0] };
+  }
+
+  // Canonical compact form of the smooth diagonal value 10{L}(α) with a
+  // NUMERIC α in [1,10): r0=[1] plus one finite row [α, L-1]. The fractional
+  // row count survives normalization (only r0 integer columns are floored)
+  // and polarize climbs it straight back to t=α at level L-1, so the smooth
+  // mantissa is preserved at arbitrary finite levels (used where the iterated
+  // arrow loop would MSI-dump the fraction away).
+  function compactSmoothValue(L, alpha) {
+    var m = new MetaNum({ sign: 1, layer: 0, array: [[1], [alpha, L - 1]] });
+    return m.normalize();
+  }
+
   // region >=ω level operations
   P.arrow = function (arrows) {
     var t = this.clone();
     arrows = new MetaNum(arrows);
-    if (!arrows.isint() || arrows.sign === -1 || arrows.sign === -2) return function () { return MetaNum.NaN.clone(); };
+    if (arrows.sign === -1 || arrows.sign === -2) return function () { return MetaNum.NaN.clone(); };
+    if (!arrows.isint()) {
+      // Fractional hyperoperation level.
+      // Geometric interpolation per README rule (i): level n+f acts as the (n+1)-level
+      // op on a geometrically interpolated argument — for the canonical
+      // diagonal 10{n+f}10 = 10{n+1}(2·5^f). General anchors: θ0 satisfies
+      // x{n+1}θ0 = x{n}y (recovered via hyper_log), θ1 = y, θf = θ0·(y/θ0)^f,
+      // so x{n+f}y = x{n+1}(θf), continuous in f with
+      // x{n}y at f=0 and x{n+1}y at f=1.
+      if (arrows.gte(MetaNum.ONE)) {
+        var nLev = arrows.floor();
+        var frac = arrows.sub(nLev);
+        var self = t;
+        return function (other) {
+          other = new MetaNum(other);
+          if (other.eq(MetaNum.ZERO)) return MetaNum.ONE.clone();
+          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 theta = theta0.mul(other.div(theta0).pow(frac));
+          return self.arrow(nLev.add(MetaNum.ONE))(theta);
+        };
+      }
+      return function () { return MetaNum.NaN.clone(); };
+    }
     if (arrows.eq(MetaNum.ZERO)) return function (other) { return t.mul(other); };
     if (arrows.eq(MetaNum.ONE)) return function (other) { return t.pow(other); };
     if (arrows.eq(2)) return function (other) { return t.tetr(other); };
@@ -1808,7 +2078,25 @@
       if (other.sign === -1 || other.sign === -2) return MetaNum.NaN.clone();
       if (other.eq(MetaNum.ZERO)) return MetaNum.ONE.clone();
       if (other.eq(MetaNum.ONE)) return t.clone();
-      if (other.eq(2)) return t.arrow(arrows.sub(MetaNum.ONE))(t);
+      if (other.eq(2)) {
+        var diagArrowsNum = arrows.toNumber();
+        // Only build directly when the whole diagonal fits r0; at/above
+        // maxCols the value must go through the truncating branch below
+        // (base [10] + first-kept row count +1), reached via the ordinary
+        // t{L-1}t call which itself reuses the fast diagonal for its tail.
+        if (isFinite(diagArrowsNum) && diagArrowsNum >= 2 &&
+            diagArrowsNum <= MetaNum.maxCols && canFastDiagonal(t)) {
+          return diagonalChain(t, diagArrowsNum - 1);
+        }
+        return t.arrow(arrows.sub(MetaNum.ONE))(t);
+      }
+      // Layer swallowing: any ω-tower operand (layer≥1) dominates a layer-0
+      // operand under every (finite or ordinal) hyperoperation; equal layers
+      // take the supremum (higher ordinal rows win). The layer itself is the
+      // ω^-tower height and must survive unchanged.
+      var dom = layerDominant(t, other);
+      if (dom !== null) return dom.clone().normalize();
+      if (t.layer > 0) return t.max(other).normalize();
       var arrowsNum = arrows.toNumber();
       if (!isFinite(arrowsNum)) {
         // arrows is a huge MetaNum (ω-level): result inherits the largest structure
@@ -1817,17 +2105,45 @@
         j.normalize();
         return j;
       }
-      if (arrows.gte(MetaNum.maxArrow)) {
+      if (arrows.gte(Number.MAX_SAFE_INTEGER)) {
         // arrows is very large but still a JS number; use approximate overflow
         var j = t.max(other).max(arrows).clone();
         j.array.push([1, 0, 1]);
         j.normalize();
         return j;
       }
+      // Fractional argument exactly at the boundary level (L == maxCols):
+      // 10{L}(α) with numeric α in (1,10) carries the smooth diagonal
+      // mantissa directly (compact form). Levels beyond maxCols with a
+      // numeric argument keep the structural integer cascade below.
+      var yNumPre = other.toNumber();
+      var boundaryFractional = isFinite(yNumPre) && yNumPre !== Math.floor(yNumPre);
+      if (arrowsNum === MetaNum.maxCols && boundaryFractional) {
+        return compactSmoothValue(arrowsNum, yNumPre);
+      }
+      // Structured finite argument at/below the boundary level
+      // (e.g. 10{L}(10{k}10)): convert the raw application count to the
+      // dlsdl smooth diagonal argument α and return 10{L+1}(α).
+      var otherFiniteChain = other.layer === 0 &&
+        other.array.slice(1).every(function (rr) { return rr.length === 2; });
+      var otherHasChain = other.array[0].length >= 2 || other.array.length >= 2;
+      if (arrowsNum >= MetaNum.maxCols &&
+          otherFiniteChain && otherHasChain && !isFinite(yNumPre) &&
+          t.layer === 0 && t.array.length === 1) {
+        var alphaC = countToDiagonalAlpha(null, arrowsNum - 1,
+                                          other.array[0], other.array.slice(1));
+        if (alphaC !== null && alphaC >= 2) return compactSmoothValue(arrowsNum + 1, alphaC);
+      }
       if (arrowsNum >= MetaNum.maxCols) {
-        // Compact ordinal-row representation: 10{1000}10 → [[10],[1,1000]].
-        // One [1|arrowsNum] row on top of the larger operand; finite arrow
-        // levels beyond r0 capacity no longer expand into a cascade of rows.
+        // Finite arrow level beyond r0 capacity:
+        // expand the level chain exactly as far as the array budget allows —
+        //   r0 filled to maxCols (levels 1..maxCols-1, the top one being the
+        //   anchor level L-1 col) + [count, level] rows for levels
+        //   maxCols..L-1 (maxRows-1 rows max; the top level L itself is the
+        //   10{L}2 = 10{L-1}10 anchor and takes no row) —
+        // and approximate beyond the budget: keep the LARGEST maxRows-1
+        // ordinal rows, the ARRAY's second row (first-kept ordinal row) first column +1,
+        // first row [10].
         // Swallowing: a finite level sits below any existing ω-level row.
         var j = t.max(other).clone();
         if (j.layer > 0) return j; // ω^ω-tower swallows any finite level
@@ -1836,23 +2152,124 @@
           var row = j.array[i];
           if (row && row.length >= 2 && (row[0] || 0) > 0) { idx = i; break; }
         }
-        if (idx < 0) {
-          j.array.push([1, arrowsNum]);
+        // value below already carries an ordinal row: merge or swallow
+        if (idx >= 0) {
+          var belowRow = j.array[idx];
+          var belowIsTower = belowRow.length >= 3;
+          var belowLevel = belowIsTower ? Infinity : belowRow[1];
+          if (belowIsTower || belowLevel > arrowsNum) { j.normalize(); return j; }
+          if (belowLevel === arrowsNum) {
+            belowRow[0] = Math.min((belowRow[0] || 0) + 1, MAX_SAFE_INTEGER);
+            j.normalize();
+            return j;
+          }
+          // belowLevel < arrowsNum: stack rows on top of the existing chain
+          var rowBudgetA = MetaNum.maxRows - 1;
+          var startA = Math.max(MetaNum.maxCols, belowLevel + 1);
+          var endA = arrowsNum - 1;
+          if (endA - startA + 1 <= rowBudgetA) {
+            for (var la = startA; la <= endA; la++) j.array.push([1, la]);
+          } else {
+            var keptFromA = endA - rowBudgetA + 1;
+            for (var lb = keptFromA; lb <= endA; lb++) {
+              var cntA = (lb === endA) ? yCnt : xCnt;
+              if (lb === keptFromA) cntA += 1;
+              j.array.push([cntA, lb]);
+            }
+            j.array[0] = [10];
+          }
+          j.normalize();
+          return j;
+        }
+        // plain finite base: expand the diagonal chain bottom-up.
+        // Exact law (matches the engine's own low-level path and the
+        // reference): x{L}y = x{L-1}^{y-2}(x{L-1}x), so the top level L-1
+        // carries (y-2) ops and every level below — the x{L-1}x tail —
+        // carries (x-2) ops:
+        //   3{9}3 → 1 op/level, 4{9}4 → 2, 10{25}10 → 8 ops/level (the
+        //   canonical all-8s form). The top level L itself is the
+        //   10{L}2 = 10{L-1}10 anchor and takes no row.
+        var subDepth = MetaNum.maxCols - 1;
+        var xBase = t.toNumber();
+        var yBase = other.toNumber();
+        var xCnt = isFinite(xBase) ? Math.min(Math.max(xBase - 2, 0), MAX_SAFE_INTEGER) : MAX_SAFE_INTEGER;
+        // Top-of-chain count: x{L}y = x{L-1}^{y-1}(x), so every level below the
+        // top carries (x-2) ops while level L-1 carries (y-2) ops for y>=3
+        // (the y=2 anchor x{L}2=x{L-1}x carries x-2 there). This makes
+        // 10{100}11 = 10{99}(10{100}10) exact (col 99 = 9, not 8).
+        var topCnt;
+        if (!isFinite(yBase)) topCnt = MAX_SAFE_INTEGER;
+        else if (yBase <= 2) topCnt = xCnt;
+        else topCnt = Math.min(Math.max(yBase - 2, 1), MAX_SAFE_INTEGER);
+        // Base-2 with y≥3: 2{L-1}(2{L}2)=2{L-1}4 expands like a base-10 tail
+        // (8 ops per level), with the fixed law level L-2 = 2 ops and
+        // level L-1 = (y-3) ops (matches the exact main-loop arrays:
+        // 2{100}3 -> cols 1..97=8, col98=2; 2{100}10 -> col99=7).
+        var base2mode = (xCnt === 0 && isFinite(yBase) && yBase >= 3);
+        var fillCnt = base2mode ? 8 : xCnt;
+        function countAt(lv) {
+          if (base2mode) {
+            if (lv === arrowsNum - 2) return 2;
+            if (lv === arrowsNum - 1) return Math.max(yBase - 3, 0);
+          }
+          return (lv === arrowsNum - 1) ? topCnt : fillCnt;
+        }
+        // base sub-chain: the tail's bottom x{subDepth}x
+        var sub;
+        if (subDepth >= 2 && subDepth < arrowsNum) {
+          if (base2mode) sub = diagonalChain(MetaNum(10), subDepth);
+          else sub = canFastDiagonal(t) ? diagonalChain(t, subDepth) : t.arrow(subDepth)(t);
         } else {
-          var top = j.array[idx].slice(1);
-          while (top.length > 0 && top[top.length - 1] === 0) top.pop();
-          var c = cmpCoeffsLevel([arrowsNum], top);
-          if (c > 0) {
-            j.array.push([1, arrowsNum]);
-          } else if (c === 0) {
-            j.array[idx][0] = Math.min((j.array[idx][0] || 0) + 1, MAX_SAFE_INTEGER);
+          sub = t.max(other).clone();
+        }
+        if (sub.layer > 0) { sub.normalize(); return sub; }
+        // top count at the anchor column (subDepth = L-1 when L == maxCols)
+        if (sub.array.length === 1) {
+          var wantLen = subDepth + 1;
+          while (sub.array[0].length < wantLen) sub.array[0].push(0);
+          if (arrowsNum === MetaNum.maxCols) {
+            // no rows above: write the exact per-level counts into r0
+            if (base2mode) {
+              for (var bl = 1; bl <= arrowsNum - 3; bl++) sub.array[0][bl] = 8;
+              sub.array[0][arrowsNum - 2] = 2;
+              sub.array[0][arrowsNum - 1] = Math.max(yBase - 3, 0);
+              if (sub.array[0][arrowsNum - 1] === 0) sub.array[0].pop();
+            } else if (topCnt > 0) {
+              sub.array[0][subDepth] = topCnt;
+            }
+          } else if (fillCnt > 0) {
+            sub.array[0][subDepth] = (sub.array[0][subDepth] || 0) + fillCnt;
           }
-          // c < 0: swallowed by the larger ordinal structure already present
         }
-        j.normalize();
-        return j;
+        // rows for levels maxCols..arrowsNum-1 within the budget
+        var rowBudget = MetaNum.maxRows - 1;
+        var startLv = subDepth + 1;
+        var endLv = arrowsNum - 1; // top level L is the anchor, no row
+        var nRows = endLv - startLv + 1;
+        if (nRows > rowBudget) {
+          // beyond budget: keep the largest rowBudget rows; the array's
+          // SECOND row (= the first-kept ordinal row) gets its first column
+          // +1 (the dropped lower chain collapses into one extra op there);
+          // first row [10] (issues.md v2.1)
+          var keptFrom = endLv - rowBudget + 1;
+          for (var lv = keptFrom; lv <= endLv; lv++) {
+            var cnt = countAt(lv);
+            if (lv === keptFrom) cnt += 1;
+            if (cnt > 0) sub.array.push([cnt, lv]);
+          }
+          sub.array[0] = [10];
+        } else {
+          for (var lv2 = startLv; lv2 <= endLv; lv2++) {
+            var cnt2 = countAt(lv2);
+            if (cnt2 > 0) sub.array.push([cnt2, lv2]);
+          }
+        }
+        sub.normalize();
+        return sub;
+      }
+      if (t.max(other).gt(hyperLevelSafe(arrowsNum + 1, MAX_SAFE_INTEGER))) {
+        return t.max(other);
       }
-      if (t.max(other).gt(hyperLevelSafe(arrowsNum + 1, MAX_SAFE_INTEGER))) return t.max(other);
       if (t.gt(hyperLevelSafe(arrowsNum, MAX_SAFE_INTEGER)) || other.gt(MetaNum.MAX_SAFE_INTEGER)) {
         var r;
         if (t.gt(hyperLevelSafe(arrowsNum, MAX_SAFE_INTEGER))) {
@@ -1886,20 +2303,45 @@
         return j;
       }
       var y = other.toNumber();
-      if (arrowsNum >= 23 && y !== Math.floor(y)) {
+      var fastDiag = isFinite(y) && Math.floor(y) === y && canFastDiagonal(t);
+      if (arrowsNum >= 23 && y !== Math.floor(y) && Math.floor(y) > 2) {
+        // Large integer part with a fractional tail at a high level: the tail
+        // would be amplified by the many iterations (e.g. 10{69}69.6 ≈
+        // 10{69}10), so use the discrete 10 anchor (accepted convention).
+        // y with floor ≤ 2 keeps the smooth fractional path — the recursion
+        // bottoms out numerically and carries the smooth Aa-diagonal mantissa
+        // (e.g. 10{101}(2.001607)).
         y = 10;
+        fastDiag = false;
       }
       var f = Math.floor(y);
       var arrows_m1 = arrows.sub(MetaNum.ONE);
-      var r = t.arrow(arrows_m1)(y - f);
       var initFloor = Math.floor(other.toNumber());
-      for (var i = 0; f !== 0 && r.lt(hyperLevelSafe(arrowsNum - 1, MAX_SAFE_INTEGER)) && i < 100; i++) {
-        if (f > 0) {
-          r = t.arrow(arrows_m1)(r);
-          f--;
+      var r, i;
+      if (fastDiag && arrowsNum >= 2 && f >= 2) {
+        // x{L}y = x{L-1}^{y-1}(x) = x{L-1}^{y-2}(x{L-1}x): seed with the
+        // diagonal D(L-1) built bottom-up and run the remaining successor
+        // iterations — same loop/guard/dump semantics as the path below,
+        // minus the two recomputed seed iterations.
+        r = diagonalChain(t, arrowsNum - 1);
+        f -= 2;
+        for (i = 0; f !== 0 && r.lt(hyperLevelSafe(arrowsNum - 1, MAX_SAFE_INTEGER)) && i < 98; i++) {
+          if (f > 0) {
+            r = t.arrow(arrows_m1)(r);
+            f--;
+          }
         }
+        if (i === 98) f = 0;
+      } else {
+        r = t.arrow(arrows_m1)(y - f);
+        for (i = 0; f !== 0 && r.lt(hyperLevelSafe(arrowsNum - 1, MAX_SAFE_INTEGER)) && i < 100; i++) {
+          if (f > 0) {
+            r = t.arrow(arrows_m1)(r);
+            f--;
+          }
+        }
+        if (i === 100) f = 0;
       }
-      if (i === 100) f = 0;
       if (arrowsNum - 1 < MetaNum.maxCols) {
         if (f > 0) {
           r.array[0][arrowsNum - 1] = (r.array[0][arrowsNum - 1] || 0) + f;
@@ -1920,14 +2362,81 @@
   Q.arrow = function (x, arrows, y) {
     return new MetaNum(x).arrow(arrows)(y);
   };
+
+  // ==================== hyper_log / hyper_root ====================
+  // Inverses of the hyperoperation a{b}c = d (arrow-style chained API):
+  //   d.hyper_log(a)(b)  = c     (recover the right operand / argument)
+  //   d.hyper_root(c)(b) = a     (recover the base / left operand)
+  // b = 0 and b = 1 use exact division and logarithms; b ≥ 2 bisects on the
+  // monotone arrow engine (issues.md addition 2). Note: for levels b beyond
+  // maxCols the forward arrow diagonalizes into one [1|b] marker row and the
+  // argument is no longer recoverable — the bisection then returns the
+  // smallest argument that reproduces d.
+  function hyperBisect(f, target, bound) {
+    // smallest integer x ≥ 1 with f(x) ≥ target (f monotone nondecreasing)
+    var lo = MetaNum.ONE.clone();
+    var hi = new MetaNum(2);
+    var iters = 0;
+    while (f(hi).lt(target)) {
+      lo = hi.clone();
+      hi = hi.mul(2);
+      if (++iters > bound) return hi;      // bracketing budget exhausted
+    }
+    iters = 0;
+    while (hi.sub(lo).gt(MetaNum.ONE) && iters++ < bound) {
+      var mid = lo.add(hi).div(2);
+      if (mid.lte(lo)) mid = lo.add(MetaNum.ONE);
+      if (mid.gte(hi)) mid = hi.sub(MetaNum.ONE);
+      if (f(mid).lt(target)) lo = mid.clone();
+      else hi = mid.clone();
+    }
+    return hi;
+  }
+
+  P.hyper_log = function (a) {
+    var d = this.clone();
+    a = new MetaNum(a);
+    return function (b) {
+      b = new MetaNum(b);
+      if (b.lt(MetaNum.ZERO) || d.lte(MetaNum.ZERO) || a.lte(MetaNum.ZERO) || a.eq(MetaNum.ONE)) {
+        return MetaNum.NaN.clone();
+      }
+      if (b.eq(MetaNum.ZERO)) return d.div(a);            // a·c = d
+      if (b.eq(MetaNum.ONE)) return d.log10().div(a.log10()); // a^c = d
+      return hyperBisect(function (x) { return a.arrow(b)(x); }, d, 200);
+    };
+  };
+  Q.hyper_log = function (d, a, b) {
+    return new MetaNum(d).hyper_log(a)(b);
+  };
+
+  P.hyper_root = function (c) {
+    var d = this.clone();
+    c = new MetaNum(c);
+    return function (b) {
+      b = new MetaNum(b);
+      if (b.lt(MetaNum.ZERO) || d.lte(MetaNum.ZERO) || c.lte(MetaNum.ZERO)) {
+        return MetaNum.NaN.clone();
+      }
+      if (b.eq(MetaNum.ZERO)) return d.div(c);            // a·c = d
+      if (c.eq(MetaNum.ONE)) return d.clone();            // a{b}1 = a
+      return hyperBisect(function (x) { return x.arrow(b)(c); }, d, 200);
+    };
+  };
+  Q.hyper_root = function (d, c, b) {
+    return new MetaNum(d).hyper_root(c)(b);
+  };
   Q.chain = function (x, y, arrows) {
     return new MetaNum(x).arrow(arrows)(y);
   };
 
-  //calc level ω: x{ω}y = x{y}y (fundamental sequence ω[y] = y)
-  //  aperiote(x,0) = x{0}0 = 0; aperiote(x,1) = x{1}1 = x; aperiote(x,2) = x{2}2 = x^x; ...
+  // level ω, rule 3 with the fundamental sequence ω[y] = y:
+  //   x{ω}y = x{ω[y]}x = x{y}x
+  // (the final operand is the base x, NOT the FS index y)
+  //   aperiote(3,0) = 3{0}3 = 9; aperiote(3,1) = 3{1}3 = 27;
+  //   aperiote(3,2) = 3{2}3 = 3^^3 = 7625597484987; ...
   P.aperiote = P.aper = P.h10 = function (y) {
-    return this.arrow(y)(y);
+    return this.arrow(y)(this);
   };
   Q.aperiote = Q.aper = Q.h10 = function (x, y) {
     return new MetaNum(x).aperiote(y);
@@ -1977,7 +2486,8 @@
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
     var base = x.aperiote(x);  // expande(x, 2) = x{x}x = x{ω}x
     if (y.eq(2)) return base.clone();
-    if (y.lt(2)) return base.clone(); // 1 < y < 2: the aperiote base
+    // 1 < y < 2 follows the successor rule too: x{ω+1}y = x{ω} applied
+    // floor(y) times to x^frac(y) (continuous with y=1 → x, y=2 → x{ω}x)
     return Q._hyperopFromOrdinal(x, y, [1, 1]);
   };
   Q.expande = Q.expa = Q.h11 = function (x, y) {
@@ -2027,7 +2537,7 @@
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
     var base = x.expande(x);  // multiexpande(x, 2)
     if (y.eq(2)) return base.clone();
-    if (y.lt(2)) return base.clone(); // 1 < y < 2
+    // 1 < y < 2 follows the successor rule (continuous with the integers)
     return Q._hyperopFromOrdinal(x, y, [2, 1]);
   };
   Q.multiexpande = Q.muea = Q.h12 = function (x, y) {
@@ -2075,7 +2585,7 @@
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
     var base = x.multiexpande(x);  // powerexpande(x, 2)
     if (y.eq(2)) return base.clone();
-    if (y.lt(2)) return base.clone(); // 1 < y < 2
+    // 1 < y < 2 follows the successor rule (continuous with the integers)
     return Q._hyperopFromOrdinal(x, y, [3, 1]);
   };
   Q.powerexpande = Q.poea = Q.h13 = function (x, y) {
@@ -2220,6 +2730,9 @@
     } else {
       var c = cmpCoeffsLevel(bt, rowToCoeffs(x.array[idx]));
       if (c > 0) {
+        // Push the larger level; if this exceeds the row budget, normalize
+        // keeps the base + the largest rows (the new row is never the one
+        // dropped — it ranks among the largest)
         x.array.push([k].concat(bt));
       } else if (c === 0) {
         var cnt = (x.array[idx][0] || 0) + k;
@@ -2230,6 +2743,112 @@
     return x.normalize();
   };
 
+  // issues.md truncation rule for ordinal expansions: when the expansion
+  // reaches row capacity (maxRows-1 ordinal rows), the base defaults to [10]
+  // and the first (smallest kept) ordinal row's count increments by 1 —
+  // marking that the exact expansion was truncated to its largest ordinals.
+  Q._applyExpansionTruncation = function (x) {
+    x = x.normalize();
+    var maxOrdinalRows = MetaNum.maxRows - 1;
+    if (x.array.length >= 2 && x.array.length - 1 >= maxOrdinalRows) {
+      x.array[0] = [10];
+      x.array[1][0] = (x.array[1][0] || 0) + 1;
+      if (x.array[1][0] > MAX_SAFE_INTEGER) x.array[1][0] = MAX_SAFE_INTEGER;
+    }
+    return x;
+  };
+
+  // ---------------------------------------------------------------------------
+  // Compact "layer marker" values for levels at or above ω^ω (README L17).
+  // Such a level has no finite CNF coefficient row, so the result of x{α}y is
+  // stored as the diagonal value of the reduced level (one rule-3 step):
+  //   layer L >= 1, rows [count, a1, …, ap]  →
+  //     10{ ω^ω^…((L-1) ω^'s)…^( Σ_i ω^(ord_i)·count_i + Σ_j ω^j·r_j ) }10
+  //   with ord_i = ω^(p-1)·ap + … + ω·a2 + a1.
+  // Examples: 10{ω^y}10 = L1 [[0],[1,y]];  10{ω^ω}10 = L1 [[0],[1,0,1]];
+  //           10{ω^ω·y}10 = L1 [[0],[y,0,1]];  10{ω^(ω+y)}10 = L1 [[0],[1,y,1]];
+  //           10{ω^(ω·y)}10 = L2 [[0],[y,1]];  10{ω^(ω^y)}10 = L3 [[y]];
+  //           10{ω^ω^…^ω(y ω's)}10 = L_y [[0],[1,1]].
+  // A marker is always stored in STANDARD FORM (Q._standardizeLayerValue):
+  // finite-level rows merge into r0 and the layer drops as far as it can.
+  // ---------------------------------------------------------------------------
+  Q._layerMarker = function (r0, layer, rows) {
+    var v = new MetaNum(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());
+    }
+    v.layer = layer > 0 ? layer : 0;
+    return Q._standardizeLayerValue(v);
+  };
+
+  // Standard form of a layer >= 1 value (README L17).  Two rewrites, both
+  // preserving the encoded ordinal, applied until no longer possible:
+  //   (a) merge: an ordinal row [count, k] holds the finite level k, i.e. the
+  //       bracket term ω^k·count — the very term r0's own k-th entry spells
+  //       (Σ_j ω^j·r_j).  So whenever k < maxCols the row folds into r0:
+  //         cube(10,3): [[10],[1,3],[1,0,1]] → [[10,0,0,1],[1,0,1]].
+  //   (b) de-layer: a layer-L value whose bracket is the finite ω-polynomial β
+  //       (no row above ω survives) equals the layer-(L-1) value carrying the
+  //       single row [1|β] (bracket ω^β, one ω^ less above it):
+  //         layer2 [[5],[3,1]] → layer2 [[5,3]] → layer1 [[10],[1,5,3]]
+  //           = 10{ω^(ω*3+5)}10;
+  //         layer3 [[3]] → layer2 [[0,0,0,1]] → layer1 [[10],[1,0,0,0,1]]
+  //           = 10{ω^ω^3}10.
+  // Each de-layer step strictly lowers `layer`, so the loop terminates; the
+  // innermost base is written as 10 (the 10{…}10 diagonal marker).
+  function mergeFiniteRowsIntoR0(arr) {
+    var r0 = arr[0];
+    var keep = [];
+    for (var i = 1; i < arr.length; i++) {
+      var row = arr[i];
+      if (row && row.length === 2 && row[1] >= 1 && row[1] < MetaNum.maxCols) {
+        var k = row[1];
+        while (r0.length <= k) r0.push(0);
+        r0[k] += (row[0] || 0);
+        continue;
+      }
+      keep.push(row);
+    }
+    arr.length = 1;
+    for (var j = 0; j < keep.length; j++) arr.push(keep[j]);
+  }
+
+  Q._standardizeLayerValue = function (v) {
+    if (!v || v.layer < 1) return v.normalize();
+    var L = v.layer;
+    var arr = [v.array[0].slice()];
+    for (var i = 1; i < v.array.length; i++) arr.push(v.array[i].slice());
+    mergeFiniteRowsIntoR0(arr);
+    while (L >= 2 && arr.length === 1) {
+      var poly = arr[0].slice();
+      while (poly.length > 0 && poly[poly.length - 1] === 0) poly.pop();
+      if (poly.length === 0) break;
+      var row = [1].concat(poly);
+      if (row.length > MetaNum.maxCols) break;      // row would not fit
+      arr = [[0], row];
+      L--;
+      mergeFiniteRowsIntoR0(arr);
+    }
+    if ((arr[0][0] || 0) === 0) arr[0][0] = 10;   // innermost base marker
+    v.array = arr;
+    v.layer = L;
+    return v.normalize();
+  };
+
+  // x{α}y when the operand y is itself an ordinal (or beyond MSI): the
+  // iteration count is unrepresentable, so the engine convention applies —
+  // "y plus one α-level marker row" (the supremum of the count-limited
+  // iterations). `row` is the marker row of α at the given `layer`.
+  Q._ordinalOperandOp = function (y, layer, row) {
+    var v = y.clone();
+    if (v.layer < layer) v.layer = layer;
+    var bt = trimCoeffs((row || []).slice(1));
+    var k = (row && row[0] > 0) ? row[0] : 1;
+    if (bt.length === 0) return v.normalize();
+    return Q._applyOrdinalRows(v, bt, k).normalize();
+  };
+
   Q._ordinalHyperop = function (x, y, coeffs, depth) {
     x = new MetaNum(x);
     y = new MetaNum(y);
@@ -2268,7 +2887,8 @@
     // the diagonalized single-row form (supremum of the iteration hierarchy).
     var hugeFs = yCnt > COEFF_BOUND && (pL >= 2 || (cf[1] || 0) > 1);
     if (hugeFs) return Q._applyOrdinalRows(x.max(y), cf, 1);
-    return Q._ordinalHyperop(x, y, fsCoeffs(cf, yCnt), depth + 1);
+    // rule 3: x{λ}y = x{λ[y]}x — the final operand is the base x
+    return Q._ordinalHyperop(x, x, fsCoeffs(cf, yCnt), depth + 1);
   };
 
   Q._iterateOrdinal = function (x, beta, V0, iters, depth) {
@@ -2296,7 +2916,7 @@
   //     enumeration representation (one row per ordinal below α, count = y-2)
   //   - everything else (any operand beyond MSI, x = 2, or enumeration too large):
   //     unified ordinal engine (README rules 1-4)
-  Q._hyperopFromOrdinal = function (x, y, coeffs) {
+  Q._hyperopFromOrdinalRaw = function (x, y, coeffs, skipFrac) {
     x = new MetaNum(x);
     y = new MetaNum(y);
     if (x.isNaN() || y.isNaN()) return MetaNum.NaN.clone();
@@ -2304,217 +2924,264 @@
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
-    var cf = trimCoeffs((coeffs || []).slice());
-    if (cf.length === 0) return x.mul(y); // rule 1: x{0}y = x*y
+
+    var cf0 = trimCoeffs((coeffs || []).slice());
+    if (cf0.length === 0) return x.mul(y); // rule 1: x{0}y = x*y
+    // Fractional level coefficients come from a fundamental sequence taken at a
+    // non-integer index.  On the diagonal ω = x, so ω^(k)·(c+f) = ω^(k)·c +
+    // ω^(k-1)·(x·f) — resolve top-down until only the constant term can still be
+    // fractional, then turn that leftover into a fractional argument one level
+    // higher:  x{γ+f}x = x{γ+1}(2·(x/2)^f)   (README: 10{ω*2}2.1 = 10{ω+2.1}10 =
+    // 10{ω+3}2·5^0.1; continuous at f=0 since x{γ+1}2 = x{γ}x).
+    if (coeffsHaveFraction(cf0)) {
+      var xnf = x.toNumber();
+      if (isFinite(xnf) && xnf >= 2) {
+        var rs = Q._resolveFracLevel(cf0, xnf);
+        if (rs.frac > 0) {
+          var up = rs.ord.slice();
+          while (up.length < 1) up.push(0);
+          up[0] = (up[0] || 0) + 1;
+          var argF = 2 * Math.pow(xnf / 2, rs.frac);
+          return Q._hyperopFromOrdinal(x, new MetaNum(argF), trimCoeffs(up));
+        }
+        cf0 = rs.ord;
+      }
+    }
+    // Non-integer argument at ordinal levels (issues.md addition 3):
+    //   successor level α (c0 > 0):  x{α}(m+f) = x{α-1} applied m times to x^f
+    //     (e.g. expa(10,2.1) = 10{ω+1}2.1 = 10{ω}10{ω}(10^0.1); continuous at
+    //     the integers since x^0 = 1 and x{α-1}1 = x)
+    //   limit level λ (c0 = 0): fundamental sequence at m = floor(y)
+    var yFracNum = y.toNumber();
+    if (!y.isint() && y.gt(MetaNum.ONE) && y.array.length === 1 && isFinite(yFracNum)) {
+      // Finite levels delegate to arrow()'s own fractional-argument machinery
+      if (!coeffsHaveOmegaPart(cf0)) return x.arrow(cf0[0])(y);
+      // ω level: match P.aperiote exactly (x{ω}y = x.arrow(y)(x)), so the
+      // successor rule composes as expa(10,2.1) = 10{ω}10{ω}(10^0.1)
+      if (cf0.length === 2 && cf0[1] === 1 && !(cf0[0] > 0)) return x.aperiote(y);
+      var ym = Math.floor(yFracNum);
+      // toPrecision(15) strips double-rounding noise in y - floor(y)
+      // (2.1 - 2 = 0.10000000000000009), so x^frac(y) reproduces x.pow(0.1)
+      // exactly and composition identities stay stable across paths
+      var yf = new MetaNum(Number((yFracNum - ym).toPrecision(15)));
+      if ((cf0[0] || 0) > 0) {
+        var xnfS = x.toNumber();
+        var xOkS = isFinite(xnfS) && xnfS >= 3 && xnfS <= MAX_SAFE_INTEGER;
+        // α-1 ≥ ω*2 only: for the ω+1/ω+2/ω+3 levels the applications after the
+        // first still have an operand inside MSI, so the engine evaluates them by
+        // the definition (10{ω}(10{ω}(10^0.1))) and that identity is exact.
+        var pred = succCoeffs(cf0);
+        var bigLevel = (pred[1] || 0) >= 2;
+        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.
+          return Q._expandedHyperop(x, new MetaNum(ym + 1), cf0,
+            Math.pow(xnfS, Number((yFracNum - ym).toPrecision(15))));
+        }
+        if (ym <= 100000) {
+          // successor rule: x{α}(m+f) = x{α-1} applied m times to x^f
+          var succ = cf0.slice();
+          succ[0] = succ[0] - 1;
+          succ = trimCoeffs(succ);
+          var v = x.pow(yf);
+          for (var it = 0; it < ym; it++) v = Q._hyperopFromOrdinalRaw(x, v, succ, true);
+          return v;
+        }
+        // Successor level with an iteration count beyond direct evaluation:
+        // successors have no fundamental sequence, so fall through to the
+        // engine's huge-y supremum convention (y + one α-row marker)
+        return Q._ordinalHyperop(x, y, cf0);
+      }
+      if (ym >= 1) {
+        // limit level: rule 3 with the FULL (fractional) index — x{λ}y =
+        // x{λ[y]}x.  λ[y] can carry fractional coefficients (10{ω*2}2.1 =
+        // 10{ω+2.1}10), which the fractional-level rule above resolves, so the
+        // fraction of y is never thrown away (flooring it would make
+        // h20(10,2.1) = h20(10,2)).
+        // Nested (skipFrac: the successor rule is already iterating a fractional
+        // start value) the index is floored — otherwise every application would
+        // take another fractional fundamental sequence and recurse forever.
+        var fsIdx = skipFrac ? Math.floor(yFracNum) : yFracNum;
+        return Q._hyperopFromOrdinalRaw(x, x, fsCoeffs(cf0, fsIdx), skipFrac);
+      }
+    }
+    var cf = cf0;
     var deg = 0;
     for (var di = 1; di < cf.length; di++) if ((cf[di] || 0) !== 0) deg = di;
     if (deg >= 1 && x.array.length === 1 && x.layer === 0
         && y.array.length === 1 && y.layer === 0) {
       var xC = metaFiniteCount(x), yC = metaFiniteCount(y);
-      if (xC >= 3 && xC <= MAX_SAFE_INTEGER && yC >= 3 && yC <= MAX_SAFE_INTEGER
-          && Math.pow(yC, deg) <= MetaNum.maxRows) {
-        return Q._enumHyperop(x, y, cf);
+      // Finite operands in [3, MSI] always take the EXPANDED cascade form — a
+      // limit operation keeps its fundamental-sequence rows all the way up to
+      // MSI (100 < y ≤ MSI included), truncated to the largest maxRows-1 rows.
+      if (xC >= 3 && xC <= MAX_SAFE_INTEGER && yC >= 3 && yC <= MAX_SAFE_INTEGER) {
+        return Q._expandedHyperop(x, y, cf);
       }
     }
     return Q._ordinalHyperop(x, y, cf);
   };
 
-  // Legacy (HEAD-compatible) enumeration-based hyperoperation for small operands.
-  Q._enumHyperop = function (x, y, coeffs) {
-    var xNum = x.toNumber();
-    var yNum = y.toNumber();
-    var maxRows = MetaNum.maxRows; // 100
-    var baseArrowLevel = Math.max(Math.floor(isFinite(xNum) ? xNum : 3), 3);
-    var baseResult = x.arrow(baseArrowLevel)(x);
-    var rows = Q._generateOrdinalRows(coeffs,
-      isFinite(xNum) ? Math.floor(xNum) : baseArrowLevel,
-      isFinite(yNum) ? Math.floor(yNum) : baseArrowLevel,
-      maxRows);
-    var result = baseResult.clone();
-    result.array = [baseResult.array[0].slice()];
-    for (var i = 0; i < rows.length; i++) result.array.push(rows[i]);
-    if (result.array.length > 1) result.layer = 0;
-    return result;
+  // Public entry point of the ordinal-level hyperoperations.  The expansion is
+  // exact while it fits the array budget; once the rule-1..4 cascade overflows
+  // maxRows the issues.md truncation rule applies (keep the largest maxRows-1
+  // ordinal rows sorted ascending, array[1][0] += 1 as the truncation marker,
+  // array[0] = [10]) — the same convention arrow() and BEAF already use.
+  Q._hyperopFromOrdinal = function (x, y, coeffs) {
+    var r = Q._hyperopFromOrdinalRaw(x, y, coeffs);
+    if (r && r._ordTrunc) {
+      delete r._ordTrunc;
+      r = Q._applyExpansionTruncation(r);
+    }
+    return r;
   };
 
-  // Legacy (HEAD-compatible) ordinal row enumeration: one row per ordinal below
-  // `coeffs` (coefficients bounded by `cardinal`), each with count = cardinal-2.
-  Q._generateOrdinalRows = function (coeffs, base, cardinal, maxRows) {
+  // ---------------------------------------------------------------------------
+  // Expanded (cascade) form of x{α}y for FINITE operands in [3, MSI] — README
+  // rules 1-4 written out row by row.  The rows are generated TOP-DOWN so a
+  // huge fundamental sequence (y up to MSI) costs nothing: generation stops as
+  // soon as the array budget is filled, keeping the LARGEST rows.
+  //
+  //   successor α = β + m  (m = c0 > 0):  x{α}y = x{β+m-1}^(y-2)(x{β+m-1}x),
+  //     so the row at β+m-1 carries y-2 applications and every row below it
+  //     (β+m-2 … β, then the cascade of β) comes from decomposing with the
+  //     BASE x as operand and therefore carries x-2 (h13(10,20) → [8,0,1],
+  //     [8,1,1], [18,2,1] — only the top row follows y).
+  //   limit α (c0 = 0): rule 3 gives x{α}opd = x{α[opd]}x, so the operand turns
+  //     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.
+  Q._cascadeRows = function (xn, cf, yn, budget, fsOpd) {
     var rows = [];
-    var m = base;
-    var n = cardinal;
-
-    function compareOrd(a, b) {
-      var maxLen = Math.max(a.length, b.length);
-      for (var i = maxLen - 1; i >= 0; i--) {
-        var va = (i < a.length) ? (a[i] || 0) : 0;
-        var vb = (i < b.length) ? (b[i] || 0) : 0;
-        if (va < vb) return -1;
-        if (va > vb) return 1;
-      }
-      return 0;
-    }
-
-    function addOrd(a, b) {
-      if (!b || b.length === 0 || (b.length === 1 && b[0] === 0)) return a.slice();
-      if (!a || a.length === 0 || (a.length === 1 && a[0] === 0)) return b.slice();
-      var result = a.slice();
-      var k = 0;
-      while (k < result.length && (result[k] || 0) === 0) k++;
-      if (k >= result.length) {
-        return b.slice();
-      } else if (k === 0) {
-        result[0] = (result[0] || 0) + (b[0] || 0);
-        for (var i = 1; i < b.length; i++) {
-          result[i] = (result[i] || 0) + (b[i] || 0);
+    if (!(budget >= 1)) return { rows: rows, baseIdx: xn };
+    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
+    var fracOpd = (fsOpd === undefined) ? null : fsOpd;
+    var baseIdx = xn;
+    var fracRem = 0;                    // fractional constant carried to the base
+    var guard = 0;
+    while (rows.length < budget && guard++ < 10000) {
+      if (!coeffsHaveOmegaPart(cfs)) break;             // finite level: no row
+      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
+        var mFr = Number((mRaw - m).toPrecision(15));
+        if (mFr > 1e-9) fracRem = mFr;
+        var beta = trimCoeffs(cfs.slice());
+        beta[0] = 0;
+        beta = trimCoeffs(beta);
+        var steps = Math.min(m, budget - rows.length + 1);
+        for (var s = 0; s < steps; s++) {
+          var j = m - 1 - s;                            // rows β+m-1 … β
+          var cnt = (first ? opd : xn) - 2;
+          first = false;
+          if (cnt < 1) continue;
+          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));
         }
+        cfs = beta;                                     // continue below β
+        opd = Math.min(xn, MAX_SAFE_INTEGER);           // everything below the top
+        continue;                                       // row is base-operand
+      }
+      // limit: fundamental sequence at the current operand (rule 3)
+      var idx = (fracOpd !== null) ? fracOpd : opd;
+      fracOpd = null;
+      baseIdx = idx;
+      var nxt = fsCoeffs(cfs, idx);
+      if (coeffsHaveFraction(nxt)) {
+        // a fractional index makes the coefficients fractional (ω^k·(c+f)) —
+        // resolve them against the base so every row coefficient stays an
+        // integer, carrying the leftover constant fraction into the base
+        var rs2 = Q._resolveFracLevel(nxt, xn);
+        cfs = rs2.ord;
+        if (rs2.frac > 0) fracRem = rs2.frac;
       } else {
-        result[k] = 0;
-        result = result.slice(0, k);
-        for (var i = 0; i < b.length; i++) {
-          result.push(b[i] || 0);
-        }
-      }
-      while (result.length > 0 && result[result.length - 1] === 0) result.pop();
-      return result;
-    }
-
-    function isZero(ord) {
-      if (!ord || ord.length === 0) return true;
-      for (var i = 0; i < ord.length; i++) {
-        if ((ord[i] || 0) !== 0) return false;
+        cfs = trimCoeffs(nxt);
       }
-      return true;
-    }
-
-    function buildRow(ord, count) {
-      var maxIdx = ord.length - 1;
-      while (maxIdx >= 0 && (ord[maxIdx] || 0) === 0) maxIdx--;
-      if (maxIdx < 0) return null;
-      var row = [count];
-      for (var i = 0; i <= maxIdx - 1; i++) row.push(ord[i] || 0);
-      row.push(ord[maxIdx]);
-      return row;
+      opd = Math.min(xn, MAX_SAFE_INTEGER);             // operand becomes x
     }
+    rows.baseIdx = baseIdx + fracRem;                   // descending by ordinal
+    return rows;
+  };
 
-    // Enumerate all ordinals below ω^k with coefficients < n
-    function enumBelowOmegaK(k, n) {
-      if (k === 0) {
-        return [[0]];
-      }
-      if (k === 1) {
-        var result = [];
-        for (var i = 0; i < n; i++) {
-          result.push([i]);
-        }
-        return result;
-      }
-      var result = [];
-      for (var a = 0; a < n; a++) {
-        var sub = enumBelowOmegaK(k - 1, n);
-        for (var i = 0; i < sub.length; i++) {
-          var combined = sub[i].slice();
-          while (combined.length < k) combined.push(0);
-          combined[k - 1] = a;
-          result.push(combined);
-        }
-      }
-      return result;
+  Q._expandedHyperop = function (x, y, cf, fsOpd) {
+    var maxRows = MetaNum.maxRows;
+    var xn = Math.floor(metaFiniteCount(x));
+    var yn = Math.floor(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;
+    if (truncated) desc = desc.slice(0, budget);   // keep the LARGEST rows
+    var rows = desc.reverse();                          // ascending
+    // base r0 = x{idx}x (rule 3 at the ω level: x{ω}x = x{x}x) — the finite part;
+    // idx is the operand of the descent that bottoms out, i.e. the fractional
+    // start value x^f when the cascade came from the fractional successor rule
+    var baseIdx = (desc.baseIdx === undefined) ? xn : desc.baseIdx;
+    // arrow() evaluates fractional levels too (10{10.2589}10 ≠ 10{10}10), so the
+    // carried fraction survives into the base
+    var baseResult = x.arrow(Math.max(baseIdx, 3))(x);
+    var result = baseResult.clone();
+    if (truncated) {
+      result.array = [[10]];
+      rows[0][0] = (rows[0][0] || 0) + 1;               // truncation marker
+      if (rows[0][0] > MAX_SAFE_INTEGER) rows[0][0] = MAX_SAFE_INTEGER;
+    } else {
+      result.array = [baseResult.array[0].slice()];
     }
+    for (var i = 0; i < rows.length; i++) result.array.push(rows[i]);
+    result.layer = 0;
+    return result.normalize();
+  };
 
-    // Enumerate all ordinals below a given ordinal
-    function enumBelow(alpha, n) {
-      if (isZero(alpha)) return [];
-
-      if ((alpha[0] || 0) > 0) {
-        var pred = alpha.slice();
-        pred[0]--;
-        while (pred.length > 0 && pred[pred.length - 1] === 0) pred.pop();
-        if (pred.length === 0) pred = [0];
-        var result = enumBelow(pred, n);
-        result.push(pred.slice());
-        return result;
-      }
-
-      var k = alpha.length - 1;
-      while (k >= 0 && (alpha[k] || 0) === 0) k--;
-      if (k < 0) return [];
-
-      var ck = alpha[k] || 0;
-      var rest = alpha.slice(0, k);
-      while (rest.length > 0 && rest[rest.length - 1] === 0) rest.pop();
-
-      var result = [];
-
-      for (var j = 0; j < ck; j++) {
-        var sub = enumBelowOmegaK(k, n);
-        for (var i = 0; i < sub.length; i++) {
-          var combined = sub[i].slice();
-          while (combined.length <= k) combined.push(0);
-          combined[k] = j;
-          result.push(combined);
-        }
-      }
-
-      if (!isZero(rest)) {
-        var restSub = enumBelow(rest, n);
-        for (var i = 0; i < restSub.length; i++) {
-          var combined = restSub[i].slice();
-          while (combined.length <= k) combined.push(0);
-          combined[k] = ck;
-          result.push(combined);
-        }
-      }
-
-      return result;
+  // Any coefficient with a non-zero fractional part?
+  function coeffsHaveFraction(coeffs) {
+    for (var i = 0; i < coeffs.length; i++) {
+      var c = coeffs[i] || 0;
+      if (c !== Math.floor(c)) return true;
     }
+    return false;
+  }
 
-    var count = n - 2;
-    if (count < 1) return rows;
-
-    var allOrdinals = enumBelow(coeffs, n);
-
-    var seen = {};
-    var uniqueOrdinals = [];
-    for (var i = 0; i < allOrdinals.length; i++) {
-      var ord = allOrdinals[i];
-      if (isZero(ord)) continue;
-
-      // Normalize: remove trailing zeros
-      var normalized = ord.slice();
-      while (normalized.length > 0 && normalized[normalized.length - 1] === 0) {
-        normalized.pop();
+  // Resolve fractional CNF coefficients against the base x (see the comment in
+  // _hyperopFromOrdinalRaw): ω^(k)·(c+f) = ω^(k)·c + ω^(k-1)·(x·f) top-down.
+  // Returns the integer level plus the fractional part left in the constant term.
+  Q._resolveFracLevel = function (cf, xn) {
+    var r = trimCoeffs((cf || []).slice());
+    for (var k = r.length - 1; k >= 1; k--) {
+      var c = r[k] || 0;
+      var fl = Math.floor(c);
+      var fr = Number((c - fl).toPrecision(15));
+      if (fr > 1e-9) {
+        r[k] = fl;
+        r[k - 1] = (r[k - 1] || 0) + xn * fr;
       }
-
-      // Skip ordinals below ω (finite ordinals: only constant term, length <= 1)
-      if (normalized.length <= 1) continue;
-
-      var key = normalized.join(',');
-      if (seen[key]) continue;
-      seen[key] = true;
-      uniqueOrdinals.push(normalized);
     }
-
-    uniqueOrdinals.sort(function (a, b) {
-      return compareOrd(a, b);
-    });
-
-    var allRows = [];
-    for (var i = 0; i < uniqueOrdinals.length; i++) {
-      var row = buildRow(uniqueOrdinals[i], count);
-      if (row) allRows.push(row);
-    }
-
-    var maxOrdinalRows = maxRows - 1;
-    if (allRows.length > maxOrdinalRows) {
-      allRows = allRows.slice(allRows.length - maxOrdinalRows);
-    }
-
-    for (var i = 0; i < allRows.length; i++) {
-      rows.push(allRows[i]);
-    }
-
-    return rows;
+    var c0 = r[0] || 0;
+    var fl0 = Math.floor(c0);
+    var fr0 = Number((c0 - fl0).toPrecision(15));
+    if (!(fr0 > 1e-9)) fr0 = 0;
+    r[0] = fl0;
+    return { ord: trimCoeffs(r), frac: fr0 };
   };
 
   // Helper: number of leading iterate applications (of level `beta`) starting
@@ -2532,6 +3199,26 @@
     return steps + 1;
   }
 
+  // Inverse of a LIMIT level taken through the expanded cascade: x{λ}y = x{λ[y]}x
+  // makes every row depend on y only through the fundamental sequence, so instead
+  // of reading a count row we search the (monotone) forward map.
+  Q._invExpandedLimit = function (base, value, coeffs) {
+    var lo = 3, hi = MAX_SAFE_INTEGER, best = 0;
+    var v3 = Q._expandedHyperop(base, new MetaNum(3), coeffs);
+    if (value.lt(v3)) return base.clone();
+    while (lo <= hi) {
+      var mid = lo + Math.floor((hi - lo) / 2);
+      if (Q._expandedHyperop(base, new MetaNum(mid), coeffs).lte(value)) {
+        best = mid; lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    if (best === 0) return base.clone();
+    var vb = Q._expandedHyperop(base, new MetaNum(best), coeffs);
+    return vb.eq(value) ? new MetaNum(best) : base.clone();
+  };
+
   // Helper: generic inverse hyperoperation from ordinal level.
   // Forward paths and the rows they leave:
   //   - small x ∈ [3, MSI] & small y (enumeration path): rows for each ordinal
@@ -2564,14 +3251,29 @@
     }
     if (cf.length === 0) return z;
 
-    // enumeration path (base z is a small finite number ≥ 3): top row count = y-2
+    // expanded cascade path (base z is a small finite number ≥ 3): the forward
+    // operation wrote the rule-1..4 cascade rows.
+    //   successor α: the row at α-1 carries exactly y-2 applications → +2
+    //   limit α: every row carries x-2 and y only appears inside the
+    //     fundamental-sequence rows, so it is recovered from the forward map
     var zC = metaFiniteCount(z);
     if (z.array.length === 1 && z.layer === 0 && zC >= 3 && zC <= MAX_SAFE_INTEGER) {
-      var lastRow = x.array[x.array.length - 1];
-      if (lastRow && lastRow.length >= 2 && (lastRow[0] || 0) > 0) {
-        return new MetaNum((lastRow[0] || 0) + 2);
+      if ((cf[0] || 0) > 0) {
+        var pred = succCoeffs(cf);
+        var predRow = null;
+        for (var pi = x.array.length - 1; pi >= 1; pi--) {
+          var prow = x.array[pi];
+          if (prow && prow.length >= 2 && (prow[0] || 0) > 0 &&
+              cmpCoeffsLevel(rowToCoeffs(prow), pred) === 0) { predRow = prow; break; }
+        }
+        if (predRow) return new MetaNum((predRow[0] || 0) + 2);
+        var lastRow = x.array[x.array.length - 1];
+        if (lastRow && lastRow.length >= 2 && (lastRow[0] || 0) > 0) {
+          return new MetaNum((lastRow[0] || 0) + 2);
+        }
+        return z;
       }
-      return z;
+      return Q._invExpandedLimit(z, x, cf);
     }
 
     // engine path: count row [c | β] with β = α-1 (successor α only)
@@ -2909,78 +3611,72 @@
   // Hyperoperations from ω^ω up to ε₀
   // ---------------------------------------------------------------------------
 
-  // iter (ω^ω): diagonalizes ω^x operations
-  // k <= maxCols-2: layer 0, multi-index; k >= maxCols-1: layer 1
-  // e.g. iter(3,5)=3{ω^ω}5=3{ω^5}5=3{ω^4*4+ω^3*4+ω^2*4+ω*4+5}5=(3{ω^4*4+ω^3*4+ω^2*4+ω*4+4})^3...
-  // so iter(3,5) → layer=0, max array row=[3,4,4,4,4,4]
-  // for maxcol-1 <= k <= MSI, iter(3,k)=3{ω^ω}k=3{ω^k}k
-  // reference to README.md, when layer=1, array=[[0],[1,k]] represents 10{ω^k}10
-  // array [[1], [1,k]] represents 10{ω^k+1}10=10{ω^k}^9 10
-  // so iter(3,k)≈10{ω^k}10 → layer=1, max array row=[[0],[1,k]]
-  // for k > MSI, iter(3,k)≈10{ω^ω}MSI → layer=1, array=[[0],[1,0,1]], which represents 10{ω^ω}MSI
-  // 10{ω^ω+1}x (2<=x<=10, =10{ω^ω+1}(>MSI) if x=2) should be treated as 10{ω^ω+a}10, a=log5(x/2)
-  // iter(10,iter(10,10))=10{ω^ω}10{ω^ω}10=10{ω^ω+1}3→array=[[log5(3/2)],[1,0,1]]
-  P.iteration = P.iter = P.hww = function (y) {
+  // ---------------------------------------------------------------------------
+  // Hyperoperations from ω^ω up to ε₀ — README rules 1-4 with the unified
+  // limit rule n{λ}b = n{λ[b]}n (the final operand is the BASE n, never b).
+  // Levels ≥ ω^ω have no finite CNF coefficient row, so — except where the
+  // reduced level λ[y] still fits a layer-0 ordinal row — the result is stored
+  // as the compact layer marker of λ[y] (see Q._layerMarker).
+  // ---------------------------------------------------------------------------
+
+  // iter (ω^ω): (ω^ω)[y] = ω^y  →  x{ω^ω}y = x{ω^y}x
+  // e.g. iter(3,5) = 3{ω^5}3 = 3{ω^4*3}3 = … = 3{ω^4*2+ω^3*2+ω^2*2+ω*2+2}3…
+  //   (whole fundamental-sequence cascade → layer 0 multi-row array)
+  // for y >= maxCols the ω^y row no longer fits → layer=1 marker [[r0],[1,y]]
+  //   (= 10{ω^y}10), and for y > MSI the operand is unrepresentable → the
+  //   ω^ω marker row [1,0,1] (= 10{ω^ω}10).
+  P.iterate = P.iter = P.hww = function (y) {
     var x = this.clone();
     y = new MetaNum(y);
     if (x.isNaN() || y.isNaN()) return MetaNum.NaN.clone();
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
-    
-    if (y.layer === 0 && y.array.length <= 1) {
-      var yn = y.toNumber();
-      var maxLevel = MetaNum.maxCols - 1;
-      if (yn < maxLevel) {
-        // y fits within ordinal levels: create ω^y at layer 0
-        // Multi-index format: [1, 0, 0, ..., 0, 1] with yn zeros
-        var result = x.clone();
-        var row = [1];
-        for (var i = 0; i < yn; i++) row.push(0);
-        row.push(1);
-        result.layer = 0;
-        result.array.push(row);
-        result.normalize();
-        return result;
-      } else {
-        // y >= maxLevel: promote to layer 1, compact format [[x],[1,yn]]
-        // ordinal level ω^y needs a row longer than maxCols, so it is stored
-        // as layer=1 (level = ω^P with P = yn constant); cap at MSI
-        var result = x.clone();
-        result.layer = 1;
-        var yv = yn > MAX_SAFE_INTEGER ? MAX_SAFE_INTEGER : yn;
-        result.array.push([1, yv]);
-        result.normalize();
-        return result;
-      }
-    }
-    
-    // y is ordinal: iter on ordinal
-    // Promote: absorb y's ordinal rows into r0, add iter marker
-    // Layer promotion consumes one level: skip the first value
-    var result = y.clone();
-    var newR0 = x.array[0].slice();
-    // Absorb y's ordinal rows into r0 (skip count and first value)
-    for (var ir = 1; ir < y.array.length; ir++) {
-      var yrow = y.array[ir];
-      // Start from index 2 to skip count and first ordinal value
-      for (var jc = 2; jc < yrow.length; jc++) {
-        newR0.push(yrow[jc]);
-      }
-    }
-    result.array[0] = newR0;
-    result.array = [newR0];
-    // Add iter's own ordinal marker
-    result.array.push([1, 0, 1]);
-    result.layer = y.layer + 1;
-    result.normalize();
-    return result;
-  };
-  Q.iteration = Q.iter = Q.hww = function (x, y) {
-    return new MetaNum(x).iteration(y);
-  };
 
-  P.inv_iteration = P.inv_iter = P.iww = function (z) {
+    // iterate(x,y) = x{ω^ω}y. Rule 3 with the fundamental sequence
+    // (ω^ω)[y] = ω^y:  x{ω^ω}y = x{ω^y}x — final operand is the base x.
+    var yc = metaFiniteCount(y);
+    if (yc === Math.floor(yc) && yc <= MAX_SAFE_INTEGER) {
+      var m = Math.max(2, Math.floor(yc));
+      if (m < MetaNum.maxCols) {
+        // ω^y is a layer-0 ordinal (coeffs with 1 at index y): evaluate
+        // x{ω^y}x through the unified rule-1..3 engine. E.g.
+        // iterate(3,5) = 3{ω^5}3 = the full FS cascade (truncated when it
+        // overflows the row budget).
+        var coeffs = [];
+        for (var ci = 0; ci < m; ci++) coeffs.push(0);
+        coeffs.push(1);
+        return Q._hyperopFromOrdinal(x, x, coeffs);
+      }
+      // y >= maxCols: ω^y needs a row longer than maxCols — store as the
+      // layer-1 compact marker 10{ω^y}10, capped at MSI
+      return Q._layerMarker([10], 1, [[1, m]]);
+    }
+    if (yc <= MAX_SAFE_INTEGER) {
+      // fractional y: (ω^ω)[y] = ω^y = ω^(m+f) = ω^m·ω^f, and on the diagonal
+      // ω^f reads as x^f — so the level is ω^m·(x^f), whose coefficients carry
+      // x^f at index m (README: 10{ω^ω}2.1 = 10{ω^2.1}10 = 10{ω^2*10^0.1}10).
+      // Flooring y would lose the fraction and make iterate(10,2.1)=iterate(10,2).
+      var mf = Math.max(2, Math.floor(yc));
+      var ff = Number((yc - Math.floor(yc)).toPrecision(15));
+      var xnf = x.toNumber();
+      var cfac = (isFinite(xnf) && xnf >= 2 && ff > 0) ? Math.pow(xnf, ff) : 1;
+      if (mf < MetaNum.maxCols) {
+        var cfw = [];
+        for (var cw = 0; cw < mf; cw++) cfw.push(0);
+        cfw.push(cfac);
+        return Q._hyperopFromOrdinal(x, x, cfw);
+      }
+      return Q._layerMarker([10], 1, [[cfac, mf]]);
+    }
+    // ordinal / out-of-range operand: y plus one ω^ω marker row
+    return Q._ordinalOperandOp(y, 1, [1, 0, 1]);
+  };
+  Q.iterate = Q.iter = Q.hww = function (x, y) {
+    return new MetaNum(x).iterate(y);
+  };
+  
+  P.inv_iterate = P.inv_iter = P.iww = function (z) {
     var x = this.clone();
     z = new MetaNum(z);
     if (x.isNaN() || z.isNaN()) return MetaNum.NaN.clone();
@@ -3029,14 +3725,17 @@
     }
     return z;
   };
-  Q.inv_iteration = Q.inv_iter = Q.iww = function (x, z) {
-    return new MetaNum(x).inv_iteration(z);
+  Q.inv_iterate = Q.inv_iter = Q.iww = function (x, z) {
+    return new MetaNum(x).inv_iterate(z);
   };
 
-  // itermult (ω^ω+1): iterates ω^ω level operations
-    // for k <= MSI, itmu(3,k)=3{ω^ω+1}k=3{ω^ω}3{ω^ω}...3 with k 3's
-    // ≈10{ω^ω+1}k → layer=1, array=[[n],[1,0,1]] (n=log5(k/2) if 2<=k<10, n=1 if k>=10)
-    // for k > MSI, itmu(3,k)≈10{ω^ω+1}MSI → layer=1, array=[[1],[1,0,1]]
+  // itermult (ω^ω+1): successor level — x{ω^ω+1}y = x{ω^ω} applied y-1 times
+  // to x (rule 2), i.e. itmu(3,k) = 3{ω^ω}3{ω^ω}…3 with k 3's.
+  //   k = 2 → x{ω^ω}x = iterate(x,x) exactly; 1 < k < 2 → x{ω^ω}(x^(k-1)).
+  //   k > 2 → layer=1 marker [[k-1],[1,0,1]] = 10{ω^ω+(k-1)}10: any finite
+  //     number of ω^ω applications stays strictly below ω^ω·2, so the count
+  //     lives in the constant term (ω^ω + n) — monotone in k and still below
+  //     cuboiter's ω^ω+ω^k.
   P.itermult = P.itmu = P.hw01 = function (y) {
     var x = this.clone();
     y = new MetaNum(y);
@@ -3044,24 +3743,20 @@
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
-    if (y.layer === 0 && y.array.length <= 1) {
-      var yn = y.toNumber();
-      var base = x.iter(x);
-      if (y.eq(2)) return base;
-      var result = base.clone();
-      result.layer = 1;
-      result.array = [base.array[0].slice()];
-      result.array[0] = [yn];
-      result.array.push([1, yn, 1]);
-      result.normalize();
-      return result;
+    var yc = metaFiniteCount(y);
+    if (yc <= MAX_SAFE_INTEGER) {
+      if (yc <= 2) {
+        // rule 2 with one iteration: x{ω^ω+1}k = x{ω^ω}(x^(k-1)) (x^1 = x)
+        var f = y.sub(MetaNum.ONE);
+        return f.eq(MetaNum.ZERO) ? x.iterate(x) : x.iterate(x.pow(f));
+      }
+      var n = Math.ceil(yc) - 1;                 // number of ω^ω applications
+      if (n < 1) n = 1;
+      if (n > MAX_SAFE_INTEGER) n = MAX_SAFE_INTEGER;
+      return Q._layerMarker([n], 1, [[1, 0, 1]]);
     }
-    var result = y.clone();
-    result.layer = Math.max(result.layer, 1);
-    var base = x.iter(x);
-    result.array[0] = base.array[0].slice();
-    result.normalize();
-    return result;
+    // ordinal / out-of-range operand: y plus one ω^ω marker row
+    return Q._ordinalOperandOp(y, 1, [1, 0, 1]);
   };
   Q.itermult = Q.itmu = Q.hw01 = function (x, y) {
     return new MetaNum(x).itermult(y);
@@ -3071,13 +3766,24 @@
     var x = this.clone();
     z = new MetaNum(z);
     if (x.isNaN() || z.isNaN()) return MetaNum.NaN.clone();
+    // marker [[n],[1,0,1]] = 10{ω^ω+n}10: the iteration count n sits in the
+    // constant term, so y = n + 1 applications of the ω^ω level.
+    if (x.layer >= 1) {
+      for (var i = x.array.length - 1; i >= 1; i--) {
+        var row = x.array[i];
+        if (row.length === 3 && row[1] === 0 && row[2] === 1 && row[0] === 1) {
+          var n = Math.round(x.array[0][0] || 0);
+          return new MetaNum(n + 1);
+        }
+      }
+    }
     if (x.array.length >= 2) {
       var result = x.clone();
-      for (var i = result.array.length - 1; i >= 1; i--) {
-        var row = result.array[i];
-        if (row.length >= 3 && row[0] > 0) {
-          row[0]--;
-          if (row[0] <= 0) result.array.splice(i, 1);
+      for (var j = result.array.length - 1; j >= 1; j--) {
+        var row2 = result.array[j];
+        if (row2.length >= 3 && row2[0] > 0) {
+          row2[0]--;
+          if (row2[0] <= 0) result.array.splice(j, 1);
           result.normalize();
           if (result.array.length <= 1) result.layer = 0;
           return result;
@@ -3091,10 +3797,10 @@
     return new MetaNum(x).inv_itermult(z);
   };
 
-  // cuboiter (ω^ω*2): x{(ω^ω)*2}y = x{ω^ω+ω^y}y
-    // for k <= MSI, cube(3,k)=3{ω^ω+ω^k}k
-    // ≈10{ω^ω+ω^k}k → layer=1, array=[[0],[1,k],[1,0,1]]
-    // for k > MSI, cube(3,k)≈10{ω^ω*2}MSI → layer=1, array=[[0],[2,0,1]]
+  // cuboiter (ω^ω*2): (ω^ω*2)[y] = ω^ω + ω^y  →  x{ω^ω*2}y = x{ω^ω+ω^y}x
+    // for k <= MSI, cube(3,k)=3{ω^ω+ω^k}3
+    // ≈10{ω^ω+ω^k}10 → layer=1, array=[[10],[1,k],[1,0,1]] (ω^k + ω^ω)
+    // for k > MSI, cube(3,k)≈10{ω^ω*2}10 → layer=1, array=[[10],[2,0,1]]
   P.cuboiter = P.cube = P.hwx2 = function (y) {
     var x = this.clone();
     y = new MetaNum(y);
@@ -3102,24 +3808,14 @@
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
-    var base = x.itermult(x);
-    if (y.layer === 0 && y.array.length <= 1) {
-      var yn = y.toNumber();
-      if (y.eq(2)) return base;
-      var result = base.clone();
-      result.layer = 1;
-      result.array = [[1]];
-      result.array.push([1, yn, 1]);
-      result.array.push([1, 0, 1]);
-      result.normalize();
-      return result;
+    var yc = metaFiniteCount(y);
+    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], 1, [[1, m], [1, 0, 1]]);
     }
-    var result = y.clone();
-    result.layer = 1;
-    result.array[0] = base.array[0].slice();
-    result.array.push([1, 0, 1]);
-    result.normalize();
-    return result;
+    // ordinal / out-of-range operand: y plus two ω^ω marker rows (ω^ω*2)
+    return Q._ordinalOperandOp(y, 1, [2, 0, 1]);
   };
   Q.cuboiter = Q.cube = Q.hwx2 = function (x, y) {
     return new MetaNum(x).cuboiter(y);
@@ -3130,20 +3826,26 @@
     z = new MetaNum(z);
     if (x.isNaN() || z.isNaN()) return MetaNum.NaN.clone();
     if (x.array.length >= 2) {
-      // For finite y: find [1, yn, 1] with yn > 0 and return yn
-      // (skip [1, 0, 1] which is the cuboiter marker)
-      for (var i = x.array.length - 1; i >= 1; i--) {
-        var row = x.array[i];
-        if (row.length === 3 && row[0] === 1 && row[2] === 1 && row[1] > 0) {
-          return new MetaNum(row[1]);
+      // standard marker [[…,1@y,…],[1,0,1]] = 10{ω^ω+ω^y}10: the ω^y term is
+      // merged into r0 (index y) whenever y < maxCols, else it is the row [1,y]
+      if (x.layer >= 1) {
+        var r0 = x.array[0];
+        for (var j = r0.length - 1; j >= 1; j--) {
+          if ((r0[j] || 0) > 0) return new MetaNum(j);
+        }
+        for (var i = x.array.length - 1; i >= 1; i--) {
+          var row = x.array[i];
+          if (row.length === 2 && row[0] === 1 && row[1] > 0) {
+            return new MetaNum(row[1]);
+          }
         }
       }
       // For ordinal y: find [1, 0, 1] marker and return y
-      for (var i = x.array.length - 1; i >= 1; i--) {
-        var row = x.array[i];
-        if (row.length >= 3 && row[1] === 0 && row[2] === 1 && row[0] === 1) {
+      for (var k = x.array.length - 1; k >= 1; k--) {
+        var row2 = x.array[k];
+        if (row2.length >= 3 && row2[1] === 0 && row2[2] === 1 && row2[0] === 1) {
           var result = x.clone();
-          result.array.splice(i, 1);
+          result.array.splice(k, 1);
           result.normalize();
           if (result.array.length <= 1) result.layer = 0;
           return result;
@@ -3156,10 +3858,10 @@
     return new MetaNum(x).inv_cuboiter(z);
   };
 
-  // expoiter (ω^(ω+1)): x{ω^(ω+1)}y = x{ω^ω * y}y
-    // for k <= MSI, expo(3,k)=3{ω^ω*k}k
-    // ≈10{ω^ω*k}k → layer=1, array=[[0],[k,0,1]]
-    // for k > MSI, expo(3,k)≈10{ω^(ω+1)}MSI → layer=1, array=[[0],[1,1,1]]
+  // expoiter (ω^(ω+1)): (ω^(ω+1))[y] = ω^ω*y  →  x{ω^(ω+1)}y = x{ω^ω*y}x
+    // for k <= MSI, expo(3,k)=3{ω^ω*k}3
+    // ≈10{ω^ω*k}10 → layer=1, array=[[10],[k,0,1]]
+    // for k > MSI, expo(3,k)≈10{ω^(ω+1)}10 → layer=1, array=[[10],[1,1,1]]
   P.expoiter = P.expo = P.hwa1 = function (y) {
     var x = this.clone();
     y = new MetaNum(y);
@@ -3167,23 +3869,14 @@
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
-    var base = x.iter(x);
-    if (y.layer === 0 && y.array.length <= 1) {
-      var yn = y.toNumber();
-      if (y.eq(2)) return x.cuboiter(x);
-      var result = base.clone();
-      result.layer = 1;
-      result.array = [[1]];
-      result.array.push([yn, 0, 1]);
-      result.normalize();
-      return result;
+    var yc = metaFiniteCount(y);
+    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], 1, [[m, 0, 1]]);
     }
-    var result = y.clone();
-    result.layer = 1;
-    result.array[0] = base.array[0].slice();
-    result.array.push([1, 0, 1]);
-    result.normalize();
-    return result;
+    // ordinal / out-of-range operand: y plus one ω^(ω+1) marker row
+    return Q._ordinalOperandOp(y, 1, [1, 1, 1]);
   };
   Q.expoiter = Q.expo = Q.hwa1 = function (x, y) {
     return new MetaNum(x).expoiter(y);
@@ -3194,24 +3887,24 @@
     z = new MetaNum(z);
     if (x.isNaN() || z.isNaN()) return MetaNum.NaN.clone();
     if (x.array.length >= 2) {
-      // For ordinal y: find [1, 0, 1] marker and return y
+      // marker [y,0,1] = 10{ω^ω·y}10 → the count carries y
       for (var i = x.array.length - 1; i >= 1; i--) {
         var row = x.array[i];
-        if (row.length >= 3 && row[1] === 0 && row[2] === 1 && row[0] === 1) {
+        if (row.length === 3 && row[1] === 0 && row[2] === 1 && row[0] > 0) {
+          return new MetaNum(row[0]);
+        }
+      }
+      // For ordinal y: find [1, 0, 1] marker and return y
+      for (var k = x.array.length - 1; k >= 1; k--) {
+        var row2 = x.array[k];
+        if (row2.length >= 3 && row2[1] === 0 && row2[2] === 1 && row2[0] === 1) {
           var result = x.clone();
-          result.array.splice(i, 1);
+          result.array.splice(k, 1);
           result.normalize();
           if (result.array.length <= 1) result.layer = 0;
           return result;
         }
       }
-      // For finite y: find [yn, 0, 1] and return yn
-      for (var i = x.array.length - 1; i >= 1; i--) {
-        var row = x.array[i];
-        if (row.length === 3 && row[1] === 0 && row[2] === 1 && row[0] > 0) {
-          return new MetaNum(row[0]);
-        }
-      }
     }
     return z;
   };
@@ -3219,10 +3912,10 @@
     return new MetaNum(x).inv_expoiter(z);
   };
 
-  // trioterate (ω^(ω*2)): x{ω^(ω*2)}y = x{ω^(ω+y)}y
-    // for k <= MSI, tria(3,k)=3{ω^(ω+k)}k
-    // ≈10{ω^(ω+k)}k → layer=1, array=[[0],[1,k,1]]
-    // for k > MSI, tria(3,k)≈10{ω^(ω*2)}MSI → layer=1, array=[[0],[1,0,2]]
+  // trioterate (ω^(ω*2)): (ω^(ω*2))[y] = ω^(ω+y)  →  x{ω^(ω*2)}y = x{ω^(ω+y)}x
+    // for k <= MSI, tria(3,k)=3{ω^(ω+k)}3
+    // ≈10{ω^(ω+k)}10 → layer=1, array=[[10],[1,k,1]] (ord = ω+k)
+    // for k > MSI, tria(3,k)≈10{ω^(ω*2)}10 → layer=1, array=[[10],[1,0,2]]
   P.trioterate = P.tria = P.hwm2 = function (y) {
     var x = this.clone();
     y = new MetaNum(y);
@@ -3230,23 +3923,14 @@
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
-    if (y.layer === 0 && y.array.length <= 1) {
-      var yn = y.toNumber();
-      var base = x.expoiter(x);
-      if (y.eq(2)) return base;
-      var result = base.clone();
-      result.layer = 1;
-      result.array = [[1]];
-      result.array.push([1, yn, 1]);
-      result.normalize();
-      return result;
+    var yc = metaFiniteCount(y);
+    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], 1, [[1, m, 1]]);
     }
-    var result = y.clone();
-    result.layer = 1;
-    var base = x.iter(x);
-    result.array[0] = base.array[0].slice();
-    result.normalize();
-    return result;
+    // ordinal / out-of-range operand: y plus one ω^(ω*2) marker row
+    return Q._ordinalOperandOp(y, 1, [1, 0, 2]);
   };
   Q.trioterate = Q.tria = Q.hwm2 = function (x, y) {
     return new MetaNum(x).trioterate(y);
@@ -3282,10 +3966,10 @@
     return new MetaNum(x).inv_trioterate(z);
   };
 
-  // trixxate (ω^(ω^2)): x{ω^(ω^2)}y=x{ω^(ω*y)}y
-    // for k <= MSI, trix(3,k)=3{ω^(ω*k)}k
-    // ≈10{ω^(ω*k)}k → layer=1, array=[[0],[1,0,k]]
-    // for k > MSI, trix(3,k)≈10{ω^(ω^2)}MSI → layer=1, array=[[0],[1,0,0,1]]
+  // trixxate (ω^(ω^2)): (ω^(ω^2))[y] = ω^(ω*y)  →  x{ω^(ω^2)}y = x{ω^(ω*y)}x
+    // for k <= MSI, trix(3,k)=3{ω^(ω*k)}3
+    // ≈10{ω^(ω*k)}10 → layer=2, array=[[10],[k,1]] (bracket = ω*k, ω^bracket)
+    // for k > MSI, trix(3,k)≈10{ω^(ω^2)}10 → layer=2, array=[[10],[1,2]]
   P.trixxate = P.trix = P.hwp2 = function (y) {
     var x = this.clone();
     y = new MetaNum(y);
@@ -3293,23 +3977,14 @@
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
-    if (y.layer === 0 && y.array.length <= 1) {
-      var yn = y.toNumber();
-      var base = x.trioterate(x);
-      if (y.eq(2)) return base;
-      var result = base.clone();
-      result.layer = 2;
-      result.array = [[1]];
-      result.array.push([1, yn, 1]);
-      result.normalize();
-      return result;
+    var yc = metaFiniteCount(y);
+    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], 2, [[m, 1]]);
     }
-    var result = y.clone();
-    result.layer = 2;
-    var base = x.trioterate(x);
-    result.array[0] = base.array[0].slice();
-    result.normalize();
-    return result;
+    // ordinal / out-of-range operand: y plus one ω^(ω^2) marker row
+    return Q._ordinalOperandOp(y, 2, [1, 2]);
   };
   Q.trixxate = Q.trix = Q.hwp2 = function (x, y) {
     return new MetaNum(x).trixxate(y);
@@ -3319,6 +3994,12 @@
     var x = this.clone();
     z = new MetaNum(z);
     if (x.isNaN() || z.isNaN()) return MetaNum.NaN.clone();
+    // standard marker [1,10,y] = 10{ω^(ω*y+10)}10 (layer 1) or [y,1] (layer 2)
+    for (var k = x.array.length - 1; k >= 1; k--) {
+      var rw = x.array[k];
+      if (rw.length === 2 && rw[0] > 0 && rw[1] === 1) return new MetaNum(rw[0]);
+      if (rw.length === 3 && rw[0] === 1 && rw[2] >= 2) return new MetaNum(rw[2]);
+    }
     if (x.array.length >= 2) {
       // For ordinal y: find [1, 0, 1] marker and return y
       for (var i = x.array.length - 1; i >= 1; i--) {
@@ -3345,11 +4026,11 @@
     return new MetaNum(x).inv_trixxate(z);
   };
 
-  // aperixxate (ω^(ω^ω)): x{ω^(ω^ω)}y=x{ω^(ω^y)}y, can reach layer 2
-    // for k < maxCol-1, apix(3,k)≈10{ω^(ω^k)}k → layer=1, array=[[0],[1,0,0,...(k zeroes)...,0,1]]
-    // for maxCol-1 <= k <= MSI → layer=2, array=[[0],[1,k]]
-    // for k > MSI, apix(3,k)≈10{ω^(ω^2)}MSI → layer=2, array=[[0],[1,0,1]]
-    // Repetition count negligible for layer >= 2 (defaults to 1)
+  // aperixxate (ω^(ω^ω)): (ω^(ω^ω))[y] = ω^(ω^y)  →  x{ω^(ω^ω)}y = x{ω^(ω^y)}x
+    // for k <= MSI, apix(3,k)=3{ω^(ω^k)}3
+    // ≈10{ω^(ω^k)}10 → layer=3, array=[[k]] (bracket = the constant k, so the
+    //   ordinal reads ω^(ω^k)); layer 3 is the ω^(ω^ω) level (README).
+    // for k > MSI, apix(3,k)≈10{ω^(ω^ω)}10 → layer=3, array=[[10],[1,1]]
   P.aperixxate = P.apix = P.hwpw = function (y) {
     var x = this.clone();
     y = new MetaNum(y);
@@ -3357,23 +4038,14 @@
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
-    if (y.layer === 0 && y.array.length <= 1) {
-      var yn = y.toNumber();
-      var base = x.trixxate(x);
-      if (y.eq(2)) return base;
-      var result = base.clone();
-      result.layer = 3;
-      result.array = [[1]];
-      result.array.push([1, yn, 1]);
-      result.normalize();
-      return result;
+    var yc = metaFiniteCount(y);
+    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([m], 3, []);
     }
-    var result = y.clone();
-    result.layer = 3;
-    var base = x.trixxate(x);
-    result.array[0] = base.array[0].slice();
-    result.normalize();
-    return result;
+    // ordinal / out-of-range operand: y plus one ω^(ω^ω) marker row
+    return Q._ordinalOperandOp(y, 3, [1, 1]);
   };
   Q.aperixxate = Q.apix = Q.hwpw = function (x, y) {
     return new MetaNum(x).aperixxate(y);
@@ -3383,6 +4055,24 @@
     var x = this.clone();
     z = new MetaNum(z);
     if (x.isNaN() || z.isNaN()) return MetaNum.NaN.clone();
+    // standard marker [[10],[1,0,…,0,1]] = 10{ω^(ω^y)}10 → y+1 zeros-and-one
+    // row length (layer 1), or the layer-≥2 merged form r0 = [...,1@y]
+    for (var k = x.array.length - 1; k >= 1; k--) {
+      var rw = x.array[k];
+      if (rw.length >= 3 && rw[0] === 1 && rw[rw.length - 1] === 1) {
+        var zeros = 0;
+        for (var j = 1; j < rw.length - 1; j++) {
+          if ((rw[j] || 0) === 0) zeros++; else break;
+        }
+        if (zeros === rw.length - 2 && zeros > 0) return new MetaNum(zeros);
+      }
+    }
+    if (x.layer >= 2 && x.array.length === 1) {
+      var rr = x.array[0];
+      for (var j2 = rr.length - 1; j2 >= 1; j2--) {
+        if ((rr[j2] || 0) > 0) return new MetaNum(j2);
+      }
+    }
     if (x.array.length >= 2) {
       // For ordinal y: find [1, 0, 1] marker and return y
       for (var i = x.array.length - 1; i >= 1; i--) {
@@ -3409,8 +4099,11 @@
     return new MetaNum(x).inv_aperixxate(z);
   };
 
-  // epsilonate (ε₀ = ω↑↑ω): x{ε₀}y=x{ω^ω^...(y ω's)}y
-  // layer varies with y
+  // epsilonate (ε₀ = ω↑↑ω): ε₀[y] = ω^ω^…(y ω's)  →  x{ε₀}y = x{ω↑↑y}x
+  // layer = y (README L17: layer L holds an ω-tower of height L), so
+  //   epsl(3,k) ≈ 10{ω^ω^…^ω(k ω's)}10 → layer=k, array=[[10],[1,1]]
+  //   (bracket = ω, (k-1) ω^'s above it → a tower of k ω's).
+  //   k > MSI → the ε-tower cap: layer=MSI (the MetaNum limit).
   P.epsilonate = P.epsl = P.hepsl = function (y) {
     var x = this.clone();
     y = new MetaNum(y);
@@ -3418,23 +4111,17 @@
     if (x.eq(MetaNum.ONE)) return MetaNum.ONE.clone();
     if (y.eq(MetaNum.ONE)) return x.clone();
     if (y.lte(MetaNum.ZERO)) return MetaNum.NaN.clone();
-    if (y.layer === 0 && y.array.length <= 1) {
-      var yn = y.toNumber();
-      var base = x.aperixxate(x);
-      if (y.eq(2)) return base;
-      var result = base.clone();
-      result.layer = yn;
-      result.array = [[1]];
-      result.array.push([1, yn, 1]);
-      result.normalize();
-      return result;
-    }
-    var result = y.clone();
-    result.layer = y.layer;
-    var base = x.aperixxate(x);
-    result.array[0] = base.array[0].slice();
-    result.normalize();
-    return result;
+    // ε₀[2] = ω^ω, so epsilonate(x,2) = x{ω^ω}x = iterate(x,x) exactly (the
+    // same value itermult(x,2) produces — x{ε₀}2 = x{ω^ω+1}2).
+    if (y.eq(2)) return x.iterate(x);
+    var yc = metaFiniteCount(y);
+    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]]);
+    }
+    // ordinal / out-of-range operand: ε₀ caps the library → the MSI ω-tower
+    return Q._layerMarker([10], MAX_SAFE_INTEGER, [[1, 1]]);
   };
   Q.epsilonate = Q.epsl = Q.hepsl = function (x, y) {
     return new MetaNum(x).epsilonate(y);
@@ -3444,6 +4131,15 @@
     var x = this.clone();
     z = new MetaNum(z);
     if (x.isNaN() || z.isNaN()) return MetaNum.NaN.clone();
+    // standard marker: layer = y-1 with the de-layered tower row [1,10,1]
+    if (x.layer >= 1) {
+      for (var k = x.array.length - 1; k >= 1; k--) {
+        var rw = x.array[k];
+        if (rw.length === 3 && rw[0] === 1 && rw[2] === 1 && (rw[1] || 0) >= 2) {
+          return new MetaNum(x.layer + 1);
+        }
+      }
+    }
     if (x.array.length >= 2) {
       // For ordinal y: find [1, 0, 1] marker and return y
       for (var i = x.array.length - 1; i >= 1; i--) {
@@ -3867,17 +4563,19 @@
           var lastRow = this.array[this.array.length - 1];
           return lastRow[0] + "Aa" + lastRow[1];
         }
-        // Non-truncated: show all rows
+        // Non-truncated: show all rows as space-separated "countAalevel"
+        // tokens (count always included, so the parser can re-split them)
         var tokens = [];
         for (var i = this.array.length - 1; i >= 1; i--) {
           var row = this.array[i];
-          var tok = row[0] > 1 ? row[0] + "Aa" + row[1] : "Aa" + row[1];
-          tokens.push(tok);
+          tokens.push(row[0] + "Aa" + row[1]);
         }
         var finOps = formatFiniteOps(this.array[0]);
         var hasAa = finOps && finOps.indexOf("Aa") !== -1;
         var baseNum = hasAa ? "" : decimalPlaces(this.array[0][0], 6);
-        return tokens.join("") + (finOps ? finOps : "") + baseNum;
+        var tokStr = tokens.join(" ");
+        if (tokStr !== "" && (finOps !== "" || baseNum !== "")) tokStr += " ";
+        return tokStr + (finOps ? finOps : "") + baseNum;
       }
       
       var ordTokens = [];
@@ -3971,6 +4669,19 @@
     return this.toString();
   };
 
+  // dlsdl letter-notation formatting (format-metanum.js, README "Format"
+  // section). The module is resolved lazily to avoid a circular require:
+  // format-metanum reads the MetaNum constructor from the global scope.
+  //   MetaNum("G600").format()      → "1.000G600"
+  //   MetaNum.hardy(4166).format()  → "2.397G5"
+  P.format = function (precision, small) {
+    var formatter = null;
+    if (typeof require == 'function') {
+      try { formatter = require('./format-metanum.js').format; } catch (e) { formatter = null; }
+    }
+    return format(this, precision, small);
+  };
+
   P.toExponential = function (places) {
     if (this.sign === -1 || this.sign === -2) return "-" + this.abs().toExponential(places);
     if (this.isNaN()) return "NaN";
@@ -4036,7 +4747,7 @@
       else x.sign = sign < 0 ? -1 : 1;
     } else x.sign = 1;
     if (typeof layer === "number" && isFinite(layer) && layer >= 0) x.layer = Math.floor(layer);
-    else x.layer = computeLayer(x.array);
+    else x.layer = 0;
     return x.normalize();
   };
 
@@ -4626,14 +5337,16 @@
             cCount = parseInt(chainTokM[2], 10);
             for (var cli = 0; cli < cLetters.length; cli++) {
               var clLevel = cLetters.charCodeAt(cli) - 68; // E->1, F->2, ...
-              if (clLevel < 1 || clLevel >= MetaNum.maxCols - 1) { chainOk = false; break; }
+              if (clLevel < 1 || clLevel > 99) { chainOk = false; break; }
               chainFin[clLevel] = (chainFin[clLevel] || 0) + (cli === cLetters.length - 1 ? cCount : 1);
             }
             if (!chainOk) break;
           } else {
             cLevel = parseInt(chainTokM[4], 10);
             cCount = parseInt(chainTokM[3], 10);
-            if (cLevel < 1 || cLevel >= MetaNum.maxCols - 1) { chainOk = false; break; }
+            // Levels beyond maxCols are fine: normalize converts the r0
+            // overflow into finite-level ordinal rows [count, level]
+            if (cLevel < 1 || cLevel > 99) { chainOk = false; break; }
             chainFin[cLevel] = (chainFin[cLevel] || 0) + cCount;
           }
         }
@@ -4641,7 +5354,7 @@
         var chainCompact = chainMatch[3] || "";
         for (var cci = 0; cci < chainCompact.length && chainOk; cci++) {
           var cclLevel = chainCompact.charCodeAt(cci) - 68;
-          if (cclLevel >= 1 && cclLevel < MetaNum.maxCols - 1) {
+          if (cclLevel >= 1 && cclLevel <= 99) {
             chainFin[cclLevel] = (chainFin[cclLevel] || 0) + 1;
           }
         }
@@ -4728,6 +5441,56 @@
         }
       }
 
+      // Stacked layer symbols: peel the outermost symbol and add its layer
+      // to the parsed remainder ("@!2.000Aaaa10" = parse of !form at one
+      // higher layer).
+      var stackedSym = rem.match(/^([!@#\$%&~<>?])([!@#\$%&~<>?]+\S*)$/);
+      if (stackedSym) {
+        var innerS = Q.fromString(stackedSym[2]);
+        // each outer symbol is exactly one more ω^-tower layer
+        innerS.layer = (innerS.layer || 0) + 1;
+        if (negateIt) innerS.sign = -1;
+        return innerS.normalize();
+      }
+
+      // Canonical diagonal-letter output "mantissa LETTER β" where LETTER is
+      // any multi-letter token ending in 'a' (Aa, Ba, Aaa, Aaaa, …), with the
+      // dlsdl diagonal mantissa α ∈ [2,10):
+      //   exact anchor α=2.000 -> the plain letter application LETTER(β)
+      //     (2·5^0=2 adds nothing);
+      //   fractional α -> compact smooth row [α, β] (r0=[1]), the same
+      //     representation the engine emits for 10{β}(structured counts).
+      var diagBinMatch = rem.match(/^([!@#\$%&~<>?]?)(\d+\.\d+)([A-Z][a-z]+)(\d[\d,]*)\s*$/);
+      if (diagBinMatch) {
+        var dbSym = diagBinMatch[1];
+        var dbMant = Number(diagBinMatch[2]);
+        var dbTok = diagBinMatch[3];
+        var dbBeta = Number(String(diagBinMatch[4]).replace(/,/g, ""));
+        if (isFinite(dbMant) && isFinite(dbBeta) &&
+            dbTok[dbTok.length - 1] === "a" && dbMant >= 2 && dbMant < 10) {
+          var dbVal;
+          if (Math.abs(dbMant - 2) < 1e-9) {
+            dbVal = Q.fromString(dbSym + dbTok + String(dbBeta));
+          } else {
+            // compact smooth form 10{β+1}(α): row [α, β] with r0=[1]
+            dbVal = new MetaNum({ sign: 1, layer: 0, array: [[1], [dbMant, dbBeta]] });
+            dbVal.normalize();
+            if (dbSym) {
+              dbVal.layer = "!@#$%&~<>?".indexOf(dbSym) + 1;
+              dbVal.normalize();
+            }
+          }
+          if (negateIt) dbVal.sign = -1;
+          return dbVal;
+        }
+      }
+
+      // Binary-form α prefix with α = 1.000 exactly: Γ(β + log 1) = Γβ, so the
+      // mantissa carries no information and can be stripped before matching
+      // (e.g. "!1.000Aa5" ≡ "!Aa5", "1.000F300" ≡ "F300"). Non-unit α needs
+      // the fractional-argument machinery and is not accepted here.
+      rem = rem.replace(/^([!@#\$%&~<>?]?)1\.0+(?=[A-Z])/, '$1');
+
       // Handle layer symbol prefix + letter pattern + optional finOps + number (e.g., !Abcd1234, !AaE16, @Bcde500)
       var symPrefixMatch = rem.match(/^([!@#\$%&~<>?])([A-Z][a-z]+(?:[A-Z][a-z]+)*)([A-Z]*)(\d+)\s*$/);
       if (symPrefixMatch) {
@@ -4737,12 +5500,17 @@
         rem = symPrefixMatch[2] + (symPrefixMatch[3] || '') + symPrefixMatch[4];
       }
 
-      var oaMatch = rem.match(/^((?:[A-Z][a-z]+)+)([A-Z]*)(\d+)/);
+      // Ordinal-prefix chain with a full number argument — the argument may be
+      // a plain integer ("AaG5"), a decimal ("AaG5.5"), or a sci-notation value
+      // ("AaGF7.626E12", the round-trip of format() displays like "AaGF7.626E12"
+      // whose letter chain carries a huge finite-arg). The old (\d+) regex ate
+      // only "7" and silently dropped ".626E12".
+      var oaMatch = rem.match(/^((?:[A-Z][a-z]+)+)([A-Z]*)((?:\d+(?:\.\d+)?(?:[Ee]\d+)?))$/);
       if (oaMatch) {
         var oaFullPrefix = oaMatch[1];
         var oaFinOps = oaMatch[2];
         var oaN = Number(oaMatch[3]);
-        if (!isNaN(oaN) && isFinite(oaN) && oaN >= 1 && oaN === Math.floor(oaN)) {
+        if (!isNaN(oaN) && isFinite(oaN) && oaN >= 0) {
           var oaTokens = [];
           var oaTokenRegex = /[A-Z][a-z]+/g;
           var oaTm;
@@ -4925,9 +5693,9 @@
 
   
   // ==================== BEAF Ordinal Helpers ====================
-  // Build ordinal coefficient array from BEAF args (each arg contributes arg-1):
-  //   BEAF(a,b,c,d,e,f,...) = a{...+ω^3*(f-1)+ω^2*(e-1)+ω*(d-1)+(c-1)}b
-  //   coeffs[0] = c-1 (ω^0 = constant term)
+  // Build ordinal coefficient array from BEAF args:
+  //   BEAF(a,b,c,d,e,f,...) = a{...+ω^3*(f-1)+ω^2*(e-1)+ω*(d-1)+c}b
+  //   coeffs[0] = c (ω^0 = constant term, no decrement)
   //   coeffs[1] = d-1 (ω^1 coefficient)
   //   coeffs[2] = e-1 (ω^2 coefficient)
   //   coeffs[3] = f-1 (ω^3 coefficient)
@@ -4947,7 +5715,8 @@
         hugeArgs.push(arg.clone());
         coeffs.push(Infinity);
       } else {
-        coeffs.push(Math.max(0, Math.floor(eff) - 1));
+        // constant term (i=2) keeps its value; ω^k coefficients (i>=3) decrement
+        coeffs.push(i === 2 ? Math.max(0, Math.floor(eff)) : Math.max(0, Math.floor(eff) - 1));
       }
     }
     return { coeffs: coeffs, hugeArgs: hugeArgs };
@@ -4972,7 +5741,7 @@
       var cf = trimCoeffs(coeffs.map(function (c) { return Math.max(0, Math.floor(c)); }));
       if (cf.length === 0) return a.pow(b); // level 0 → a^b (b arg is the level-1 op)
       if (!coeffsHaveOmegaPart(cf)) return a.arrow(cf[0])(b); // finite level c
-      return Q._ordinalHyperop(a, b, cf);
+      return Q._applyExpansionTruncation(Q._ordinalHyperop(a, b, cf));
     }
     // collapse at the highest huge coefficient: coeffs[iHuge+1] += 1, zero the rest below
     var cf = coeffs.slice();
@@ -4983,7 +5752,183 @@
     // anchor: the largest operand dominates (right-to-left composition)
     var anchor = a.max(b);
     for (var j = 0; j < (hugeArgs || []).length; j++) anchor = anchor.max(hugeArgs[j]);
-    return Q._applyOrdinalRows(anchor, cf, 1);
+    return Q._applyExpansionTruncation(Q._applyOrdinalRows(anchor, cf, 1));
+  };
+
+  // ==================== Hardy Hierarchy ====================
+  // H_α(n) via transfinite recursion (issues.md / README):
+  //   H_0(n) = n
+  //   H_{α+1}(n) = H_α(n+1)          (successor step: only +1, never iterated)
+  //   H_λ(n) = H_{λ[n]}(n)           (limit step: CNF fundamental sequence at n)
+  // where λ[n] acts on the lowest limit term: (… + ω^j·c_j)[n] = … + ω^j·(c_j−1)
+  // + ω^{j−1}·n.  Closed forms keep the recursion finite:
+  //   H_{β+c}(n)   = H_β(n+c)        (c successor steps)
+  //   H_{β+ω·c}(n) = H_β(n·2^c)      (c ω-level limit steps)
+  // For ω^j·c segments with c beyond the exact-iteration bound (j ≥ 2) the
+  // value collapses into the hyperoperation engine, mirroring the classic
+  // identity F_j = H^{ω^j} (F_2(n)=n·2^n, F_3(n)≈2↑↑n, …):
+  //   H_{β+ω^j·c}(n) ≈ H_β(2{c}^j)   i.e. 2.arrow(j)(c)
+  var HARDY_EXACT_BOUND = 50;
+  // H_α(n) — ITERATIVE (the original tail recursion grew hundreds of frames
+  // 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) {
+    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]));
+    var n = MN(nArg);
+    var guard2 = 200000;
+    // The exact limit-step expansion is only feasible while the running base n
+    // stays a small plain integer; once n is structured (or the step budget is
+    // exhausted) the nested expansion would take ~n^degree steps, so take the
+    // same supremum collapse the engine uses above HARDY_EXACT_BOUND.
+    function nIsSmallPlain() {
+      if (n.layer !== 0 || n.array.length !== 1) return false;
+      var nv = n.toNumber();
+      return isFinite(nv) && nv === Math.floor(nv) && Math.abs(nv) <= HARDY_EXACT_BOUND;
+    }
+    while (--guard2 >= 0) {
+      while (c.length > 0 && c[c.length - 1].eq(MetaNum.ZERO)) c.pop();
+      if (c.length === 0) return n;                        // H_0(n) = n
+      if (c.length === 1) return n.add(c[0]);              // H_c(n) = n + c
+      if (c[0].gt(MetaNum.ZERO)) {                         // successor strip
+        n = n.add(c[0]);
+        c[0] = MetaNum.ZERO.clone();
+        continue;
+      }
+      var j = 1;
+      while (j < c.length && !c[j].gt(MetaNum.ZERO)) j++;
+      if (j === 1) {                                       // ω-segment closed form
+        // H_{β + ω·c1}(n) = H_β(n · 2^{c1}) — evaluate with the OLD c1
+        var nWf = n.mul(new MetaNum(2).pow(c[1]));
+        var beta = [MetaNum.ZERO.clone(), MetaNum.ZERO.clone()];
+        for (var k = 2; k < c.length; k++) beta.push(c[k]);
+        c = beta;
+        n = nWf;
+        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]);
+        var beta2 = [MetaNum.ZERO.clone()];
+        for (var k2 = 0; k2 < j; k2++) beta2.push(MetaNum.ZERO.clone());
+        for (var k3 = j + 1; k3 < c.length; k3++) beta2.push(c[k3]);
+        c = beta2;
+        n = nCol;
+        continue;
+      }
+      // exact limit step on ω^j·c_j: c_j-=1, c_{j-1}=n
+      c[j] = c[j].sub(MetaNum.ONE);
+      c[j - 1] = n.clone();
+    }
+    // budget exhausted: keep whatever was accumulated (monotone)
+    return n;
+  };
+
+  // MetaNum.hardy(n): the Hardy level of n.
+  //   n < 10 → 10 + n;  otherwise the decimal digits of n become the CNF
+  //   coefficients of an ordinal α (hardy(1234) = H_{ω³+ω²·2+ω·3+4}(10)) and
+  //   the result is H_α(10).
+  Q.hardy = function (n) {
+    n = new MetaNum(n);
+    if (n.sign !== 1) {
+      throw Error(metaNumError + 'hardy: n must be a non-negative integer');
+    }
+    // v2.1 (issues.md): MetaNum-object input. Values beyond double range or
+    // carrying ordinal rows/layers read their STRUCTURE as the ordinal:
+    //   a power tower 10^^k shadows to ω^ω^…^ω (k ω's), and H there is the
+    //   engine diagonal 10{ω^ω^…^ω(k ω's)}10 = 10.epsilonate(k) — so
+    //   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;
+    if (!isFinite(num)) {
+      if (n.layer === 0 && n.array.length === 1) {
+        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)
+        if (hVal.layer === 0 && hVal.array.length === 1 && hVal.array[0].length === 1) {
+          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();
+          }
+        }
+        // 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();
+    }
+    var s = 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)
+    var eMatch = s.match(/^(\d)(?:\.(\d+))?e\+?(\d+)$/);
+    if (eMatch) {
+      var eFrac = eMatch[2] || '';
+      var eZeros = Number(eMatch[3]) - eFrac.length;
+      if (eZeros > 0) s = eMatch[1] + eFrac + '0'.repeat(eZeros);
+    }
+    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:
+      //   n = dk·10^kExp + rest  →  α = ω^ord(kExp)·dk + ord(rest)
+      //   H_α(10) = H_{ω^ord(kExp)·dk}(H_ord(rest)(10)) — the lower part acts
+      // first: n1 = H_ord(rest)(10) (recursive, exact path for rest < 1e10).
+      //   n1 = H_rest(10) becomes the fundamental-sequence argument of the
+      // leading term:
+      //   kExp = 10 (ord = ω):  H_{ω^ω·dk}(n1) = H_{ω^n1}(n1) exact (first
+      //     segment), the remaining dk−1 ω^ω-segments each add one ω-row —
+      //     hardy(1e10) = H_{ω^10}(10) = [3086.036065328153, 9×8] EXACTLY,
+      //     strictly below 10{10}10 (issues.md);
+      //   kExp ≥ 11 (ord = ω+c): mirror the engine's own ordinal rows for
+      //     10{ω+c}(9+dk) on the from-below base H_{ω^n1}(n1) — hardy(1e11)
+      //     = H_{ω^(ω+1)}(10) keeps expande(10,10)'s row structure with the
+      //     strictly smaller definitional base, so hardy(1e11) < 10{ω+1}10
+      //     (issues.md).
+      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);
+      }
+      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)
+      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]);
+      }
+      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());
   };
 
   // ==================== BEAF Array Notation ====================
@@ -5019,7 +5964,7 @@
         var cNum = c.toNumber();
         if (isFinite(cNum)) {
           // any finite integer level: arrow() covers small, compact ordinal-row
-          // (level ≥ maxCols) and the ≥ maxArrow approximation branches
+          // (level ≥ maxCols) approximation branches
           return args[0].arrow(cNum)(args[1]);
         }
       }
@@ -5116,7 +6061,7 @@
           if (allNonNegative) {
             var a = decimalPlaces(x.array[0][0], 6);
             // Reconstruct BEAF: {a, ?, c, d, e, ...} from ordinal row [1, c, d, e, ..., 1]
-            // (raw coefficient convention: BEAF(a,b,c,d,...) = a{...+ω*d+c}b)
+            // (issues.md convention: BEAF(a,b,c,d,...) = a{...+ω*(d-1)+c}b)
             var beafParts = [a, '?'];
             for (var i = 0; i < vals.length; i++) {
               beafParts.push(String(vals[i]));
@@ -5312,7 +6257,7 @@
 
     if (obj === void 0) obj = {};
     if (obj) {
-      ps = ['maxRows', 'maxCols', 'maxArrow', 'serializeMode', 'debug'];
+      ps = ['maxRows', 'maxCols', 'serializeMode', 'debug'];
       for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];
     }
 
@@ -5322,6 +6267,27 @@
   }
 
   function defineConstants(obj) {
+    // maxRows / maxCols are clamped to [10, 1000] on every write, direct or
+    // through config() — outside the range the array structures lose their
+    // invariants (r0 diagonal needs ≥ 2 levels, row budgets exceed the
+    // ordinal-row machinery).
+    if (Object.defineProperty) {
+      ['maxRows', 'maxCols'].forEach(function (p) {
+        var store = obj[p];
+        Object.defineProperty(obj, p, {
+          configurable: true,
+          enumerable: true,
+          get: function () { return store; },
+          set: function (v) {
+            var n = Math.floor(Number(v));
+            if (!isFinite(n)) return;
+            if (n < 10) n = 10;
+            if (n > 1000) n = 1000;
+            store = n;
+          }
+        });
+      });
+    }
     for (var prop in R) {
       if (R.hasOwnProperty(prop)) {
         var val = R[prop];
@@ -5350,7 +6316,6 @@
       ps = [
         'maxRows', 10, 1000,
         'maxCols', 10, 1000,
-        'maxArrow', 1, Number.MAX_SAFE_INTEGER,
         'serializeMode', 0, 1,
         'debug', 0, 2
       ];