卡①T3(核心数据面结构收敛批): 生成器族两文件拆分——board_generator generate收束(_board_params快照+_attempt_loop重试主循环+_accept_fallback三分出口)+_attempt布雷剃雷两域(_populate_mines Fisher-Yates取号段整体随迁+_shave_ring零RNG)+measure三算子域(_apply_chain_rule/_apply_single_rules/_derived_constraints/_apply_derived_rules)+_finalize删_db参5参化;node_map_generator validate_output六阶段域(_vo_node_fields/_vo_edges/_vo_flow_facts/_vo_depth_reach/_vo_shop_counts/_vo_terminal_shops/_vo_terminal_depths/_vo_width_rules/_vo_params_check)+check_params两分(_cp_domain/_cp_structural)+_build主链区域两段(_build_trunk/_build_region零RNG)+_add_forks锚收集段零RNG提取+_assign_types两分(_fill_ratios取号序整体搬迁+_fix_detour_heads零RNG)+_check_fork_rules签名两助手;RNG消费序冻结同种子逐位一致,17键全清,node_map三件+generator套件全绿

game/core/node_map_generator.gd

@@ -66,6 +66,14 @@ func _setup_and_build(params: Dictionary, seed_val: int) -> Dictionary:
 
 ## 参数档可行性判定（执行边界③：参数无解＝配置错误）——域校验外加深度预算与战斗保底可放性。
 static func check_params(params: Dictionary) -> Array:
+	var errs: Array[Dictionary] = _cp_domain(params)
+	if not errs.is_empty():
+		return errs
+	return _cp_structural(params)
+
+
+## 域校验段：五旋钮值域／岔口去路数锁值／配比四类合计 1
+static func _cp_domain(params: Dictionary) -> Array[Dictionary]:
 	var errs: Array[Dictionary] = []
 	var L := int(params.get("layers", 0))
 	var e := int(params.get("exit_count", 0))
@@ -89,8 +97,16 @@ static func check_params(params: Dictionary) -> Array:
 		sum += float(params.get(rk, -1.0))
 	if not is_equal_approx(sum, 1.0):
 		errs.append({"category": "domain", "message": "配比四类合计 %f ≠ 1" % sum})
-	if not errs.is_empty():
-		return errs
+	return errs
+
+
+## 结构可行性段：主链段容量与战斗保底可放性（多出口按区域签名累加可放槽）
+static func _cp_structural(params: Dictionary) -> Array[Dictionary]:
+	var errs: Array[Dictionary] = []
+	var L := int(params.get("layers", 0))
+	var e := int(params.get("exit_count", 0))
+	var en := int(params.get("entry_count", 0))
+	var bf := int(params.get("battle_floor", -1))
 	var t := 0 if e == 1 else _trunk_len(L, e)
 	if e > 1 and t < 1:
 		errs.append({"category": "structural", "message": "层深 %d 与出口数 %d 无解（主链段放不下归属区域）" % [L, e]})
@@ -116,11 +132,33 @@ func validate_output(graph: Dictionary, params: Dictionary = {}) -> Array:
 		return errs
 	var by_id := {}
 	var indeg := {}
+	if not _vo_node_fields(nodes, errs, by_id, indeg):
+		return errs
+	if not _vo_edges(nodes, by_id, indeg, errs):
+		return errs
+	var flow := _vo_flow_facts(nodes, indeg, errs)
+	if not flow["ok"]:
+		return errs
+	if not _vo_depth_reach(nodes, by_id, flow["entries"], flow["terminals"], errs):
+		return errs
+	_vo_shop_counts(nodes, flow["terminals"], errs)
+	_vo_terminal_shops(nodes, flow["terminals"], errs)
+	if not _all_paths_one_shop(by_id, flow["entries"], flow["terminals"]):
+		errs.append({"category": "structural", "message": "存在入口→终点路径穿店数 ≠ 1（必经恰一店破）"})
+	_check_fork_rules(nodes, by_id, errs)
+	_vo_terminal_depths(flow["terminals"], by_id, errs)
+	_vo_width_rules(nodes, errs)
+	_vo_params_check(params, nodes, by_id, [flow["entries"], flow["terminals"]], errs)
+	return errs
+
+
+## 阶段一·节点字段域：字段齐备/句柄唯一/类型词表/深度非负（by_id/indeg 引用填充）
+func _vo_node_fields(nodes: Array, errs: Array, by_id: Dictionary, indeg: Dictionary) -> bool:
 	for n in nodes:
 		for k in ["id", "type", "depth", "next"]:
 			if not (n as Dictionary).has(k):
 				errs.append({"category": "structural", "message": "节点字段缺失: %s" % k})
