15.2 同源不同宿主

#!/usr/bin/env python3
# file: sim/gd_mech_15_host.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/gd_mech_15_host.py
"""15.2 同源不同宿主（S 层）。

同一份源码换宿主（Python / Node / 浏览器），语言原语的差异在三处咬人：

  ① 整数域：Python 的 int 任意精度；JS 的 number 是 float64，安全整数只到
     2^53-1。越过它，Number 静默丢位：JS 里 (2**53+1)===2**53 为真。
  ② 大数：幂与增长曲线很快越过 2^53，TS 侧必须走 BigInt；而 BigInt 进不了
     JSON.stringify（第 15.1 节反例三），所以机制层的「摘要」永远不能是大数。
  ③ 字符串：Python len 是码点数，JS .length 是 UTF-16 码元数，UTF-8 字节数又是
     第三个数。中文在 BMP 内时前两者相等（「灰烬牌库」都是 4），表情符号不在
     BMP 内时 JS .length=2 而码点只有 1。

本脚本把三处差异各量一遍，并核对本规格的机制层量全部落在安全整数域内——
这正是「机制层可要求逐字一致、表现层只能按容差」的宿主侧根据。
"""
from __future__ import annotations

import json
import os

import ashlib

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)

SAFE = 2 ** 53 - 1  # JS Number.MAX_SAFE_INTEGER
SAMPLES = ["灰烬牌库", "ashdeck", "🎴"]


def spec_numeric_max(spec: dict) -> tuple[int, str]:
    """规格里所有整数字段的最大绝对值（机制层量级）。"""
    best, where = 0, "-"
    for k, v in spec["params"].items():
        if isinstance(v, int) and abs(v) > best:
            best, where = abs(v), f"params.{k}"
    for c in spec["cards"]:
        for k in ("cost", "damage", "block", "count"):
            if abs(c[k]) > best:
                best, where = abs(c[k]), f"cards.{c['id']}.{k}"
    if abs(spec["seed"]) > best:
        best, where = abs(spec["seed"]), "seed"
    return best, where


