diff --git a/server/sim/content/kits/index.js b/server/sim/content/kits/index.js
index abd79935..aef00a38 100644
--- a/server/sim/content/kits/index.js
+++ b/server/sim/content/kits/index.js
@@ -64,7 +64,7 @@ export const KIT_FILES = Object.freeze([
  * A stand-in without a file fights with the generic kit (content/generic.js) plus its unconditional stat talents
  * (genericTalents) — the eight 预备干员 need no file.
  */
-export const STANDIN_KIT_FILES = Object.freeze([]);
+export const STANDIN_KIT_FILES = Object.freeze(['standin-acnipe.js', 'standin-accast.js', 'standin-acsupo.js']);
 
 async function loadKitFile(file) {
   try {
diff --git a/server/sim/content/kits/ops/standin-accast.js b/server/sim/content/kits/ops/standin-accast.js
new file mode 100644
index 00000000..94416aa2
--- /dev/null
+++ b/server/sim/content/kits/ops/standin-accast.js
@@ -0,0 +1,97 @@
+// server/sim/content/kits/ops/standin-accast.js — Pith (char_612_accast) 补位 stand-in kit: 6★ 扩散术师 for 烛煌 (T5) and
+// 焰影苇草 / 迷迭香 / 荒芜拉普兰德 (T6), all S3 + SPC-X; every skill at every form.
+// Kit contract and the stand-in rules: ../README.md ("Stand-in kits").
+//
+// Sources: data/backups.json (character_table / skill_table / battle_equip_table at E2 Lv1 rank 4 and E2 Lv60 rank 7),
+// PRTS Pith(卫戍协议) (S3 备注 "※溅射范围扩大至1.2") and the client's battle data (charpack char_612_accast,
+// battle/buff_template_data.json accast_s_3[AOE]).
+// - 扩散术师 trait "攻击造成群体法术伤害": the splash around each struck target, radius = the trait's
+//   attack@projectile_range (1.1, PRTS 溅射半径一览's branch value); a skill's attack@projectile_range replaces it while it runs.
+// - T1 "见我所见" "攻击无视目标12法术抗性": magic_resist_penetrate_fixed — a flat 法术穿透 attribute (charpack accast_t_1:
+//   attribute 27 from the blackboard; PRTS Pith 备注 "无视法抗效果为增加自身法术穿透属性（直接加算）"): every arts damage she deals.
+// - T2 "授我所授" "自身及相邻四格的【术师】干员攻击力+10%" (module SPC-X level 2 / 3: +15 / +20 %): an aura on her own tile and
+//   the 4 orthogonal ones, 【术师】 operators only (charpack: profession mask CASTER, removed when the target leaves);
+//   several sources keep the strongest (installAura, [ASSUMED] like every same-named talent aura of the mode).
+// - S1 "书我所书" (自动触发, 25 s): ASPD +attack_speed, splash radius attack@projectile_range (1.5). Trigger: the data's
+//   DEFAULT — an AUTO attack buff waits for her next attack (W5C's AUTO audit: "attack modes / attack buffs" keep waiting).
+// - S2 "为我所为" (35 s): her ASPD +attack_speed; "所有【术师】干员攻击力+atk" — an aura on every 【术师】 operator of the field
+//   (her included) while it runs, refreshed every AURA_IV s; the strongest of several sources applies [ASSUMED].
+// - S3 "驭我所驭" (35 s): at the cast, one atk_scale_aoe × ATK arts hit on every enemy in her attack range (accast_s_3[AOE]:
+//   AOEDamage MAGICAL, its s3_selector; a skill hit, not an attack); then attack@max_target targets (+1), ASPD
+//   +attack_speed, splash attack@projectile_range (1.2, PRTS 备注).
+// - Module SPC-X "攻击范围扩大": her range becomes the module's own grid (the 3×3 caster range + the tile [0,3]; shared
+//   tier5 moduleRangeUp), so the S3 burst covers it too; HP / ATK in the stats; T2 +20 % at level 3 (composed talents).
+
+import { num, talentBb, skillRec, statBuff, installAura, up } from '../shared/tier1.js';
+import { moduleRangeUp } from '../shared/tier5.js';
+
+const S1 = 'skchr_accast_1';
+const S2 = 'skchr_accast_2';
+const S3 = 'skchr_accast_3';
+/** Refresh period / length of the S2 aura buff (the non-stacking aura convention of the kits). */
+const AURA_IV = 0.25;
+const AURA_DUR = 0.4;
+const S2_KEY = 'accast:s2';
+
+const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
+/** A 【术师】 operator (summons are never 【术师】 operators). */
+const isCaster = (a) => !!a && a.kind === 'op' && a.def?.profession === 'CASTER';
+/** One of the 4 tiles next to `u` (相邻四格). */
+const adjacent4 = (a, u) => Math.abs(a.tileR - u.tileR) + Math.abs(a.tileC - u.tileC) === 1;
+
+/** S2: ATK +v on every 【术师】 operator unless a stronger one from another source is on it. */
+function casterAtk(battle, unit, v) {
+  if (!(v > 0)) return;
+  for (const a of battle.alliesFor(unit)) {
+    if (!isCaster(a)) continue;
+    const cur = a.findBuff(S2_KEY);
+    if (cur && cur.source !== unit && (cur.data?.v ?? 0) > v && cur.timeLeft > 0.05) continue;
+    battle.addBuff(a, { key: S2_KEY, duration: AURA_DUR, mods: { atkPct: v }, source: unit, data: { v }, tags: ['aura'] });
+  }
+}
+
+export default {
+  char_612_accast: (bb, chess) => {
+    const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1);
+    const tb = chess?.trait?.bb ?? {};
+    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
+    return {
+      trait: { splashRadius: num(tb['attack@projectile_range'], 1.1) },
+      skills: {
+        [S1]: { kind: 'duration', mods: { aspd: num(b1.attack_speed) }, attack: { splashRadius: num(b1['attack@projectile_range'], 1.5) } },
+        [S2]: {
+          kind: 'duration',
+          mods: { aspd: num(b2.attack_speed) },
+          onStart({ battle, unit }) { casterAtk(battle, unit, num(b2.atk)); },
+        },
+        [S3]: {
+          kind: 'duration',
+          mods: { aspd: num(b3.attack_speed) },
+          targeting: { maxTargets: Math.max(1, Math.floor(num(b3['attack@max_target'], 2))) },
+          attack: { splashRadius: num(b3['attack@projectile_range'], 1.2) },
+          onStart({ battle, unit }) {
+            const scale = num(b3.atk_scale_aoe, 1);
+            for (const e of battle.enemiesInKeys(unit.rangeKeys, unit, unit.profile)) {
+              battle.dealDamage(unit, e, { amount: unit.s.atk * scale, type: 'arts', isSkill: true, tags: ['skill', 'accast:aoe'] });
+              battle.fx('aoe', { x: e.x, y: e.y, r: 0.5, id: unit.id, skill: 'accast' });
+            }
+          },
+        },
+      },
+      talents: [
+        { install(battle, unit) { statBuff(battle, unit, 'talent:accast:res', { resIgnoreFlat: num(t0.magic_resist_penetrate_fixed) }); } },
+        { install(battle, unit) {
+          const v = num(t1.atk);
+          if (v) installAura(battle, unit, { key: 'talent:accast', value: v, select: (a) => isCaster(a) && (a === unit || adjacent4(a, unit)), mods: { atkPct: v } });
+        } },
+      ],
+      install(battle, unit) {
+        moduleRangeUp(battle, unit, chess);
+        if (unit.skill?.id !== S2) return;
+        // S2's aura while it runs (its onStart gives the first application at the cast)
+        const v2 = num(b2.atk);
+        battle.every(AURA_IV, () => { if (up(unit) && unit.skill.active) casterAtk(battle, unit, v2); }, { owner: unit });
+      },
+    };
+  },
+};
diff --git a/server/sim/content/kits/ops/standin-acnipe.js b/server/sim/content/kits/ops/standin-acnipe.js
new file mode 100644
index 00000000..ffdd3f9f
--- /dev/null
+++ b/server/sim/content/kits/ops/standin-acnipe.js
@@ -0,0 +1,93 @@
+// server/sim/content/kits/ops/standin-acnipe.js — Stormeye (char_611_acnipe) 补位 stand-in kit: 6★ 速射手 for 空弦 (T3, S3),
+// 莫斯提马 (T4, S2), 百炼嘉维尔 / 妮芙 (T5, S3 + MAR-X) and 蕾缪安 / 异客 (T6, S3 + MAR-X); every skill at every form.
+// Kit contract and the stand-in rules: ../README.md ("Stand-in kits").
+//
+// Sources: data/backups.json (character_table / skill_table / battle_equip_table at E2 Lv1 rank 4 and E2 Lv60 rank 7)
+// and the client's battle data (charpack char_611_acnipe, battle/buff_template_data.json — the templates quoted below).
+// - 速射手 trait 优先攻击空中单位 (data `targetPriority` 'fly', `canHitFly`); module MAR-X "攻击空中单位时攻击力提升至110%"
+//   (trait atk_scale 1.1, template acnipe_e_002_trait: CheckMotionMode FLY → AtkScaleUp on every damage calculation) is
+//   the fastshot profile's own (professions.js fastshot `flyScale` from the trait blackboard): no kit code. The module's
+//   HP / ATK are in the stats; at level 3 it raises 风坠 to 190 % (the composed talents).
+// - T1 风坠 "攻击时有25%的概率攻击力提升至180%" — acnipe_t_1: ON_CALCULATE_DAMAGE → Dice(prob) → AtkScaleUp(atk_scale): a roll
+//   on EVERY damage instance of an attack (each target, each hit of S3's double hit), ATK × atk_scale before DEF / RES.
+//   S3 raises `prob` to its talent@prob.
+// - T2 风雨欲来 "自身未进行攻击时，技力回复速度+0.2/秒" (sp_recovery_per_sec, delay 2): +0.2 SP/s once she has made no attack
+//   for `delay` s — [ASSUMED] the reading of `delay` (no text or PRTS note gives it), counted from her deployment too.
+// - S1 破空: ATK +atk, ASPD +attack_speed, 无视 def_penetrate_fixed DEF (defIgnoreFlat) for its 20 s.
+// - S2 心手合一 (自动触发, 持续时间无限): ATK +atk and attack@max_target targets until she is knocked out (a toggle). Trigger:
+//   the data's DEFAULT — an AUTO attack buff waits for her next attack like 能天使 S3 / 乌尔比安 S2 (W5C's AUTO audit:
+//   "attack modes / attack buffs" keep waiting); being endless it changes nothing but the moment of the cast.
+// - S3 旋臂: attack@max_target targets, attack@times hits each (二连击), 风坠 at talent@prob; and "攻击目标生命值高于90%时额外
+//   造成1次伤害": the S3 attack carries acnipe_s_3[extra] (`_onlyFeedActiveBuffToFirstOne`: the first hit of the double hit
+//   only) — FilterByTargetHpRatio GE attack@hp_ratio, then AdvancedApplyDamage PHYSICAL attack@atk_scale_extra × ATK with
+//   `_emitSourceOnCalculateDamage` false: one extra physical instance per target per attack, which neither 风坠 nor the
+//   MAR-X trait touches (no isAttack: no "攻击时" effect sees it). [ASSUMED] the HP ratio is read when that first hit lands,
+//   before its damage (as 异客's 机理分析 kit reads it; the order of the buff and the hit is not in the data).
+
+import { num, talentBb, skillRec, spTimeBonus } from '../shared/tier1.js';
+
+const S1 = 'skchr_acnipe_1';
+const S2 = 'skchr_acnipe_2';
+const S3 = 'skchr_acnipe_3';
+/** Tag of S3's extra damage instance (not an attack: 风坠 skips it). */
+const EXTRA = 'acnipe:extra';
+
+const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
+const count = (v, d) => Math.max(1, Math.floor(num(v, d)));
+const s3On = (unit) => !!(unit.skill && unit.skill.active && unit.skill.id === S3);
+
+export default {
+  char_611_acnipe: (bb, chess) => {
+    const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1);
+    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
+    return {
+      skills: {
+        [S1]: { kind: 'duration', mods: { atkPct: num(b1.atk), aspd: num(b1.attack_speed), defIgnoreFlat: num(b1.def_penetrate_fixed) } },
+        [S2]: { kind: 'toggle', mods: { atkPct: num(b2.atk) }, targeting: { maxTargets: count(b2['attack@max_target'], 2) } },
+        [S3]: {
+          kind: 'duration',
+          targeting: { maxTargets: count(b3['attack@max_target'], 3) },
+          attack: {
+            hits: count(b3['attack@times'], 2),
+            // the extra instance, after the attack's hits on that target (marked by the install's first-hit check)
+            onEachHit({ battle, unit, target, kind }) {
+              const due = unit.mem.acnipeExtra;
+              if (kind !== 'main' || !due || !due.has(target)) return;
+              due.delete(target);
+              if (target.alive) battle.dealDamage(unit, target, { amount: unit.s.atk * num(b3['attack@atk_scale_extra'], 1), type: 'phys', isSkill: true, tags: ['skill', EXTRA] });
+            },
+          },
+        },
+      },
+      talents: [
+        { install(battle, unit) { // 风坠: every damage instance of an attack rolls
+          const scale = num(t0.atk_scale, 1), base = num(t0.prob);
+          if (!(scale > 0) || scale === 1) return;
+          battle.on('hit', (ctx) => {
+            const d = ctx.dmg;
+            if (ctx.source !== unit || !ctx.target || ctx.target.side !== 'enemy' || !d.isAttack || d.type === 'element' || (d.tags || []).includes(EXTRA)) return;
+            const p = s3On(unit) ? num(b3['talent@prob'], base) : base;
+            if (p > 0 && battle.rng.chance(p)) d.amount *= scale;
+          }, { owner: unit });
+        } },
+        { install(battle, unit) { // 风雨欲来: no attack for `delay` s (her deployment counts as the start) ⇒ +SP/s
+          const delay = num(t1.delay, 0);
+          spTimeBonus(battle, unit, num(t1.sp_recovery_per_sec), () => battle.time - Math.max(unit.lastAttackAt, unit.deployedAt) >= delay - 1e-9);
+        } },
+      ],
+      install(battle, unit) {
+        if (unit.skill?.id !== S3) return;
+        // S3 [extra]: the first hit of each attack on a target checks its HP ratio before that hit's damage
+        const ratio = num(b3['attack@hp_ratio'], 0.9);
+        battle.on('hit', (ctx) => {
+          const t = ctx.target, d = ctx.dmg;
+          if (ctx.source !== unit || !t || t.side !== 'enemy' || !d.isAttack || d.isSplash || !s3On(unit)) return;
+          const seen = unit.mem.acnipeSeen ??= new WeakMap();
+          if (d.attackId && seen.get(t) === d.attackId) return;
+          seen.set(t, d.attackId);
+          if (t.hpRatio >= ratio - 1e-9) (unit.mem.acnipeExtra ??= new Set()).add(t);
+        }, { owner: unit });
+      },
+    };
+  },
+};
diff --git a/server/sim/content/kits/ops/standin-acsupo.js b/server/sim/content/kits/ops/standin-acsupo.js
new file mode 100644
index 00000000..269bea00
--- /dev/null
+++ b/server/sim/content/kits/ops/standin-acsupo.js
@@ -0,0 +1,156 @@
+// server/sim/content/kits/ops/standin-acsupo.js — Raidian (char_614_acsupo) 补位 stand-in kit: 6★ 凝滞师 for 灵知 (T4, S2),
+// 夕 / 安洁莉娜 (T5, S3 + DEC-X) and 浊心斯卡蒂 / 仇白 (T6, S3 + DEC-X); every skill at every form.
+// Kit contract and the stand-in rules: ../README.md ("Stand-in kits").
+//
+// Sources: data/backups.json (character_table / skill_table / battle_equip_table at E2 Lv1 rank 4 and E2 Lv60 rank 7),
+// PRTS Raidian(卫戍协议) (S3 备注 on its 虚弱), PRTS 命中率 and the client's battle data (charpack char_614_acsupo).
+// - 凝滞师 trait "攻击造成法术伤害，并对敌人造成短暂的停顿": arts, 停顿 `sluggish` s on every target (professions.js slower,
+//   from the trait blackboard); S2 lengthens it (attack@sluggish).
+// - T1 同调 "攻击速度+15，相邻的干员攻击速度+10" (module DEC-X level 2 / 3: 18 / 11, 20 / 12): her own ASPD (charpack
+//   acsupo_t_1[self]) and an aura on the operators of the 4 tiles next to her (acsupo_t_1[ally]: profession mask of every
+//   operator class — no summon —, removed when the target leaves); several sources keep the strongest [ASSUMED]. S3
+//   multiplies both by talent_scale (the S3 mode's `_applyTalentScale`).
+// - T2 诱引 "攻击范围内敌人的物理和法术命中率降低10%" (damage_hitrate_physical / damage_hitrate_magical): PRTS 命中率 — every
+//   unit has 100 % 物理 / 法术命中率; an attack of that damage type made at a lower rate rolls once when it starts, and a
+//   failed roll misses as a whole: every target and hit of that attack, its splash, and the effects it would carry
+//   ("攻击未命中…在输出伤害事件前就算作处理失败", no 晕眩 / 停顿 …). Here: one roll per enemy attack (its `attackId`) while the
+//   attacker stands in a Raidian's current attack range (S3's included), made by a battle-wide `hit` handler at
+//   LURE_PRIORITY — before the enemy content's own hit riders (content/enemies.js, priority 200) and everything else —
+//   which cancels every damage instance of a missed attack and stops the hook there. A target's own 闪避 is a separate roll
+//   in the damage pipeline. [ASSUMED] the roll is made at the attack's first damage instance (a ranged enemy's at its
+//   projectile's arrival; it stands still through its attack clip) rather than at its wind-up; two Raidians' cuts never
+//   add up (the stronger one counts, like the mode's other same-named effects — the charpack's `disableOverride` might
+//   mean they coexist); true damage is never affected (PRTS: neither 物理 nor 法术).
+// - S1 双声 (24 s): ATK +atk, attack@max_target targets.
+// - S2 三形 (14 / 17 s): base attack time + base_attack_time s (PRTS "略微缩短(-0.1)" / "缩短(-0.2)": a flat change, batMod),
+//   attack@max_target targets, 停顿 attack@sluggish s.
+// - S3 信号跃动 (30 / 35 s): range y-4 (the skill's rangeGrid) — its auto-cast is the data's ACTIVE_RANGE (the owner's rule
+//   of 2026-10-05: an enemy inside the larger range casts it; tools/build-data.mjs resolveTrigger, not this kit) —, ATK
+//   +acsupo_s_3.atk, T1 × talent_scale, and every enemy in her attack range takes 脆弱 damage_scale − 1 and 虚弱 1 − atk:
+//   the catalogue statuses (同名效果取最高), refreshed every AURA_IV s while the skill runs. The 虚弱 stacks as `atk`
+//   (0.9 / 0.8: PRTS 备注 "此技能的虚弱在叠加时视为90%（1级~6级）/80%（7级~专精二）…的虚弱（仅影响叠加优先级，不影响实际效果）"
+//   — applyStatus `stackAs`), so it outranks every weaker 虚弱 while it lasts.
+// - Module DEC-X "攻击范围内存在敌人时技力自然恢复速度+0.2/秒" (hidden talent sp_recovery_per_sec; acsupo_e_002_t: one
+//   +0.2 whatever the number of enemies); HP / ATK in the stats; T1 changes at level 2 / 3 (composed talents).
+
+import { canTargetEnemy } from '../../../targeting.js';
+import { bodyInKeys } from '../../../body.js';
+import { num, talentBb, moduleBb, skillRec, statBuff, spTimeBonus, enemyInRange, up, batMod } from '../shared/tier1.js';
+
+const S1 = 'skchr_acsupo_1';
+const S2 = 'skchr_acsupo_2';
+const S3 = 'skchr_acsupo_3';
+/** Refresh period / length of the auras (T1 on allies, S3 on enemies): the non-stacking aura convention of the kits. */
+const AURA_IV = 0.25;
+const AURA_DUR = 0.4;
+const T1_KEY = 'acsupo:t1';
+/** 诱引's battle-wide `hit` handler runs before every other one (the enemy content's riders sit at 200). */
+const LURE_PRIORITY = 300;
+const ANY = Object.freeze({ canHitFly: true });
+
+const bbOf = (chess, id) => skillRec(chess, id)?.bb ?? {};
+const count = (v, d) => Math.max(1, Math.floor(num(v, d)));
+const adjacent4 = (a, u) => Math.abs(a.tileR - u.tileR) + Math.abs(a.tileC - u.tileC) === 1;
+const s3On = (unit) => !!(unit.skill && unit.skill.active && unit.skill.id === S3);
+
+// ---- 诱引 (T2): one battle-wide handler over every Raidian of the battle -------------------------------------------
+/** battle → { srcs: [{ unit, phys, arts }], last: WeakMap(enemy → { id, miss }) }. */
+const LURE = new WeakMap();
+
+/** The hit-rate cut (0–1) `e`'s attack of damage type `type` suffers: the strongest of the Raidians whose range holds it. */
+function lureCut(st, e, type) {
+  let cut = 0;
+  for (const s of st.srcs) {
+    const u = s.unit, v = Math.abs(type === 'arts' ? s.arts : s.phys);
+    if (v > cut && up(u) && u.rangeKeySet && canTargetEnemy(u, e, ANY) && bodyInKeys(e, u.rangeKeySet)) cut = v;
+  }
+  return Math.min(1, cut);
+}
+
+function lureHit(battle, st, ctx) {
+  const e = ctx.source, d = ctx.dmg;
+  if (!e || e.side !== 'enemy' || !d || !d.isAttack || d.cancel || (d.type !== 'phys' && d.type !== 'arts')) return;
+  // one roll per attack: every damage instance of it (each target, a multi-hit) shares the first instance's result
+  const prev = d.attackId ? st.last.get(e) : null;
+  let miss;
+  if (prev && prev.id === d.attackId) miss = prev.miss;
+  else {
+    const cut = lureCut(st, e, d.type);
+    miss = cut > 0 && battle.rng() < cut;
+    if (d.attackId) st.last.set(e, { id: d.attackId, miss });
+  }
+  if (!miss) return;
+  d.cancel = true;
+  ctx.stopPropagation = true;
+  if (ctx.target) battle.fx('dodge', { x: ctx.target.x, y: ctx.target.y, id: ctx.target.id });
+}
+
+function installLure(battle, unit, phys, arts) {
+  if (!phys && !arts) return;
+  let st = LURE.get(battle);
+  if (!st) {
+    st = { srcs: [], last: new WeakMap() };
+    LURE.set(battle, st);
+    // no owner: it serves every Raidian of the battle, whichever is on the field
+    battle.on('hit', (ctx) => lureHit(battle, st, ctx), { priority: LURE_PRIORITY });
+  }
+  st.srcs.push({ unit, phys, arts });
+}
+
+// ---- the kit ---------------------------------------------------------------------------------------------------------
+export default {
+  char_614_acsupo: (bb, chess) => {
+    const t0 = talentBb(chess, 0), t1 = talentBb(chess, 1);
+    const b1 = bbOf(chess, S1), b2 = bbOf(chess, S2), b3 = bbOf(chess, S3);
+    const grid3 = skillRec(chess, S3)?.rangeGrid;
+    const self = num(t0.attack_speed), ally = num(t0['acsupo_t_1[ally].attack_speed']);
+    const scale = num(b3.talent_scale, 1);
+    const fragile = num(b3.damage_scale, 1) - 1, atkMul = num(b3.atk, 1);
+    /** S3: 脆弱 / 虚弱 on every enemy of her (skill) range — at the cast, then every AURA_IV s while it runs. */
+    const s3Aura = (battle, unit) => {
+      for (const e of battle.enemiesInKeys(unit.rangeKeys, unit, ANY)) {
+        if (fragile > 0) battle.applyStatus(e, 'fragile', { duration: AURA_DUR, value: fragile, source: unit });
+        if (atkMul > 0 && atkMul < 1 && e.alive) battle.applyStatus(e, 'weaken', { duration: AURA_DUR, value: 1 - atkMul, stackAs: atkMul, source: unit });
+      }
+    };
+    return {
+      skills: {
+        [S1]: { kind: 'duration', mods: { atkPct: num(b1.atk) }, targeting: { maxTargets: count(b1['attack@max_target'], 2) } },
+        [S2]: {
+          kind: 'duration',
+          mods: { batPct: batMod(b2.base_attack_time, chess) },
+          targeting: { maxTargets: count(b2['attack@max_target'], 3) },
+          attack: { onHitStatus: { key: 'sluggish', duration: num(b2['attack@sluggish'], 1.1) } },
+        },
+        [S3]: {
+          kind: 'duration',
+          // T1 × talent_scale: her own part here, the allies' in the T1 aura
+          mods: { atkPct: num(b3['acsupo_s_3.atk']), aspd: self * (scale - 1) },
+          ...(grid3 && grid3.length ? { targeting: { rangeGrid: grid3.map((p) => [p[0], p[1]]) } } : {}),
+          onStart({ battle, unit }) { s3Aura(battle, unit); },
+        },
+      },
+      talents: [
+        { install(battle, unit) { // 同调
+          statBuff(battle, unit, 'talent:acsupo', { aspd: self });
+          if (!ally) return;
+          battle.every(AURA_IV, () => {
+            if (!up(unit)) return;
+            const v = ally * (s3On(unit) ? scale : 1);
+            for (const a of battle.alliesFor(unit)) {
+              if (a === unit || a.kind !== 'op' || !adjacent4(a, unit)) continue;
+              const cur = a.findBuff(T1_KEY);
+              if (cur && cur.source !== unit && (cur.data?.v ?? 0) > v && cur.timeLeft > 0.05) continue;
+              battle.addBuff(a, { key: T1_KEY, duration: AURA_DUR, mods: { aspd: v }, source: unit, data: { v }, tags: ['aura'] });
+            }
+          }, { owner: unit, immediate: true });
+        } },
+        { install(battle, unit) { installLure(battle, unit, num(t1.damage_hitrate_physical), num(t1.damage_hitrate_magical)); } }, // 诱引
+      ],
+      install(battle, unit) {
+        spTimeBonus(battle, unit, num(moduleBb(chess).sp_recovery_per_sec), () => enemyInRange(battle, unit)); // DEC-X
+        if (unit.skill?.id === S3) battle.every(AURA_IV, () => { if (up(unit) && s3On(unit)) s3Aura(battle, unit); }, { owner: unit });
+      },
+    };
+  },
+};
diff --git a/test/content/standin_accast.test.js b/test/content/standin_accast.test.js
new file mode 100644
index 00000000..ec732d02
--- /dev/null
+++ b/test/content/standin_accast.test.js
@@ -0,0 +1,209 @@
+// test/content/standin_accast.test.js — the 补位 stand-in Pith (char_612_accast, kits/ops/standin-accast.js) on every chess
+// it replaces (烛煌 T5, 焰影苇草 / 迷迭香 / 荒芜拉普兰德 T6, all S3 + SPC-X), normal and elite: every skill (S1 "书我所书", S2
+// "为我所为", S3 "驭我所驭" with its burst), both talents (12 RES ignored; ATK +10 % on herself and the 【术师】 of the 4 tiles
+// next to her), the module (SPC-X range, stats, T2 +20 % at level 3), the splash radius per skill, the data triggers,
+// anti-air.
+// Run: node --test test/content/standin_accast.test.js
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
+import { unitForm } from '../../shared/standIn.js';
+import { absoluteRangeKeys } from '../../server/sim/targeting.js';
+import { COLS } from '../../server/sim/constants.js';
+
+const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8'));
+const CHESS = load('chess');
+const BACKUPS = load('backups');
+const PITH = 'char_612_accast';
+const [S1, S2, S3] = ['skchr_accast_1', 'skchr_accast_2', 'skchr_accast_3'];
+const RECORDS = BACKUPS.units[PITH].standsIn.flatMap((a) => [a, a.replace(/_a$/, '_b')]);
+const DUMMIES = {
+  d: enemyRec({ key: 'd', hp: 1e7, speed: 0 }),
+  r: enemyRec({ key: 'r', hp: 1e7, res: 50, speed: 0 }),
+  f: enemyRec({ key: 'f', hp: 1e7, speed: 0, motion: 'FLY' }),
+};
+const close = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps, `${msg}: ${a} vs ${b}`);
+const formOf = (id) => unitForm(BACKUPS, PITH, CHESS[id].status);
+const skillOf = (id, sid) => formOf(id).skills.find((s) => s.skillId === sid);
+const moduleOf = (id) => {
+  const c = CHESS[id];
+  return c.status.equipLevel > 0 && c.backup.uniEquipId ? formOf(id).modules.find((m) => m.uniEquipId === c.backup.uniEquipId) : null;
+};
+const key = (r, c) => r * COLS + c;
+
+/** Pith at (10,4) facing right (3-6: rows 9–11, cols 4–6; SPC-X adds (10,7)); dummies at `enemies`; extra `units`. */
+function arena(chessId, { standIn = true, enemies = [], units = [], sp = 999, seed = 5, timeLimit = 200 } = {}) {
+  return makeBattle({
+    defs: { enemies: DUMMIES }, seed, timeLimit, autoFinish: false,
+    units: [{ chessId, row: 10, col: 4, dir: 'RIGHT', standIn, ...(sp != null ? { carryState: { sp } } : {}) }, ...units],
+    enemies, hooks: ['skillStart', 'skillEnd', 'damaged', 'attack'], captureNoisy: true,
+  });
+}
+const done = (h) => { assert.deepEqual(h.b.errors.map((e) => `${e.label} ${e.message}`), []); checkInvariants(h.b); };
+const hits = (h, u, t0 = -1) => h.hooksOf('damaged').filter((c) => c.source === u && c.t >= t0);
+
+test('Pith on every chess it replaces: the stand-in body, its kit, S3; SPC-X on the elites (level 1 at T5, 3 at T6) with its range; arts splash 1.1, anti-air', () => {
+  assert.equal(RECORDS.length, 8);
+  for (const id of RECORDS) {
+    const c = CHESS[id];
+    const form = formOf(id), mod = moduleOf(id);
+    const h = arena(id, { sp: null });
+    h.step();
+    const u = h.unit(1);
+    const where = `${id} ${c.name}`;
+    assert.deepEqual([u.def.charId, u.def.standInFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [PITH, c.charId, S3, false, 'skills'], where);
+    assert.equal(!!u.def.raw.module?.active, !!mod, `${where}: module only on the elite`);
+    assert.equal(!!mod, id.endsWith('_b'), where);
+    if (mod) assert.equal(u.def.raw.module.level, c.tier === 6 ? 3 : 1, where);
+    assert.equal(u.base.atk, form.stats.atk + (mod ? mod.attr.atk : 0), `${where}: ATK`);
+    assert.equal(u.base.maxHp, form.stats.maxHp + (mod ? mod.attr.maxHp : 0), `${where}: HP`);
+    assert.deepEqual([u.profile.dmgType, u.profile.splashRadius, u.profile.canHitFly], ['arts', 1.1, true], `${where}: profile`);
+    // the range: 3-6 (9 tiles), SPC-X its 3-1 grid (+ the tile [0,3])
+    const want = absoluteRangeKeys(mod ? mod.talentChanges.find((t) => t.talentIndex === -1).rangeGrid : form.rangeGrid, 10, 4, 'RIGHT', 0);
+    assert.deepEqual([...u.rangeKeys].sort((a, b) => a - b), [...want].sort((a, b) => a - b), `${where}: range`);
+    assert.equal(u.rangeKeySet.has(key(10, 7)), !!mod, `${where}: (10,7) only with SPC-X`);
+    const t1 = u.def.raw.talents.find((t) => t.index === 1);
+    assert.equal(t1.bb.atk, mod && mod.level === 3 ? 0.2 : 0.1, `${where}: 授我所授`);
+    done(h);
+  }
+});
+
+test('Pith triggers: the data rules — S1 AUTO DEFAULT (an attack buff waits for her attack), S2 / S3 MANUAL DEFAULT', () => {
+  for (const id of ['chess_char_5_03_a', 'chess_char_5_03_b']) {
+    for (const [i, sid] of [[0, S1], [1, S2], [2, S3]]) {
+      const h = arena(id, { standIn: { skillIndex: i }, sp: null });
+      h.step();
+      const u = h.unit(1);
+      assert.deepEqual([u.skill.id, u.skill.rule, u.def.skill.skillType], [sid, 'DEFAULT', sid === S1 ? 'AUTO' : 'MANUAL'], `${id} ${sid}`);
+      done(h);
+    }
+  }
+});
+
+test('"见我所见": her arts hits ignore 12 RES (flat 法术穿透)', () => {
+  for (const id of ['chess_char_5_03_a', 'chess_char_6_12_b']) {
+    const h = arena(id, { sp: null, enemies: [{ key: 'r', pos: [10, 6] }] });
+    const u = h.unit(1);
+    assert.equal(u.s.resIgnoreFlat, 12);
+    h.run(1);
+    const t0 = h.b.time;
+    assert.ok(h.runUntil(() => hits(h, u, t0).length > 0, 5));
+    close(hits(h, u, t0)[0].amount, u.s.atk * (1 - (50 - 12) / 100), `${id}: RES 50 − 12`, 1e-3);
+    done(h);
+  }
+});
+
+test('"授我所授": ATK +10 % (T6 elite: +20 %) on herself and the 【术师】 operators of the 4 tiles next to her — not diagonal, not farther, not another class', () => {
+  for (const [id, v] of [['chess_char_5_03_a', 0.1], ['chess_char_5_03_b', 0.1], ['chess_char_6_08_b', 0.2]]) {
+    const h = arena(id, { sp: null, units: [
+      { chessId: 'chess_char_1_03_a', row: 10, col: 3 },   // 惊蛰 (CASTER), behind her: adjacent
+      { chessId: 'chess_char_1_14_a', row: 9, col: 3 },    // 格雷伊 (CASTER), diagonal
+      { chessId: 'chess_char_1_17_a', row: 12, col: 4 },   // 深靛 (CASTER), two tiles away
+      { chessId: 'chess_char_1_02_a', row: 11, col: 4 },   // 角峰 (TANK), adjacent
+    ] });
+    h.run(1);
+    const [p, adj, diag, far, tank] = [1, 2, 3, 4, 5].map((uid) => h.unit(uid));
+    const buff = (x) => x.findBuff('talent:accast')?.mods?.atkPct ?? 0;
+    assert.deepEqual([buff(p), buff(adj), buff(diag), buff(far), buff(tank)], [v, v, 0, 0, 0], id);
+    close(p.s.atk, p.base.atk * (1 + v), `${id}: her ATK`);
+    done(h);
+  }
+});
+
+test('S1 "书我所书" (自动触发): no enemy, no cast; at her attack: ASPD +30 / +40 and the splash radius 1.5 for 25 s (1.1 before and after)', () => {
+  for (const id of ['chess_char_5_03_a', 'chess_char_5_03_b']) {
+    const sk = skillOf(id, S1);
+    // (10,6) is a target; (11,7) is 1.41 tiles from it and out of her range: splash only, within 1.5 but not 1.1
+    const h = arena(id, { standIn: { skillIndex: 0 }, enemies: [{ key: 'd', pos: [10, 6], time: 3 }, { key: 'd', pos: [11, 7], time: 3 }] });
+    const u = h.unit(1);
+    h.run(2.9);
+    assert.equal(u.skill.activations, 0, `${id}: nobody to attack — no cast`);
+    assert.ok(h.runUntil(() => u.skill.active, 3), `${id}: cast`);
+    const start = h.b.time;
+    assert.equal(u.s.aspd, 100 + sk.bb.attack_speed, `${id}: ASPD`);
+    const side = h.b.enemies.find((e) => Math.round(e.y) === 11);
+    h.run(5);
+    assert.ok(hits(h, u, start).some((c) => c.target === side && c.dmg.isSplash), `${id}: the 1.41-tile neighbour takes the splash`);
+    assert.ok(h.runUntil(() => !u.skill.active, 30));
+    close(h.b.time - start, sk.duration, `${id}: ${sk.duration} s`, 0.05);
+    assert.equal(u.s.aspd, 100);
+    const t1 = h.b.time + 1.5;  // the last S1 bolts land
+    h.run(6);
+    assert.equal(hits(h, u, t1).filter((c) => c.target === side).length, 0, `${id}: splash 1.1 again`);
+    assert.ok(hits(h, u, t1).length > 0);
+    done(h);
+  }
+});
+
+test('S2 "为我所为": her ASPD +35 / +50 and every 【术师】 operator ATK +30 / +35 % (herself included, wherever they stand; no other class) for 35 s', () => {
+  for (const id of ['chess_char_5_03_a', 'chess_char_5_03_b']) {
+    const sk = skillOf(id, S2);
+    const h = arena(id, { standIn: { skillIndex: 1 }, enemies: [{ key: 'd', pos: [10, 6] }], units: [
+      { chessId: 'chess_char_1_03_a', row: 12, col: 9 },   // 惊蛰 (CASTER), far away
+      { chessId: 'chess_char_1_02_a', row: 9, col: 2 },    // 角峰 (TANK)
+    ] });
+    const [u, caster, tank] = [1, 2, 3].map((uid) => h.unit(uid));
+    assert.ok(h.runUntil(() => u.skill.active, 3), `${id}: cast`);
+    const start = h.b.time;
+    assert.equal(u.s.aspd, 100 + sk.bb.attack_speed, `${id}: ASPD`);
+    h.run(0.5);
+    const buff = (x) => x.findBuff('accast:s2')?.mods?.atkPct ?? 0;
+    assert.deepEqual([buff(u), buff(caster), buff(tank)], [sk.bb.atk, sk.bb.atk, 0], id);
+    close(u.s.atk, u.base.atk * (1 + 0.1 + sk.bb.atk), `${id}: her ATK (T2 + S2)`);
+    h.run(30);
+    assert.equal(buff(caster), sk.bb.atk, `${id}: kept up while it runs`);
+    assert.ok(h.runUntil(() => !u.skill.active, 10));
+    close(h.b.time - start, sk.duration, `${id}: ${sk.duration} s`, 0.05);
+    h.run(0.5);
+    assert.deepEqual([buff(u), buff(caster)], [0, 0], `${id}: gone after it`);
+    done(h);
+  }
+});
+
+test('S3 "驭我所驭": one 100 / 140 % arts hit on every enemy of her range at the cast (SPC-X range included), then 2 targets, ASPD +40 / +55, splash 1.2, 35 s', () => {
+  for (const id of ['chess_char_5_03_a', 'chess_char_6_08_b']) {
+    const sk = skillOf(id, S3), elite = id.endsWith('_b');
+    const h = arena(id, { sp: null, enemies: [[10, 5], [9, 6], [11, 6], [10, 7], [9, 8]].map((pos) => ({ key: 'd', pos })) });
+    const u = h.unit(1);
+    h.run(1);
+    u.skill.gainSp(999);
+    assert.ok(h.runUntil(() => u.skill.active, 3), `${id}: cast`);
+    const start = h.hooksOf('skillStart').find((c) => c.unit === u).t, atk = u.s.atk;
+    const burst = hits(h, u, start).filter((c) => (c.dmg.tags || []).includes('accast:aoe'));
+    const at = (c) => `${Math.round(c.target.y)},${Math.round(c.target.x)}`;
+    const want = ['10,5', '9,6', '11,6', ...(elite ? ['10,7'] : [])].sort();
+    assert.deepEqual(burst.map(at).sort(), want, `${id}: every enemy of her range once — (9,8) is out of it`);
+    assert.ok(burst.every((c) => Math.abs(c.amount - atk * sk.bb.atk_scale_aoe) < 1e-6 && c.type === 'arts' && c.dmg.isSkill && !c.dmg.isAttack), `${id}: ATK × ${sk.bb.atk_scale_aoe} arts, a skill hit`);
+    assert.equal(u.s.aspd, 100 + sk.bb.attack_speed, `${id}: ASPD`);
+    h.run(8);
+    const atks = h.hooksOf('attack').filter((c) => c.attacker === u && c.t >= start);
+    assert.ok(atks.length >= 3 && atks.every((c) => c.targets.length === 2), `${id}: 2 targets per attack (the cast's own attack too)`);
+    assert.equal(h.hooksOf('skillStart').filter((c) => c.unit === u).length, 1, 'one burst per cast');
+    assert.ok(h.runUntil(() => !u.skill.active, 40));
+    close(h.b.time - start, sk.duration, `${id}: ${sk.duration} s`, 0.05);
+    done(h);
+  }
+  // the splash radius 1.2: a neighbour 1.15 tiles from her only target, out of her range, is splashed during S3 only
+  const h = arena('chess_char_5_03_a', { sp: null, enemies: [{ key: 'd', pos: [10, 6] }, { key: 'd', pos: [10, 7.15] }] });
+  const u = h.unit(1);
+  h.run(3);
+  const side = h.b.enemies.find((e) => e.x > 7);
+  assert.ok(side && hits(h, u).length > 0);
+  assert.equal(hits(h, u).filter((c) => c.target === side).length, 0, 'splash 1.1: not reached');
+  u.skill.gainSp(999);
+  assert.ok(h.runUntil(() => u.skill.active, 3));
+  const t0 = h.b.time + 0.01;
+  h.run(4);
+  assert.ok(hits(h, u, t0).some((c) => c.target === side && c.dmg.isSplash), 'splash 1.2: reached');
+  done(h);
+});
+
+test('Pith hits air units too: a flyer in range is her target', () => {
+  const h = arena('chess_char_6_12_a', { sp: null, enemies: [{ key: 'f', pos: [10, 6], route: 2 }] });
+  const u = h.unit(1);
+  assert.ok(h.runUntil(() => hits(h, u).length > 0, 5));
+  assert.ok(hits(h, u)[0].target.isFlying);
+  done(h);
+});
diff --git a/test/content/standin_acnipe.test.js b/test/content/standin_acnipe.test.js
new file mode 100644
index 00000000..82c9081b
--- /dev/null
+++ b/test/content/standin_acnipe.test.js
@@ -0,0 +1,241 @@
+// test/content/standin_acnipe.test.js — the 补位 stand-in Stormeye (char_611_acnipe, kits/ops/standin-acnipe.js) on every
+// chess it replaces (空弦 T3 S3, 莫斯提马 T4 S2, 百炼嘉维尔 / 妮芙 T5 S3 + MAR-X, 蕾缪安 / 异客 T6 S3 + MAR-X), normal and elite:
+// every skill (S1 破空, S2 心手合一, S3 旋臂 with its extra hit), both talents (风坠 on every damage instance, 风雨欲来), the
+// module (MAR-X ×1.1 on air units, stats, 风坠 190 % at level 3), the data triggers, anti-air and the 'fly' priority.
+// Run: node --test test/content/standin_acnipe.test.js
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { makeBattle, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
+import { unitForm } from '../../shared/standIn.js';
+import { canTargetAlly } from '../../server/sim/targeting.js';
+
+const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8'));
+const CHESS = load('chess');
+const BACKUPS = load('backups');
+const STORM = 'char_611_acnipe';
+const [S1, S2, S3] = ['skchr_acnipe_1', 'skchr_acnipe_2', 'skchr_acnipe_3'];
+const EXTRA = 'acnipe:extra';
+const RECORDS = BACKUPS.units[STORM].standsIn.flatMap((a) => [a, a.replace(/_a$/, '_b')]);
+const DUMMIES = {
+  d: enemyRec({ key: 'd', hp: 1e7, speed: 0 }),
+  dd: enemyRec({ key: 'dd', hp: 1e7, def: 300, speed: 0 }),
+  f: enemyRec({ key: 'f', hp: 1e7, speed: 0, motion: 'FLY' }),
+};
+const close = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps, `${msg}: ${a} vs ${b}`);
+const formOf = (id) => unitForm(BACKUPS, STORM, CHESS[id].status);
+const skillOf = (id, sid) => formOf(id).skills.find((s) => s.skillId === sid);
+/** The module the elite record fields (null without one). */
+const moduleOf = (id) => {
+  const c = CHESS[id];
+  return c.status.equipLevel > 0 && c.backup.uniEquipId ? formOf(id).modules.find((m) => m.uniEquipId === c.backup.uniEquipId) : null;
+};
+
+/** Stormeye at (10,4) facing right (range 3-3: rows 9–11, cols 4–7); dummies at `enemies`. */
+function arena(chessId, { standIn = true, enemies = [], sp = 999, seed = 3, timeLimit = 200 } = {}) {
+  return makeBattle({
+    defs: { enemies: DUMMIES }, seed, timeLimit, autoFinish: false,
+    units: [{ chessId, row: 10, col: 4, dir: 'RIGHT', standIn, ...(sp != null ? { carryState: { sp } } : {}) }],
+    enemies, hooks: ['skillStart', 'skillEnd', 'damaged', 'attack'], captureNoisy: true,
+  });
+}
+const done = (h) => { assert.deepEqual(h.b.errors.map((e) => `${e.label} ${e.message}`), []); checkInvariants(h.b); };
+/** Damage instances Stormeye dealt (captured `damaged` ctx), optionally from `t0` on. */
+const hits = (h, u, t0 = -1) => h.hooksOf('damaged').filter((c) => c.source === u && c.t >= t0);
+
+test('Stormeye on every chess it replaces: the stand-in body, its kit (never generic), the chess backup skill, the module on the T5 / T6 elites only; anti-air, fly first, ground-targetable', () => {
+  assert.equal(RECORDS.length, 12);
+  for (const id of RECORDS) {
+    const c = CHESS[id];
+    const form = formOf(id), mod = moduleOf(id);
+    const sk = form.skills.find((s) => s.index === c.backup.skillIndex);
+    const h = arena(id, { sp: null });
+    h.step();
+    const u = h.unit(1);
+    const where = `${id} ${c.name}`;
+    assert.deepEqual([u.def.charId, u.def.standInFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [STORM, c.charId, sk.skillId, false, 'skills'], where);
+    assert.equal(u.skill.kind, sk.skillId === S2 ? 'toggle' : 'duration', where);
+    assert.equal(!!u.def.raw.module?.active, !!mod, `${where}: module only on the T5 / T6 elite`);
+    if (mod) assert.equal(u.def.raw.module.level, c.tier === 6 ? 3 : 1, where);
+    assert.equal(u.base.atk, form.stats.atk + (mod ? mod.attr.atk : 0), `${where}: ATK`);
+    assert.equal(u.base.maxHp, form.stats.maxHp + (mod ? mod.attr.maxHp : 0), `${where}: HP`);
+    assert.deepEqual([u.profile.canHitFly, u.profile.priority, u.profile.dmgType, u.profile.flyScale], [true, 'fly', 'phys', mod ? 1.1 : 1], `${where}: profile`);
+    const t0 = u.def.raw.talents.find((t) => t.index === 0);
+    assert.equal(t0.bb.atk_scale, mod && mod.level === 3 ? 1.9 : 1.8, `${where}: 风坠`);
+    // ground-targetable: an enemy ranged attack may select her (no 起飞 / 迷彩 / 隐匿)
+    assert.ok(canTargetAlly({ blockedBy: null }, u, true), `${where}: an enemy may target her`);
+    done(h);
+  }
+});
+
+test('Stormeye triggers: the data rules — S1 / S3 MANUAL DEFAULT (no range change), S2 AUTO DEFAULT (an attack buff waits for her next attack, endless)', () => {
+  for (const id of ['chess_char_3_21_a', 'chess_char_3_21_b']) {
+    for (const [i, sid] of [[0, S1], [1, S2], [2, S3]]) {
+      const h = arena(id, { standIn: { skillIndex: i }, sp: null });
+      h.step();
+      const u = h.unit(1);
+      assert.deepEqual([u.skill.id, u.skill.rule, u.def.skill.trigger.rule, u.def.skill.skillType], [sid, 'DEFAULT', 'DEFAULT', sid === S2 ? 'AUTO' : 'MANUAL'], `${id} ${sid}`);
+      done(h);
+    }
+  }
+});
+
+test('S1 破空: ATK +15 %, ASPD +30 / +50, 100 DEF ignored on her hits, for 20 s; then all of it ends', () => {
+  for (const id of ['chess_char_3_21_a', 'chess_char_3_21_b']) {
+    const sk = skillOf(id, S1);
+    const h = arena(id, { standIn: { skillIndex: 0 }, enemies: [{ key: 'dd', pos: [10, 6] }] });
+    const u = h.unit(1);
+    h.b.rng.chance = () => false; // no 风坠
+    assert.ok(h.runUntil(() => u.skill.active, 3), `${id}: cast`);
+    const start = h.b.time, base = u.base.atk;
+    close(u.s.atk, base * (1 + sk.bb.atk), `${id}: ATK`);
+    assert.equal(u.s.aspd, 100 + sk.bb.attack_speed, `${id}: ASPD`);
+    assert.equal(u.s.defIgnoreFlat, 100, `${id}: DEF ignored`);
+    assert.ok(h.runUntil(() => hits(h, u, start).length > 0, 3));
+    close(hits(h, u, start)[0].amount, base * (1 + sk.bb.atk) - (300 - 100), `${id}: a hit on DEF 300`, 1e-3);
+    assert.ok(h.runUntil(() => !u.skill.active, 30));
+    close(h.b.time - start, sk.duration, `${id}: ${sk.duration} s`, 0.05);
+    assert.deepEqual([u.s.atk, u.s.aspd, u.s.defIgnoreFlat], [base, 100, 0], `${id}: back`);
+    done(h);
+  }
+});
+
+test('S2 心手合一 (自动触发): no enemy, no cast; with one it casts at her attack — ATK +5 %, one extra target per attack, endless and no SP meanwhile; a knock-out ends it', () => {
+  for (const id of ['chess_char_4_02_a', 'chess_char_4_02_b']) {
+    const sk = skillOf(id, S2);
+    const h = arena(id, { timeLimit: 400, enemies: [{ key: 'd', pos: [10, 6], time: 5 }, { key: 'd', pos: [9, 6], time: 5 }] });
+    const u = h.unit(1);
+    h.run(4.9);
+    assert.equal(u.skill.activations, 0, `${id}: full SP, nobody to attack — no cast`);
+    assert.ok(h.runUntil(() => u.skill.active, 3), `${id}: cast`);
+    assert.equal(h.hooksOf('skillStart')[0].reason, 'DEFAULT');
+    const base = u.base.atk;
+    close(u.s.atk, base * (1 + sk.bb.atk), `${id}: ATK`);
+    h.run(10);
+    const atks = h.hooksOf('attack').filter((c) => c.attacker === u);
+    assert.ok(atks.length >= 9 && atks.every((c) => c.targets.length === sk.bb['attack@max_target']), `${id}: ${sk.bb['attack@max_target']} targets per attack`);
+    h.run(120);
+    assert.ok(u.skill.active && u.skill.kind === 'toggle', `${id}: still on after 130 s`);
+    assert.equal(u.skill.sp, 0, `${id}: no SP while it runs`);
+    h.b.kill(u);
+    assert.ok(h.runUntil(() => u.alive && u.deployed, 120), 'redeployed');
+    h.step();
+    assert.equal(u.skill.active, false, `${id}: off after the knock-out`);
+    close(u.skill.sp, sk.initSp, `${id}: SP back to its initial ${sk.initSp}`, 0.1);
+    done(h);
+  }
+});
+
+test('S3 旋臂: 3 targets, a double hit on each, 风坠 at 30 / 35 % (25 % before), one extra 100 % hit per attack on a target at ≥ 90 % HP — none below; 30 s', () => {
+  for (const id of ['chess_char_3_21_a', 'chess_char_6_01_b']) {
+    const sk = skillOf(id, S3);
+    const h = arena(id, { sp: null, enemies: [[10, 5], [10, 6], [9, 6], [11, 6]].map((pos) => ({ key: 'd', pos })) });
+    const u = h.unit(1);
+    const probs = [];
+    h.b.rng.chance = (p) => { probs.push([h.b.time, p, !!(u.skill.active)]); return false; };
+    // before the cast: one target, 风坠 at the talent's 25 %
+    assert.ok(h.runUntil(() => hits(h, u).length >= 2, 5));
+    assert.ok(probs.length >= 2 && probs.every(([, p, on]) => !on && p === 0.25), `${id}: 25 % outside S3`);
+    u.skill.gainSp(999);
+    assert.ok(h.runUntil(() => u.skill.active, 3), `${id}: S3 cast`);
+    const start = h.b.time;
+    h.run(6);
+    const during = probs.filter(([t]) => t > start + 0.5);
+    assert.ok(during.length > 10 && during.every(([, p]) => p === sk.bb['talent@prob']), `${id}: 风坠 at ${sk.bb['talent@prob']}`);
+    // per attack: 3 targets × (2 attack hits + 1 extra at 100 % ATK, never rolled)
+    const atk = u.s.atk;
+    const byAttack = new Map();
+    for (const c of hits(h, u, start + 0.5)) {
+      const k = c.dmg.attackId || `x${c.t}`;
+      if (!byAttack.has(k)) byAttack.set(k, []);
+      byAttack.get(k).push(c);
+    }
+    const attacks = h.hooksOf('attack').filter((c) => c.attacker === u && c.t > start + 0.5 && c.t < h.b.time - 1);
+    assert.ok(attacks.length >= 3 && attacks.every((c) => c.targets.length === 3), `${id}: 3 targets`);
+    const normal = hits(h, u, start + 0.5).filter((c) => c.dmg.isAttack);
+    const extra = hits(h, u, start + 0.5).filter((c) => (c.dmg.tags || []).includes(EXTRA));
+    assert.ok(normal.every((c) => Math.abs(c.amount - atk) < 1e-6), `${id}: every attack hit = ATK (no 风坠)`);
+    assert.ok(extra.length > 0 && extra.every((c) => Math.abs(c.amount - atk * sk.bb['attack@atk_scale_extra']) < 1e-6 && !c.dmg.isAttack && c.type === 'phys'), `${id}: the extra hit: ATK × atk_scale_extra, physical, not an attack`);
+    // every target of an attack: exactly 2 attack hits and 1 extra
+    const perTarget = new Map();
+    for (const c of normal.concat(extra)) {
+      const k = `${c.target.id}`;
+      perTarget.set(k, perTarget.get(k) ?? { n: 0, x: 0 });
+      perTarget.get(k)[(c.dmg.tags || []).includes(EXTRA) ? 'x' : 'n']++;
+    }
+    for (const [k, v] of perTarget) assert.equal(v.n, 2 * v.x, `${id}: target ${k} — 2 hits per extra (${v.n} / ${v.x})`);
+    // a target below 90 %: no extra
+    const low = h.b.enemies.find((e) => perTarget.has(`${e.id}`));
+    low.hp = low.s.maxHp * 0.85;
+    const t1 = h.b.time;
+    h.run(3);
+    assert.ok(hits(h, u, t1).some((c) => c.target === low && c.dmg.isAttack), 'the low target is still attacked');
+    assert.equal(hits(h, u, t1).filter((c) => c.target === low && (c.dmg.tags || []).includes(EXTRA)).length, 0, `${id}: no extra below 90 %`);
+    // 风坠 on: the attack hits ×1.8 / 1.9, the extra stays at 100 %
+    h.b.rng.chance = () => true;
+    const t2 = h.b.time;
+    h.run(2);
+    const scale = u.def.raw.talents.find((t) => t.index === 0).bb.atk_scale;
+    const crit = hits(h, u, t2);
+    assert.ok(crit.filter((c) => c.dmg.isAttack).every((c) => Math.abs(c.amount - u.s.atk * scale) < 1e-6), `${id}: 风坠 ×${scale}`);
+    assert.ok(crit.filter((c) => (c.dmg.tags || []).includes(EXTRA)).every((c) => Math.abs(c.amount - u.s.atk) < 1e-6), `${id}: never on the extra`);
+    assert.ok(h.runUntil(() => !u.skill.active, 40));
+    close(h.b.time - start, sk.duration, `${id}: ${sk.duration} s`, 0.05);
+    done(h);
+  }
+});
+
+test('风坠: an attack hit at ATK × 1.8 (T6 elite, MAR-X level 3: × 1.9) before DEF, on 25 % of the hits', () => {
+  for (const id of ['chess_char_3_21_a', 'chess_char_6_05_b']) {
+    const h = arena(id, { sp: null, enemies: [{ key: 'dd', pos: [10, 6] }] });
+    const u = h.unit(1);
+    h.b.rng.chance = () => true;
+    assert.ok(h.runUntil(() => hits(h, u).length > 0, 5));
+    const scale = id.endsWith('_b') ? 1.9 : 1.8;
+    close(hits(h, u)[0].amount, u.s.atk * scale - 300, `${id}: ATK × ${scale} − DEF`, 1e-3);
+    done(h);
+  }
+  // the real roll: about a quarter of 200 hits (seeded)
+  const h = arena('chess_char_3_21_a', { sp: null, seed: 11, enemies: [{ key: 'd', pos: [10, 6] }], timeLimit: 400 });
+  const u = h.unit(1);
+  h.run(42);   // S3 is cast at 44 s
+  const all = hits(h, u).filter((c) => c.dmg.isAttack);
+  const crits = all.filter((c) => c.amount > u.s.atk * 1.5);
+  assert.ok(all.length >= 40, `${all.length} hits`);
+  assert.ok(crits.length / all.length > 0.1 && crits.length / all.length < 0.45, `${crits.length} of ${all.length} hits ×1.8`);
+  done(h);
+});
+
+test('MAR-X (T5 / T6 elite): attacks on air units at ATK × 1.1; the normal form has no bonus; fly targets first', () => {
+  for (const [id, mul] of [['chess_char_5_18_b', 1.1], ['chess_char_6_01_b', 1.1], ['chess_char_5_18_a', 1]]) {
+    const h = arena(id, { sp: null, enemies: [{ key: 'd', pos: [10, 5] }, { key: 'f', pos: [10, 7], route: 2 }] });
+    const u = h.unit(1);
+    h.b.rng.chance = () => false;
+    assert.ok(h.runUntil(() => hits(h, u).length >= 3, 6));
+    const first = hits(h, u);
+    assert.ok(first.slice(0, 3).every((c) => c.target.isFlying), `${id}: the flyer first, though the ground dummy is nearer`);
+    close(first[0].amount, u.s.atk * mul, `${id}: ×${mul} on the flyer`);
+    done(h);
+  }
+});
+
+test('风雨欲来: +0.2 SP/s once she has not attacked for 2 s (her deployment counts); attacking every second, none', () => {
+  const sk = skillOf('chess_char_3_21_a', S3);
+  const idle = arena('chess_char_3_21_a', { sp: null });
+  const u = idle.unit(1);
+  idle.step();
+  const t0 = idle.b.time, sp0 = u.skill.sp;
+  idle.run(12);
+  const dt = idle.b.time - t0;
+  close(u.skill.sp - sp0, dt + 0.2 * (dt - 2), 'idle: +1/s, +0.2/s after 2 s', 0.08);
+  done(idle);
+  const busy = arena('chess_char_3_21_a', { sp: null, enemies: [{ key: 'd', pos: [10, 6] }] });
+  const v = busy.unit(1);
+  busy.step();
+  const b0 = busy.b.time, bs0 = v.skill.sp;
+  busy.run(12);
+  close(v.skill.sp - bs0, busy.b.time - b0, 'attacking: +1/s only', 0.08);
+  assert.ok(v.skill.sp < sk.spCost);
+  done(busy);
+});
diff --git a/test/content/standin_acsupo.test.js b/test/content/standin_acsupo.test.js
new file mode 100644
index 00000000..a6afd6d7
--- /dev/null
+++ b/test/content/standin_acsupo.test.js
@@ -0,0 +1,297 @@
+// test/content/standin_acsupo.test.js — the 补位 stand-in Raidian (char_614_acsupo, kits/ops/standin-acsupo.js) on every
+// chess it replaces (灵知 T4 S2, 夕 / 安洁莉娜 T5 S3 + DEC-X, 浊心斯卡蒂 / 仇白 T6 S3 + DEC-X), normal and elite: every skill
+// (S1 双声, S2 三形, S3 信号跃动 with its range, auras and the data's ACTIVE_RANGE trigger), both talents (同调 on herself and
+// the operators next to her, 诱引's hit-rate cut on the attacks of the enemies in her range — PRTS 命中率), the module
+// (DEC-X SP, stats, 同调 at level 3), the 停顿 trait, anti-air; and the engine option behind S3's 虚弱 (applyStatus stackAs).
+// Run: node --test test/content/standin_acsupo.test.js
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { makeBattle, chessRec, enemyRec, checkInvariants } from '../helpers/battleHarness.js';
+import { unitForm } from '../../shared/standIn.js';
+import { COLS } from '../../server/sim/constants.js';
+
+const load = (f) => JSON.parse(readFileSync(new URL(`../../data/${f}.json`, import.meta.url), 'utf8'));
+const CHESS = load('chess');
+const BACKUPS = load('backups');
+const RAID = 'char_614_acsupo';
+const [S1, S2, S3] = ['skchr_acsupo_1', 'skchr_acsupo_2', 'skchr_acsupo_3'];
+const RECORDS = BACKUPS.units[RAID].standsIn.flatMap((a) => [a, a.replace(/_a$/, '_b')]);
+const ENEMIES = {
+  d: enemyRec({ key: 'd', hp: 1e7, speed: 0 }),
+  brute: enemyRec({ key: 'brute', hp: 1e7, atk: 200, bat: 1, speed: 1 }),
+  holy: enemyRec({ key: 'holy', hp: 1e7, atk: 200, bat: 1, speed: 1, dmgType: 'true' }),
+  archer: enemyRec({ key: 'archer', hp: 1e7, atk: 200, bat: 1, speed: 0, range: 2.5 }),
+};
+/** A plain blocker without a kit (no randomness of its own). */
+const TANK = chessRec({ id: 't_tank', profession: 'TANK', subProfessionId: 'protector', stats: { maxHp: 1e6, def: 0, atk: 1, blockCnt: 3 }, rangeGrid: [[0, 0]], skill: null });
+const close = (a, b, msg, eps = 1e-6) => assert.ok(Math.abs(a - b) <= eps, `${msg}: ${a} vs ${b}`);
+const formOf = (id) => unitForm(BACKUPS, RAID, CHESS[id].status);
+const skillOf = (id, sid) => formOf(id).skills.find((s) => s.skillId === sid);
+const moduleOf = (id) => {
+  const c = CHESS[id];
+  return c.status.equipLevel > 0 && c.backup.uniEquipId ? formOf(id).modules.find((m) => m.uniEquipId === c.backup.uniEquipId) : null;
+};
+const key = (r, c) => r * COLS + c;
+
+/** Raidian at (10,4) facing right (y-2: rows 9–11, cols 3–6; S3's y-4 adds (10,7) and rows 8 / 12); extra `units`. */
+function arena(chessId, { standIn = true, enemies = [], units = [], sp = 999, seed = 7, timeLimit = 200, setup = null } = {}) {
+  return makeBattle({
+    defs: { enemies: ENEMIES, chess: { t_tank: TANK } }, seed, timeLimit, autoFinish: false, setup,
+    units: [{ chessId, row: 10, col: 4, dir: 'RIGHT', standIn, ...(sp != null ? { carryState: { sp } } : {}) }, ...units],
+    enemies, hooks: ['skillStart', 'skillEnd', 'damaged', 'attack', 'statusApplied'], captureNoisy: true,
+  });
+}
+const done = (h) => { assert.deepEqual(h.b.errors.map((e) => `${e.label} ${e.message}`), []); checkInvariants(h.b); };
+const castOf = (h, u) => h.hooksOf('skillStart').find((c) => c.unit === u);
+
+test('Raidian on every chess it replaces: the stand-in body, its kit, the backup skill (S2 for 灵知, S3 else), DEC-X on the T5 / T6 elites; arts + 停顿 0.8 s, anti-air', () => {
+  assert.equal(RECORDS.length, 10);
+  for (const id of RECORDS) {
+    const c = CHESS[id];
+    const form = formOf(id), mod = moduleOf(id);
+    const sk = form.skills.find((s) => s.index === c.backup.skillIndex);
+    const h = arena(id, { sp: null });
+    h.step();
+    const u = h.unit(1);
+    const where = `${id} ${c.name}`;
+    assert.deepEqual([u.def.charId, u.def.standInFor, u.skill.id, !!u.kit.generic, u.kit.skillSource], [RAID, c.charId, sk.skillId, false, 'skills'], where);
+    assert.equal(sk.skillId, c.tier === 4 ? S2 : S3, where);
+    assert.equal(!!u.def.raw.module?.active, !!mod, `${where}: module only on the T5 / T6 elite`);
+    if (mod) assert.equal(u.def.raw.module.level, c.tier === 6 ? 3 : 1, where);
+    assert.equal(u.base.atk, form.stats.atk + (mod ? mod.attr.atk : 0), `${where}: ATK`);
+    assert.equal(u.base.maxHp, form.stats.maxHp + (mod ? mod.attr.maxHp : 0), `${where}: HP`);
+    assert.deepEqual([u.profile.dmgType, u.profile.canHitFly, u.profile.onHitStatus], ['arts', true, { key: 'sluggish', duration: 0.8 }], `${where}: profile`);
+    assert.equal(u.rangeKeys.length, 12, `${where}: y-2`);
+    const t0 = u.def.raw.talents.find((t) => t.index === 0).bb;
+    assert.deepEqual([t0.attack_speed, t0['acsupo_t_1[ally].attack_speed']], mod && mod.level === 3 ? [20, 12] : [15, 10], `${where}: 同调`);
+    assert.equal(u.s.aspd, 100 + t0.attack_speed, `${where}: her ASPD`);
+    done(h);
+  }
+});
+
+test('Raidian triggers: S1 / S2 MANUAL DEFAULT; S3 the data\'s ACTIVE_RANGE over its y-4 (the owner\'s rule), the kit sets none', () => {
+  for (const id of ['chess_char_4_13_a', 'chess_char_5_12_b']) {
+    for (const [i, sid] of [[0, S1], [1, S2], [2, S3]]) {
+      const h = arena(id, { standIn: { skillIndex: i }, sp: null });
+      h.step();
+      const u = h.unit(1);
+      const rule = sid === S3 ? 'ACTIVE_RANGE' : 'DEFAULT';
+      assert.deepEqual([u.skill.id, u.skill.rule, u.def.skill.trigger.rule, u.kit.skill.trigger], [sid, rule, rule, undefined], `${id} ${sid}`);
+      if (sid === S3) assert.deepEqual(u.def.skill.trigger.grid, skillOf(id, S3).rangeGrid, 'trigger grid = the skill range');
+      done(h);
+    }
+  }
+});
+
+test('S3 ACTIVE_RANGE: an enemy only in its y-4 range ((10,7)) casts it at once, before any attack; none there, or one beyond it, no cast', () => {
+  for (const id of ['chess_char_5_12_a', 'chess_char_6_15_b']) {
+    const h = arena(id, { enemies: [{ key: 'd', pos: [10, 7] }] });
+    const u = h.unit(1);
+    assert.ok(h.runUntil(() => u.skill.active, 2), `${id}: cast`);
+    assert.equal(castOf(h, u).reason, 'ACTIVE_RANGE');
+    assert.equal(h.hooksOf('attack').filter((c) => c.attacker === u && c.t < castOf(h, u).t).length, 0, 'no attack before (it is out of y-2)');
+    assert.ok(u.rangeKeySet.has(key(10, 7)), 'then in her running range');
+    h.run(3);
+    assert.ok(h.hooksOf('attack').some((c) => c.attacker === u), 'and she attacks it');
+    done(h);
+    for (const enemies of [[], [{ key: 'd', pos: [10, 8] }]]) {
+      const g = arena(id, { enemies });
+      g.run(5);
+      assert.equal(g.unit(1).skill.activations, 0, `${id}: no cast with ${JSON.stringify(enemies)}`);
+      done(g);
+    }
+  }
+});
+
+test('S1 双声: ATK +25 / +40 %, one extra target, 24 s', () => {
+  for (const id of ['chess_char_4_13_a', 'chess_char_5_20_b']) {
+    const sk = skillOf(id, S1);
+    const h = arena(id, { standIn: { skillIndex: 0 }, enemies: [{ key: 'd', pos: [10, 5] }, { key: 'd', pos: [10, 6] }, { key: 'd', pos: [9, 6] }] });
+    const u = h.unit(1);
+    assert.ok(h.runUntil(() => u.skill.active, 3));
+    const start = castOf(h, u).t;
+    close(u.s.atk, u.base.atk * (1 + sk.bb.atk), `${id}: ATK`);
+    h.run(6);
+    const atks = h.hooksOf('attack').filter((c) => c.attacker === u && c.t >= start);
+    assert.ok(atks.length >= 3 && atks.every((c) => c.targets.length === 2), `${id}: 2 targets`);
+    assert.ok(h.runUntil(() => !u.skill.active, 30));
+    close(h.b.time - start, sk.duration, `${id}: ${sk.duration} s`, 0.05);
+    done(h);
+  }
+});
+
+test('S2 三形: base attack time 1.9 → 1.8 / 1.7 s, 3 targets, 停顿 1.1 / 1.2 s (0.8 s before), 14 / 17 s', () => {
+  for (const id of ['chess_char_4_13_a', 'chess_char_4_13_b']) {
+    const sk = skillOf(id, S2);
+    const h = arena(id, { sp: null, enemies: [[10, 5], [10, 6], [9, 6], [11, 6]].map((pos) => ({ key: 'd', pos })) });
+    const u = h.unit(1);
+    h.run(2);
+    const slow = (t0, t1) => h.hooksOf('statusApplied').filter((c) => c.source === u && c.status === 'sluggish' && c.t >= t0 && c.t < t1).map((c) => c.duration);
+    assert.ok(slow(0, 2).length > 0 && slow(0, 2).every((d) => d === 0.8), 'the trait: 0.8 s');
+    u.skill.gainSp(999);
+    assert.ok(h.runUntil(() => u.skill.active, 3));
+    const start = castOf(h, u).t;
+    close(u.s.interval * u.s.aspd / 100, 1.9 + sk.bb.base_attack_time, `${id}: base attack time`);
+    h.run(5);
+    const atks = h.hooksOf('attack').filter((c) => c.attacker === u && c.t >= start);
+    assert.ok(atks.length >= 3 && atks.every((c) => c.targets.length === 3), `${id}: 3 targets`);
+    const during = slow(start, h.b.time);
+    assert.ok(during.length >= 9 && during.every((d) => d === sk.bb['attack@sluggish']), `${id}: 停顿 ${sk.bb['attack@sluggish']} s`);
+    assert.ok(h.runUntil(() => !u.skill.active, 30));
+    close(h.b.time - start, sk.duration, `${id}: ${sk.duration} s`, 0.05);
+    close(u.s.interval * u.s.aspd / 100, 1.9, 'back to 1.9 s');
+    done(h);
+  }
+});
+
+test('S3 信号跃动: y-4 while it runs, ATK +40 / +50 %, 同调 ×2 / ×2.5, enemies in range 脆弱 + 虚弱 10 / 20 % (the 虚弱 stacking as 90 / 80 %), 30 / 35 s', () => {
+  for (const id of ['chess_char_5_12_a', 'chess_char_6_04_b']) {
+    const sk = skillOf(id, S3), elite = id.endsWith('_b');
+    const t0 = formOf(id).talents.find((t) => t.index === 0).bb;
+    const self = elite ? 20 : t0.attack_speed, ally = elite ? 12 : t0['acsupo_t_1[ally].attack_speed'];
+    const h = arena(id, { enemies: [{ key: 'd', pos: [10, 6] }, { key: 'd', pos: [10, 9] }], units: [{ chessId: 't_tank', row: 11, col: 4 }] });
+    const [u, tank] = [h.unit(1), h.unit(2)];
+    h.step();
+    const [inR, outR] = [...h.b.enemies].sort((a, b) => a.x - b.x);
+    h.b.applyStatus(inR, 'weaken', { value: 0.3, duration: 100 });   // a stronger 虚弱 of another source
+    assert.ok(h.runUntil(() => u.skill.active, 2), `${id}: cast`);
+    const start = castOf(h, u).t;
+    h.run(0.5);
+    assert.equal(u.rangeKeys.length, 19, `${id}: y-4`);
+    close(u.s.atk, u.base.atk * (1 + sk.bb['acsupo_s_3.atk']), `${id}: ATK`);
+    close(u.s.aspd, 100 + self * sk.bb.talent_scale, `${id}: her ASPD`);
+    close(tank.findBuff('acsupo:t1')?.mods?.aspd ?? 0, ally * sk.bb.talent_scale, `${id}: the neighbour's ASPD`);
+    const fr = inR.findBuff('fragile'), wk = inR.findBuff('weaken');
+    close(fr?.data?.value ?? 0, sk.bb.damage_scale - 1, `${id}: 脆弱`);
+    close(inR.s.dmgTakenMul, sk.bb.damage_scale, `${id}: damage taken`);
+    assert.deepEqual([wk?.data?.value, wk?.data?.stackAs].map((v) => Math.round(v * 1e6) / 1e6), [Math.round((1 - sk.bb.atk) * 1e6) / 1e6, sk.bb.atk], `${id}: 虚弱 ${1 - sk.bb.atk}, stacking as ${sk.bb.atk}`);
+    close(inR.s.atk, inR.base.atk * sk.bb.atk, `${id}: its 虚弱 outranks the 30 % one (PRTS 备注)`);
+    assert.deepEqual([outR.findBuff('fragile') ?? null, outR.findBuff('weaken') ?? null], [null, null], `${id}: nothing out of her range`);
+    assert.ok(h.runUntil(() => !u.skill.active, 40));
+    close(h.b.time - start, sk.duration, `${id}: ${sk.duration} s`, 0.05);
+    h.run(0.5);
+    assert.deepEqual([u.rangeKeys.length, u.s.aspd, tank.findBuff('acsupo:t1')?.mods?.aspd], [12, 100 + self, ally], `${id}: back`);
+    assert.equal(inR.findBuff('fragile') ?? null, null, `${id}: 脆弱 gone`);
+    close(inR.findBuff('weaken')?.data?.value ?? 0, 0.3, `${id}: the 30 % 虚弱 resumes`);
+    done(h);
+  }
+});
+
+test('同调: ASPD +15 / +20 on herself, +10 / +12 on the operators of the 4 tiles next to her — not diagonal, not farther', () => {
+  for (const [id, v] of [['chess_char_5_12_a', 10], ['chess_char_6_15_b', 12]]) {
+    const h = arena(id, { sp: null, units: [
+      { chessId: 't_tank', row: 11, col: 4 },              // adjacent
+      { chessId: 'chess_char_1_03_a', row: 9, col: 5 },    // diagonal
+      { chessId: 'chess_char_1_17_a', row: 10, col: 2 },   // two tiles away
+    ] });
+    h.run(1);
+    const [adj, diag, far] = [2, 3, 4].map((uid) => h.unit(uid));
+    const buff = (x) => x.findBuff('acsupo:t1')?.mods?.aspd ?? 0;
+    assert.deepEqual([buff(adj), buff(diag), buff(far), buff(h.unit(1))], [v, 0, 0, 0], id);
+    done(h);
+  }
+});
+
+/** A blocked brute (atk 200, 1 attack/s) on t_tank at `tile`; `rng0`: every direct battle.rng() draw returns that value. */
+function lureField(id, { tile = [10, 5], enemy = 'brute', rng0 = null, standIn = true } = {}) {
+  const h = arena(id, { sp: null, standIn, enemies: [{ key: enemy, pos: tile }], units: [{ chessId: 't_tank', row: tile[0], col: tile[1] }] });
+  if (rng0 != null) { const real = h.b.rng; h.b.rng = Object.assign(() => rng0, real); }
+  const seen = [];
+  h.b.on('hit', (c) => { if (c.source && c.source.side === 'enemy') seen.push(c.dmg.attackId); });   // a later hit handler
+  return { h, u: h.unit(1), tank: h.unit(2), seen };
+}
+
+test('诱引: an enemy attacking inside her range misses as a whole on a failed roll (no damage, no later hit handler), the attack still spent; outside her range, or true damage, never', () => {
+  for (const id of ['chess_char_4_13_a', 'chess_char_6_04_b']) {
+    const miss = lureField(id, { rng0: 0 });
+    miss.h.run(8);
+    const e = miss.h.b.enemies[0];
+    assert.ok(e.blockedBy === miss.tank && e.stats.attacks >= 6, `${id}: it attacks every second (${e.stats.attacks})`);
+    assert.equal(miss.tank.stats.taken, 0, `${id}: every attack missed`);
+    assert.equal(miss.seen.length, 0, 'no later hit handler saw them');
+    assert.ok(miss.h.eventsOf('fx').filter((f) => f[1] === 'dodge' && f[4].id === miss.tank.id).length >= 6, 'a miss shows on the target');
+    done(miss.h);
+    const land = lureField(id, { rng0: 0.99 });
+    land.h.run(8);
+    close(land.tank.stats.taken, land.h.b.enemies[0].stats.attacks * 200, `${id}: a passed roll lands`, 1e-6);
+    done(land.h);
+  }
+  // out of her range ((10,8)): no roll — even a draw of 0 lands
+  const out = lureField('chess_char_5_12_a', { tile: [10, 8], rng0: 0 });
+  out.h.run(5);
+  assert.ok(out.tank.stats.taken > 0, 'outside her range: no cut');
+  done(out.h);
+  // true damage has no 物理 / 法术 hit rate
+  const holy = lureField('chess_char_5_12_a', { enemy: 'holy', rng0: 0 });
+  holy.h.run(5);
+  assert.ok(holy.tank.stats.taken > 0, 'true damage: never misses');
+  done(holy.h);
+  // the real roll: about one attack in ten (seeded)
+  const real = lureField('chess_char_4_13_a', {});
+  real.h.run(150);
+  const n = real.h.b.enemies[0].stats.attacks, landed = Math.round(real.tank.stats.taken / 200);
+  assert.ok(n >= 140, `${n} attacks`);
+  assert.ok(n - landed >= 4 && n - landed <= 30, `${n - landed} of ${n} attacks missed (10 %)`);
+  done(real.h);
+});
+
+test('诱引: one roll per attack — every damage instance of a two-target attack shares it', () => {
+  const h = arena('chess_char_5_12_a', {
+    sp: null, enemies: [{ key: 'archer', pos: [10, 6] }],
+    units: [{ chessId: 't_tank', row: 10, col: 5 }, { chessId: 't_tank', row: 11, col: 5 }],
+    setup: (b) => b.on('enemySpawn', ({ enemy }) => { enemy.profile.maxTargets = 2; }),
+  });
+  const landed = new Map();
+  h.b.on('damaged', (c) => { if (c.source && c.source.side === 'enemy') landed.set(c.dmg.attackId, (landed.get(c.dmg.attackId) ?? 0) + 1); });
+  h.run(120);
+  h.b.applyStatus(h.b.enemies[0], 'disarm', { duration: 100, force: true });   // no new attack; the arrows in flight land
+  h.run(2);
+  const atks = h.hooksOf('attack').filter((c) => c.attacker.side === 'enemy');
+  assert.ok(atks.length >= 100 && atks.every((c) => c.targets.length === 2), `${atks.length} two-target attacks`);
+  const counts = [...landed.values()];
+  assert.ok(counts.every((k) => k === 2), 'a landed attack lands on both targets');
+  const missed = atks.length - landed.size;
+  assert.ok(missed >= 3 && missed <= 25, `${missed} of ${atks.length} attacks missed whole`);
+  done(h);
+});
+
+test('DEC-X (T5 / T6 elite): +0.2 SP/s while an enemy is in her range; none without one, nor on the normal form', () => {
+  for (const [id, enemy, rate] of [['chess_char_5_12_b', true, 1.2], ['chess_char_5_12_b', false, 1], ['chess_char_5_12_a', true, 1], ['chess_char_6_15_b', true, 1.2]]) {
+    const h = arena(id, { sp: null, enemies: enemy ? [{ key: 'd', pos: [10, 6] }] : [] });
+    const u = h.unit(1);
+    h.step();
+    const t0 = h.b.time, sp0 = u.skill.sp;
+    h.run(10);
+    assert.equal(u.skill.activations, 0);
+    close((u.skill.sp - sp0) / (h.b.time - t0), rate, `${id} ${enemy ? 'enemy in range' : 'no enemy'}`, 0.01);
+    done(h);
+  }
+});
+
+test('engine: applyStatus stackAs — a 同名效果取最高 status competing with another strength than its effect; tails keep it; without it nothing changes', () => {
+  const h = makeBattle({ defs: { enemies: ENEMIES }, enemies: [{ key: 'd', pos: [10, 6] }], autoFinish: false, timeLimit: 60 });
+  h.step();
+  const e = h.b.enemies[0], b = h.b;
+  const now = () => e.findBuff('weaken');
+  b.applyStatus(e, 'weaken', { value: 0.3, duration: 10 });
+  assert.deepEqual(now().data, { value: 0.3, tail: null }, 'the plain data shape');
+  b.applyStatus(e, 'weaken', { value: 0.1, stackAs: 0.9, duration: 2 });
+  assert.deepEqual([now().data.value, now().data.stackAs, now().mods.atkMul, now().data.tail.value, now().data.tail.stackAs], [0.1, 0.9, 0.9, 0.3, undefined], 'it outranks the 30 % (its effect stays 10 %); the 30 % waits as the tail');
+  b.applyStatus(e, 'weaken', { value: 0.5, duration: 1 });
+  assert.equal(now().data.value, 0.1, 'a 50 % one does not outrank 90 %');
+  h.run(2.1);
+  assert.deepEqual([now().data.value, now().data.stackAs], [0.3, undefined], 'the 30 % resumes after it');
+  h.run(8);
+  assert.equal(now() ?? null, null, 'all over');
+  b.applyStatus(e, 'weaken', { value: 0.05, stackAs: 0.8, duration: 20 });
+  assert.deepEqual(now().data, { value: 0.05, stackAs: 0.8, tail: null });
+  b.applyStatus(e, 'weaken', { value: 0.2, stackAs: 0.95, duration: 1 });
+  assert.deepEqual([now().data.value, now().data.tail.value, now().data.tail.stackAs], [0.2, 0.05, 0.8], 'its tail keeps stackAs');
+  h.run(1.1);
+  assert.deepEqual([now().data.value, now().data.stackAs], [0.05, 0.8], 'and resumes with it');
+  b.applyStatus(e, 'weaken', { value: 0.5, duration: 5 });
+  assert.equal(now().data.value, 0.05, 'a plain 50 % does not outrank it either');
+  checkInvariants(h.b);
+});