-				return errs
+				return false
 		var id: int = int(n["id"])
 		if by_id.has(id):
 			errs.append({"category": "dup_key", "message": "节点句柄重复: %d" % id})
@@ -130,8 +168,11 @@ func validate_output(graph: Dictionary, params: Dictionary = {}) -> Array:
 		if int(n["depth"]) < 0:
 			errs.append({"category": "domain", "message": "节点深度为负: %d" % n["depth"]})
 		indeg[id] = 0
-	if not errs.is_empty():
-		return errs
+	return errs.is_empty()
+
+
+## 阶段二·边域：出边悬空与环/回边判据（indeg 引用累计）
+func _vo_edges(nodes: Array, by_id: Dictionary, indeg: Dictionary, errs: Array) -> bool:
 	for n in nodes:
 		for oid in (n["next"] as Array):
 			if not by_id.has(int(oid)):
@@ -141,9 +182,11 @@ func validate_output(graph: Dictionary, params: Dictionary = {}) -> Array:
 				errs.append({"category": "structural", "message": "连线未朝前进方向（目标深度 %d 不严格大于源 %d）——环/回边" % [
 					int(by_id[int(oid)]["depth"]), int(n["depth"])]})
 			indeg[int(oid)] = int(indeg[int(oid)]) + 1
-	if not errs.is_empty():
-		return errs
+	return errs.is_empty()
 
+
+## 阶段三·流事实域：入口集（入度 0）／终点集（无出边）与 Boss 终点判据、去路数形态
+func _vo_flow_facts(nodes: Array, indeg: Dictionary, errs: Array) -> Dictionary:
 	var entries := []
 	var terminals := []
 	for n in nodes:
@@ -159,11 +202,12 @@ func validate_output(graph: Dictionary, params: Dictionary = {}) -> Array:
 			errs.append({"category": "structural", "message": "Boss 节点带出边: %d" % id0})
 		elif outs.size() != 1 and not (outs.size() >= 2 and outs.size() <= 3):
 			errs.append({"category": "domain", "message": "节点 %d 去路数 %d 非〔恰一条或岔口 2–3〕" % [id0, outs.size()]})
-	if not errs.is_empty():
-		return errs
+	return {"entries": entries, "terminals": terminals, "ok": errs.is_empty()}
 
-	# 深度＝自入口最长路径步数（契约 2 赋值语义——出边严格前进的无环判据成立的前提）
-	var longest := _longest_paths(nodes, by_id, entries, indeg)
+
+## 阶段四·深度与可达域：深度＝自入口最长路径步数（契约 2）＋全节点可达某终点
+func _vo_depth_reach(nodes: Array, by_id: Dictionary, entries: Array, terminals: Array, errs: Array) -> bool:
+	var longest := _longest_paths(nodes, by_id, entries)
 	for n in nodes:
 		var id1: int = int(n["id"])
 		if int(n["depth"]) != int(longest.get(id1, -1)):
@@ -175,16 +219,21 @@ func validate_output(graph: Dictionary, params: Dictionary = {}) -> Array:
 	for n in nodes:
 		if not reaches.has(int(n["id"])):
 			errs.append({"category": "structural", "message": "节点 %d 不可达任何终点（断头/孤儿）" % n["id"]})
