kn-es-features 1.0.0

package/src/features/es2025/06-json-parse-source.js

@@ -0,0 +1,86 @@
+/**
+ * ES2025 —— JSON.parse with Source Text Access
+ *
+ * JSON.parse 的 reviver 函数新增第三个参数 context，
+ * context.source 携带该值在原始 JSON 字符串中的原始文本片段。
+ *
+ * 主要用途：
+ *   1. 精确解析超大整数（BigInt），不丢失精度
+ *   2. 调试时查看原始文本
+ *   3. 保留数字字面量的原始格式
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testJsonParseSource() {
+  const { test, assert, getResults } = createSuite('JSON.parse Source Text Access (ES2025)')
+
+  // 检测支持性：调用 reviver 看第三参数是否存在
+  let supported = false
+  try {
+    JSON.parse('1', (key, value, context) => {
+      if (context && typeof context.source === 'string') supported = true
+      return value
+    })
+  } catch (e) { /* ignore */ }
+
+  test('reviver 接收第三个参数 context', () => {
+    if (!supported) { assert(true, '(跳过：环境不支持 JSON.parse source text access)'); return }
+    let receivedContext = null
+    JSON.parse('"hello"', (key, value, ctx) => {
+      if (key === '') receivedContext = ctx
+      return value
+    })
+    assert(receivedContext !== null && typeof receivedContext.source === 'string',
+      'reviver 应收到含 source 属性的 context 对象')
+  })
+
+  test('context.source 为该值的原始 JSON 文本', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const sources = {}
+    JSON.parse('{"a":  42, "b": "hello"}', (key, value, ctx) => {
+      if (key !== '') sources[key] = ctx.source
+      return value
+    })
+    // source 保留原始空白
+    assert(sources.a === '42', `数字的 source 应为 "42"，实际: "${sources.a}"`)
+    assert(sources.b === '"hello"', `字符串的 source 应为 '"hello"'，实际: "${sources.b}"`)
+  })
+
+  test('利用 source 精确解析超大整数（BigInt）', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    // JS 数字最大安全整数为 2^53-1，超出后会丢失精度
+    const bigNum = '9007199254740993' // 2^53 + 1，普通 JSON.parse 会精度丢失
+    const parsed = JSON.parse(`{"id":${bigNum}}`, (key, value, ctx) => {
+      if (key === '' ) return value
+      // 用 source 转 BigInt，避免精度损失
+      if (/^\d+$/.test(ctx.source)) return BigInt(ctx.source)
+      return value
+    })
+    assert(typeof parsed.id === 'bigint', '超大整数应被转为 BigInt')
+    assert(parsed.id === BigInt(bigNum), `BigInt 值应精确等于 ${bigNum}`)
+  })
+
+  test('嵌套对象中每个值都能获取自己的 source', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const collected = []
+    JSON.parse('{"x":1,"arr":[2,3]}', (key, value, ctx) => {
+      if (key !== '') collected.push(ctx.source)
+      return value
+    })
+    assert(collected.includes('1') && collected.includes('2') && collected.includes('3'),
+      '嵌套结构中每个原始值都应能取到 source')
+  })
+
+  test('null / boolean 也有对应 source', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const sources = {}
+    JSON.parse('{"a":null,"b":true,"c":false}', (key, value, ctx) => {
+      if (key !== '') sources[key] = ctx.source
+      return value
+    })
+    assert(sources.a === 'null' && sources.b === 'true' && sources.c === 'false',
+      'null/true/false 的 source 应为对应的原始文本')
+  })
+
+  return getResults()
+}

package/src/features/es2025/07-error-is-error.js

