13.1 霓虹调色板与色彩分级

#!/usr/bin/env python3
# file: sim/st13_neon.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/st13_neon.py
"""13.1 霓虹调色板与色彩分级（S 层，复古 / 赛博）。

读 config/st13_neon.json 与 sp16_themes.json 的 retro-cyber / cozy-clean 两组 token，算三笔整数账：

① 霓虹下限账：饱和度 `sat = (max − min) × 1000 // max`，亮度 `luma = luma255 × 1000 // 255`。
   发光色（emissive）饱和度 ≥ 500‰、地色（ground）亮度 ≤ 250‰ —— 把「暗底 + 高饱和发光」
   与「亮底低饱和」分开。
② 对比度账：5 对 WCAG ×10 整数口径（floor10 = 45，与卷一 ch4 同源）。
③ 分级账：整数分级 `c' = clamp(luma + (c − luma) × gain // 1000 + lift)`。分级只改色、
   不改地色亮度上限，故对亮底主题分级也变不出霓虹。

全部整数地板除，跨语言逐位一致。落 out/st13_neon.json。
"""
import hashlib
import json
import os
import sys

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


def luma255(rgb):
    return (2126 * rgb[0] + 7152 * rgb[1] + 722 * rgb[2]) // 10000


def luma_permille(rgb):
    return luma255(rgb) * 1000 // 255


def sat_permille(rgb):
    """饱和度千分比（HSV 口径）：max 为 0 时记 0。"""
    mx, mn = max(rgb), min(rgb)
    return 0 if mx == 0 else (mx - mn) * 1000 // mx