-	if not errs.is_empty():
-		return errs
+	return errs.is_empty()
 
-	# 摆放约束①：每终点前一位恰一店、商店总数＝终点数、终点前一层去路集合恰含一个终点
+
+## 摆放约束①前半·商店总数：商店总数＝终点数（商店数＝出口数已锁）
+func _vo_shop_counts(nodes: Array, terminals: Array, errs: Array) -> void:
 	var shop_count := 0
 	for n in nodes:
 		if String(n["type"]) == "shop":
 			shop_count += 1
 	if shop_count != terminals.size():
 		errs.append({"category": "structural", "message": "商店总数 %d ≠ 终点数 %d（商店数＝出口数已锁）" % [shop_count, terminals.size()]})
+
+
+## 摆放约束①后半·终点前驱：每终点前一位恰一店且为唯一前驱、终点前一层去路集合恰含一个终点
+func _vo_terminal_shops(nodes: Array, terminals: Array, errs: Array) -> void:
 	for tid in terminals:
 		var preds := []
 		for n in nodes:
@@ -204,16 +253,19 @@ func validate_output(graph: Dictionary, params: Dictionary = {}) -> Array:
 		if t_hits != 1:
 			errs.append({"category": "structural", "message": "终点 %d 前一层去路集合含终点 %d 个（归属锁定破）" % [tid, t_hits]})
 
-	if not _all_paths_one_shop(by_id, entries, terminals):
-		errs.append({"category": "structural", "message": "存在入口→终点路径穿店数 ≠ 1（必经恰一店破）"})
-	_check_fork_rules(nodes, by_id, errs)
 
+## 计数规则①·多终点深度互异（推论条款 A——定位信息只有两样）
+func _vo_terminal_depths(terminals: Array, by_id: Dictionary, errs: Array) -> void:
 	var tdepths := {}
 	for tid in terminals:
 		var dd: int = int(by_id[tid]["depth"])
 		if tdepths.has(dd):
 			errs.append({"category": "structural", "message": "多终点同深度 %d（推论条款 A 破——定位信息只有两样）" % dd})
 		tdepths[dd] = true
+
+
+## 计数规则②·宽度上限：同深度节点数 ≤ 分叉生长上限 4（禁平行层摆放）
+func _vo_width_rules(nodes: Array, errs: Array) -> void:
 	var per_depth := {}
 	for n in nodes:
 		var d2: int = int(n["depth"])
@@ -222,23 +274,28 @@ func validate_output(graph: Dictionary, params: Dictionary = {}) -> Array:
 		if int(per_depth[d3]) > MAX_WIDTH:
 			errs.append({"category": "structural", "message": "深度 %d 节点数 %d 超分叉生长上限 4（平行层摆放）" % [d3, per_depth[d3]]})
 
+
+## 计数规则③·参数档对照：战斗保底／入口数／终点数／层高（params 为空时跳过）
+func _vo_params_check(params: Dictionary, nodes: Array, by_id: Dictionary, flow_ends: Array, errs: Array) -> void:
+	var entries: Array = flow_ends[0]
+	var terminals: Array = flow_ends[1]
 	var battles := 0
 	for n in nodes:
 		if String(n["type"]) == "battle":
 			battles += 1
