@lotics/app-sdk 0.120.1 → 0.120.3

package/dist/{chunk-NZXJENJ2.js → chunk-ABDSJ25E.js}

@@ -185,28 +185,651 @@ function bandOf(tiers, figure) {
   return { min: tiers[at - 1] ?? null, max: tiers[at] ?? null };
 }
 
-// ../shared/src/utils.ts
-function decimalPlaces(value) {
-  if (Number.isInteger(value)) return 0;
-  const [mantissa = "", exponent = "0"] = String(value).split("e");
-  const fraction = mantissa.split(".")[1]?.length ?? 0;
-  return Math.max(0, fraction - Number(exponent));
+// ../../node_modules/big.js/big.mjs
+var DP = 20;
+var RM = 1;
+var MAX_DP = 1e6;
+var MAX_POWER = 1e6;
+var NE = -7;
+var PE = 21;
+var STRICT = false;
+var NAME = "[big.js] ";
+var INVALID = NAME + "Invalid ";
+var INVALID_DP = INVALID + "decimal places";
+var INVALID_RM = INVALID + "rounding mode";
+var DIV_BY_ZERO = NAME + "Division by zero";
+var P = {};
+var UNDEFINED = void 0;
+var NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
+function _Big_() {
+  function Big2(n) {
+    var x = this;
+    if (!(x instanceof Big2)) {
+      return n === UNDEFINED && arguments.length === 0 ? _Big_() : new Big2(n);
+    }
+    if (n instanceof Big2) {
+      x.s = n.s;
+      x.e = n.e;
+      x.c = n.c.slice();
+    } else {
+      if (typeof n !== "string") {
+        if (Big2.strict === true && typeof n !== "bigint") {
+          throw TypeError(INVALID + "value");
+        }
+        n = n === 0 && 1 / n < 0 ? "-0" : String(n);
+      }
+      parse(x, n);
+    }
+    x.constructor = Big2;
+  }
+  Big2.prototype = P;
+  Big2.DP = DP;
+  Big2.RM = RM;
+  Big2.NE = NE;
+  Big2.PE = PE;
+  Big2.strict = STRICT;
+  Big2.roundDown = 0;
+  Big2.roundHalfUp = 1;
+  Big2.roundHalfEven = 2;
+  Big2.roundUp = 3;
+  return Big2;
+}
+function parse(x, n) {
+  var e, i, nl;
+  if (!NUMERIC.test(n)) {
+    throw Error(INVALID + "number");
+  }
+  x.s = n.charAt(0) == "-" ? (n = n.slice(1), -1) : 1;
+  if ((e = n.indexOf(".")) > -1) n = n.replace(".", "");
+  if ((i = n.search(/e/i)) > 0) {
+    if (e < 0) e = i;
+    e += +n.slice(i + 1);
+    n = n.substring(0, i);
+  } else if (e < 0) {
+    e = n.length;
+  }
+  nl = n.length;
+  for (i = 0; i < nl && n.charAt(i) == "0"; ) ++i;
+  if (i == nl) {
+    x.c = [x.e = 0];
+  } else {
+    for (; nl > 0 && n.charAt(--nl) == "0"; ) ;
+    x.e = e - i - 1;
+    x.c = [];
+    for (e = 0; i <= nl; ) x.c[e++] = +n.charAt(i++);
+  }
+  return x;
+}
+function round(x, sd, rm, more) {
+  var xc = x.c;
+  if (rm === UNDEFINED) rm = x.constructor.RM;
+  if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {
+    throw Error(INVALID_RM);
+  }
+  if (sd < 1) {
+    more = rm === 3 && (more || !!xc[0]) || sd === 0 && (rm === 1 && xc[0] >= 5 || rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED)));
+    xc.length = 1;
+    if (more) {
+      x.e = x.e - sd + 1;
+      xc[0] = 1;
+    } else {
+      xc[0] = x.e = 0;
+    }
+  } else if (sd < xc.length) {
+    more = rm === 1 && xc[sd] >= 5 || rm === 2 && (xc[sd] > 5 || xc[sd] === 5 && (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) || rm === 3 && (more || !!xc[0]);
+    xc.length = sd;
+    if (more) {
+      for (; ++xc[--sd] > 9; ) {
+        xc[sd] = 0;
+        if (sd === 0) {
+          ++x.e;
+          xc.unshift(1);
+          break;
+        }
+      }
+    }
+    for (sd = xc.length; !xc[--sd]; ) xc.pop();
+  }
+  return x;
+}
+function stringify(x, doExponential, isNonzero) {
+  var e = x.e, s = x.c.join(""), n = s.length;
+  if (doExponential) {
+    s = s.charAt(0) + (n > 1 ? "." + s.slice(1) : "") + (e < 0 ? "e" : "e+") + e;
+  } else if (e < 0) {
+    for (; ++e; ) s = "0" + s;
+    s = "0." + s;
+  } else if (e > 0) {
+    if (++e > n) {
+      for (e -= n; e--; ) s += "0";
+    } else if (e < n) {
+      s = s.slice(0, e) + "." + s.slice(e);
+    }
+  } else if (n > 1) {
+    s = s.charAt(0) + "." + s.slice(1);
+  }
+  return x.s < 0 && isNonzero ? "-" + s : s;
+}
+P.abs = function() {
+  var x = new this.constructor(this);
+  x.s = 1;
+  return x;
+};
+P.cmp = function(y) {
+  var isneg, x = this, xc = x.c, yc = (y = new x.constructor(y)).c, i = x.s, j = y.s, k = x.e, l = y.e;
+  if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;
+  if (i != j) return i;
+  isneg = i < 0;
+  if (k != l) return k > l ^ isneg ? 1 : -1;
+  j = (k = xc.length) < (l = yc.length) ? k : l;
+  for (i = -1; ++i < j; ) {
+    if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
+  }
+  return k == l ? 0 : k > l ^ isneg ? 1 : -1;
+};
+P.div = function(y) {
+  var x = this, Big2 = x.constructor, a = x.c, b = (y = new Big2(y)).c, k = x.s == y.s ? 1 : -1, dp = Big2.DP;
+  if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
+    throw Error(INVALID_DP);
+  }
+  if (!b[0]) {
+    throw Error(DIV_BY_ZERO);
+  }
+  if (!a[0]) {
+    y.s = k;
+    y.c = [y.e = 0];
+    return y;
+  }
+  var bl, bt, n, cmp, ri, bz = b.slice(), ai = bl = b.length, al = a.length, r = a.slice(0, bl), rl = r.length, q = y, qc = q.c = [], qi = 0, p = dp + (q.e = x.e - y.e) + 1;
+  q.s = k;
+  k = p < 0 ? 0 : p;
+  bz.unshift(0);
+  for (; rl++ < bl; ) r.push(0);
+  do {
+    for (n = 0; n < 10; n++) {
+      if (bl != (rl = r.length)) {
+        cmp = bl > rl ? 1 : -1;
+      } else {
+        for (ri = -1, cmp = 0; ++ri < bl; ) {
+          if (b[ri] != r[ri]) {
+            cmp = b[ri] > r[ri] ? 1 : -1;
+            break;
+          }
+        }
+      }
+      if (cmp < 0) {
+        for (bt = rl == bl ? b : bz; rl; ) {
+          if (r[--rl] < bt[rl]) {
+            ri = rl;
+            for (; ri && !r[--ri]; ) r[ri] = 9;
+            --r[ri];
+            r[rl] += 10;
+          }
+          r[rl] -= bt[rl];
+        }
+        for (; !r[0]; ) r.shift();
+      } else {
+        break;
+      }
+    }
+    qc[qi++] = cmp ? n : ++n;
+    if (r[0] && cmp) r[rl] = a[ai] || 0;
+    else r = [a[ai]];
+  } while ((ai++ < al || r[0] !== UNDEFINED) && k--);
+  if (!qc[0] && qi != 1) {
+    qc.shift();
+    q.e--;
+    p--;
+  }
+  if (qi > p) round(q, p, Big2.RM, r[0] !== UNDEFINED);
+  return q;
+};
+P.eq = function(y) {
+  return this.cmp(y) === 0;
+};
+P.gt = function(y) {
+  return this.cmp(y) > 0;
+};
+P.gte = function(y) {
+  return this.cmp(y) > -1;
+};
+P.lt = function(y) {
+  return this.cmp(y) < 0;
+};
+P.lte = function(y) {
+  return this.cmp(y) < 1;
+};
+P.minus = P.sub = function(y) {
+  var i, j, t, xlty, x = this, Big2 = x.constructor, a = x.s, b = (y = new Big2(y)).s;
+  if (a != b) {
+    y.s = -b;
+    return x.plus(y);
+  }
+  var xc = x.c.slice(), xe = x.e, yc = y.c, ye = y.e;
+  if (!xc[0] || !yc[0]) {
+    if (yc[0]) {
+      y.s = -b;
+    } else if (xc[0]) {
+      y = new Big2(x);
+    } else {
+      y.s = 1;
+    }
+    return y;
+  }
+  if (a = xe - ye) {
+    if (xlty = a < 0) {
+      a = -a;
+      t = xc;
+    } else {
+      ye = xe;
+      t = yc;
+    }
+    t.reverse();
+    for (b = a; b--; ) t.push(0);
+    t.reverse();
+  } else {
+    j = ((xlty = xc.length < yc.length) ? xc : yc).length;
+    for (a = b = 0; b < j; b++) {
+      if (xc[b] != yc[b]) {
+        xlty = xc[b] < yc[b];
+        break;
+      }
+    }
+  }
+  if (xlty) {
+    t = xc;
+    xc = yc;
+    yc = t;
+    y.s = -y.s;
+  }
+  if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--; ) xc[i++] = 0;
+  for (b = i; j > a; ) {
+    if (xc[--j] < yc[j]) {
+      for (i = j; i && !xc[--i]; ) xc[i] = 9;
+      --xc[i];
+      xc[j] += 10;
+    }
+    xc[j] -= yc[j];
+  }
+  for (; xc[--b] === 0; ) xc.pop();
+  for (; xc[0] === 0; ) {
+    xc.shift();
+    --ye;
+  }
+  if (!xc[0]) {
+    y.s = 1;
+    xc = [ye = 0];
+  }
+  y.c = xc;
+  y.e = ye;
+  return y;
+};
+P.mod = function(y) {
+  var ygtx, x = this, Big2 = x.constructor, a = x.s, b = (y = new Big2(y)).s;
+  if (!y.c[0]) {
+    throw Error(DIV_BY_ZERO);
+  }
+  x.s = y.s = 1;
+  ygtx = y.cmp(x) == 1;
+  x.s = a;
+  y.s = b;
+  if (ygtx) return new Big2(x);
+  a = Big2.DP;
+  b = Big2.RM;
+  Big2.DP = Big2.RM = 0;
+  x = x.div(y);
+  Big2.DP = a;
+  Big2.RM = b;
+  return this.minus(x.times(y));
+};
+P.neg = function() {
+  var x = new this.constructor(this);
+  x.s = -x.s;
+  return x;
+};
+P.plus = P.add = function(y) {
+  var e, k, t, x = this, Big2 = x.constructor;
+  y = new Big2(y);
+  if (x.s != y.s) {
+    y.s = -y.s;
+    return x.minus(y);
+  }
+  var xe = x.e, xc = x.c, ye = y.e, yc = y.c;
+  if (!xc[0] || !yc[0]) {
+    if (!yc[0]) {
+      if (xc[0]) {
+        y = new Big2(x);
+      } else {
+        y.s = x.s;
+      }
+    }
+    return y;
+  }
+  xc = xc.slice();
+  if (e = xe - ye) {
+    if (e > 0) {
+      ye = xe;
+      t = yc;
+    } else {
+      e = -e;
+      t = xc;
+    }
+    t.reverse();
+    for (; e--; ) t.push(0);
+    t.reverse();
+  }
+  if (xc.length - yc.length < 0) {
+    t = yc;
+    yc = xc;
+    xc = t;
+  }
+  e = yc.length;
+  for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;
+  if (k) {
+    xc.unshift(k);
+    ++ye;
+  }
+  for (e = xc.length; xc[--e] === 0; ) xc.pop();
+  y.c = xc;
+  y.e = ye;
+  return y;
+};
+P.pow = function(n) {
+  var x = this, one = new x.constructor("1"), y = one, isneg = n < 0;
+  if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) {
+    throw Error(INVALID + "exponent");
+  }
+  if (isneg) n = -n;
+  for (; ; ) {
+    if (n & 1) y = y.times(x);
+    n >>= 1;
+    if (!n) break;
+    x = x.times(x);
+  }
+  return isneg ? one.div(y) : y;
+};
+P.prec = function(sd, rm) {
+  if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
+    throw Error(INVALID + "precision");
+  }
+  return round(new this.constructor(this), sd, rm);
+};
+P.round = function(dp, rm) {
+  if (dp === UNDEFINED) dp = 0;
+  else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) {
+    throw Error(INVALID_DP);
+  }
+  return round(new this.constructor(this), dp + this.e + 1, rm);
+};
+P.sqrt = function() {
+  var r, c, t, x = this, Big2 = x.constructor, s = x.s, e = x.e, half = new Big2("0.5");
+  if (!x.c[0]) return new Big2(x);
+  if (s < 0) {
+    throw Error(NAME + "No square root");
+  }
+  s = Math.sqrt(+stringify(x, true, true));
+  if (s === 0 || s === 1 / 0) {
+    c = x.c.join("");
+    if (!(c.length + e & 1)) c += "0";
+    s = Math.sqrt(c);
+    e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
+    r = new Big2((s == 1 / 0 ? "5e" : (s = s.toExponential()).slice(0, s.indexOf("e") + 1)) + e);
+  } else {
+    r = new Big2(s + "");
+  }
+  e = r.e + (Big2.DP += 4);
+  do {
+    t = r;
+    r = half.times(t.plus(x.div(t)));
+  } while (t.c.slice(0, e).join("") !== r.c.slice(0, e).join(""));
+  return round(r, (Big2.DP -= 4) + r.e + 1, Big2.RM);
+};
+P.times = P.mul = function(y) {
+  var c, x = this, Big2 = x.constructor, xc = x.c, yc = (y = new Big2(y)).c, a = xc.length, b = yc.length, i = x.e, j = y.e;
+  y.s = x.s == y.s ? 1 : -1;
+  if (!xc[0] || !yc[0]) {
+    y.c = [y.e = 0];
+    return y;
+  }
+  y.e = i + j;
+  if (a < b) {
+    c = xc;
+    xc = yc;
+    yc = c;
+    j = a;
+    a = b;
+    b = j;
+  }
+  for (c = new Array(j = a + b); j--; ) c[j] = 0;
+  for (i = b; i--; ) {
+    b = 0;
+    for (j = a + i; j > i; ) {
+      b = c[j] + yc[i] * xc[j - i - 1] + b;
+      c[j--] = b % 10;
+      b = b / 10 | 0;
+    }
+    c[j] = b;
+  }
+  if (b) ++y.e;
+  else c.shift();
+  for (i = c.length; !c[--i]; ) c.pop();
+  y.c = c;
+  return y;
+};
+P.toExponential = function(dp, rm) {
+  var x = this, n = x.c[0];
+  if (dp !== UNDEFINED) {
+    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
+      throw Error(INVALID_DP);
+    }
+    x = round(new x.constructor(x), ++dp, rm);
+    for (; x.c.length < dp; ) x.c.push(0);
+  }
+  return stringify(x, true, !!n);
+};
+P.toFixed = function(dp, rm) {
+  var x = this, n = x.c[0];
+  if (dp !== UNDEFINED) {
+    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
+      throw Error(INVALID_DP);
+    }
+    x = round(new x.constructor(x), dp + x.e + 1, rm);
+    for (dp = dp + x.e + 1; x.c.length < dp; ) x.c.push(0);
+  }
+  return stringify(x, false, !!n);
+};
+P.toJSON = P.toString = function() {
+  var x = this, Big2 = x.constructor;
+  return stringify(x, x.e <= Big2.NE || x.e >= Big2.PE, !!x.c[0]);
+};
+if (typeof Symbol !== "undefined") {
+  P[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = P.toJSON;
+}
+P.toNumber = function() {
+  var n = +stringify(this, true, true);
+  if (this.constructor.strict === true && !this.eq(n.toString())) {
+    throw Error(NAME + "Imprecise conversion");
+  }
+  return n;
+};
+P.toPrecision = function(sd, rm) {
+  var x = this, Big2 = x.constructor, n = x.c[0];
+  if (sd !== UNDEFINED) {
+    if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
+      throw Error(INVALID + "precision");
+    }
+    x = round(new Big2(x), sd, rm);
+    for (; x.c.length < sd; ) x.c.push(0);
+  }
+  return stringify(x, sd <= x.e || x.e <= Big2.NE || x.e >= Big2.PE, !!n);
+};
+P.valueOf = function() {
+  var x = this, Big2 = x.constructor;
+  if (Big2.strict === true) {
+    throw Error(NAME + "valueOf disallowed");
+  }
+  return stringify(x, x.e <= Big2.NE || x.e >= Big2.PE, true);
+};
+var Big = _Big_();
+var big_default = Big;
+
+// ../shared/src/decimal.ts
+var DIVISION_DIGITS = 24;
+var ROUNDING_PLACES = 1e6;
+var POWER_DIGITS = 300;
+var SIGNIFICANT_DIGITS = 15;
+var SHORT_DIGITS = 12;
+var WHOLE_DIGITS_LIMIT = 10 ** SIGNIFICANT_DIGITS;
+var DIVISION_SCALES = [10, 100, 1e3, 1e4, 1e5, 1e6];
+var Decimal = big_default();
+Decimal.DP = DIVISION_DIGITS;
+Decimal.RM = big_default.roundDown;
+var QUOTIENT_STEP = new Decimal(`1e-${DIVISION_DIGITS}`);
+function takesFloat(left, right) {
+  return !Number.isFinite(left) || !Number.isFinite(right) || left === 0 || right === 0;
+}
+function isExactInteger(left, right, result) {
+  return Number.isSafeInteger(left) && Number.isSafeInteger(right) && Number.isSafeInteger(result);
+}
+function isInexact(value, decimal) {
+  return decimal.c.length > SHORT_DIGITS && !Number.isSafeInteger(value);
+}
+function settled(result, inexact) {
+  if (!inexact) return result;
+  const reading = result.prec(SIGNIFICANT_DIGITS, big_default.roundHalfUp);
+  return reading.c.length <= SHORT_DIGITS ? reading : result;
+}
+function addDecimal(left, right) {
+  const float = left + right;
+  if (takesFloat(left, right) || isExactInteger(left, right, float)) return float;
+  const augend = new Decimal(left);
+  const addend = new Decimal(right);
+  return settled(augend.plus(addend), isInexact(left, augend) || isInexact(right, addend)).toNumber();
+}
+function subtractDecimal(left, right) {
+  const float = left - right;
+  if (takesFloat(left, right) || isExactInteger(left, right, float)) return float;
+  const minuend = new Decimal(left);
+  const subtrahend = new Decimal(right);
+  return settled(minuend.minus(subtrahend), isInexact(left, minuend) || isInexact(right, subtrahend)).toNumber();
+}
+function multiplyDecimal(left, right) {
+  return product(left, right, true);
+}
+function multiplyExactly(left, right) {
+  return product(left, right, false);
+}
+function product(left, right, settles) {
+  const float = left * right;
+  if (takesFloat(left, right) || isExactInteger(left, right, float)) return float;
+  const multiplicand = new Decimal(left);
+  const multiplier = new Decimal(right);
+  return settled(multiplicand.times(multiplier), settles && (isInexact(left, multiplicand) || isInexact(right, multiplier))).toNumber();
+}
+function divideDecimal(left, right) {
+  if (takesFloat(left, right) || Number.isSafeInteger(left) && Number.isSafeInteger(right)) return left / right;
+  const scaled = scaledQuotient(left, right);
+  if (scaled !== void 0) return scaled;
+  const dividend = new Decimal(left);
+  const divisor = new Decimal(right);
+  return quotient(dividend, divisor, isInexact(left, dividend) || isInexact(right, divisor));
+}
+function scaledQuotient(left, right) {
+  for (const scale2 of DIVISION_SCALES) {
+    const dividend = Math.round(left * scale2);
+    if (Math.abs(dividend) >= WHOLE_DIGITS_LIMIT || dividend / scale2 !== left) continue;
+    const divisor = Math.round(right * scale2);
+    if (Math.abs(divisor) < WHOLE_DIGITS_LIMIT && divisor / scale2 === right) return dividend / divisor;
+  }
+  return void 0;
+}
+function moduloDecimal(left, right) {
+  if (takesFloat(left, right)) return left % right;
+  const remainder = new Decimal(left).mod(right);
+  if (remainder.eq(0)) return left < 0 ? -0 : 0;
+  return remainder.toNumber();
+}
+function readAtSignificantDigits(value) {
+  if (Number.isInteger(value) || !Number.isFinite(value)) return value;
+  if (Math.abs(value) >= WHOLE_DIGITS_LIMIT) return Math.sign(value) * Math.round(Math.abs(value));
+  return Number(value.toPrecision(SIGNIFICANT_DIGITS));
+}
+function compareDecimal(left, right) {
+  if (left === right) return 0;
+  if (Number.isNaN(left) || Number.isNaN(right)) return NaN;
+  const leftRead = readAtSignificantDigits(left);
+  const rightRead = readAtSignificantDigits(right);
+  if (leftRead === rightRead) return 0;
+  return leftRead < rightRead ? -1 : 1;
 }
 function sumDecimal(values, divisor = 1) {
-  const float = values.reduce((total2, value) => total2 + value, 0) / divisor;
-  if (!values.every(Number.isFinite)) return float;
-  const factor = 10 ** values.reduce((places, value) => Math.max(places, decimalPlaces(value)), 0);
-  const scaled = values.map((value) => Math.round(value * factor));
-  const total = scaled.reduce((sum, value) => sum + value, 0);
-  const exact = Number.isSafeInteger(total) && scaled.every((one, index) => Number.isSafeInteger(one) && one / factor === values[index]);
-  return exact ? total / (factor * divisor) : float;
+  if (!values.every(Number.isFinite) || !Number.isFinite(divisor) || divisor === 0) {
+    return values.reduce((total2, value) => total2 + value, 0) / divisor;
+  }
+  const { total, inexact } = isWithinSafeIntegers(values) ? { total: new Decimal(values.reduce((sum, value) => sum + value, 0)), inexact: false } : totalOf(values);
+  if (total.eq(0)) return 0;
+  if (divisor === 1) return total.toNumber();
+  const by = new Decimal(divisor);
+  return quotient(total, by, inexact || isInexact(divisor, by));
+}
+function totalOf(values) {
+  let total = new Decimal(0);
+  let inexact = false;
+  for (const value of values) {
+    const term = new Decimal(value);
+    inexact ||= isInexact(value, term);
+    total = total.plus(term);
+  }
+  return { total: settled(total, inexact), inexact };
+}
+function isWithinSafeIntegers(values) {
+  return values.every(Number.isSafeInteger) && values.reduce((magnitude, value) => magnitude + Math.abs(value), 0) <= Number.MAX_SAFE_INTEGER;
 }