def grade(rgb, lift, gain):
    """整数分级：抬黑 lift + 绕 luma 的饱和度增益，逐通道 clamp 到 0–255。"""
    l = luma255(rgb)
    return [max(0, min(255, l + (c - l) * gain // 1000 + lift)) for c in rgb]


def srgb_to_linear(c):
    s = c / 255
    return s / 12.92 if s <= 0.04045 else ((s + 0.055) / 1.055) ** 2.4


def contrast10(a, b):
    """WCAG 对比度 ×10 取整 → 整数类，逐位一致（与卷一 ch4 同源）。"""
    la = 0.2126 * srgb_to_linear(a[0]) + 0.7152 * srgb_to_linear(a[1]) + 0.0722 * srgb_to_linear(a[2])
    lb = 0.2126 * srgb_to_linear(b[0]) + 0.7152 * srgb_to_linear(b[1]) + 0.0722 * srgb_to_linear(b[2])
    hi, lo = max(la, lb), min(la, lb)
    return round((hi + 0.05) / (lo + 0.05) * 10)


def audit(tokens, cfg):
    """下限账 + 对比度账 → (rows, sat_fails, luma_fails, contrast, contrast_fails)。"""
    rows, sat_fails, luma_fails = [], [], []
    for name in cfg["order"]:
        rgb = tokens[name]
        s, l = sat_permille(rgb), luma_permille(rgb)
        rows.append({"token": name, "rgb": rgb, "satPermille": s, "lumaPermille": l})
        if name in cfg["emissive"] and s < cfg["floors"]["emissiveSatPermille"]:
            sat_fails.append(name)
        if name in cfg["ground"] and l > cfg["floors"]["groundLumaPermille"]:
            luma_fails.append(name)
    contrast, con_f = [], []
    for a, b in cfg["contrastPairs"]:
        c = contrast10(tokens[a], tokens[b])
        contrast.append({"pair": f"{a}/{b}", "contrast10": c, "ok": c >= cfg["contrastFloor10"]})
        if c < cfg["contrastFloor10"]:
            con_f.append(f"{a}/{b}")
    return rows, sat_fails, luma_fails, contrast, con_f


def fails_of(tokens, cfg, order):
    """对一组（可能已分级的）token 取 emissive 饱和度 / ground 亮度违例。"""
    return ([n for n in cfg["emissive"] if sat_permille(tokens[n]) < cfg["floors"]["emissiveSatPermille"]],
            [n for n in cfg["ground"] if luma_permille(tokens[n]) > cfg["floors"]["groundLumaPermille"]])


def main():
    cfg = json.load(open(os.path.join(ROOT, "config/st13_neon.json"), encoding="utf-8"))
    themes = json.load(open(os.path.join(ROOT, "config/sp16_themes.json"), encoding="utf-8"))
    by_id = {t["id"]: t for t in themes["themes"]}
    tt, ct = by_id[cfg["theme"]], by_id[cfg["compareTheme"]]
    g = cfg["grading"]

    rows, sat_f, luma_f, contrast, con_f = audit(tt["tokens"], cfg)
    c_rows, c_sat_f, c_luma_f, c_contrast, c_con_f = audit(ct["tokens"], cfg)
    graded = {n: grade(tt["tokens"][n], g["lift"], g["satGainPermille"]) for n in cfg["order"]}
    c_graded = {n: grade(ct["tokens"][n], g["lift"], g["satGainPermille"]) for n in cfg["order"]}
    graded_sat = [sat_permille(graded[n]) for n in cfg["order"]]
    graded_luma = [luma_permille(graded[n]) for n in cfg["order"]]
    gs_f, gl_f = fails_of(graded, cfg, cfg["order"])
    cgs_f, cgl_f = fails_of(c_graded, cfg, cfg["order"])

    canon = json.dumps({
        "satFails": sat_f, "lumaFails": luma_f, "contrastFails": con_f,
        "cmpSatFails": c_sat_f, "cmpLumaFails": c_luma_f, "cmpContrastFails": c_con_f,
        "gradedSat": graded_sat, "gradedLuma": graded_luma,
        "gradedSatFails": gs_f, "gradedLumaFails": gl_f,
        "cmpGradedSatFails": cgs_f, "cmpGradedLumaFails": cgl_f,
    }, separators=(",", ":"))
    report = {
        "project": cfg["project"], "theme": cfg["theme"], "compareTheme": cfg["compareTheme"],
        "floors": cfg["floors"], "contrastFloor10": cfg["contrastFloor10"], "grading": g,
        "tokens": rows, "satFails": sat_f, "lumaFails": luma_f,
        "contrast": contrast, "contrastFails": con_f,
        "compare": {"tokens": c_rows, "satFails": c_sat_f, "lumaFails": c_luma_f,
                    "contrast": c_contrast, "contrastFails": c_con_f},
        "graded": [{"token": n, "rgb": graded[n], "satPermille": graded_sat[i], "lumaPermille": graded_luma[i]}
                   for i, n in enumerate(cfg["order"])],
        "gradedSatFails": gs_f, "gradedLumaFails": gl_f,
        "compareGraded": {"satFails": cgs_f, "lumaFails": cgl_f},
        "canonical": canon, "digest": hashlib.sha256(canon.encode("utf-8")).hexdigest()[:16],
    }
    out = os.path.join(ROOT, "out")
    os.makedirs(out, exist_ok=True)
    with open(os.path.join(out, "st13_neon.json"), "w", encoding="utf-8") as f:
        json.dump(report, f, ensure_ascii=False, indent=2, sort_keys=True)
        f.write("\n")

    print(f"theme={cfg['theme']} compare={cfg['compareTheme']}")
    print(f"satFloorPermille={cfg['floors']['emissiveSatPermille']} groundCeilPermille={cfg['floors']['groundLumaPermille']}")
    print(f"emissive sat fails={sat_f} ground luma fails={luma_f} contrast fails={con_f}")
    print(f"compare sat fails={c_sat_f} ground luma fails={c_luma_f} contrast fails={c_con_f}")
    print(f"graded sat={graded_sat}")
    print(f"graded satFails={gs_f} lumaFails={gl_f}")
    print(f"compare graded satFails={cgs_f} lumaFails={cgl_f}")
    print(f"digest={report['digest']}")
    print("wrote out/st13_neon.json")
    return 0


if __name__ == "__main__":
    sys.exit(main())

theme=retro-cyber compare=cozy-clean
satFloorPermille=500 groundCeilPermille=250
emissive sat fails=[] ground luma fails=[] contrast fails=[]
compare sat fails=['ink', 'ok'] ground luma fails=['bg', 'surface'] contrast fails=[]
graded sat=[457, 483, 623, 295, 792, 654, 874, 701]
graded satFails=[] lumaFails=[]
compare graded satFails=['ink'] lumaFails=['bg', 'surface']
digest=156a04b26195071e
wrote out/st13_neon.json

// file: core/src/st13/neon.ts
// tier: P
// verify: node --test 'core/test/st13_*.test.ts'
// 13.1 霓虹调色板与色彩分级的 TS 内核：整数饱和度 / 亮度、整数分级、霓虹下限与对比度判定。
// 对比度复用 sp00/spec.ts 的 contrast10（转换常数两语言同源）。只允许可擦除 TS 语法
// （禁 enum / namespace / 参数属性 / 装饰器）。

import { contrast10 } from "../sp00/spec.ts";

export type RGB = number[];
export type TokenMap = Record<string, RGB>;

/** 整数亮度（0–255）：权重 2126/7152/722 逼近 Rec.709 luma。 */
export function luma255(rgb: RGB): number {
  return Math.floor((2126 * rgb[0] + 7152 * rgb[1] + 722 * rgb[2]) / 10000);
}

/** 亮度千分比，整数地板除。 */
export function lumaPermille(rgb: RGB): number {
  return Math.floor((luma255(rgb) * 1000) / 255);
}

/** 饱和度千分比（HSV 口径）：(max − min) × 1000 // max；max 为 0 时记 0。 */
export function satPermille(rgb: RGB): number {
  const mx = Math.max(rgb[0], rgb[1], rgb[2]);
  const mn = Math.min(rgb[0], rgb[1], rgb[2]);
  return mx === 0 ? 0 : Math.floor(((mx - mn) * 1000) / mx);
}

/** 整数分级：抬黑 lift + 绕 luma 的饱和度增益，逐通道 clamp 到 0–255。 */
export function grade(rgb: RGB, lift: number, gainPermille: number): RGB {
  const l = luma255(rgb);
  return rgb.map((c) => Math.max(0, Math.min(255, l + Math.floor(((c - l) * gainPermille) / 1000) + lift)));
}

/** 对一组 token 跑下限账 + 对比度账。 */
export function auditTokens(
  tokens: TokenMap,
  order: string[],
  emissive: string[],
  ground: string[],
  floors: { emissiveSatPermille: number; groundLumaPermille: number },
  contrastPairs: string[][],
  contrastFloor10: number,
): {
  rows: { token: string; rgb: RGB; satPermille: number; lumaPermille: number }[];
  satFails: string[];
  lumaFails: string[];
  contrast: { pair: string; contrast10: number; ok: boolean }[];
  contrastFails: string[];
} {
  const rows = order.map((name) => ({
    token: name, rgb: tokens[name], satPermille: satPermille(tokens[name]), lumaPermille: lumaPermille(tokens[name]),
  }));
  const satFails = emissive.filter((n) => satPermille(tokens[n]) < floors.emissiveSatPermille);
  const lumaFails = ground.filter((n) => lumaPermille(tokens[n]) > floors.groundLumaPermille);
  const contrast = contrastPairs.map(([a, b]) => {
    const c = contrast10(tokens[a], tokens[b]);
    return { pair: `${a}/${b}`, contrast10: c, ok: c >= contrastFloor10 };
  });
  const contrastFails = contrast.filter((r) => !r.ok).map((r) => r.pair);
  return { rows, satFails, lumaFails, contrast, contrastFails };
}

✔ 整数饱和度/亮度：与 Python 逐位一致 (0.488916ms)
✔ 主题霓虹下限账：emissive 饱和度 / ground 亮度 / 对比度，与 Python 逐位一致 (0.501542ms)
✔ 对照主题（亮底低饱和）下限账：与 Python 逐位一致 (0.144375ms)
✔ 整数分级：分级后的 sat/luma 列表与 Python 逐位一致 (0.136333ms)
✔ 跨语言：canonical 摘要与 digest 完全一致 (0.400083ms)
✔ 负例：分级改色不改地色亮度上限，亮底分级后 ground 仍不达标 (0.100667ms)
ℹ tests 6
ℹ pass 6
ℹ fail 0