-	if not params.is_empty():
-		if battles < int(params.get("battle_floor", 0)):
-			errs.append({"category": "domain", "message": "战斗节点数 %d 低于保底 %d" % [battles, params.get("battle_floor", 0)]})
-		if entries.size() != int(params.get("entry_count", entries.size())):
-			errs.append({"category": "structural", "message": "入口数 %d ≠ 参数档 entry_count %d" % [entries.size(), params.get("entry_count", 0)]})
-		if terminals.size() != int(params.get("exit_count", terminals.size())):
-			errs.append({"category": "structural", "message": "终点数 %d ≠ 参数档 exit_count %d" % [terminals.size(), params.get("exit_count", 0)]})
-		var maxd := 0
-		for tid in terminals:
-			maxd = maxi(maxd, int(by_id[tid]["depth"]))
-		if maxd != int(params.get("layers", maxd)):
-			errs.append({"category": "domain", "message": "层高（最长路径步数）%d ≠ 参数档 layers %d" % [maxd, params.get("layers", 0)]})
-	return errs
+	if params.is_empty():
+		return
+	if battles < int(params.get("battle_floor", 0)):
+		errs.append({"category": "domain", "message": "战斗节点数 %d 低于保底 %d" % [battles, params.get("battle_floor", 0)]})
+	if entries.size() != int(params.get("entry_count", entries.size())):
+		errs.append({"category": "structural", "message": "入口数 %d ≠ 参数档 entry_count %d" % [entries.size(), params.get("entry_count", 0)]})
+	if terminals.size() != int(params.get("exit_count", terminals.size())):
+		errs.append({"category": "structural", "message": "终点数 %d ≠ 参数档 exit_count %d" % [terminals.size(), params.get("exit_count", 0)]})
+	var maxd := 0
+	for tid in terminals:
+		maxd = maxi(maxd, int(by_id[tid]["depth"]))
+	if maxd != int(params.get("layers", maxd)):
+		errs.append({"category": "domain", "message": "层高（最长路径步数）%d ≠ 参数档 layers %d" % [maxd, params.get("layers", 0)]})
 
 
 # ---- 构型（长图算法 HOW 归实现——D1:28；合法性由 validate_output 强制）----
@@ -252,28 +309,11 @@ func _build(rg: RandomNumberGenerator) -> Dictionary:
 	var entries: Array[int] = []
 	for i in range(en):
 		entries.append(_mk("battle", 0))
-	var prevs: Array[int] = entries.duplicate()
-	for d in range(1, t + 1):
-		var nid := _mk("battle", d)
-		for p in prevs:
-			(_by_id[p]["next"] as Array).append(nid)
-		prevs = [nid]
+	var prevs: Array = _build_trunk(t, entries.duplicate())
 
 	var terminals: Array[int] = []
 	for r in range(e):
-		var bdepth := L - r
-		var bid := _mk("boss", bdepth)
-		var sid := _mk("shop", bdepth - 1)
-		(_by_id[sid]["next"] as Array).append(bid)
-		var cur := sid
-		var sig := String(REGION_SIGNATURES[r]) if e > 1 else "battle"
-		for d in range(bdepth - 2, t, -1):
-			var fid := _mk(sig, d)
-			(_by_id[fid]["next"] as Array).append(cur)
-			cur = fid
-		terminals.append(bid)
-		for p in prevs:
-			(_by_id[p]["next"] as Array).append(cur)
+		_build_region(r, e, L, prevs, terminals)
 	# e>1 时 prevs 收束为主链段末节点一处 ⇒ 该节点即归属大岔口（各区域互不连达）；
 	# e==1 时 prevs 为入口数组，直接接单区域头（无大岔口——L1 出口恒 1）。
 
@@ -281,41 +321,61 @@ func _build(rg: RandomNumberGenerator) -> Dictionary:
 	_assign_types(rg, e)
 
 	var nodes: Array[Dictionary] = []
-	for n in _pool:
-		nodes.append(n)
+	nodes.assign(_pool)
 	return {"nodes": nodes, "entries": entries, "terminals": terminals}
 
 