-function sample(arr) {
-  if (arr.length === 0) return void 0;
-  return arr[Math.floor(Math.random() * arr.length)];
+function roundDecimal(value, places) {
+  if (!Number.isFinite(value) || value === 0 || !Number.isInteger(places) || Math.abs(places) > ROUNDING_PLACES) {
+    const multiplier = Math.pow(10, places);
+    return Math.sign(value) * Math.round(Math.abs(value) * multiplier) / multiplier;
+  }
+  const rounded = new Decimal(value).round(places, big_default.roundHalfUp);
+  if (rounded.eq(0)) return value < 0 ? -0 : 0;
+  return rounded.toNumber();
+}
+function percentOf(part, total) {
+  return roundDecimal(divideDecimal(multiplyDecimal(part, 100), total), 0);
+}
+function fixedDecimal(value, places) {
+  if (!Number.isFinite(value) || Math.abs(value) >= 1e21) return value.toFixed(places);
+  return new Decimal(value).toFixed(places, big_default.roundHalfUp);
+}
+function powerDecimal(base, exponent) {
+  const float = Math.pow(base, exponent);
+  if (takesFloat(base, exponent) || !Number.isInteger(exponent)) return float;
+  const decimal = new Decimal(base);
+  if (decimal.c.length * Math.abs(exponent) > POWER_DIGITS) return float;
+  const inexact = isInexact(base, decimal);
+  const power = settled(decimal.pow(Math.abs(exponent)), inexact);
+  return exponent > 0 ? power.toNumber() : quotient(new Decimal(1), power, inexact);
+}
+function quotient(dividend, divisor, inexact) {
+  const sign = dividend.s === divisor.s ? 1 : -1;
+  const numerator = coefficientOf(dividend);
+  const denominator = coefficientOf(divisor);
+  for (let carried = 0; ; carried = carried * 2 + DIVISION_DIGITS) {
+    const scaled = new Decimal(`${numerator.digits}e${carried}`);
+    const low = scaled.div(denominator.digits);
+    const exponent = numerator.exponent - denominator.exponent - carried;
+    if (inexact) {
+      const short = settled(low, true);
+      if (short !== low) return sign * Number(`${short.toFixed()}e${exponent}`);
+    }
+    const lowNumber = Number(`${low.toFixed()}e${exponent}`);
+    const highNumber = Number(`${low.plus(QUOTIENT_STEP).toFixed()}e${exponent}`);
+    if (lowNumber === highNumber || low.times(denominator.digits).eq(scaled)) return sign * lowNumber;
+  }
 }
-function assertNever(value) {
-  throw new Error(`Unhandled union member: ${JSON.stringify(value)}`);
+function coefficientOf(decimal) {
+  const [digits = "", exponent = "0"] = decimal.abs().toExponential().split("e");
+  return { digits, exponent: Number(exponent) };
 }
 
 // ../shared/src/schemas/read_row.ts
@@ -1242,9 +1865,18 @@ export {
   tiersAscend,
   bandKey,
   bandOf,
+  addDecimal,
+  subtractDecimal,
+  multiplyDecimal,
+  multiplyExactly,
+  divideDecimal,
+  moduloDecimal,
+  compareDecimal,
   sumDecimal,
-  sample,
-  assertNever,
+  roundDecimal,
+  percentOf,
+  fixedDecimal,
+  powerDecimal,
   AGGREGATE_COUNT_COLUMN,
   AGGREGATE_SUM_COLUMN,
   aggregateRows,

package/dist/index.js

@@ -3,35 +3,44 @@ import {
   AGGREGATE_SUM_COLUMN,
   DEFAULT_IMAGE_FIDELITY,
   __export,
+  addDecimal,
   aggregateRows,
   anyRecordingLive,
   applyPatch,
-  assertNever,
   bandKey,
   bandOf,
+  compareDecimal,
   decodeAll,
+  divideDecimal,
   encodePatch,
+  fixedDecimal,
   getUrlParams,
   isEmbedded,
+  moduloDecimal,
+  multiplyDecimal,
+  multiplyExactly,
   paramsEqual,
   peekUrlParams,
+  percentOf,
   postHostNotification,
+  powerDecimal,
   readRecordingSnapshot,
   recordingStateOf,
   recordingsVersion,
   replaceRecordings,
+  roundDecimal,
   rpc,
   rpcAgentRun,
   rpcAgentRunContinue,
-  sample,
   setUrlParams,
   subscribeQueriesChanged,
   subscribeRecordings,
   subscribeUrlParams,
+  subtractDecimal,
   sumDecimal,
   tiersAscend,
   urlParam
-} from "./chunk-NZXJENJ2.js";
+} from "./chunk-ABDSJ25E.js";
 
 // src/mount.tsx
 import { createRoot } from "react-dom/client";
@@ -1729,6 +1738,15 @@ var customRandom = (alphabet, defaultSize, getRandom) => {
 };
 var customAlphabet = (alphabet, size2 = 21) => customRandom(alphabet, size2 | 0, random);
 
+// ../shared/src/utils.ts
+function sample(arr) {
+  if (arr.length === 0) return void 0;
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function assertNever(value) {
+  throw new Error(`Unhandled union member: ${JSON.stringify(value)}`);
+}
+
 // ../shared/src/expression_array.ts
 var expression_array_exports = {};
 __export(expression_array_exports, {
@@ -2782,7 +2800,7 @@ function formatNumber(value, decimals) {
     throw new Error("formatNumber: expected number, got " + typeof value);
   }
   assertDecimals(decimals, "formatNumber");
-  return value.toFixed(decimals);
+  return fixedDecimal(value, decimals);
 }
 function formatDecimal(value, decimals, locale) {
   if (value == null) return "";
@@ -2902,9 +2920,7 @@ function round(value, precision) {
   if (precision != null && typeof precision !== "number") {
     throw new Error("round: precision must be a number");
   }
-  const prec = precision != null ? precision : 0;
-  const multiplier = Math.pow(10, prec);
-  return Math.round(value * multiplier) / multiplier;
+  return roundDecimal(value, precision ?? 0);
 }
 function sum(arr) {
   if (arr == null) return 0;
@@ -2970,12 +2986,8 @@ function percentage(part, total, decimals) {
   if (decimals != null && typeof decimals !== "number") {
     throw new Error("percentage: decimals must be a number");
   }
-  const percent = part / total * 100;
-  if (decimals != null) {
-    const multiplier = Math.pow(10, decimals);
-    return Math.round(percent * multiplier) / multiplier;
-  }
-  return percent;
+  const percent = divideDecimal(multiplyDecimal(part, 100), total);
+  return decimals != null ? roundDecimal(percent, decimals) : percent;
 }
 function pow(base, exponent) {
   if (base == null || exponent == null) return null;
@@ -2985,7 +2997,7 @@ function pow(base, exponent) {
   if (typeof exponent !== "number") {
     throw new Error("pow: exponent must be a number");
   }
-  return Math.pow(base, exponent);
+  return powerDecimal(base, exponent);
 }
 function sqrt(n) {
   if (n == null) return null;
@@ -3008,7 +3020,7 @@ function mod(n, divisor) {
   if (divisor === 0) {
     throw new Error("mod: divisor cannot be zero");
   }
-  return n % divisor;
+  return moduloDecimal(n, divisor);
 }
 
 // ../shared/src/expression_object.ts
@@ -5815,9 +5827,21 @@ function isNothing(value) {
   return value === null || value === void 0;
 }
 var MULTIPLICATIVE_OPERATORS = /* @__PURE__ */ new Map([
-  ["*", (left, right) => left * right],
-  ["/", (left, right) => left / right],
-  ["%", (left, right) => left % right]
+  ["*", multiplyDecimal],
+  ["/", divideDecimal],
+  ["%", moduloDecimal]
+]);
+var COMPARISONS = /* @__PURE__ */ new Map([
+  // eslint-disable-next-line eqeqeq
+  ["==", { ofNumbers: (order) => order === 0, ofOthers: (left, right) => left == right }],
+  // eslint-disable-next-line eqeqeq
+  ["!=", { ofNumbers: (order) => order !== 0, ofOthers: (left, right) => left != right }],
+  ["===", { ofNumbers: (order) => order === 0, ofOthers: (left, right) => left === right }],
+  ["!==", { ofNumbers: (order) => order !== 0, ofOthers: (left, right) => left !== right }],
+  ["<", { ofNumbers: (order) => order < 0, ofOthers: (left, right) => left < right }],
+  ["<=", { ofNumbers: (order) => order <= 0, ofOthers: (left, right) => left <= right }],
+  [">", { ofNumbers: (order) => order > 0, ofOthers: (left, right) => left > right }],
+  [">=", { ofNumbers: (order) => order >= 0, ofOthers: (left, right) => left >= right }]
 ]);
 var SafeEvalAstFactory = class extends EvalAstFactory {
   id(name) {
@@ -5856,6 +5880,26 @@ var SafeEvalAstFactory = class extends EvalAstFactory {
         }
       };
     }
+    const comparison = COMPARISONS.get(op);
+    if (comparison) {
+      return {
+        type: "Binary",
+        operator: op,
+        left,
+        right,
+        evaluate(scope) {
+          const leftValue = this.left.evaluate(scope);
+          const rightValue = this.right.evaluate(scope);
+          if (typeof leftValue === "number" && typeof rightValue === "number") return comparison.ofNumbers(compareDecimal(leftValue, rightValue));
+          return comparison.ofOthers(leftValue, rightValue);
+        },
+        getIds(idents) {
+          this.left.getIds(idents);
+          this.right.getIds(idents);
+          return idents;
+        }
+      };
+    }
     if (op !== "+" && op !== "-") {
       return super.binary(left, op, right);
     }
@@ -5871,7 +5915,8 @@ var SafeEvalAstFactory = class extends EvalAstFactory {
           if (isNothing(leftValue) && isNothing(rightValue)) return null;
           const leftOperand = leftValue ?? 0;
           const rightOperand = rightValue ?? 0;
-          return op === "+" ? leftOperand + rightOperand : Number(leftOperand) - Number(rightOperand);
+          if (op === "-") return subtractDecimal(Number(leftOperand), Number(rightOperand));
+          return typeof leftOperand === "number" && typeof rightOperand === "number" ? addDecimal(leftOperand, rightOperand) : leftOperand + rightOperand;
         };
         return op === "+" ? addOrConcat(leftValue, rightValue, combine) : combine();
       },
@@ -21164,7 +21209,7 @@ function aggregateTextField(values2, operation) {
       const emptyCount = values2.filter(
         (value) => value === null || value === void 0 || value === ""
       ).length;
-      const percentage2 = Math.round(emptyCount / totalCount * 100);
+      const percentage2 = percentOf(emptyCount, totalCount);
       return { result: percentage2 };
     }
     case "percent_filled": {
@@ -21172,7 +21217,7 @@ function aggregateTextField(values2, operation) {
       const filledCount = values2.filter(
         (value) => value !== null && value !== void 0 && value !== ""
       ).length;
-      const percentage2 = Math.round(filledCount / totalCount * 100);
+      const percentage2 = percentOf(filledCount, totalCount);
       return { result: percentage2 };
     }
     case "unique": {
@@ -21188,7 +21233,7 @@ function aggregateTextField(values2, operation) {
       );
       if (filledValues.length === 0) return { result: 0 };
       const uniqueValues = new Set(filledValues);
-      const percentage2 = Math.round(uniqueValues.size / filledValues.length * 100);
+      const percentage2 = percentOf(uniqueValues.size, filledValues.length);
       return { result: percentage2 };
     }
     default:
@@ -21212,13 +21257,13 @@ function aggregateNumberField(values2, operation) {
     case "percent_empty": {
       if (totalCount === 0) return { result: 0 };
       const emptyCount = values2.filter((value) => !hasNumberValue(value)).length;
-      const percentage2 = Math.round(emptyCount / totalCount * 100);
+      const percentage2 = percentOf(emptyCount, totalCount);
       return { result: percentage2 };
     }
     case "percent_filled": {
       if (totalCount === 0) return { result: 0 };
       const filledCount = values2.filter(hasNumberValue).length;
-      const percentage2 = Math.round(filledCount / totalCount * 100);
+      const percentage2 = percentOf(filledCount, totalCount);
       return { result: percentage2 };
     }
     case "unique": {
@@ -21230,7 +21275,7 @@ function aggregateNumberField(values2, operation) {
       const filledValues = values2.filter(hasNumberValue);
       if (filledValues.length === 0) return { result: 0 };
       const uniqueValues = new Set(filledValues);
-      const percentage2 = Math.round(uniqueValues.size / filledValues.length * 100);
+      const percentage2 = percentOf(uniqueValues.size, filledValues.length);
       return { result: percentage2 };
     }
   }
@@ -21288,13 +21333,13 @@ function aggregateBooleanField(values2, operation) {
     case "percent_checked": {
       if (totalCount === 0) return { result: 0 };
       const checkedCount = values2.filter((value) => value === true).length;
-      const percentage2 = Math.round(checkedCount / totalCount * 100);
+      const percentage2 = percentOf(checkedCount, totalCount);
       return { result: percentage2 };
     }
     case "percent_unchecked": {
       if (totalCount === 0) return { result: 0 };
       const uncheckedCount = values2.filter((value) => !value).length;
-      const percentage2 = Math.round(uncheckedCount / totalCount * 100);
+      const percentage2 = percentOf(uncheckedCount, totalCount);
       return { result: percentage2 };
     }
     default:
@@ -21321,7 +21366,7 @@ function aggregateDateField(values2, operation) {
       const emptyCount = values2.filter(
         (value) => value === null || value === void 0 || value === ""
       ).length;
-      const percentage2 = Math.round(emptyCount / totalCount * 100);
+      const percentage2 = percentOf(emptyCount, totalCount);
       return { result: percentage2 };
     }
     case "percent_filled": {
@@ -21329,7 +21374,7 @@ function aggregateDateField(values2, operation) {
       const filledCount = values2.filter(
         (value) => value !== null && value !== void 0 && value !== ""
       ).length;
-      const percentage2 = Math.round(filledCount / totalCount * 100);
+      const percentage2 = percentOf(filledCount, totalCount);
       return { result: percentage2 };
     }
     case "unique": {
@@ -21345,7 +21390,7 @@ function aggregateDateField(values2, operation) {
       );
       if (filledValues.length === 0) return { result: 0 };
       const uniqueValues = new Set(filledValues);
-      const percentage2 = Math.round(uniqueValues.size / filledValues.length * 100);
+      const percentage2 = percentOf(uniqueValues.size, filledValues.length);
       return { result: percentage2 };
     }
   }
@@ -21451,13 +21496,13 @@ function aggregateGenericField(values2, operation) {
     case "percent_empty": {
       if (totalCount === 0) return { result: 0 };
       const emptyCount = values2.filter(isEmpty2).length;
-      const percentage2 = Math.round(emptyCount / totalCount * 100);
+      const percentage2 = percentOf(emptyCount, totalCount);
       return { result: percentage2 };
     }
     case "percent_filled": {
       if (totalCount === 0) return { result: 0 };
       const filledCount = values2.filter((value) => !isEmpty2(value)).length;
-      const percentage2 = Math.round(filledCount / totalCount * 100);
+      const percentage2 = percentOf(filledCount, totalCount);
       return { result: percentage2 };
     }
     case "unique": {
@@ -21484,7 +21529,7 @@ function aggregateGenericField(values2, operation) {
           uniqueValues.add(value);
         }
       }
-      const percentage2 = Math.round(uniqueValues.size / filledValues.length * 100);
+      const percentage2 = percentOf(uniqueValues.size, filledValues.length);
       return { result: percentage2 };
     }
     case "selected":
@@ -21513,13 +21558,13 @@ function aggregateSelectRecordLinkField(values2, operation) {
     case "percent_empty": {
       if (totalCount === 0) return { result: 0 };
       const emptyCount = values2.filter(isEmpty2).length;
-      const percentage2 = Math.round(emptyCount / totalCount * 100);
+      const percentage2 = percentOf(emptyCount, totalCount);
       return { result: percentage2 };
     }
     case "percent_filled": {
       if (totalCount === 0) return { result: 0 };
       const filledCount = values2.filter((value) => !isEmpty2(value)).length;
-      const percentage2 = Math.round(filledCount / totalCount * 100);
+      const percentage2 = percentOf(filledCount, totalCount);
       return { result: percentage2 };
     }
     case "selected":
@@ -21564,13 +21609,13 @@ function aggregateRollupField(values2, operation) {
     case "percent_empty": {
       if (totalCount === 0) return { result: 0 };
       const emptyCount = values2.filter(isEmpty2).length;
-      const percentage2 = Math.round(emptyCount / totalCount * 100);
+      const percentage2 = percentOf(emptyCount, totalCount);
       return { result: percentage2 };
     }
     case "percent_filled": {
       if (totalCount === 0) return { result: 0 };
       const filledCount = values2.filter((value) => !isEmpty2(value)).length;
-      const percentage2 = Math.round(filledCount / totalCount * 100);
+      const percentage2 = percentOf(filledCount, totalCount);
       return { result: percentage2 };
     }
     case "unique": {
@@ -21583,7 +21628,7 @@ function aggregateRollupField(values2, operation) {
       const filledValues = values2.filter((value) => !isEmpty2(value));
       if (filledValues.length === 0) return { result: 0 };
       const uniqueValues = new Set(filledValues);
-      const percentage2 = Math.round(uniqueValues.size / filledValues.length * 100);
+      const percentage2 = percentOf(uniqueValues.size, filledValues.length);
       return { result: percentage2 };
     }
   }
@@ -21904,9 +21949,8 @@ function currencyCodeOf(written) {
   if (Intl.supportedValuesOf("currency").includes(upper2)) return upper2;
   return DONG_SPELLINGS.includes(unitKey(written)) ? "VND" : void 0;
 }
-var EXACT_DIGITS = 15;
 function convert(value, from, to) {
-  return from.code === to.code ? value : Number((value * from.factor / to.factor).toPrecision(EXACT_DIGITS));
+  return from.code === to.code ? value : divideDecimal(multiplyDecimal(value, from.factor), to.factor);
 }
 function scaleIn(own, pack) {
   const kin = MEASURED_UNITS.filter((one) => one.dimension === own.dimension);
@@ -25051,7 +25095,7 @@ var tableDateFieldSchema = tableFieldBaseSchema.extend({
   format: dateFormatSchema.optional(),
   timezone: zod_default.string().optional().describe("IANA timezone"),
   derive_from: zod_default.enum(["created_at", "updated_at"]).optional().describe(
-    "Auto-populate from the row's system timestamp. `created_at` stamps once at insert time; `updated_at` re-stamps on every record edit. A derived field is read-only: a write naming it is refused, as for formula/rollup/lookup. Replaces the per-table after_create workflow pattern."
+    "Auto-populate from the row's system timestamp. `created_at` stamps once at insert time; `updated_at` re-stamps on every record edit. A derived field is read-only: a write naming it is refused, as for formula/rollup/lookup."
   ),
   // A derived date is read-only, so derive_from and default_value are mutually
   // exclusive — enforced in validateFieldDefaultValue.
@@ -28163,33 +28207,34 @@ async function evaluateBinary(op, leftExpr, rightExpr, ctx) {
         assertCheap(ctx.evaluation_budget, left, right);
         assertTextWithin("+", typeof left === "string" ? null : left, typeof right === "string" ? null : right);
       }
-      const sum2 = addOrConcat(left, right, () => assertNumber(left, "add", "left") + assertNumber(right, "add", "right"));
+      const sum2 = addOrConcat(left, right, () => addDecimal(assertNumber(left, "add", "left"), assertNumber(right, "add", "right")));
       charge(ctx, builtSize(sum2));
       return sum2;
     }
     case "sub":
-      return assertNumber(left, "sub", "left") - assertNumber(right, "sub", "right");
+      return subtractDecimal(assertNumber(left, "sub", "left"), assertNumber(right, "sub", "right"));
     case "mul":
-      return assertNumber(left, "mul", "left") * assertNumber(right, "mul", "right");
+      return multiplyDecimal(assertNumber(left, "mul", "left"), assertNumber(right, "mul", "right"));
     case "div": {
       const r = assertNumber(right, "div", "right");
       if (r === 0) {
         throw new WorkflowEvalError("Division by zero", { kind: "binary", at: "div" });
       }
-      return assertNumber(left, "div", "left") / r;
+      return divideDecimal(assertNumber(left, "div", "left"), r);
     }
     case "mod": {
       const r = assertNumber(right, "mod", "right");
       if (r === 0) {
         throw new WorkflowEvalError("Modulo by zero", { kind: "binary", at: "mod" });
       }
-      return assertNumber(left, "mod", "left") % r;
+      return moduloDecimal(assertNumber(left, "mod", "left"), r);
     }
   }
 }
 function looseEq(a, b) {
   if (isComposite(a) && b !== null && b !== void 0 && !isComposite(b)) return looseEq(textOf(a), b);
   if (isComposite(b) && a !== null && a !== void 0 && !isComposite(a)) return looseEq(a, textOf(b));
+  if (typeof a === "number" && typeof b === "number") return compareDecimal(a, b) === 0;
   return a == b;
 }
 function isComposite(value) {
@@ -28204,6 +28249,7 @@ function isScalar(value) {
   return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
 }
 function strictEq(a, b) {
+  if (typeof a === "number" && typeof b === "number") return compareDecimal(a, b) === 0;
   return a === b;
 }
 function compareOrdered(a, b) {
@@ -28211,7 +28257,7 @@ function compareOrdered(a, b) {
     return NaN;
   }
   if (typeof a === "number" && typeof b === "number") {
-    return a - b;
+    return compareDecimal(a, b);
   }
   if (typeof a === "string" && typeof b === "string") {
     return a < b ? -1 : a > b ? 1 : 0;
@@ -30510,7 +30556,7 @@ function evaluateCondition(record2, fieldByKey, looseCondition, memberContext, f
     if (reading.unit !== void 0 && filterCondition.value !== null && filterCondition.value !== void 0) {
       const factor = rowUnitFactor(reading.unit, data);
       if (factor === void 0) return false;
-      const inBase = { ...filterCondition, value: filterCondition.value * reading.unit.factor };
+      const inBase = { ...filterCondition, value: multiplyExactly(filterCondition.value, reading.unit.factor) };
       return matchCell(columnValue, field, inBase, looseCondition, memberContext, fileFacts, factor);
     }
   }
@@ -30619,7 +30665,7 @@ function matchCell(cell, field, filterCondition, looseCondition, memberContext,
       matches = foldedValue !== void 0 && needles.some((needle) => foldedValue.includes(needle));
     }
   } else if (filterCondition.type === "number") {
-    const numberValue = typeof columnValue === "number" ? columnValue * figureFactor : columnValue;
+    const numberValue = typeof columnValue === "number" ? multiplyExactly(columnValue, figureFactor) : columnValue;
     if (filterCondition.operator === "is_empty") {
       matches = !numberValue && numberValue !== 0;
     } else if (filterCondition.operator === "is_not_empty") {

package/dist/router.js

@@ -2,7 +2,7 @@ import {
   isEmbedded,
   postHostNotification,
   setUrlParams
-} from "./chunk-NZXJENJ2.js";
+} from "./chunk-ABDSJ25E.js";
 
 // src/router.tsx
 import { useEffect } from "react";

package/docs/mutations.md

@@ -397,8 +397,8 @@ Why a full-form snapshot save is a bug, not a style choice — three independent
    moment *any* field is touched — there is no value-equality pass (deep equality over stored
    shapes would be a silent lock bypass). A snapshot touches every field, so it turns every
    save against a locked record into a total rejection even when nothing changed.
-2. **A table's checks and `after_update` workflows run on the write.** They run on every
-   write that touches the record — a snapshot save runs them for fields the user never edited.
+2. **A table's checks run on the write.** They run on every write that touches the record —
+   a snapshot save runs them for fields the user never edited.
 3. **Snapshots clobber concurrent edits.** An update writes exactly the fields present in the
    payload; unsent fields keep their current value. A diff therefore coexists with a
    colleague's concurrent edit to a *different* field — a snapshot overwrites it with the

package/docs/workflows.md

@@ -51,9 +51,7 @@ compile-time "cannot find name", not a runtime `undefined`.
 |---|---|---|
 | `trigger` | every context | the trigger namespace. For an app workflow: `trigger.app_workflow.inputs.<name>` |
 | `runtime` | every context | execution context — see the key table below |
-| `record` | button + table-lifecycle workflows | the record the trigger fired on (merged data on update) |
-| `prev_record` | table `*_update` / `*_delete` | the prior record state — same shape as `record` |
-| `changes` | table `*_update` | per-field diff — a *partial* map, so read it `changes["fld_x"]?.next_value` / `?.prev_value` |
+| `record` | button workflows | the record the button was pressed on |
 | `index` | inside a `for-of` body | the current 0-based iteration index — always the **innermost** loop's. To use an outer loop's index in a nested body, bind it in the outer one (`const outerIdx = index;`) and read that |
 | `<bind_name>` | inside a `for-of` body | the current item. Each loop keeps its own, so a nested body reads the outer loop's item by its own bind name |
 | `<name>` | its block, after the declaration | a `const` — a step's output (`rows.records`, `approval.status`, …) or a bound value |
@@ -61,10 +59,6 @@ compile-time "cannot find name", not a runtime `undefined`.
 | `<param>` | inside a helper callback | that lambda's parameter |
 | `(await <tool>({…}))` | anywhere the call runs unconditionally | that call's output, read in place (see *`await` inside a statement*) |
 
-`record`, `prev_record` and `changes` are the **canonical** roots. `trigger.data`,
-`trigger.prev_data` and `trigger.changes` are accepted and lower onto them, so a saved body prints
-back in the bare form. Write the bare form.
-
 A body bound to an app alias is an app workflow: it sees `trigger` and `runtime` only. There is
 no `record` — an app workflow is not attached to a table. Pass the record id in as a
 `record_link` input and `get_record` it.
@@ -72,11 +66,9 @@ no `record` — an app workflow is not attached to a table. Pass the record id i
 `runtime` keys: `timezone`, `now`, `workflow_id`, `execution_id`, `workspace_id`,
 `organization_id`, `triggered_by_member_id` (`null` for a system trigger or an anonymous
 public-app caller), and `change_origin` — a discriminated union over how the **execution** was
-started: `button` · `automation` · `app_action` · `app_workflow` · `table_workflow`. It describes
+started: `button` · `automation` · `app_action` · `app_workflow`. It describes
 the dispatch, never the person, and it is fixed per attachment — an app workflow always reads
-`app_workflow`, a table workflow always `table_workflow`. To branch on *who wrote the record*,
-read `trigger.change_origin` on a table workflow (that one carries the originating write's
-origin, and spans every write path: `member`, `chat_agent`, `app_workflow`, …). `runtime`
+`app_workflow`. `runtime`
 is never null, so `runtime?.x` is rejected outright. Prefer the helper `now()` over
 `runtime.now`.
 
@@ -118,16 +110,13 @@ is a second call (`linked(linked(order.data["fld_a"])[0]["fld_b"])[0]`). A linke
 deleted, or that the run may not read, stays a positional `null`, so `linked(P)[i]` is always the
 row `P[i]` names.
 
-The argument is a path ending on a link field, off anything record-shaped: `record` /
-`prev_record`, a `for-of` item, a lambda parameter, a `let` binding, or a `get_record` /
+The argument is a path ending on a link field, off anything record-shaped: `record`, a `for-of` item, a lambda parameter, a `let` binding, or a `get_record` /
 `query_records` output. The server checks the far field at save only where it can name the table
 before the run — a call with a **literal** `table_id` — and the fetch works either way. Guard **inside** the
 argument — `linked(record?.["fld_link"])[0]` — never on the call: `linked(P)?.[i]` is rejected,
 because the call always returns an array and the guard could never fire. Two more rejections:
 `const ids = record["fld_link"]; linked(ids)`, since the field name comes from the argument's last
-member access (`linked(row["fld_link"])` off a bound ROW is fine), and
-`linked(changes["fld_link"]?.next_value)`, since a diff is not a record — read
-`linked(record["fld_link"])` or `linked(prev_record["fld_link"])`, which hold the same ids.
+member access (`linked(row["fld_link"])` off a bound ROW is fine).
 `linked` is grammar, not a helper: it cannot be shadowed, bound, called as a method, or awaited.
 
 ## Step forms
@@ -257,13 +246,12 @@ only the dialog. What it may name depends on who renders the refusal:
 | Workflow | `field_key` may name |
 |---|---|
 | app workflow | a declared INPUT name (`order_code`, a key of the binding's `inputs`), or the `fld_` key of a field on a table the body names as a literal (a `table_id: "tbl_…"`, or a `const` holding one) |
-| table-triggered (lifecycle, button) | the `fld_` key of a field on the trigger table |
+| button | the `fld_` key of a field on the button's table |
 | recordless automation (schedule, webhook, email) | anything — nothing renders it, so nothing checks it |
 
 An app workflow whose alias declares no inputs leaves input-shaped keys unchecked, so a body can
 be written before its declaration. A key outside its row is refused when the body is SAVED — by
-`set_app_workflow`, by an agent binding one, by a table workflow's save — and by a
-`verify_only` call before that. `return({ field_errors })` keys are not checked.
+`set_app_workflow`, by an agent binding one — and by a `verify_only` call before that. `return({ field_errors })` keys are not checked.
 
 ### `wait_for_approval` — the one wait worth binding
 
@@ -396,8 +384,8 @@ body does not look like what you typed.
 | `x.length` (dot only) | `length(x)` — strings and arrays. `x["length"]` still reads a field |
 | `String(x)`, `Number(x)`, `parseFloat(x)`, `+x` | `toString(x)` / `toNumber(x)` |
 | `x.toUpperCase()`, `x.toLowerCase()` | `upper(x)`, `lower(x)` |
-| `x.toFixed(2)` | `formatNumber(x, 2)` |
-| `Math.round/min/max/abs/floor/ceil/pow/sqrt(…)` | the like-named helper |
+| `x.toFixed(2)` | `formatNumber(x, 2)` — rounds the decimal, a half away from zero: `1.005` is `"1.01"` |
+| `Math.round/min/max/abs/floor/ceil/pow/sqrt(…)` | the like-named helper. `round` rounds the decimal, a half away from zero: `round(-2.5)` is `-3` |
 | `Math.max(...arr)` / `Math.min(...arr)` | `max(arr)` / `min(arr)` |
 | `JSON.parse`, `JSON.stringify` | `parseJson`, `toJson` |
 | `Array.isArray`, `Object.keys/values/entries` | `isArray`, `keys`/`values`/`entries` |
@@ -657,9 +645,8 @@ linked record id as `RecordId<"tbl_…">`. They come out branded from a record r
 or from a workflow input declared `member` / `file` / `record_link` — a `rec_*` string carried in
 a plain `text` input does *not* type-check into a link field, so declare the input for what it is.
 
-A link **read** is an id array, so it feeds straight back: `set: { fld_link: record["fld_link"] }`,
-and the same for `prev_record["fld_link"]` and for a diff's `changes["fld_link"]?.next_value` /
-`?.prev_value`. What does not feed back is a ROW: a link field takes ids, so from rows you already
+A link **read** is an id array, so it feeds straight back: `set: { fld_link: record["fld_link"] }`.
+What does not feed back is a ROW: a link field takes ids, so from rows you already
 hold write `pluck(rows.records, (r) => r.id)`, or `[x.id]` for one. Never route a link read through
 `linked(...)` to get its ids back — it holds them already, and the fetch costs one read per row and
 yields `null` where a row is deleted or unreadable, which the write then rejects.
@@ -796,8 +783,7 @@ The rules that are easy to get wrong because the failing code looks correct.
   `` `Status: ${record["fld_status"]}` `` prints "Done" while
   `record["fld_status"] == "opt_done"` compares keys — both correct, and neither substitutes for
   the other. It holds on every route a record arrives by — a `let`, a callback parameter, a row
-  from a variable `table_id` — and a change-diff read (`changes["fld_status"]?.next_value`)
-  behaves exactly like the same field read off the record.
+  from a variable `table_id`.
 - **Multi-select `==` quietly desugars.** On a multi-select field,
   `record["fld_tags"] == "opt_urgent"` rewrites to `includes(…)` at save. Either spelling is
   fine — but a `switch` on a multi-select discriminant is **rejected**, because its value is an
@@ -810,15 +796,6 @@ The rules that are easy to get wrong because the failing code looks correct.
   `xs = concat(xs, someArray)` fails to typecheck; appending a whole *array* has no `push`
   spelling. Start that binding from the first array instead of seeding it `[]`. Appending single
   **items** (`xs.push(item)`) works on a bare `[]` seed.
-- **A mutation on the trigger table of an `after_*` workflow can re-trigger itself** — a lint
-  warning, not an error. Gate it on `trigger.change_origin` — the originating write's origin —
-  and name every origin you mean to let through, rather than testing for one. `member` is a
-  person in the browser and **only** that: the same edit made over MCP, the CLI, or a direct API
-  call arrives as `api_client`, and one made by the chat agent as `chat_agent`. A gate meaning
-  "someone did this by hand" is
-  `includes(["member", "chat_agent", "api_client"], trigger.change_origin.type)`. Not
-  `runtime.change_origin`: that is the execution's own origin, always `table_workflow` here, so
-  it discriminates nothing.
 - **Expressions are bounded.** A helper that builds an array — `range`, `list`, `flatten`,
   `concat` of arrays, `split`'s parts — makes at most 100,000 elements, and a callback helper
   takes an array of at most 100,000. `join`, `replaceAll`, `padStart`, `padEnd`, `toString`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/app-sdk",
-  "version": "0.120.1",
+  "version": "0.120.3",
   "description": "The SDK a Lotics custom-code app reads and writes through — typed hooks over the host bridge, cell readers, mount() and AppRouter",
   "type": "module",
   "exports": {