@@ -0,0 +1,83 @@
+/**
+ * ES2025 —— Error.isError()
+ *
+ * Error.isError(value) 是一个静态方法，用来可靠地判断一个值是否为 Error 实例。
+ *
+ * 为什么需要它？
+ *   - instanceof Error 跨 realm（iframe、vm、Worker）会失效
+ *   - Object.prototype.toString 返回 "[object Error]" 但并不区分 Error 子类
+ *   - Error.isError 基于内部槽位（[[ErrorData]]）判断，跨 realm 安全
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testErrorIsError() {
+  const { test, assert, getResults } = createSuite('Error.isError (ES2025)')
+
+  const supported = typeof Error.isError === 'function'
+
+  test('原生 Error 实例返回 true', () => {
+    if (!supported) { assert(true, '(跳过：环境不支持 Error.isError)'); return }
+    assert(Error.isError(new Error('test')) === true, 'new Error() 应返回 true')
+  })
+
+  test('Error 子类实例返回 true', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    assert(Error.isError(new TypeError('type'))     === true, 'TypeError 应返回 true')
+    assert(Error.isError(new RangeError('range'))   === true, 'RangeError 应返回 true')
+    assert(Error.isError(new SyntaxError('syntax')) === true, 'SyntaxError 应返回 true')
+    assert(Error.isError(new ReferenceError('ref')) === true, 'ReferenceError 应返回 true')
+    assert(Error.isError(new URIError('uri'))        === true, 'URIError 应返回 true')
+    assert(Error.isError(new EvalError('eval'))      === true, 'EvalError 应返回 true')
+  })
+
+  test('自定义 Error 子类实例返回 true', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    class AppError extends Error {
+      constructor(msg) { super(msg); this.name = 'AppError' }
+    }
+    assert(Error.isError(new AppError('app')) === true, '自定义 Error 子类应返回 true')
+  })
+
+  test('普通对象返回 false', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    assert(Error.isError({}) === false, '普通对象应返回 false')
+    assert(Error.isError({ message: 'fake', stack: '' }) === false, '伪造 Error 对象应返回 false')
+  })
+
+  test('模拟 Error 对象（纯 JS 构造）返回 false', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    // 即使 prototype 指向 Error.prototype，没有内部槽位也应返回 false
+    const fake = Object.create(Error.prototype)
+    fake.message = 'fake'
+    // 注意：某些实现可能对此行为有差异，但规范要求基于内部槽位
+    // 这里只验证 Error.isError 不会误判明确不是 Error 的值
+    assert(Error.isError(null)      === false, 'null 应返回 false')
+    assert(Error.isError(undefined) === false, 'undefined 应返回 false')
+    assert(Error.isError(42)        === false, '数字应返回 false')
+    assert(Error.isError('error')   === false, '字符串 "error" 应返回 false')
+  })
+
+  test('数组、函数、正则等非 Error 值返回 false', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    assert(Error.isError([])          === false, '数组应返回 false')
+    assert(Error.isError(() => {})    === false, '函数应返回 false')
+    assert(Error.isError(/regex/)     === false, '正则应返回 false')
+    assert(Error.isError(new Date())  === false, 'Date 应返回 false')
+  })
+
+  test('实际使用场景：统一捕获并判断 catch 的值', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    function riskyOp(throwError) {
+      if (throwError) throw new TypeError('类型错误')
+      return Promise.reject('string rejection')
+    }
+
+    let caughtError = null
+    try { riskyOp(true) } catch (e) { caughtError = e }
+
+    assert(Error.isError(caughtError) === true,  'try/catch 捕获的 Error 应识别为 true')
+    assert(Error.isError('string rejection') === false, '字符串 rejection 应识别为 false')
+  })
+
+  return getResults()
+}

package/src/features/es2025/08-float16array.js

@@ -0,0 +1,88 @@
+/**
+ * ES2025 —— Float16Array
+ *
+ * 新增 16 位半精度浮点数类型化数组，以及配套的：
+ *   Math.f16round(x)               —— 将数字舍入为最近的 float16 可表示值
+ *   DataView.prototype.getFloat16  —— 读取 16 位浮点数
+ *   DataView.prototype.setFloat16  —— 写入 16 位浮点数
+ *
+ * 主要场景：WebGL、机器学习（半精度权重）、图像处理，节省内存（Float32 的一半）。
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testFloat16Array() {
+  const { test, assert, getResults } = createSuite('Float16Array (ES2025)')
+
+  const supported = typeof Float16Array !== 'undefined'
+
+  test('Float16Array 可正常创建', () => {
+    if (!supported) { assert(true, '(跳过：环境不支持 Float16Array)'); return }
+    const arr = new Float16Array(4)
+    assert(arr.length === 4, 'Float16Array 长度应为 4')
+    assert(arr.BYTES_PER_ELEMENT === 2, '每个元素应占 2 字节（16 位）')
+  })
+
+  test('从数组初始化并读取值', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const arr = new Float16Array([1.0, 0.5, -1.0, 0.0])
+    assert(arr[0] === 1.0,  'arr[0] 应为 1.0')
+    assert(arr[1] === 0.5,  'arr[1] 应为 0.5')
+    assert(arr[2] === -1.0, 'arr[2] 应为 -1.0')
+    assert(arr[3] === 0.0,  'arr[3] 应为 0.0')
+  })
+
+  test('精度低于 Float32（半精度特性）', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const arr = new Float16Array([Math.PI])
+    // Float16 只有约 3.3 位十进制精度，Math.PI ≈ 3.140625（最近 float16 值）
+    assert(Math.abs(arr[0] - Math.PI) > 0.001, 'Float16 精度应低于 Float64 的 Math.PI')
+    assert(Math.abs(arr[0] - Math.PI) < 0.01,  'Float16 近似误差应在合理范围内')
+  })
+
+  test('Math.f16round() 舍入到最近 float16 值', () => {
+    if (typeof Math.f16round !== 'function') { assert(true, '(跳过：环境不支持 Math.f16round)'); return }
+    // 1.337 → float16 最近值约为 1.3369140625
+    const r = Math.f16round(1.337)
+    assert(typeof r === 'number', 'Math.f16round 应返回数字')
+    assert(Math.abs(r - 1.337) < 0.01, '舍入误差应在 0.01 以内')
+    assert(r !== 1.337, '应发生精度损失，结果不等于输入值')
+  })
+
+  test('Math.f16round(Infinity) / (-Infinity) / NaN 特殊值', () => {
+    if (typeof Math.f16round !== 'function') { assert(true, '(跳过)'); return }
+    assert(Math.f16round(Infinity)  ===  Infinity, 'Infinity 应保持不变')
+    assert(Math.f16round(-Infinity) === -Infinity, '-Infinity 应保持不变')
+    assert(Number.isNaN(Math.f16round(NaN)), 'NaN 应保持 NaN')
+    assert(Math.f16round(0) === 0, '0 应保持 0')
+  })
+
+  test('DataView.getFloat16 / setFloat16', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const dv = new DataView(new ArrayBuffer(4))
+    if (typeof dv.setFloat16 !== 'function') { assert(true, '(跳过：DataView 不支持 float16)'); return }
+    dv.setFloat16(0, 1.5, true) // little-endian
+    const val = dv.getFloat16(0, true)
+    assert(val === 1.5, 'DataView setFloat16/getFloat16 round-trip 应还原 1.5')
+  })
+
+  test('Float16Array 支持 TypedArray 通用方法', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const arr = new Float16Array([3, 1, 4, 1, 5])
+    // sort
+    arr.sort()
+    assert(arr[0] === 1 && arr[4] === 5, 'sort 后最小值应为 1，最大值应为 5')
+    // map → 返回新 Float16Array
+    const doubled = arr.map(x => x * 2)
+    assert(doubled instanceof Float16Array, 'map 应返回 Float16Array')
+  })
+
+  test('Float16Array 内存占用是 Float32Array 的一半', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const n = 100
+    const f16 = new Float16Array(n)
+    const f32 = new Float32Array(n)
+    assert(f16.byteLength === f32.byteLength / 2, 'Float16Array 字节长度应是 Float32Array 的一半')
+  })
+
+  return getResults()
+}

package/src/features/es2026/01-math-sum-precise.js

@@ -0,0 +1,79 @@
+/**
+ * ES2026 —— Math.sumPrecise()
+ *
+ * Math.sumPrecise(iterable) 对可迭代对象中的所有数值进行精确求和，
+ * 内部使用"精确求和算法"（类似 Kahan 补偿求和），避免浮点数累积误差。
+ *
+ * 对比 Array.prototype.reduce：
+ *   [0.1, 0.2, 0.3].reduce((a, b) => a + b)  // 0.6000000000000001（精度损失）
+ *   Math.sumPrecise([0.1, 0.2, 0.3])          // 0.6（精确）
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testMathSumPrecise() {
+  const { test, assert, getResults } = createSuite('Math.sumPrecise() (ES2026)')
+
+  const supported = typeof Math.sumPrecise === 'function'
+
+  test('基本求和 —— 整数', () => {
+    if (!supported) { assert(true, '(跳过：环境不支持 Math.sumPrecise)'); return }
+    assert(Math.sumPrecise([1, 2, 3, 4, 5]) === 15, '整数求和应为 15')
+    assert(Math.sumPrecise([])              === 0,  '空数组求和应为 0')
+    assert(Math.sumPrecise([42])            === 42, '单元素求和应为自身')
+  })
+
+  test('精确处理浮点数累积误差', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    // 普通 reduce 会产生浮点误差
+    const naive = [0.1, 0.2, 0.3].reduce((a, b) => a + b)
+    const precise = Math.sumPrecise([0.1, 0.2, 0.3])
+    assert(naive !== 0.6,    '普通 reduce 应存在浮点误差（验证前提）')
+    assert(precise === 0.6,  'Math.sumPrecise 应精确返回 0.6')
+  })
+
+  test('大量小数精确求和', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    // 1/3 * 3 在浮点运算中通常不等于 1
+    const third = 1 / 3
+    const result = Math.sumPrecise([third, third, third])
+    // sumPrecise 应在 IEEE 754 精度内尽可能精确
+    assert(typeof result === 'number', '应返回数值类型')
+    assert(result > 0.999 && result <= 1.0, '三个 1/3 之和应尽量接近 1')
+  })
+
+  test('接受任意可迭代对象', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    // Set
+    const fromSet = Math.sumPrecise(new Set([10, 20, 30]))
+    assert(fromSet === 60, '支持 Set 可迭代对象')
+
+    // Generator
+    function* gen() { yield 1; yield 2; yield 3 }
+    const fromGen = Math.sumPrecise(gen())
+    assert(fromGen === 6, '支持 Generator 可迭代对象')
+  })
+
+  test('特殊值处理', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    // +0 与 -0
+    assert(Math.sumPrecise([+0]) === 0,  '+0 求和应为 0')
+    assert(Math.sumPrecise([-0]) === 0,  '-0 求和应为 0（结果为 +0）')
+
+    // Infinity
+    assert(Math.sumPrecise([1, Infinity])  === Infinity,    '含 Infinity 结果应为 Infinity')
+    assert(Math.sumPrecise([-Infinity, 1]) === -Infinity,   '含 -Infinity 结果应为 -Infinity')
+    assert(Number.isNaN(Math.sumPrecise([Infinity, -Infinity])), 'Inf + (-Inf) 应为 NaN')
+
+    // NaN 传染
+    assert(Number.isNaN(Math.sumPrecise([1, NaN, 3])), '含 NaN 结果应为 NaN')
+  })
+
+  test('非数值元素应抛出 TypeError', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    let threw = false
+    try { Math.sumPrecise([1, '2', 3]) } catch (e) { threw = e instanceof TypeError }
+    assert(threw, '非数值元素应抛出 TypeError')
+  })
+
+  return getResults()
+}

package/src/features/es2026/02-regexp-escape.js

@@ -0,0 +1,80 @@
+/**
+ * ES2026 —— RegExp.escape()
+ *
+ * RegExp.escape(string) 将字符串中所有具有正则特殊含义的字符进行转义，
+ * 返回可安全嵌入正则表达式的字符串。
+ *
+ * 常见需求：用户输入作为字面量匹配时，防止注入特殊字符破坏正则逻辑。
+ * 例如：用户输入 "price: $10.00"，直接放入 new RegExp(input) 会出错。
+ *
+ * 需要转义的字符：^ $ . * + ? ( ) [ ] { } | \ /
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testRegExpEscape() {
+  const { test, assert, getResults } = createSuite('RegExp.escape() (ES2026)')
+
+  const supported = typeof RegExp.escape === 'function'
+
+  test('转义正则特殊字符', () => {
+    if (!supported) { assert(true, '(跳过：环境不支持 RegExp.escape)'); return }
+    const special = '^$.*+?()[]{}|\\'
+    const escaped = RegExp.escape(special)
+    // 所有特殊字符前应加反斜杠
+    assert(typeof escaped === 'string', '应返回字符串')
+    assert(escaped.includes('\\^'),  '^ 应被转义')
+    assert(escaped.includes('\\$'),  '$ 应被转义')
+    assert(escaped.includes('\\.'),  '. 应被转义')
+    assert(escaped.includes('\\*'),  '* 应被转义')
+  })
+
+  test('普通字符不被转义', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    assert(RegExp.escape('hello') === 'hello',   '纯字母不应被转义')
+    assert(RegExp.escape('12345') === '12345',   '纯数字不应被转义')
+    assert(RegExp.escape('hello world') === 'hello world', '空格不应被转义')
+  })
+
+  test('转义结果可安全构造正则', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const userInput = 'price: $10.00 (sale!)'
+    const re = new RegExp(RegExp.escape(userInput))
+    assert(re.test('price: $10.00 (sale!)'), '转义后的正则应能精确匹配原字符串')
+    assert(!re.test('price: X10X00 Xsale!'), '不应匹配用特殊字符替换后的字符串')
+  })
+
+  test('防止正则注入攻击', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    // 如果不转义，恶意输入 "(.*)" 可以匹配任何字符串
+    const maliciousInput = '(.*)'
+    const unsafeRe = new RegExp(maliciousInput)
+    const safeRe   = new RegExp(RegExp.escape(maliciousInput))
+
+    assert( unsafeRe.test('anything'),    '未转义的正则可匹配任意字符串（注入漏洞）')
+    assert(!safeRe.test('anything'),      '转义后只能匹配字面量 "(.*)"')
+    assert( safeRe.test('(.*)'),          '转义后精确匹配字面字符串 "(.*)"')
+  })
+
+  test('中文等 Unicode 字符不应被转义', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const chinese = '你好，世界'
+    assert(RegExp.escape(chinese) === chinese, 'Unicode 字符不需要转义')
+  })
+
+  test('空字符串返回空字符串', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    assert(RegExp.escape('') === '', '空字符串转义后应仍为空字符串')
+  })
+
+  test('与 /g 标志组合 —— 高亮搜索词', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    // 模拟在文本中高亮用户搜索词（含特殊字符）
+    const text    = '商品价格 $10.00，原价 $20.00'
+    const keyword = '$10.00'
+    const re      = new RegExp(RegExp.escape(keyword), 'g')
+    const count   = (text.match(re) || []).length
+    assert(count === 1, '含特殊字符的关键词应精确匹配 1 次')
+  })
+
+  return getResults()
+}

package/src/features/es2026/03-explicit-resource-management.js

@@ -0,0 +1,117 @@
+/**
+ * ES2026 —— Explicit Resource Management（显式资源管理）
+ *
+ * 引入两个新关键字：
+ *   using       —— 同步资源，块退出时自动调用 [Symbol.dispose]()
+ *   await using —— 异步资源，块退出时自动调用 [Symbol.asyncDispose]()
+ *
+ * 以及两个新 Symbol：
+ *   Symbol.dispose      —— 同步清理方法
+ *   Symbol.asyncDispose —— 异步清理方法
+ *
+ * 解决了"忘记关闭资源"的问题，类似 C# using / Python with / Java try-with-resources。
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export async function testExplicitResourceManagement() {
+  const { test, assert, getResults } = createSuite('Explicit Resource Management (ES2026)')
+
+  // 检测语法支持（using 是新语法，需用 Function 构造器探测）
+  const supported = (() => {
+    try {
+      new Function('Symbol', `
+        const r = { [Symbol.dispose]() {} }
+        { using x = r }
+      `)(Symbol)
+      return true
+    } catch { return false }
+  })()
+
+  test('Symbol.dispose 已定义', () => {
+    assert(typeof Symbol.dispose === 'symbol', 'Symbol.dispose 应是 symbol 类型')
+  })
+
+  test('Symbol.asyncDispose 已定义', () => {
+    assert(typeof Symbol.asyncDispose === 'symbol', 'Symbol.asyncDispose 应是 symbol 类型')
+  })
+
+  test('using —— 块退出时自动调用 Symbol.dispose', () => {
+    if (!supported) { assert(true, '(跳过：环境不支持 using 语法)'); return }
+    const log = []
+    new Function('log', 'Symbol', `
+      {
+        using r = {
+          [Symbol.dispose]() { log.push('disposed') }
+        }
+        log.push('in-block')
+      }
+      log.push('after-block')
+    `)(log, Symbol)
+    assert(log[0] === 'in-block',    '块内代码应正常执行')
+    assert(log[1] === 'disposed',    '块退出时应自动调用 dispose')
+    assert(log[2] === 'after-block', 'dispose 之后块后代码才继续执行')
+  })
+
+  test('using —— 异常时也会调用 dispose（保证清理）', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const log = []
+    try {
+      new Function('log', 'Symbol', `
+        {
+          using r = { [Symbol.dispose]() { log.push('cleanup') } }
+          throw new Error('意外错误')
+        }
+      `)(log, Symbol)
+    } catch {}
+    assert(log[0] === 'cleanup', '即使抛出异常也应执行 dispose 清理')
+  })
+
+  test('多个 using 资源按 LIFO 顺序释放', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const order = []
+    new Function('order', 'Symbol', `
+      {
+        using a = { [Symbol.dispose]() { order.push('A') } }
+        using b = { [Symbol.dispose]() { order.push('B') } }
+        using c = { [Symbol.dispose]() { order.push('C') } }
+      }
+    `)(order, Symbol)
+    // 后声明的先释放（栈顺序）
+    assert(order.join(',') === 'C,B,A', '多资源应按 LIFO（后进先出）顺序释放')
+  })
+
+  test('await using —— 异步 dispose', async () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    const log = []
+    const fn = new Function('log', 'Symbol', `
+      return (async () => {
+        {
+          await using r = {
+            async [Symbol.asyncDispose]() {
+              await new Promise(res => setTimeout(res, 0))
+              log.push('async-disposed')
+            }
+          }
+          log.push('in-block')
+        }
+        log.push('after-block')
+      })()
+    `)
+    await fn(log, Symbol)
+    assert(log[0] === 'in-block',        '异步块内应正常执行')
+    assert(log[1] === 'async-disposed',  'await using 应等待异步 dispose 完成')
+    assert(log[2] === 'after-block',     'dispose 之后才继续执行块后代码')
+  })
+
+  test('DisposableStack —— 手动管理资源栈', () => {
+    if (typeof DisposableStack === 'undefined') { assert(true, '(跳过：环境不支持 DisposableStack)'); return }
+    const log = []
+    const stack = new DisposableStack()
+    stack.defer(() => log.push('deferred-1'))
+    stack.defer(() => log.push('deferred-2'))
+    stack.dispose()
+    assert(log.join(',') === 'deferred-2,deferred-1', 'DisposableStack 应按 LIFO 执行')
+  })
+
+  return getResults()
+}

package/src/features/es2026/04-atomics-pause.js

@@ -0,0 +1,81 @@
+/**
+ * ES2026 —— Atomics.pause()
+ *
+ * Atomics.pause(iterationNumber?) 向 CPU 发出"自旋等待"提示，
+ * 告知处理器当前处于忙等循环中，允许其优化资源分配（降低功耗、避免流水线冲刷）。
+ *
+ * 类似于 x86 的 PAUSE 指令 / ARM 的 YIELD 指令。
+ *
+ * 用途：SharedArrayBuffer + Atomics 实现的多线程自旋锁（spinlock）。
+ * 注意：纯 JS 主线程中调用无害但也无实际效果，仅在 Worker 忙等场景有优化意义。
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testAtomicsPause() {
+  const { test, assert, getResults } = createSuite('Atomics.pause() (ES2026)')
+
+  const supported = typeof Atomics.pause === 'function'
+
+  test('Atomics.pause 函数存在', () => {
+    if (!supported) { assert(true, '(跳过：环境不支持 Atomics.pause)'); return }
+    assert(typeof Atomics.pause === 'function', 'Atomics.pause 应为函数')
+  })
+
+  test('无参数调用不抛出错误', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    let threw = false
+    try { Atomics.pause() } catch { threw = true }
+    assert(!threw, 'Atomics.pause() 无参数调用不应抛出')
+  })
+
+  test('传入整数参数不抛出错误', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    let threw = false
+    try {
+      Atomics.pause(0)
+      Atomics.pause(1)
+      Atomics.pause(100)
+    } catch { threw = true }
+    assert(!threw, 'Atomics.pause(N) 应接受非负整数参数')
+  })
+
+  test('返回值为 undefined', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    assert(Atomics.pause() === undefined, 'Atomics.pause() 应返回 undefined')
+  })
+
+  test('自旋等待模式下连续调用不崩溃', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    // 模拟自旋锁循环：每次迭代调用 pause 并递增计数
+    let i = 0
+    for (; i < 10; i++) {
+      Atomics.pause(i) // 传入迭代次数，允许实现做自适应暂停
+    }
+    assert(i === 10, '10 次自旋循环应正常完成')
+  })
+
+  test('与 SharedArrayBuffer + Atomics.load 配合（模拟场景）', () => {
+    if (!supported) { assert(true, '(跳过)'); return }
+    if (typeof SharedArrayBuffer === 'undefined') {
+      assert(true, '(跳过：环境不支持 SharedArrayBuffer)')
+      return
+    }
+    // 创建一个共享标志位，初始为 0
+    const buf   = new SharedArrayBuffer(4)
+    const flag  = new Int32Array(buf)
+    flag[0] = 1  // 模拟"锁已被占用"
+
+    let spinCount = 0
+    const MAX_SPIN = 5
+    // 模拟自旋等待：检查标志位，若被占用则 pause 后重试
+    while (Atomics.load(flag, 0) !== 0 && spinCount < MAX_SPIN) {
+      Atomics.pause(spinCount)
+      spinCount++
+      if (spinCount === 3) Atomics.store(flag, 0, 0) // 模拟锁被释放
+    }
+    assert(Atomics.load(flag, 0) === 0, '自旋等待后标志位应变为 0（锁释放）')
+    assert(spinCount === 3, '应在第 3 次迭代时检测到锁释放')
+  })
+
+  return getResults()
+}