+## 主链段（深度 1..t 逐层单链，主链段零 RNG）：返回链末节点集（e>1 时收束为一处即归属大岔口）
+func _build_trunk(t: int, prevs: Array) -> Array:
+	for d in range(1, t + 1):
+		var nid := _mk("battle", d)
+		for p in prevs:
+			(_by_id[p]["next"] as Array).append(nid)
+		prevs = [nid]
+	return prevs
+
+
+## 归属区域段（每出口一条支路：Boss 终点＋店＋签名填充链；区域段零 RNG）：
+## Boss 深度 = L−r、店在其前一位、签名链自店向主链段方向回铺，支路头接入 prevs（归属大岔口）
+func _build_region(r: int, e: int, L: int, prevs: Array, terminals: Array) -> void:
+	var t := 0 if e == 1 else _trunk_len(L, e)
+	var bdepth := L - r
+	var bid := _mk("boss", bdepth)
+	var sid := _mk("shop", bdepth - 1)
+	(_by_id[sid]["next"] as Array).append(bid)
+	var cur := sid
+	var sig := String(REGION_SIGNATURES[r]) if e > 1 else "battle"
+	for d in range(bdepth - 2, t, -1):
+		var fid := _mk(sig, d)
+		(_by_id[fid]["next"] as Array).append(cur)
+		cur = fid
+	terminals.append(bid)
+	for p in prevs:
+		(_by_id[p]["next"] as Array).append(cur)
+
+
 ## 岔口布置：主链段（深度 ≤ t-2）或单出口图链上（深度 ≤ L-3）的节点扩为 2–3 去路岔口；
 ## 侧支节点与主去路同深（保持「深度＝自入口最长路径步数」不变量），两支各自汇入主去路的后继，
 ## 于是支路互斥段＝{主去路节点} 与 {侧支节点}——两支类型互异即同时满足「下一跳互异」与「各有独有类型」。
 func _add_forks(rg: RandomNumberGenerator, L: int, t: int, e: int) -> void:
 	var wanted := clampi(int(round(float(_params["branch_density"]) * float(L))), 1, 24)
-	var anchors := []
-	for n in _pool:
-		if int(n["depth"]) > (t - 2 if e > 1 else L - 3):
-			continue
-		if (n["next"] as Array).size() != 1:
-			continue
-		anchors.append(n)
+	var anchors := _collect_fork_anchors(L, t, e)
 	anchors = _shuffle(rg, anchors)
 	var selected := {}      # 已扩岔节点 id
 	var succ_selected := {}   # 已扩岔节点的主去路 id（禁再作锚点）
 	for a in anchors:
 		if wanted <= 0:
 			break
-		var node = a
-		var nid := int(node["id"])
-		if (node["next"] as Array).size() != 1:
+		var nid := int(a["id"])
+		if (a["next"] as Array).size() != 1:
 			continue   # 同一节点不重复扩岔（去路数上限 3）
-		var v = _by_id[int((node["next"] as Array)[0])]
+		var v = _by_id[int((a["next"] as Array)[0])]
 		var vid := int(v["id"])
 		# 相邻两层不得同时扩岔：若主去路 v 也是岔口，v 的侧支会落进本岔口主支路的互斥段，
 		# 使侧支自己的类型不再独有（契约 5③）——两个方向都要拦。
 		if selected.has(vid) or succ_selected.has(nid):
 			continue
-		var v_outs = v["next"]
-		if v_outs.is_empty():
+		if (v["next"] as Array).is_empty():
 			continue   # 主去路无后继（无可汇入点）——该锚点弃用
 		var extra := 2 if (int(_params["fork_ways_max"]) >= 3 and rg.randf() < 0.35) else 1
 		var made := 0
@@ -323,8 +383,8 @@ func _add_forks(rg: RandomNumberGenerator, L: int, t: int, e: int) -> void:
 			if _depth_count(int(v["depth"])) >= MAX_WIDTH:
 				break
 			var wid := _mk("battle", int(v["depth"]))
-			(node["next"] as Array).append(wid)
-			(_by_id[wid]["next"] as Array).append(int(v_outs[0]))
+			(a["next"] as Array).append(wid)
+			(_by_id[wid]["next"] as Array).append(int((v["next"] as Array)[0]))
 			_detour_heads.append(_by_id[wid])
 			_detour_ids[wid] = true
 			made += 1
@@ -334,6 +394,18 @@ func _add_forks(rg: RandomNumberGenerator, L: int, t: int, e: int) -> void:
 			wanted -= 1
 
 
