@aster-cloud/aster-lang-ts 1.0.30 → 1.0.32

package/dist/src/core/interpreter.js

@@ -38,6 +38,12 @@ function decimalRoundingMode(mode) {
             throw new InterpreterError(`Decimal: unknown rounding mode ${JSON.stringify(mode)}; use "HALF_UP", "HALF_EVEN" or "DOWN".`);
     }
 }
+/**
+ * 十进制数值字面量（整数/小数/科学计数）。无歧义分支、线性匹配，见 decimalScale 里
+ * 记录的 ReDoS 教训。"0x10"/"Infinity"/"NaN"/"" 一律不匹配——与 Java
+ * `Double.parseDouble` 拒绝十六进制整数、与本仓 toInt 拒绝空串同向。
+ */
+const NUMERIC_LITERAL_RE = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
 /** scale 参数校验：必须是 0..18 的整数（v1 上限 scale 18，与 ADR 0025 一致）。 */
 function decimalScale(scale) {
     let n;
@@ -56,7 +62,7 @@ function decimalScale(scale) {
         //   scale 可由宿主传入，属不可控输入，必须走线性匹配。
         //   改写后语义完全一致（"2"/"1e1"/"+2"/"2.0"/".5"/"2." 接受；
         //   "2d"/"0x10"/"0x1p3"/"" 拒绝），2 万字符耗时降到 0.07ms。
-        if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(t)) {
+        if (!NUMERIC_LITERAL_RE.test(t)) {
             throw new InterpreterError(`Decimal: scale must be an integer in [0, 18], got ${JSON.stringify(scale)}.`);
         }
         n = Number(t);
@@ -119,6 +125,60 @@ function toInt(v, ctx) {
     }
     return bad();
 }
+/** Verdict 构造参数必须是非空白 Text：空/纯空白理由等于没有决策（与 @id 拒空白同口径），非 Text 不做隐式转换（与 truffle 一致）。 */
+function verdictText(v, fn, field) {
+    if (typeof v !== 'string')
+        throw new InterpreterError(`${fn}: ${field} must be Text, got ${Array.isArray(v) ? 'List' : typeof v}`);
+    if (v.trim() === '')
+        throw new InterpreterError(`${fn}: ${field} must not be empty`);
+    return v;
+}
+/** 布尔上下文遇到 Verdict 时的统一错误信息（与 truffle Builtins.toBool 同文）。 */
+const VERDICT_AS_BOOL_ERROR = 'Verdict cannot be used as Bool; compare its outcome field instead';
+/** 运行时 Verdict 值：带 `__type: "Verdict"` 标记的对象。 */
+function isVerdictValue(v) {
+    return typeof v === 'object' && v !== null && v.__type === 'Verdict';
+}
+/**
+ * 严格数值换算——truffle `Builtins.toDouble` 接受集的**严格子集**（issue #193）。
+ *
+ * List.sum/min/max/sort/sortBy/minBy/maxBy 此前直接 `Number(x)`：`Number("2o")`
+ * 得 NaN，sum 静默产出 NaN、max 静默返回首元素，而 truffle 同输入抛
+ * `NumberFormatException`。与 `toDouble`（`Double.parseDouble`）的已知差异：本函数额外
+ * 拒绝 "NaN"/"Infinity"/类型后缀（"1d"）/十六进制浮点（"0x1p3"）——它们在合规引擎里
+ * 只可能是坏输入。另注意 truffle 的 `List.sum` 实际走 `toLong`（仅整数），两侧字符串
+ * 接受集尚未统一，见 aster-lang-ts#199。逐条语义：
+ * - number  → 原样返回（含真实 NaN/Infinity：Java `doubleValue()` 同样不拦，
+ *             它们只能来自算术，不是坏输入）；
+ * - bigint / Decimal → 转 double（对齐 `Number.doubleValue()`）；
+ * - string  → 严格十进制解析且结果有限；空串、"NaN"、"Infinity"、非数值文本拒绝；
+ * - 其他    → 抛错。
+ *
+ * ★不能退回裸 `Number(v)`：`Number([...])` 会对数组调 `toString()`，把整个嵌套结构
+ * 物化成巨型字符串再返回 NaN，那份巨串不经过 chargeAllocation（实测 9 层嵌套 +
+ * `List.sort` 10787ms / +707MB 且 success=true），且与 truffle 的类型闸门判定分叉。
+ */
+function toNum(v, ctx) {
+    const bad = () => {
+        throw new InterpreterError(`${ctx}: expected Number, got ${JSON.stringify(v) ?? String(v)}`);
+    };
+    if (typeof v === 'number')
+        return v;
+    if (typeof v === 'bigint')
+        return Number(v);
+    if (v instanceof Decimal)
+        return v.toNumber();
+    if (typeof v === 'string') {
+        const t = v.trim();
+        if (!NUMERIC_LITERAL_RE.test(t))
+            return bad();
+        const n = Number(t);
+        if (!Number.isFinite(n))
+            return bad();
+        return n;
+    }
+    return bad();
+}
 /** 把任意操作数转成 Decimal（Int/Long 精确提升；Double 禁；已是 Decimal 原样）。 */
 function toDecimalArg(v, ctx) {
     if (v instanceof Decimal)
@@ -481,6 +541,40 @@ const MAX_CALL_DEPTH = 50;
 // statementLimit/MAX_STEPS 只数解释器步进不数 native range 循环 → range(0, 2e9) 会
 // 撑爆内存。与 aster-lang-truffle Builtins.MAX_RANGE_SIZE 保持一致，维持双引擎 parity。
 const MAX_RANGE_SIZE = 1_000_000;
+/**
+ * 单次执行允许物化的元素总数上限（累计分配预算）。
+ *
+ * ★**为什么单个 builtin 的上限不够**：`List.range` 封顶 1e6、`List.combinations`
+ * 封顶 C(n,k)≤5000，单看都对，但**组合起来没有任何约束**：
+ *
+ *     Let v0 be List.range(0, 1000000).
+ *     Let v1 be List.concat(v0, v0).   -- 每行翻倍
+ *     ... 重复 8 次 ...
+ *
+ * 不到 200 字节源码即可把规模推到约 1.3 亿元素。实测本引擎 7 轮=1.28 亿元素吃掉
+ * 3.3GB 堆且**返回 success**（静默成功，最坏形态）；8 轮=2.56 亿则撞 V8 的
+ * `Array.concat` 2^27 上限报 `Invalid array length`——**那是 V8 的硬限不是我们的防护**。
+ * truffle 侧 1403ms 抛 `Java heap space`。
+ *
+ * ★**为什么既有防护全没拦住**：`MAX_STEPS` 只数解释器步进——`concat` 在它眼里是
+ * 1 步，底层却是几千万次数组拷贝；宿主侧 5 秒 wall-clock 看门狗**来不及**
+ * （OOM 在 1.4 秒），它只对「慢」攻击有效，对「快而肥」的从不参与。
+ *
+ * ★**为什么是累计预算而非给 concat 加上限**：逐个 builtin 打补丁是打地鼠
+ * （map/filter/groupBy 同样能放大）。收敛成单一防线，在 `evalStdlibCall`
+ * 唯一调用点统一计量。
+ *
+ * 与 aster-lang-truffle `AllocationBudget.MAX_ALLOCATION_BUDGET` **必须同值**，
+ * 否则同一规则两引擎一个通过一个拒绝 = parity 分叉。
+ *
+ * 固定常量，不跟随堆/GC 状态——跟随运行时状态会破坏「两引擎逐字节一致 + 可回放」。
+ */
+const MAX_ALLOCATION_BUDGET = 10_000_000;
+/**
+ * 计量递归的深度上限，与 truffle `Builtins.CHARGE_MAX_DEPTH` **必须同值**。
+ * 固定常量不跟随运行时栈——同 VALUE_EQUALS_MAX_DEPTH 的理由。
+ */
+const CHARGE_MAX_DEPTH = 8;
 /** evalStdlibCall 的哨兵返回值：表示"不是已知 stdlib 调用"。用 Symbol 避免与任何合法返回值冲突。 */
 const NOT_STDLIB = Symbol('not-stdlib');
 /**
@@ -565,6 +659,10 @@ const BUILTIN_ARITY = {
     'Result.tapError': [2, 2],
     'Result.unwrap': [1, 1],
     'Result.unwrapErr': [1, 1],
+    'Verdict.allow': [0, 0],
+    'Verdict.deny': [1, 1],
+    'Verdict.require_approval': [2, 2],
+    'Verdict.escalate': [1, 1],
     'Text.concat': [2, 2],
     'Text.contains': [2, 2],
     'Text.equals': [2, 2],
@@ -647,6 +745,8 @@ class Interpreter {
     enumVariantToEnum;
     /** 执行步数计数器（防无限循环） */
     steps = 0;
+    /** 本次执行累计物化的集合元素数（见 MAX_ALLOCATION_BUDGET）。 */
+    allocated = 0;
     /** 步数上限（默认 MAX_STEPS，可由受信调用方上调） */
     maxSteps;
     /** 调用深度计数器（防无限递归） */
@@ -971,8 +1071,13 @@ class Interpreter {
         // 必须在用户函数查找之前，否则 Text.concat 落入未定义函数分支。
         if (call.target.kind === 'Name' && call.target.name.includes('.')) {
             const stdlib = this.evalStdlibCall(call.target.name, call.args, env);
-            if (stdlib !== NOT_STDLIB)
+            if (stdlib !== NOT_STDLIB) {
+                // 累计分配预算：在**唯一调用点**统一计量，而非 evalStdlibCall 内部 70+ 个
+                // return 逐个补——逐个补必然漏掉新增的那个。与 truffle Builtins.call 同位置。
+                // （本引擎这里确实是唯一调用点；truffle 侧则不是，内联特化会绕过 Builtins.call。）
+                this.chargeAllocation(stdlib);
                 return stdlib;
+            }
         }
         // 函数调用：可能是用户定义的模块函数，或绑定在环境里的闭包变量
         // （Let f be function with …）。先求值参数，再分派。
@@ -1389,28 +1494,38 @@ class Interpreter {
                 return acc;
             }
             // === 通用集合 stdlib（ADR 0024 受控扩展，与 truffle Builtins 镜像，逐位 parity）===
-            // 数值序用 Number() 比较；排序稳定、升序。
+            // 数值序用 toNum 严格换算后比较（非数值元素响亮失败，见 toNum）；排序稳定、升序。
             case 'List.sum': {
                 const l = reqList('List.sum', a()[0]);
                 let s = 0;
                 for (const x of l)
-                    s += Number(x);
+                    s += toNum(x, 'List.sum');
                 return s;
             }
             case 'List.min': {
                 const l = reqNonEmpty('List.min', a()[0]);
                 let best = l[0];
-                for (const x of l)
-                    if (Number(x) < Number(best))
+                let bestK = toNum(best, 'List.min');
+                for (const x of l) {
+                    const k = toNum(x, 'List.min');
+                    if (k < bestK) {
                         best = x;
+                        bestK = k;
+                    }
+                }
                 return best;
             }
             case 'List.max': {
                 const l = reqNonEmpty('List.max', a()[0]);
                 let best = l[0];
-                for (const x of l)
-                    if (Number(x) > Number(best))
+                let bestK = toNum(best, 'List.max');
+                for (const x of l) {
+                    const k = toNum(x, 'List.max');
+                    if (k > bestK) {
                         best = x;
+                        bestK = k;
+                    }
+                }
                 return best;
             }
             case 'List.distinct': {
@@ -1455,11 +1570,13 @@ class Interpreter {
             // 与 truffle 逐位一致：纯整数索引推进算法（不依赖语言细节）。DoS 防护：n≤64 +
             // 结果数 C(n,k)≤上限（先算组合数，超限即抛，不先生成）——多租户沙箱铁律。
             // 边界：k<0 抛错；k>n 返回 []；k=0 返回 [[]]。保留元素原值与相对顺序。
+            // k 走严格 toInt（对齐 truffle `toInt`：Integer.parseInt / intValue）——裸 Number()
+            // 下 ""→0、true→1、"0x2"→2 会被静默接受，Number.isInteger 只拦得住 NaN。
             case 'List.combinations': {
                 const l = reqList('List.combinations', a()[0]);
-                const k = Number(a()[1]);
-                if (!Number.isInteger(k) || k < 0)
-                    throw new InterpreterError(`List.combinations: k 须为非负整数，got ${a()[1]}`);
+                const k = toInt(a()[1], 'List.combinations');
+                if (k < 0)
+                    throw new InterpreterError(`List.combinations: k 须为非负整数，got ${k}`);
                 const n = l.length;
                 const MAX_N = 64, MAX_RESULT = 5000;
                 if (n > MAX_N)
@@ -1495,7 +1612,7 @@ class Interpreter {
             }
             case 'List.sort': {
                 const l = reqList('List.sort', a()[0]);
-                return [...l].sort((x, y) => Number(x) - Number(y));
+                return [...l].sort((x, y) => toNum(x, 'List.sort') - toNum(y, 'List.sort'));
             }
             case 'List.count': {
                 const l = reqList('List.count', this.evalExpr(argExprs[0], env));
@@ -1509,15 +1626,16 @@ class Interpreter {
             case 'List.sortBy': {
                 const l = reqList('List.sortBy', this.evalExpr(argExprs[0], env));
                 const keyFn = callableArg(1);
-                return [...l].sort((x, y) => Number(this.applyCallable(keyFn, [x])) - Number(this.applyCallable(keyFn, [y])));
+                const key = (x) => toNum(this.applyCallable(keyFn, [x]), 'List.sortBy');
+                return [...l].sort((x, y) => key(x) - key(y));
             }
             case 'List.minBy': {
                 const l = reqNonEmpty('List.minBy', this.evalExpr(argExprs[0], env));
                 const keyFn = callableArg(1);
                 let best = l[0];
-                let bestK = Number(this.applyCallable(keyFn, [best]));
+                let bestK = toNum(this.applyCallable(keyFn, [best]), 'List.minBy');
                 for (const x of l) {
-                    const k = Number(this.applyCallable(keyFn, [x]));
+                    const k = toNum(this.applyCallable(keyFn, [x]), 'List.minBy');
                     if (k < bestK) {
                         best = x;
                         bestK = k;
@@ -1529,9 +1647,9 @@ class Interpreter {
                 const l = reqNonEmpty('List.maxBy', this.evalExpr(argExprs[0], env));
                 const keyFn = callableArg(1);
                 let best = l[0];
-                let bestK = Number(this.applyCallable(keyFn, [best]));
+                let bestK = toNum(this.applyCallable(keyFn, [best]), 'List.maxBy');
                 for (const x of l) {
-                    const k = Number(this.applyCallable(keyFn, [x]));
+                    const k = toNum(this.applyCallable(keyFn, [x]), 'List.maxBy');
                     if (k > bestK) {
                         best = x;
                         bestK = k;
@@ -1634,6 +1752,20 @@ class Interpreter {
                 }
                 throw new InterpreterError('Result.tapError: expected Result (Ok or Err)');
             }
+            // === Verdict（ADR 0039）：与 truffle Builtins 同键序；reason/role 必须是非空 Text ===
+            case 'Verdict.allow': return { __type: 'Verdict', outcome: 'ALLOW' };
+            case 'Verdict.deny': {
+                const [r] = a();
+                return { __type: 'Verdict', outcome: 'DENY', reason: verdictText(r, 'Verdict.deny', 'reason') };
+            }
+            case 'Verdict.require_approval': {
+                const [role, r] = a();
+                return { __type: 'Verdict', outcome: 'REQUIRE_APPROVAL', role: verdictText(role, 'Verdict.require_approval', 'role'), reason: verdictText(r, 'Verdict.require_approval', 'reason') };
+            }
+            case 'Verdict.escalate': {
+                const [r] = a();
+                return { __type: 'Verdict', outcome: 'ESCALATE', reason: verdictText(r, 'Verdict.escalate', 'reason') };
+            }
             default:
                 return NOT_STDLIB;
         }
@@ -1757,7 +1889,15 @@ class Interpreter {
         switch (op) {
             case '+': {
                 if (typeof left === 'string' || typeof right === 'string') {
-                    return String(left) + String(right);
+                    const joined = String(left) + String(right);
+                    // ★`+` 的字符串分支走 evalBinary，**不经过 evalStdlibCall**，
+                    // 而 chargeAllocation 的唯一调用点在那条 stdlib 分支上 → 此处必须单独记账。
+                    // 否则用 `plus` 代替 `Text.concat` 做翻倍即可完全绕过预算：
+                    // 实测 20 轮 → 3355 万字符 success=true，而同一份 IR 在 truffle 侧
+                    // （`+`→`add` builtin 经 Builtins.call 被计量）是 REJECTED
+                    // ——这是一条真实发生的**双引擎判定分叉**。
+                    this.chargeAllocation(joined);
+                    return joined;
                 }
                 this.assertNumbers(op, left, right);
                 return left + right;
@@ -1845,10 +1985,74 @@ class Interpreter {
             throw new InterpreterError(`Maximum execution steps (${this.maxSteps}) exceeded — possible infinite loop`);
         }
     }
+    /**
+     * 按返回值的规模扣减分配预算（见 MAX_ALLOCATION_BUDGET）。
+     *
+     * 逐个**顶层**元素计量。嵌套结构（如 groupBy 的 Map<K, List>）的内层元素本身
+     * 来自已被计过的入参列表——内层每个 List.range 都各自经过本方法单独计量，
+     * 故不会漏计，也不会因重复计量误拒合法的分组操作。
+     *
+     * 与 truffle `Builtins.chargeForResult` 口径逐条对齐：
+     * Array↔Collection、Map↔Map、string↔CharSequence。
+     * ★两边的类型判据必须保持等价——若将来有 builtin 返回 Set（Java 的 Set 是
+     * Collection、会被计量；TS 的 Set 不是 Array、不会被计量），就是 parity 分叉。
+     * 现已确认两侧均无 builtin 返回 Set。
+     */
+    chargeAllocation(result) {
+        const count = this.countElements(result, 0);
+        if (count <= 0)
+            return;
+        // 先判溢出再累加，与 truffle AllocationBudget.charge 同形。
+        if (count > MAX_ALLOCATION_BUDGET ||
+            this.allocated > MAX_ALLOCATION_BUDGET - count) {
+            this.allocated = MAX_ALLOCATION_BUDGET + 1;
+            throw new InterpreterError(`分配预算耗尽：单次执行累计物化元素数超过上限 ${MAX_ALLOCATION_BUDGET}，拒绝以防内存耗尽 DoS`);
+        }
+        this.allocated += count;
+    }
+    /**
+     * 递归统计返回值物化出的元素总数（深度有界）。
+     *
+     * ★**为什么必须递归、不能只计顶层**：只计顶层有一个 Critical 绕过——
+     * `List.groupBy(a, one)` 把 1e6 元素全归进同一组，返回的 Map 顶层 size=1，
+     * **只扣 1 点而真实物化 1e6**。重复 20 次即 840 字节源码 → 实测 Java 侧 1972ms
+     * 物化 210MB 且 SUCCESS；本引擎抬高 maxSteps 后同样 success、+396MB。
+     *
+     * 此前注释写的「内层元素来自已被计过的入参列表，故不会漏计」是**错的**：
+     * 入参只被扣过**一次**，却可被**重新物化任意多次**。
+     *
+     * 深度上限固定 8，与 truffle `CHARGE_MAX_DEPTH` **必须同值**；理由同
+     * VALUE_EQUALS_MAX_DEPTH：固定常量不跟随运行时栈，否则同一规则在不同机器
+     * 给出不同结果。超深不再下探（宁可少算也不抛）。
+     *
+     * 字符串按字符数计（`Text.concat` 翻倍向量，见 MAX_ALLOCATION_BUDGET 注释）。
+     */
+    countElements(value, depth) {
+        if (depth > CHARGE_MAX_DEPTH)
+            return 0;
+        if (Array.isArray(value)) {
+            let n = value.length;
+            for (const e of value)
+                n += this.countElements(e, depth + 1);
+            return n;
+        }
+        if (value instanceof Map) {
+            let n = value.size;
+            for (const e of value.values())
+                n += this.countElements(e, depth + 1);
+            return n;
+        }
+        if (typeof value === 'string')
+            return value.length;
+        return 0;
+    }
     /** 判断值是否为 truthy */
     isTruthy(value) {
         if (value === null || value === undefined)
             return false;
+        // Verdict 不可当布尔用（ADR 0039 §2.2）：DENY 若按对象真值放行即 fail-open，必须直接失败（与 truffle toBool 一致）
+        if (isVerdictValue(value))
+            throw new InterpreterError(VERDICT_AS_BOOL_ERROR);
         if (typeof value === 'boolean')
             return value;
         if (typeof value === 'number')