def main() -> int:
    spec = ashlib.load_spec()

    rows = [
        ["safe_integer_max", str(SAFE)],
        ["py_2p53_plus_1", str(2 ** 53 + 1)],
        ["float_2p53_plus_1", str(int(float(2 ** 53 + 1)))],
        ["float_loses_at_2p53", str(int(float(2 ** 53 + 1)) != 2 ** 53 + 1).lower()],
        ["py_3p40", str(3 ** 40)],
        ["float_3p40_lost_bits", str(int(float(3 ** 40)) != 3 ** 40).lower()],
    ]
    for s in SAMPLES:
        rows.append([f"codepoints({s})", str(len(s))])
        rows.append([f"utf8_bytes({s})", str(len(s.encode("utf-8")))])
        rows.append([f"utf16_units({s})", str(len(s.encode("utf-16-le")) // 2)])

    csv_path = os.path.join(ROOT, "out", "mech15_host.csv")
    ashlib.write_csv(csv_path, ["quantity", "value"], rows)

    maxv, where = spec_numeric_max(spec)
    in_safe = maxv <= SAFE
    report = {
        "spec": spec["id"],
        "safeIntegerMax": SAFE,
        "py2p53plus1": 2 ** 53 + 1,
        "float2p53plus1": int(float(2 ** 53 + 1)),
        "floatLosesAt2p53": int(float(2 ** 53 + 1)) != 2 ** 53 + 1,
        "py3p40": 3 ** 40,
        "float3p40LostBits": int(float(3 ** 40)) != 3 ** 40,
        "encoding": [
            {"s": s, "codepoints": len(s), "utf8Bytes": len(s.encode("utf-8")),
             "utf16Units": len(s.encode("utf-16-le")) // 2}
            for s in SAMPLES
        ],
        "specNumericMax": maxv,
        "specNumericWhere": where,
        "specWithinSafeInteger": in_safe,
    }
    out = os.path.join(ROOT, "out", "gd_mech_15_host.json")
    with open(out, "w", encoding="utf-8") as f:
        json.dump(report, f, ensure_ascii=False, indent=2, sort_keys=True)
        f.write("\n")

    lost = int(float(2 ** 53 + 1)) != 2 ** 53 + 1
    print(f"safe_integer_max={SAFE} py_2p53_plus_1={2 ** 53 + 1} "
          f"float_2p53_plus_1={int(float(2 ** 53 + 1))} float_loses={lost}")
    print(f"py_3p40={3 ** 40} float_3p40_lost_bits={int(float(3 ** 40)) != 3 ** 40}")
    for s in SAMPLES:
        print(f"encoding {s} codepoints={len(s)} utf8_bytes={len(s.encode('utf-8'))} "
              f"utf16_units={len(s.encode('utf-16-le')) // 2}")
    print(f"spec_numeric_max={maxv} where={where} within_safe_integer={in_safe}")
    print(f"wrote out/gd_mech_15_host.json wrote out/mech15_host.csv rows={len(rows)}")
    return 0 if in_safe else 1


if __name__ == "__main__":
    raise SystemExit(main())

safe_integer_max=9007199254740991 py_2p53_plus_1=9007199254740993 float_2p53_plus_1=9007199254740992 float_loses=True
py_3p40=12157665459056928801 float_3p40_lost_bits=True
encoding 灰烬牌库 codepoints=4 utf8_bytes=12 utf16_units=4
encoding ashdeck codepoints=7 utf8_bytes=7 utf16_units=7
encoding 🎴 codepoints=1 utf8_bytes=4 utf16_units=2
spec_numeric_max=20261014 where=seed within_safe_integer=True
wrote out/gd_mech_15_host.json wrote out/mech15_host.csv rows=15

// snippet: core/test/gd_mech_15_host.test.ts 的核心断言（完整版见工作区）
test("整数域：number 的安全上界是 2^53-1，越过就丢位", () => {
  assert.equal(Number.MAX_SAFE_INTEGER, 2 ** 53 - 1);
  assert.equal(2 ** 53 + 1 === 2 ** 53, true); // 求值后塌回 2^53
  assert.equal(2 ** 53 + 1, 9007199254740992);
  assert.equal(Number.isSafeInteger(2 ** 53 - 1), true); // 上界本身安全
  assert.equal(Number.isSafeInteger(2 ** 53), false); // 越界，不再安全
});

test("大数：BigInt 精确，换算回 number 就丢 1", () => {
  assert.equal(2n ** 53n + 1n, 9007199254740993n);
  assert.equal(BigInt(2 ** 53 + 1) !== 2n ** 53n + 1n, true);
  assert.equal(2n ** 53n + 1n - BigInt(2 ** 53 + 1), 1n); // 丢位的具体数值
  assert.notEqual(BigInt(3 ** 40), 3n ** 40n);
});

test("字符串：码点数 / UTF-16 码元数 / UTF-8 字节数是三个数", () => {
  assert.equal("灰烬牌库".length, 4);
  assert.equal(Buffer.byteLength("灰烬牌库", "utf8"), 12);
  assert.equal("🎴".length, 2); // 代理对
  assert.equal([..."🎴"].length, 1); // 码点
  assert.equal(Buffer.byteLength("🎴", "utf8"), 4);
});

✔ 整数域：number 的安全上界是 2^53-1，越过就丢位 (0.870667ms)
✔ 大数：BigInt 精确，换算回 number 就丢 1 (0.131625ms)
✔ 字符串：码点数 / UTF-16 码元数 / UTF-8 字节数是三个数 (0.074083ms)
✔ 机制层量全部落在安全整数域内（这是 number 能当机制层载体的根据） (0.0965ms)
✔ 摘要的值域落在安全整数内（大数被挡在机制层之外） (0.263125ms)
ℹ tests 5
ℹ suites 0
ℹ pass 5
ℹ fail 0