+## 锚收集段（零 RNG）：主链段（深度 ≤ t-2）或单出口图链上（深度 ≤ L-3）的去路恰一节点
+func _collect_fork_anchors(L: int, t: int, e: int) -> Array:
+	var anchors := []
+	for n in _pool:
+		if int(n["depth"]) > (t - 2 if e > 1 else L - 3):
+			continue
+		if (n["next"] as Array).size() != 1:
+			continue
+		anchors.append(n)
+	return anchors
+
+
 # 确定性洗牌（Fisher-Yates，取数只经注入的纯流 RNG——Array.shuffle() 走引擎全局随机、
 # 破「同（种子,参数档）⇒ 同图」的纯函数复现前提，禁用于生成器）
 func _shuffle(rg: RandomNumberGenerator, arr: Array) -> Array:
@@ -358,31 +430,42 @@ func _depth_count(d: int) -> int:
 ## 单出口图的配比填余（摆放优先、配比填余、战斗保底兜底——§8.1 次序），再统一修岔口下一跳互异。
 func _assign_types(rg: RandomNumberGenerator, e: int) -> void:
 	if e == 1:
-		var free: Array[Dictionary] = []
-		var chain_battles := 0
-		for n in _pool:
-			if String(n["type"]) == "shop" or String(n["type"]) == "boss":
-				continue
-			if _detour_ids.has(int(n["id"])):
-				continue   # 侧链节点类型由岔口互异修型决定，不占配比填余面
-			if int(n["depth"]) == 1:
-				continue   # 区域首节点留战斗——配比填余不破坏岔口下一跳互异的基准形
-			if String(n["type"]) == "battle":
-				chain_battles += 1
-			free.append(n)
-		free = _shuffle(rg, free)
-		var want := int(round(float(_pool.size()) * (float(_params["reward_ratio"]) + float(_params["rest_ratio"]))))
-		var floor_n := int(_params["battle_floor"])
-		var rest_first := rg.randf() < 0.5
-		for i in range(want):
-			if i >= free.size():
-				break
-			# 战斗保底优先：链上战斗数降到保底下限即停（侧链修型可能再让出战斗位，故保底只看链上）
-			if chain_battles - 1 < floor_n:
-				break
-			var node = free[i]
-			node["type"] = "rest" if ((i % 2 == 0) == rest_first) else "reward"
-			chain_battles -= 1
+		_fill_ratios(rg)
+	_fix_detour_heads()
+
+
+## 配比填余段（单出口图；shuffle+randf 取号序整体搬迁——战斗保底优先、侧链不占填余面）：
+## 摆放优先、配比填余、战斗保底兜底——§8.1 次序
+func _fill_ratios(rg: RandomNumberGenerator) -> void:
+	var free: Array[Dictionary] = []
+	var chain_battles := 0
+	for n in _pool:
+		if String(n["type"]) == "shop" or String(n["type"]) == "boss":
+			continue
+		if _detour_ids.has(int(n["id"])):
+			continue   # 侧链节点类型由岔口互异修型决定，不占配比填余面
+		if int(n["depth"]) == 1:
+			continue   # 区域首节点留战斗——配比填余不破坏岔口下一跳互异的基准形
+		if String(n["type"]) == "battle":
+			chain_battles += 1
+		free.append(n)
+	free = _shuffle(rg, free)
+	var want := int(round(float(_pool.size()) * (float(_params["reward_ratio"]) + float(_params["rest_ratio"]))))
+	var floor_n := int(_params["battle_floor"])
+	var rest_first := rg.randf() < 0.5
+	for i in range(want):
+		if i >= free.size():
+			break
+		# 战斗保底优先：链上战斗数降到保底下限即停（侧链修型可能再让出战斗位，故保底只看链上）
+		if chain_battles - 1 < floor_n:
+			break
+		var node = free[i]
+		node["type"] = "rest" if ((i % 2 == 0) == rest_first) else "reward"
+		chain_battles -= 1
+
+
+## 岔口修型段（零 RNG）：侧链首节点类型取岔口各去路下一节点类型的补集首件——下一跳互异承面
+func _fix_detour_heads() -> void:
 	for head in _detour_heads:
 		var h = head
 		var fork = null
@@ -416,12 +499,15 @@ static func _trunk_len(L: int, e: int) -> int:
 
 # ---- 自证辅助 ----
 
-func _longest_paths(nodes: Array, by_id: Dictionary, entries: Array, indeg: Dictionary) -> Dictionary:
+func _longest_paths(nodes: Array, by_id: Dictionary, entries: Array) -> Dictionary:
 	var out := {}
 	var din := {}
 	var q := []
-	for id in indeg:
-		din[int(id)] = int(indeg[int(id)])
+	for n in nodes:
+		din[int(n["id"])] = 0
+	for n in nodes:
+		for oid in (n["next"] as Array):
+			din[int(oid)] = int(din[int(oid)]) + 1
 	for eid in entries:
 		out[int(eid)] = 0
 		q.append(int(eid))
@@ -476,44 +562,53 @@ func _check_fork_rules(nodes: Array, by_id: Dictionary, errs: Array) -> void:
 			if head_types.has(ty):
 				errs.append({"category": "structural", "message": "岔口 %d 各去路下一节点类型重复: %s" % [n["id"], ty]})
 			head_types[ty] = true
-		var reach_sets := []
-		for oid in outs:
-			reach_sets.append(_descendants(int(oid), by_id))
-		var comps := []
-		for i in range(reach_sets.size()):
-			var excl := {}
-			for rid in reach_sets[i]:
-				var shared := false
-				for j in range(reach_sets.size()):
-					if j != i and reach_sets[j].has(rid):
-						shared = true
-						break
-				if not shared:
-					excl[int(rid)] = String(by_id[int(rid)]["type"])
-			var arr := []
-			for v in excl.values():
-				arr.append(v)
-			arr.sort()
-			comps.append(arr)
+		var comps := _fork_signatures(outs, by_id)
 		for i in range(comps.size()):
 			for j in range(i + 1, comps.size()):
 				if comps[i] == comps[j]:
 					errs.append({"category": "structural", "message": "岔口 %d 支路 %d/%d 类型构成相同" % [n["id"], i, j]})
 		for i in range(comps.size()):
-			var uniq := false
-			for ty in comps[i]:
-				var in_other := false
-				for j in range(comps.size()):
-					if j != i and (comps[j] as Array).has(ty):
-						in_other = true
-						break
-				if not in_other:
-					uniq = true
-					break
-			if not uniq:
+			if not _fork_has_unique(comps, i):
 				errs.append({"category": "structural", "message": "岔口 %d 支路 %d 无独有类型" % [n["id"], i]})
 
 
+## 支路签名构造：各去路的独占后代类型集（他人不可达的后代类型，排序数组——支路互斥段签名）
+func _fork_signatures(outs: Array, by_id: Dictionary) -> Array:
+	var reach_sets := []
+	for oid in outs:
+		reach_sets.append(_descendants(int(oid), by_id))
+	var comps := []
+	for i in range(reach_sets.size()):
+		var excl := {}
+		for rid in reach_sets[i]:
+			var shared := false
+			for j in range(reach_sets.size()):
+				if j != i and reach_sets[j].has(rid):
+					shared = true
+					break
+			if not shared:
+				excl[int(rid)] = String(by_id[int(rid)]["type"])
+		var arr := []
+		for v in excl.values():
+			arr.append(v)
+		arr.sort()
+		comps.append(arr)
+	return comps
+
+
+## 独有类型判定：支路 i 的签名中存在他支路不含的类型
+func _fork_has_unique(comps: Array, i: int) -> bool:
+	for ty in comps[i]:
+		var in_other := false
+		for j in range(comps.size()):
+			if j != i and (comps[j] as Array).has(ty):
+				in_other = true
+				break
+		if not in_other:
+			return true
+	return false
+
+
 func _descendants(start: int, by_id: Dictionary) -> Dictionary:
 	var out := {start: true}
 	var q := [start]