aps-agent/server/aps_domain/kangni_intake.py

# ============================================================
# 现场「完整生产路线」导入（moduleId: domain-kangni-intake, 可重生 ✅）
# 将康尼现场 Excel 落到 flex* 键，替换演示种子，供 PoolEngine 排产。
# 口径：docs/product/demand-data-intake.md；缺口用显式推断并写入 flexParams.siteInferences。
# 客户差异（工厂命名/工时推断规则/默认路径）收敛在 server/importers/profiles/kangni.json，
# 本模块仅保留解析逻辑 + 兜底默认值（profile 缺失时可独立运行）。
# ============================================================
from __future__ import annotations

import re
from copy import deepcopy
from datetime import datetime
from pathlib import Path
from typing import Any

World = dict[str, Any]


class KangniDataMappingError(ValueError):
    """康尼源表无法唯一、安全映射到订单时抛出。"""


def _profile() -> dict[str, Any]:
    """加载康尼导入 profile（配置文件缺失时返回空 dict → 走内置兜底）。"""
    try:
        from server.importers.excel_importer import load_profile
        return load_profile("kangni")
    except Exception:
        return {}


_P = _profile()

# 现场默认路径（profile 可覆盖；再可被环境变量 / API / 脚本覆盖）
DEFAULT_ROUTE_XLSX = Path(_P.get("defaultRouteXlsx") or (
    r"D:\ItemSpace\14.工业智核\康尼\数据\outputs"
    r"\019f8987-be3f-7261-a9d3-efc1ecf9c27d\订单102285668_完整生产路线.xlsx"
))
DEFAULT_DATA_DIR = Path(_P.get("dataDir") or r"D:\ItemSpace\14.工业智核\康尼\数据")

# 工时/产能缺口推断（源表「待维护」时启用；单位：分钟/件）
_INFER_STD_MIN = {k: float(v) for k, v in (_P.get("inferStdMin") or {"部装": 45.0, "装配": 30.0, "_default": 30.0}).items()}
_DEFAULT_STATION_COUNT = int(_P.get("stationCount") or 4)
_FLEX_CLEAR_KEYS = (
    "flexZones", "flexOperations", "flexEquipment", "flexMolds",
    "flexMaterials", "flexBom", "flexRoutings", "flexTeams", "flexCalendar",
    "flexOrders", "flexParams",
    "flexScheduleVersions", "flexVirtualLines", "flexWorkOrders", "flexConflicts",
)

# 固定轨 + 排产产物：加载现场时整表清空（去掉演示垃圾）
_FIXED_CLEAR_KEYS = (
    "factories", "workshops", "lines", "workstations", "equipment",
    "operations", "routings", "routingSteps", "materials", "boms", "bomItems",
    "lineProducts", "workstationOperations", "teams", "shifts", "shiftCalendar",
    "maintenance", "salesOrders", "productionOrders", "workOrders",
    "purchaseOrders", "outsourceOrders", "forecastOrders", "changeoverMatrix",
    "scheduleVersions", "conflicts", "logs",
)


def _clean(v: Any) -> str:
    if v is None:
        return ""
    return str(v).replace("\u200b", "").strip()


def _num(v: Any, default: float = 0.0) -> float:
    if v is None or v == "":
        return default
    if isinstance(v, (int, float)):
        return float(v)
    s = _clean(v).replace(",", "")
    try:
        return float(s)
    except ValueError:
        return default


def _sequence(v: Any, fallback: int) -> int:
    s = _clean(v)
    if not s:
        return fallback
    try:
        return int(float(s))
    except ValueError:
        return fallback


def _is_pending(v: Any) -> bool:
    s = _clean(v)
    return (not s) or ("待维护" in s) or s.lower() in ("n/a", "na", "-", "—")


def _parse_dt_date(v: Any) -> str | None:
    """任意日期/时间 → YYYY-MM-DD。"""
    if v is None or v == "":
        return None
    if isinstance(v, datetime):
        return v.strftime("%Y-%m-%d")
    s = _clean(v)
    m = re.match(r"(\d{4}-\d{2}-\d{2})", s)
    if m:
        return m.group(1)
    try:
        return datetime.fromisoformat(s.replace("/", "-")).strftime("%Y-%m-%d")
    except ValueError:
        return None


def _infer_std_min(op_type: str, raw_hours: Any, infer_map: dict[str, float] | None = None) -> tuple[float, bool]:
    """返回 (分钟/件, 是否推断)。源表工时单位为小时；推断规则可由 profile 覆盖。"""
    rules = infer_map or _INFER_STD_MIN
    if not _is_pending(raw_hours):
        h = _num(raw_hours, 0.0)
        if h > 0:
            return (h * 60.0, False)
    t = _clean(op_type)
    for key, mins in rules.items():
        if key != "_default" and key in t:
            return (float(mins), True)
    return (float(rules.get("_default", 30.0)), True)


def _find_file(data_dir: Path, kind: str) -> Path | None:
    """按语义找源表（文件名乱码时靠 sheet 特征）。kind: orders|routing|bom|equipment|molds|materials。"""
    if not data_dir.exists():
        return None
    try:
        import openpyxl
    except ImportError:
        return None
    name_hints = {
        "orders": ("订单",),
        "routing": ("工艺路线", "路线"),
        "stdtime": ("工时",),
        "equipmap": ("设备能力",),
        "moldmap": ("模具适配",),
        "bom": ("BOM", "bom"),
        "equipment": ("设备", "Equipment"),
        "molds": ("模具", "Mould", "Mold"),
        "materials": ("物料",),
    }
    for f in sorted(data_dir.glob("*.xlsx")):
        if any(h.lower() in f.name.lower() for h in name_hints.get(kind, ())):
            return f
    for f in sorted(data_dir.glob("*.xlsx")):
        try:
            wb = openpyxl.load_workbook(f, read_only=True, data_only=True)
            names = wb.sheetnames
            # 读首行表头
            ws = wb[names[0]]
            header = []
            for i, row in enumerate(ws.iter_rows(values_only=True)):
                header = [_clean(c) for c in row]
                break
            wb.close()
        except Exception:
            continue
        hs = "".join(header)
        if kind == "orders" and ("生产订单" in hs or "WBS" in hs) and "计划" in hs:
            return f
        if kind == "routing" and "工序编号" in hs and "标准工时" in hs and "工序类型" in hs:
            return f
        if kind == "stdtime" and "工序编号" in hs and "标准工时" in hs and "工序名称" in hs:
            return f
        if kind == "equipmap" and "设备编号" in hs and "可执行工序" in hs:
            return f
        if kind == "moldmap" and "模具编号" in hs and "适用工序" in hs:
            return f
        if kind == "bom" and "MES工序编号" in hs and "物料编号" in hs:
            return f
        if kind == "equipment" and ("设备编号" in hs or names == ["Equipment"]):
            return f
        if kind == "molds" and ("工装模具" in hs or "模具编号" in hs or "ABC分类" in hs):
            return f
        if kind == "materials" and "物料代码" in hs:
            return f
        # 工艺/BOM 多 sheet 名为订单号
        if kind in ("routing", "bom") and any(re.fullmatch(r"\d{6,}", n or "") for n in names):
            # 再看第一个订单 sheet 表头
            try:
                wb = openpyxl.load_workbook(f, read_only=True, data_only=True)
                order_sheets = [n for n in wb.sheetnames if re.fullmatch(r"\d{6,}", n)]
                if not order_sheets:
                    wb.close()
                    continue
                ws = wb[order_sheets[0]]
                hdr = []
                for row in ws.iter_rows(values_only=True):
                    hdr = [_clean(c) for c in row]
                    break
                wb.close()
                blob = "".join(hdr)
                if kind == "routing" and "工序编号" in blob:
                    return f
                if kind == "bom" and "物料编号" in blob:
                    return f
            except Exception:
                continue
    return None


def parse_std_time_sheet(path: Path, order_no: str) -> dict[str, float]:
    """从「工时.xlsx」按订单 sheet 读标准工时（分钟/件）。"""
    import openpyxl

    wb = openpyxl.load_workbook(path, data_only=True)
    try:
        if order_no not in wb.sheetnames:
            return {}
        ws = wb[order_no]
        rows = list(ws.iter_rows(values_only=True))
    finally:
        wb.close()
    if not rows:
        return {}
    headers = [_clean(c) for c in rows[0]]
    col = {h: i for i, h in enumerate(headers) if h}
    out: dict[str, float] = {}
    op_col = col.get("工序编号")
    std_cols = [i for n, i in col.items() if n in ("标准工时/分钟", "标准工时", "工时")]
    for row in rows[1:]:
        if op_col is None or op_col >= len(row):
            continue
        code = _clean(row[op_col])
        if not code:
            continue
        v = 0.0
        for idx in std_cols:
            if idx < len(row):
                v = _num(row[idx], 0.0)
                if v > 0:
                    break
        if v > 0:
            out[code] = float(v)
    return out


def load_std_time_map(data_dir: Path) -> dict[str, dict[str, float]]:
    """扫描「工时.xlsx」全部订单 sheet → {订单号: {工序编号: 分钟}}。"""
    if not data_dir.exists():
        return {}
    std_xlsx = _find_file(data_dir, "stdtime")
    if not std_xlsx:
        return {}
    import openpyxl

    wb = openpyxl.load_workbook(std_xlsx, read_only=True, data_only=True)
    try:
        names = list(wb.sheetnames)
    finally:
        wb.close()
    result: dict[str, dict[str, float]] = {}
    for order_no in names:
        times = parse_std_time_sheet(std_xlsx, order_no)
        if times:
            result[order_no] = times
    return result


def load_std_route_map(data_dir: Path) -> dict[str, list[dict[str, Any]]]:
    """从工时表订单命名 sheet 读取规范工序序列，供 generic routing 安全匹配。"""
    if not data_dir.exists():
        return {}
    std_xlsx = _find_file(data_dir, "stdtime")
    if not std_xlsx:
        return {}
    import openpyxl

    wb = openpyxl.load_workbook(std_xlsx, read_only=True, data_only=True)
    try:
        result: dict[str, list[dict[str, Any]]] = {}
        for order_no in wb.sheetnames:
            rows = list(wb[order_no].iter_rows(values_only=True))
            if not rows:
                continue
            headers = [_clean(c) for c in rows[0]]
            col = {h: i for i, h in enumerate(headers) if h}
            specs: list[dict[str, Any]] = []
            for row in rows[1:]:
                code = _clean(_cell(row, col, "工序编号"))
                if not code:
                    continue
                specs.append({
                    "seq": _sequence(
                        _cell(row, col, "排序号", "序号"),
                        (len(specs) + 1) * 10,
                    ),
                    "operationCode": code,
                    "operationName": _clean(_cell(row, col, "工序名称")) or code,
                    "opType": _clean(_cell(row, col, "工序类型", "类型")),
                })
            if specs:
                result[_clean(order_no)] = specs
        return result
    finally:
        wb.close()


def _apply_std_time_map(
    order: dict[str, Any],
    std_time_map: dict[str, dict[str, float]],
    *,
    override_existing: bool = False,
) -> None:
    """用工时表回填；真实主单入口可显式要求覆盖完整路线中的旧值。"""
    times = (std_time_map or {}).get(order.get("orderNo") or "") or {}
    if not times:
        return
    for op in order.get("operations") or []:
        code = op.get("operationCode")
        if code in times and (override_existing or op.get("stdTimeInferred")):
            op["stdTimePerUnit"] = float(times[code])
            op["stdTimeInferred"] = False
            op["stdTimeSource"] = "工时表"


def _split_multi(v: Any) -> list[str]:
    """逗号/顿号/分号分隔的多值列。"""
    return [x.strip() for x in re.split(r"[,，;；、]", _clean(v)) if x.strip()]


def _bool_yn(v: Any) -> bool:
    s = _clean(v).lower()
    return s in ("1", "true", "yes", "y", "是", "启用")


def _cell(row: tuple, col: dict[str, int], *names: str) -> Any:
    """按别名读单元格，避免循环内闭包。"""
    for n in names:
        idx = col.get(n)
        if idx is not None and idx < len(row):
            return row[idx]
    return None


def parse_equipment_capability_map(path: Path) -> list[dict[str, Any]]:
    """读取「设备能力映射模板.xlsx」→ flexEquipment 行。"""
    import openpyxl

    wb = openpyxl.load_workbook(path, data_only=True)
    try:
        rows = list(wb.active.iter_rows(values_only=True))
    finally:
        wb.close()
    if not rows:
        return []
    headers = [_clean(c) for c in rows[0]]
    col = {h: i for i, h in enumerate(headers) if h}
    out: list[dict[str, Any]] = []
    for row in rows[1:]:
        code = _clean(_cell(row, col, "设备编号", "设备编码"))
        if not code:
            continue
        caps = _split_multi(_cell(row, col, "可执行工序编号", "能力工序"))
        op_std: dict[str, float] = {}
        op_std_raw = _clean(_cell(row, col, "单件工时", "工序工时", "单件工时(分钟,工序:分钟;多值分号)"))
        for part in op_std_raw.split(";"):
            if ":" in part:
                k, v = part.split(":", 1)
                op_std[_clean(k)] = _num(v, 0.0)
        out.append({
            "code": code,
            "name": _clean(_cell(row, col, "设备名称")) or code,
            "capabilities": caps,
            "opStdTime": op_std,
            "movable": _bool_yn(_cell(row, col, "是否可移动", "可移动")),
            "moveTimeMin": _num(_cell(row, col, "移动耗时", "移动耗时(分钟)"), 0.0),
            "zone": _clean(_cell(row, col, "区域编码", "区域")),
            "adaptableMolds": _split_multi(_cell(row, col, "适配模具编号", "适配模具", "适配模具编号(逗号分隔)")),
            "availabilityRate": _num(_cell(row, col, "可动率", "可用率"), 0.95) or 0.95,
            "status": _clean(_cell(row, col, "状态")) or "RUNNING",
            "note": _clean(_cell(row, col, "备注")),
        })
    return out


def parse_mold_adaptation_map(path: Path) -> list[dict[str, Any]]:
    """读取「模具适配映射模板.xlsx」→ flexMolds 行。"""
    import openpyxl

    wb = openpyxl.load_workbook(path, data_only=True)
    try:
        rows = list(wb.active.iter_rows(values_only=True))
    finally:
        wb.close()
    if not rows:
        return []
    headers = [_clean(c) for c in rows[0]]
    col = {h: i for i, h in enumerate(headers) if h}
    out: list[dict[str, Any]] = []
    for row in rows[1:]:
        code = _clean(_cell(row, col, "模具编号", "模具编码"))
        if not code:
            continue
        out.append({
            "code": code,
            "name": _clean(_cell(row, col, "模具名称")) or code,
            "operationCode": _clean(_cell(row, col, "适用工序编号", "适用工序")),
            "adaptableEquipment": _split_multi(_cell(row, col, "适配设备编号", "适配设备", "适配设备编号(逗号分隔)")),
            "lifeTotal": _num(_cell(row, col, "寿命上限"), 0.0),
            "lifeUsed": _num(_cell(row, col, "已用寿命"), 0.0),
            "zone": _clean(_cell(row, col, "区域编码", "区域")),
            "changeoverMin": _num(_cell(row, col, "换型耗时", "换型耗时(分钟)"), 10.0) or 10.0,
            "status": _clean(_cell(row, col, "状态")) or "AVAILABLE",
            "note": _clean(_cell(row, col, "备注")),
        })
    return out


def build_flex_equipment_and_molds(
    data_dir: Path,
    packages: list[dict[str, Any]],
    op_std: dict[str, float],
    all_op_codes: list[str],
    profile: dict[str, Any],
) -> tuple[list[dict[str, Any]], list[dict[str, Any]], set[str], list[str]]:
    """优先用设备能力/模具适配映射表；缺表时回退合成共享装配工位。"""
    inferences: list[str] = []
    equip_map_path = _find_file(data_dir, "equipmap") if data_dir.exists() else None
    mold_map_path = _find_file(data_dir, "moldmap") if data_dir.exists() else None
    equipment: list[dict[str, Any]] = []
    molds: list[dict[str, Any]] = []
    mold_ops: set[str] = set()
    zone_cfg = profile.get("zone") or {}
    default_zone = zone_cfg.get("code") or "ZONE-CG"

    if equip_map_path:
        equipment = parse_equipment_capability_map(equip_map_path)
        for i, row in enumerate(equipment):
            row["id"] = i + 1
            row["zone"] = row.get("zone") or default_zone
            row["availabilityRate"] = float(row.get("availabilityRate") or profile.get("availabilityRate") or 0.95)
            row["status"] = row.get("status") or "RUNNING"
            row["inferred"] = False
            times = dict(row.get("opStdTime") or {})
            for cap in row.get("capabilities") or []:
                times.setdefault(cap, op_std.get(cap, 30.0))
            row["opStdTime"] = times
        if equipment:
            inferences.append(f"设备能力映射表已读取（{len(equipment)} 台）")

    if mold_map_path:
        molds = parse_mold_adaptation_map(mold_map_path)
        for i, row in enumerate(molds):
            row["id"] = i + 1
            row["zone"] = row.get("zone") or default_zone
            row["status"] = row.get("status") or "AVAILABLE"
            row["changeoverMin"] = float(row.get("changeoverMin") or 10.0)
            row["lifeTotal"] = float(row.get("lifeTotal") or 0.0)
            row["lifeUsed"] = float(row.get("lifeUsed") or 0.0)
            row["inferred"] = False
            if row.get("operationCode"):
                mold_ops.add(row["operationCode"])
        if molds:
            inferences.append(f"模具适配映射表已读取（{len(molds)} 套）")

    if not equipment:
        station_count = int(profile.get("stationCount") or 4)
        ws_prefix = profile.get("stationCodePrefix") or "WS-CG-"
        ws_name = profile.get("stationNamePrefix") or "城轨机构装配工位"
        avail = float(profile.get("availabilityRate") or 0.95)
        for i in range(station_count):
            code = f"{ws_prefix}{i + 1:02d}"
            equipment.append({
                "id": i + 1,
                "code": code,
                "name": f"{ws_name}#{i + 1}",
                "capabilities": list(all_op_codes),
                "opStdTime": dict(op_std),
                "movable": False,
                "moveTimeMin": 0,
                "zone": default_zone,
                "adaptableMolds": [],
                "availabilityRate": avail,
                "status": "RUNNING",
                "inferred": True,
            })
        inferences.append(
            f"设备/工位源表待维护 → 合成 {station_count} 台共享装配工位 "
            f"（能力=全部 {len(all_op_codes)} 道工序）"
        )

    if not molds:
        inferences.append("模具未匹配到本产品 → requireMold=false，不占模具槽")
    return equipment, molds, mold_ops, inferences


def parse_complete_route_xlsx(path: str | Path, infer_map: dict[str, float] | None = None) -> dict[str, Any]:
    """解析「订单XXXX_完整生产路线.xlsx」→ 单订单包（infer_map=profile 工时推断规则）。"""
    import openpyxl

    path = Path(path)
    if not path.exists():
        raise FileNotFoundError(f"找不到生产路线文件: {path}")

    wb = openpyxl.load_workbook(path, data_only=True)
    ws = wb.active
    rows = [[ws.cell(r, c).value for c in range(1, ws.max_column + 1)]
            for r in range(1, ws.max_row + 1)]
    wb.close()

    order: dict[str, Any] = {
        "orderNo": "", "productCode": "", "productName": "", "drawingNo": "",
        "quantity": 1.0, "planStart": None, "dueDate": None,
        "wbs": "", "project": "", "status": "RELEASED", "kitStatus": "",
        "operations": [], "bom": [], "source": str(path),
    }

    # ---- 头信息：扫前 15 行键值对 ----
    for row in rows[:15]:
        cells = [_clean(c) for c in row]
        for i, cell in enumerate(cells):
            nxt = cells[i + 1] if i + 1 < len(cells) else ""
            if cell in ("订单代码", "订单号") and nxt:
                order["orderNo"] = nxt
            elif cell in ("产品料号", "料号") and nxt:
                order["productCode"] = nxt
            elif cell == "订单数量" and nxt:
                order["quantity"] = _num(nxt, 1.0) or 1.0
            elif cell in ("计划开始",) and nxt:
                order["planStart"] = _parse_dt_date(nxt)
            elif cell in ("计划结束", "交期") and nxt:
                order["dueDate"] = _parse_dt_date(nxt)
            elif cell == "WBS" and nxt:
                order["wbs"] = nxt
            elif cell == "项目" and nxt:
                order["project"] = nxt
            elif cell == "订单状态" and nxt:
                order["status"] = "RELEASED" if "运行" in nxt or nxt in ("RELEASED", "已下达") else "CREATED"
            elif cell == "备料状态" and nxt:
                order["kitStatus"] = nxt

    # 标题行补充产品名
    if rows:
        title = _clean(rows[1][0] if len(rows) > 1 else "")
        m = re.search(r"产品\s*(\S+)[｜|].+?(?:图号\s*(\S+))?", title)
        if m:
            if not order["productCode"]:
                order["productCode"] = m.group(1)
            order["drawingNo"] = m.group(2) or ""
            # 「产品 CODE｜NAME｜图号」
            parts = re.split(r"[｜|]", title)
            if len(parts) >= 2:
                order["productName"] = parts[1].strip()

    # ---- 工艺明细表 ----
    op_header_idx = None
    for i, row in enumerate(rows):
        cells = [_clean(c) for c in row]
        if "工序编号" in cells and ("标准工时" in "".join(cells) or "顺序" in cells):
            op_header_idx = i
            break
    if op_header_idx is not None:
        headers = [_clean(c) for c in rows[op_header_idx]]
        col = {h: i for i, h in enumerate(headers) if h}

        def _c(row, *names, default=""):
            for n in names:
                if n in col and col[n] < len(row):
                    return row[col[n]]
            return default

        for row in rows[op_header_idx + 1:]:
            code = _clean(_c(row, "工序编号"))
            if not code or not re.match(r"^[\w\-]+$", code):
                # 遇到下一节标题则停
                first = _clean(row[0]) if row else ""
                if first.startswith("三、") or first.startswith("关键说明") or first.startswith("BOM"):
                    break
                continue
            name = _clean(_c(row, "工序名称"))
            op_type = _clean(_c(row, "类型", "工序类型"))
            raw_std = _c(row, "标准工时(h)", "标准工时")
            std_min, inferred = _infer_std_min(op_type, raw_std, infer_map)
            seq = int(_num(_c(row, "顺序", "序号", "排序号"), len(order["operations"]) + 1))
            order["operations"].append({
                "seq": seq * 10 if seq < 100 else seq,
                "operationCode": code,
                "operationName": name or code,
                "opType": op_type,
                "stdTimePerUnit": std_min,
                "stdTimeInferred": inferred,
                "resourceGroup": _clean(_c(row, "资源组")),
                "equipmentHint": _clean(_c(row, "具体设备/工位")),
                "moldHint": _clean(_c(row, "工装/模具")),
                "requireMold": False,  # 源表未匹配专用模具
            })

    # ---- BOM ----
    bom_header_idx = None
    for i, row in enumerate(rows):
        cells = [_clean(c) for c in row]
        if "物料编号" in cells or ("物料编码" in cells and "投料点" in cells):
            bom_header_idx = i
            break
    if bom_header_idx is not None:
        headers = [_clean(c) for c in rows[bom_header_idx]]
        col = {h: i for i, h in enumerate(headers) if h}

        def _b(row, *names, default=""):
            for n in names:
                if n in col and col[n] < len(row):
                    return row[col[n]]
            return default

        for row in rows[bom_header_idx + 1:]:
            mat = _clean(_b(row, "物料编号", "物料编码"))
            if not mat or mat.startswith("关键") or mat.startswith("BOM"):
                first = _clean(row[0]) if row else ""
                if first.startswith("关键") or first.startswith("四、"):
                    break
                continue
            # 过滤层级伪编码（M01 / 1.1.01 误入物料列）
            if re.match(r"^M\d{2}$", mat) or re.match(r"^\d+\.\d+", mat) or len(mat) < 4:
                continue
            op_code = _clean(_b(row, "工序编号", "MES工序编号"))
            qty = _num(_b(row, "单位用量", "用量", "数量"), 1.0)
            name = _clean(_b(row, "物料名称", "名称"))
            if not name and len(row) > 4:
                name = _clean(row[4])
            order["bom"].append({
                "materialCode": mat,
                "materialName": name or mat,
                "quantity": qty,
                "consumeOp": op_code or (order["operations"][0]["operationCode"] if order["operations"] else ""),
                "isKey": qty >= 1.0,
            })

    if not order["orderNo"]:
        raise ValueError(f"未能从 {path.name} 解析出订单号")
    if not order["operations"]:
        raise ValueError(f"{path.name} 无工艺工序明细，无法排产")
    if not order["dueDate"]:
        order["dueDate"] = order["planStart"] or datetime.now().strftime("%Y-%m-%d")
    if not order["productName"]:
        order["productName"] = order["productCode"] or order["orderNo"]
    return order


def parse_orders_workbook(path: Path) -> list[dict[str, Any]]:
    """解析源表「订单.xlsx」。"""
    import openpyxl

    wb = openpyxl.load_workbook(path, data_only=True)
    ws = wb[wb.sheetnames[0]]
    rows = list(ws.iter_rows(values_only=True))
    wb.close()
    if not rows:
        return []
    headers = [_clean(c) for c in rows[0]]
    col = {h: i for i, h in enumerate(headers) if h}
    out = []
    for row in rows[1:]:
        def g(*names):
            for n in names:
                if n in col and col[n] < len(row):
                    return row[col[n]]
            return None

        ono = _clean(g("生产订单", "订单号", "订单代码"))
        if not ono:
            continue
        out.append({
            "orderNo": ono,
            "wbs": _clean(g("WBS号", "WBS")),
            "productCode": _clean(g("料号", "产品料号")),
            "productName": _clean(g("物料名称", "产品名称")),
            "drawingNo": _clean(g("图号")),
            "planStart": _parse_dt_date(g("计划开始时间", "计划开始")),
            "dueDate": _parse_dt_date(g("计划结束时间", "计划结束", "交期")),
            "quantity": _num(g("订单数量", "数量"), 1.0) or 1.0,
            "status": "RELEASED",
        })
    return out


def _routing_sheet_sort_key(name: str) -> tuple[int, int | str]:
    match = re.fullmatch(r"Sheet(\d+)", name, re.IGNORECASE)
    return (1, int(match.group(1))) if match else (0, name)


def _read_routing_operations(
    worksheet: Any,
    infer_map: dict[str, float] | None,
    std_times: dict[str, float] | None,
) -> list[dict[str, Any]]:
    rows = list(worksheet.iter_rows(values_only=True))
    if not rows:
        return []
    headers = [_clean(c) for c in rows[0]]
    col = {h: i for i, h in enumerate(headers) if h}
    if "工序编号" not in col:
        return []
    ops: list[dict[str, Any]] = []
    std_times = std_times or {}
    for row in rows[1:]:
        code = _clean(_cell(row, col, "工序编号"))
        if not code:
            continue
        op_type = _clean(_cell(row, col, "工序类型", "类型"))
        raw_std = _cell(row, col, "标准工时")
        if code in std_times:
            std_min = float(std_times[code])
            inferred = False
            std_source = "工时表"
        else:
            std_min, inferred = _infer_std_min(op_type, raw_std, infer_map)
            std_source = "推断" if inferred else "实测"
        ops.append({
            "seq": _sequence(
                _cell(row, col, "排序号", "序号"),
                (len(ops) + 1) * 10,
            ),
            "operationCode": code,
            "operationName": _clean(_cell(row, col, "工序名称")) or code,
            "opType": op_type,
            "stdTimePerUnit": std_min,
            "stdTimeInferred": inferred,
            "stdTimeSource": std_source,
            "resourceGroup": "",
            "requireMold": False,
        })
    return ops


def _operation_signature(
    operations: list[dict[str, Any]],
    *,
    full: bool,
) -> tuple[tuple[Any, ...], ...]:
    ordered = sorted(
        operations,
        key=lambda op: (int(op.get("seq") or 0), _clean(op.get("operationCode"))),
    )
    if full:
        return tuple((
            _clean(op.get("operationCode")),
            int(op.get("seq") or 0),
            _clean(op.get("operationName")),
            _clean(op.get("opType")),
        ) for op in ordered)
    return tuple((
        _clean(op.get("operationCode")),
        int(op.get("seq") or 0),
    ) for op in ordered)


def parse_routing_sheet(
    path: Path,
    order_no: str,
    infer_map: dict[str, float] | None = None,
    std_times: dict[str, float] | None = None,
    *,
    canonical_operations: list[dict[str, Any]] | None = None,
    diagnostics: dict[str, Any] | None = None,
) -> list[dict[str, Any]]:
    """解析 exact sheet；generic sheet 必须由工时表规范工序序列唯一证明。"""
    import openpyxl

    path = Path(path)
    order_no = _clean(order_no)
    wb = openpyxl.load_workbook(path, read_only=True, data_only=True)
    try:
        if order_no in wb.sheetnames:
            selected = order_no
            candidates = [order_no]
            match_mode = "exact-sheet"
            ops = _read_routing_operations(wb[selected], infer_map, std_times)
            if not ops:
                raise KangniDataMappingError(
                    f"工艺路线 {path.name}/{selected} 未读到工序，订单 {order_no} 拒绝导入"
                )
        else:
            if not canonical_operations:
                raise KangniDataMappingError(
                    f"工艺路线缺少订单 sheet {order_no}，且工时表无规范工序序列，拒绝猜测 generic sheet"
                )
            expected = _operation_signature(canonical_operations, full=False)
            if not expected:
                raise KangniDataMappingError(
                    f"工时表订单 {order_no} 的规范工序序列为空，拒绝匹配 generic sheet"
                )
            matched: dict[str, list[dict[str, Any]]] = {}
            for sheet_name in wb.sheetnames:
                if not re.fullmatch(r"Sheet\d+", sheet_name, re.IGNORECASE):
                    continue
                sheet_ops = _read_routing_operations(wb[sheet_name], infer_map, std_times)
                if _operation_signature(sheet_ops, full=False) == expected:
                    matched[sheet_name] = sheet_ops
            if not matched:
                raise KangniDataMappingError(
                    f"订单 {order_no} 没有与工时表 code+排序号一致的 generic routing sheet"
                )
            candidates = sorted(matched, key=_routing_sheet_sort_key)
            contents = {
                _operation_signature(matched[name], full=True)
                for name in candidates
            }
            if len(contents) != 1:
                raise KangniDataMappingError(
                    f"订单 {order_no} 匹配多个 generic routing sheet {candidates}，但规范工艺内容不一致"
                )
            selected = candidates[0]
            match_mode = "generic-std-sequence"
            ops = matched[selected]
        if diagnostics is not None:
            diagnostics.update({
                "orderNo": order_no,
                "status": "matched",
                "matchMode": match_mode,
                "matchedSheet": selected,
                "matchedSheetCandidates": candidates,
                "operationCount": len(ops),
                "canonicalSource": f"工时.xlsx/{order_no}",
            })
        return ops
    finally:
        wb.close()


def _bom_row_signature(row: dict[str, Any]) -> tuple[Any, ...]:
    return (
        row["materialCode"],
        row["materialName"],
        float(row["quantity"]),
        row["consumeOp"],
        bool(row["isKey"]),
    )


def parse_bom_sheet(
    path: Path,
    order_no: str,
    *,
    diagnostics: dict[str, Any] | None = None,
) -> list[dict[str, Any]]:
    """独立扫描全部 BOM sheets，只按结构化工单编号归集，绝不绑定 routing 同名 sheet。"""
    import openpyxl

    path = Path(path)
    order_no = _clean(order_no)
    wb = openpyxl.load_workbook(path, read_only=True, data_only=True)
    try:
        per_sheet: list[tuple[str, list[dict[str, Any]]]] = []
        for sheet_name in wb.sheetnames:
            rows = list(wb[sheet_name].iter_rows(values_only=True))
            if not rows:
                continue
            headers = [_clean(c) for c in rows[0]]
            col = {h: i for i, h in enumerate(headers) if h}
            order_col = next((
                col[name]
                for name in ("工单编号", "生产订单", "订单号", "订单代码")
                if name in col
            ), None)
            is_exact = sheet_name == order_no
            if order_col is None and not is_exact:
                continue
            if is_exact and order_col is not None:
                foreign_orders = {
                    _clean(row[order_col])
                    for row in rows[1:]
                    if order_col < len(row)
                    and _clean(row[order_col])
                    and _clean(_cell(row, col, "物料编号", "物料编码"))
                    and _clean(row[order_col]) != order_no
                }
                if foreign_orders:
                    raise KangniDataMappingError(
                        f"BOM exact sheet {sheet_name} 含其它工单 {sorted(foreign_orders)}，订单 {order_no} 拒绝导入"
                    )
            parsed: list[dict[str, Any]] = []
            for row in rows[1:]:
                row_order = _clean(row[order_col]) if order_col is not None and order_col < len(row) else ""
                if order_col is not None and row_order != order_no:
                    continue
                material = _clean(_cell(row, col, "物料编号", "物料编码"))
                if not material:
                    continue
                quantity = _num(_cell(row, col, "单位用量", "用量"), 1.0)
                parsed.append({
                    "materialCode": material,
                    "materialName": _clean(_cell(row, col, "物料名称")) or material,
                    "quantity": quantity,
                    "consumeOp": _clean(_cell(row, col, "MES工序编号", "工序编号")),
                    "isKey": quantity >= 1.0,
                })
            if parsed:
                per_sheet.append((sheet_name, parsed))

        matched_sheets = [name for name, _ in per_sheet]
        if not per_sheet:
            if diagnostics is not None:
                diagnostics.update({
                    "orderNo": order_no,
                    "status": "missing",
                    "matchMode": "structured-order-field",
                    "matchedSheetCandidates": [],
                    "sourceRowCount": 0,
                    "outputRowCount": 0,
                    "deduplicatedRows": 0,
                })
            return []

        merged: list[dict[str, Any]] = []
        merged_by_identity: dict[tuple[str, str], dict[str, Any]] = {}
        prior_signatures: set[tuple[Any, ...]] = set()
        prior_sheets_by_identity: dict[tuple[str, str], set[str]] = {}
        deduplicated = 0
        aggregated = 0
        aggregation_groups: dict[tuple[str, str], dict[str, Any]] = {}
        for sheet_name, sheet_rows in per_sheet:
            for row in sheet_rows:
                signature = _bom_row_signature(row)
                identity = (row["materialCode"], row["consumeOp"])
                if signature in prior_signatures:
                    deduplicated += 1
                    prior_sheets_by_identity.setdefault(identity, set()).add(sheet_name)
                    continue
                prior_signatures.add(signature)
                prior = merged_by_identity.get(identity)
                if prior is not None and prior["materialName"] != row["materialName"]:
                    raise KangniDataMappingError(
                        f"订单 {order_no} 的 BOM 在 {identity} 上物料名称冲突；"
                        f"已见 sheets={sorted(prior_sheets_by_identity.get(identity) or set())}，"
                        f"当前 sheet={sheet_name}"
                    )
                if prior is None:
                    projected = deepcopy(row)
                    merged.append(projected)
                    merged_by_identity[identity] = projected
                    aggregation_groups[identity] = {
                        "materialCode": identity[0],
                        "consumeOp": identity[1],
                        "sourceRows": 1,
                        "quantity": float(projected["quantity"]),
                    }
                else:
                    prior["quantity"] = round(
                        float(prior["quantity"]) + float(row["quantity"]), 9
                    )
                    prior["isKey"] = float(prior["quantity"]) >= 1.0
                    group = aggregation_groups[identity]
                    group["sourceRows"] += 1
                    group["quantity"] = float(prior["quantity"])
                    aggregated += 1
                prior_sheets_by_identity.setdefault(identity, set()).add(sheet_name)

        if diagnostics is not None:
            diagnostics.update({
                "orderNo": order_no,
                "status": "matched",
                "matchMode": "exact-or-structured-order-field",
                "matchedSheet": matched_sheets[0],
                "matchedSheetCandidates": matched_sheets,
                "sourceRowCount": sum(len(rows) for _, rows in per_sheet),
                "outputRowCount": len(merged),
                "deduplicatedRows": deduplicated,
                "aggregatedRows": aggregated,
                "aggregationGroups": [
                    aggregation_groups[key]
                    for key in sorted(aggregation_groups)
                    if aggregation_groups[key]["sourceRows"] > 1
                ],
            })
        return merged
    finally:
        wb.close()


def _collect_kangni_packages(
    primary: dict[str, Any],
    route_path: Path,
    data_dir: Path,
    infer_map: dict[str, float] | None,
    std_time_map: dict[str, dict[str, float]],
    std_route_map: dict[str, list[dict[str, Any]]],
) -> tuple[list[dict[str, Any]], dict[str, Any]]:
    """按订单表收集主单和兄弟单，并返回逐单 routing/BOM 映射证据。"""
    packages = [primary]
    routing_mappings: dict[str, dict[str, Any]] = {
        primary["orderNo"]: {
            "orderNo": primary["orderNo"],
            "status": "matched",
            "matchMode": "complete-route",
            "matchedSheet": route_path.name,
            "matchedSheetCandidates": [route_path.name],
            "operationCount": len(primary.get("operations") or []),
            "canonicalSource": f"工时.xlsx/{primary['orderNo']}",
        },
    }
    bom_mappings: dict[str, dict[str, Any]] = {}
    orders_xlsx = _find_file(data_dir, "orders")
    routing_xlsx = _find_file(data_dir, "routing")
    bom_xlsx = _find_file(data_dir, "bom")
    if not orders_xlsx:
        return packages, {
            "routing": routing_mappings,
            "bom": bom_mappings,
            "sourceFiles": {},
        }

    source_orders = parse_orders_workbook(orders_xlsx)
    order_numbers = [order["orderNo"] for order in source_orders]
    duplicates = sorted({order_no for order_no in order_numbers if order_numbers.count(order_no) > 1})
    if duplicates:
        raise KangniDataMappingError(f"订单表存在重复工单编号 {duplicates}，拒绝导入")
    primary_seen = False
    for order in source_orders:
        order_no = order["orderNo"]
        bom_diag: dict[str, Any] = {}
        bom = parse_bom_sheet(bom_xlsx, order_no, diagnostics=bom_diag) if bom_xlsx else []
        if not bom_xlsx:
            bom_diag = {
                "orderNo": order_no,
                "status": "missing",
                "matchedSheetCandidates": [],
                "sourceRowCount": 0,
                "outputRowCount": 0,
                "deduplicatedRows": 0,
            }
        bom_mappings[order_no] = bom_diag
        if order_no == primary["orderNo"]:
            primary_seen = True
            for key in ("wbs", "productCode", "productName", "drawingNo", "planStart", "dueDate", "quantity"):
                if order.get(key) and not primary.get(key):
                    primary[key] = order[key]
            if bom:
                primary["bom"] = bom
            continue
        if not routing_xlsx:
            raise KangniDataMappingError(
                f"订单 {order_no} 需要兄弟单工艺，但数据目录缺少工艺路线.xlsx"
            )
        route_diag: dict[str, Any] = {}
        operations = parse_routing_sheet(
            routing_xlsx,
            order_no,
            infer_map,
            std_times=std_time_map.get(order_no) or {},
            canonical_operations=std_route_map.get(order_no),
            diagnostics=route_diag,
        )
        routing_mappings[order_no] = route_diag
        packages.append({
            **order,
            "kitStatus": "未知",
            "operations": operations,
            "bom": bom,
            "source": orders_xlsx.name,
            "routingSource": routing_xlsx.name,
        })

    if not primary_seen:
        bom_diag = {}
        bom = parse_bom_sheet(bom_xlsx, primary["orderNo"], diagnostics=bom_diag) if bom_xlsx else []
        if bom:
            primary["bom"] = bom
        bom_mappings[primary["orderNo"]] = bom_diag or {
            "orderNo": primary["orderNo"],
            "status": "missing",
            "matchedSheetCandidates": [],
            "sourceRowCount": 0,
            "outputRowCount": 0,
            "deduplicatedRows": 0,
        }
    return packages, {
        "routing": routing_mappings,
        "bom": bom_mappings,
        "sourceFiles": {
            "orders": str(orders_xlsx),
            "routing": str(routing_xlsx) if routing_xlsx else "",
            "bom": str(bom_xlsx) if bom_xlsx else "",
        },
    }


def _build_flex_bundle_from_packages(
    packages: list[dict[str, Any]],
    source_path: str | Path,
    data_dir: str | Path,
    *,
    station_count: int = _DEFAULT_STATION_COUNT,
    profile: dict[str, Any],
    mapping_evidence: dict[str, Any],
    source_mode: str,
) -> dict[str, Any]:
    """从已验证订单包构建 flex*，供完整路线和 data-dir-only 两种入口复用。"""
    if not packages:
        raise KangniDataMappingError("无订单包可构建 flex payload")
    prof = profile
    primary = packages[0]
    route_path = Path(source_path)
    data_dir = Path(data_dir)

    inferences: list[str] = []
    routing_record_count = sum(len(pkg.get("operations") or []) for pkg in packages)
    bom_source_row_count = sum(
        int(mapping.get("sourceRowCount") or 0)
        for mapping in (mapping_evidence.get("bom") or {}).values()
    )
    if not bom_source_row_count:
        bom_source_row_count = sum(len(pkg.get("bom") or []) for pkg in packages)
    std_time_source_counts: dict[str, int] = {}
    for package in packages:
        for operation in package.get("operations") or []:
            source = operation.get("stdTimeSource") or (
                "推断" if operation.get("stdTimeInferred") else "实测"
            )
            std_time_source_counts[source] = std_time_source_counts.get(source, 0) + 1
    used_std_ops = sum(
        1 for pkg in packages for op in pkg["operations"]
        if op.get("stdTimeSource") == "工时表"
    )
    if used_std_ops:
        inferences.append(f"{used_std_ops} 个工序标准工时来自 工时.xlsx（分钟/件）")
    for order_no, bom_mapping in (mapping_evidence.get("bom") or {}).items():
        if bom_mapping.get("status") == "missing":
            inferences.append(f"订单 {order_no} 未匹配 BOM 源行，已保留为空并等待现场确认")
    aggregated_bom_rows = sum(
        int(mapping.get("aggregatedRows") or 0)
        for mapping in (mapping_evidence.get("bom") or {}).values()
    )
    deduplicated_bom_rows = sum(
        int(mapping.get("deduplicatedRows") or 0)
        for mapping in (mapping_evidence.get("bom") or {}).values()
    )
    if aggregated_bom_rows or deduplicated_bom_rows:
        inferences.append(
            f"BOM 多行用量按订单+物料+消耗工序显式汇总："
            f"求和 {aggregated_bom_rows} 行，完全重复去重 {deduplicated_bom_rows} 行"
        )
    generic_mappings = [
        mapping
        for mapping in (mapping_evidence.get("routing") or {}).values()
        if mapping.get("matchMode") == "generic-std-sequence"
    ]
    if generic_mappings:
        reused = sum(
            1 for mapping in generic_mappings
            if len(mapping.get("matchedSheetCandidates") or []) > 1
        )
        inferences.append(
            f"{len(generic_mappings)} 个订单通过工时表规范序列匹配 generic routing sheet"
            f"（{reused} 个订单复用内容完全相同的多候选）"
        )
    chg_map = prof.get("changeoverMin") or {"部装": 15, "_default": 10}
    ops_map: dict[str, dict] = {}
    for pkg in packages:
        for op in pkg["operations"]:
            code = op["operationCode"]
            if code not in ops_map:
                chg = chg_map.get("_default", 10)
                for key, mins in chg_map.items():
                    if key != "_default" and key in (op.get("opType") or ""):
                        chg = mins
                        break
                ops_map[code] = {
                    "code": code,
                    "name": op["operationName"],
                    "isBottleneck": False,
                    "changeoverMin": chg,
                }
            if op.get("stdTimeInferred"):
                inferences.append(
                    f"工序 {code} 标准工时源表待维护 → 推断 {op['stdTimePerUnit']} 分钟/件"
                    f"（类型={op.get('opType') or '默认'}）"
                )

    # 部装标瓶颈（首道/部装类）
    for code, op in ops_map.items():
        if "部装" in op["name"] or code.endswith("Z1M") and "部装" in op["name"]:
            op["isBottleneck"] = True
    if not any(o["isBottleneck"] for o in ops_map.values()) and packages:
        first = packages[0]["operations"][0]["operationCode"]
        ops_map[first]["isBottleneck"] = True
        inferences.append(f"未标注瓶颈 → 将首道工序 {first} 标为瓶颈")

    all_op_codes = list(ops_map.keys())
    inferences.append(
        f"导入对账：{len(packages)} 个订单 / {routing_record_count} 条工序记录 / "
        f"{len(all_op_codes)} 个工序种 / {bom_source_row_count} 条 BOM 源行"
    )
    zone_cfg = prof.get("zone") or {}
    zone = {"code": zone_cfg.get("code") or "ZONE-CG", "name": zone_cfg.get("name") or "城轨机构装配区"}
    op_std: dict[str, float] = {}
    for pkg in packages:
        for op in pkg["operations"]:
            op_std.setdefault(op["operationCode"], op["stdTimePerUnit"])

    equipment, molds, mold_ops, res_inferences = build_flex_equipment_and_molds(
        data_dir, packages, op_std, all_op_codes, prof,
    )
    inferences.extend(res_inferences)
    equipment_without_capability = sum(1 for row in equipment if not row.get("capabilities"))
    shared_placeholder = any(row.get("code") == "EQ-SHARED-CG-01" for row in equipment)
    molds_without_operation = sum(1 for row in molds if not row.get("operationCode"))
    molds_without_equipment = sum(1 for row in molds if not row.get("adaptableEquipment"))
    molds_without_life = sum(1 for row in molds if float(row.get("lifeTotal") or 0.0) <= 0)
    if equipment_without_capability:
        placeholder_note = "；EQ-SHARED-CG-01 仅为共享占位" if shared_placeholder else ""
        inferences.append(
            f"资源缺口：{len(equipment)} 台设备中 {equipment_without_capability} 台未维护可执行工序"
            f"{placeholder_note}，不代表生产能力已确认"
        )
    if molds and (molds_without_operation or molds_without_equipment or molds_without_life):
        inferences.append(
            f"资源缺口：{len(molds)} 套模具中，缺适用工序 {molds_without_operation} 套、"
            f"缺适配设备 {molds_without_equipment} 套、缺寿命上限 {molds_without_life} 套；"
            "模具映射未达到生产就绪"
        )
    resource_quality = {
        "equipmentCount": len(equipment),
        "equipmentWithoutCapability": equipment_without_capability,
        "sharedPlaceholder": shared_placeholder,
        "moldCount": len(molds),
        "moldsWithoutOperation": molds_without_operation,
        "moldsWithoutEquipment": molds_without_equipment,
        "moldsWithoutLifeTotal": molds_without_life,
        "productionReady": bool(equipment)
        and equipment_without_capability == 0
        and molds_without_operation == 0
        and molds_without_equipment == 0
        and molds_without_life == 0,
    }

    materials: dict[str, dict] = {}
    material_source_orders: dict[str, set[str]] = {}
    bom_rows: list[dict] = []
    routings: list[dict] = []
    orders: list[dict] = []

    for pkg in packages:
        pc = pkg["productCode"] or f"P-{pkg['orderNo']}"
        pn = pkg.get("productName") or pc
        existing_product = materials.get(pc)
        if existing_product and _clean(existing_product.get("name")) != _clean(pn):
            raise KangniDataMappingError(
                f"物料编码 {pc} 名称冲突；已有={existing_product.get('name')} "
                f"orders={sorted(material_source_orders.get(pc) or set())}，"
                f"当前={pn} order={pkg['orderNo']}"
            )
        if not existing_product:
            materials[pc] = {
                "code": pc, "name": pn, "type": "FINISHED_PRODUCT", "unit": "套",
                "stock": 0, "inTransit": 0, "safetyStock": 0, "procurementLeadTime": 0,
                "drawingNo": pkg.get("drawingNo") or "",
            }
        material_source_orders.setdefault(pc, set()).add(pkg["orderNo"])
        for op in sorted(pkg["operations"], key=lambda x: x["seq"]):
            routings.append({
                "productCode": pc,
                "productName": pn,
                "seq": op["seq"],
                "operationCode": op["operationCode"],
                "requireMold": op["operationCode"] in mold_ops,
                "stdTimePerUnit": op["stdTimePerUnit"],
                "stdTimeSource": op.get("stdTimeSource") or ("推断" if op.get("stdTimeInferred") else "实测"),
            })
        kit_ready = "已完成" in (pkg.get("kitStatus") or "")
        for b in pkg["bom"]:
            mc = b["materialCode"]
            need = float(b["quantity"]) * float(pkg["quantity"])
            stock = max(need * 5.0, need + 10.0) if kit_ready else max(need * 2.0, 10.0)
            material_name = b["materialName"]
            existing_material = materials.get(mc)
            if existing_material and _clean(existing_material.get("name")) != _clean(material_name):
                raise KangniDataMappingError(
                    f"物料编码 {mc} 名称冲突；已有={existing_material.get('name')} "
                    f"orders={sorted(material_source_orders.get(mc) or set())}，"
                    f"当前={material_name} order={pkg['orderNo']}"
                )
            if mc not in materials:
                materials[mc] = {
                    "code": mc, "name": material_name, "type": "RAW_MATERIAL",
                    "unit": "件", "stock": stock, "inTransit": 0,
                    "safetyStock": max(1.0, need * 0.1), "procurementLeadTime": 7,
                }
            else:
                materials[mc]["stock"] = max(float(materials[mc].get("stock") or 0), stock)
            material_source_orders.setdefault(mc, set()).add(pkg["orderNo"])
            consume = b.get("consumeOp") or (pkg["operations"][0]["operationCode"] if pkg["operations"] else "")
            bom_rows.append({
                "productCode": pc,
                "materialCode": mc,
                "quantity": float(b["quantity"]),
                "consumeOp": consume,
                "isKey": bool(b.get("isKey")),
                "_orderNo": pkg["orderNo"],
            })
        if kit_ready:
            inferences.append(f"订单 {pkg['orderNo']} 备料状态=已完成 → 原料库存按齐套放大")

        orders.append({
            "orderNo": pkg["orderNo"],
            "productCode": pc,
            "quantity": int(pkg["quantity"]) if float(pkg["quantity"]).is_integer() else float(pkg["quantity"]),
            "dueDate": pkg["dueDate"],
            "priority": 1 if pkg["orderNo"] == primary["orderNo"] else 2,
            "wbs": pkg.get("wbs") or "",
            "productionController": "现场导入",
            "status": pkg.get("status") or "RELEASED",
            "project": pkg.get("project") or "",
            "sourceFile": pkg.get("source") or "",
            "kitStatus": pkg.get("kitStatus") or "",
            "requiredSkillLevel": (prof.get("team") or {}).get("skillLevel") or "L3",
        })

    # 产品 BOM 保留消耗工序维度；同一投影键跨订单不一致时失败关闭。
    seen_bom: dict[tuple[str, str, str], dict[str, Any]] = {}
    uniq_bom: list[dict[str, Any]] = []
    for b in bom_rows:
        key = (b["productCode"], b["materialCode"], b["consumeOp"])
        signature = (float(b["quantity"]), bool(b["isKey"]))
        prior = seen_bom.get(key)
        if prior is not None:
            if signature != prior["signature"]:
                raise KangniDataMappingError(
                    f"flex BOM 投影冲突 productCode={key[0]} materialCode={key[1]} "
                    f"consumeOp={key[2]}；"
                    f"已有={prior['signature']} orders={sorted(prior['orders'])}，"
                    f"当前={signature} order={b['_orderNo']}"
                )
            prior["orders"].add(b["_orderNo"])
            continue
        seen_bom[key] = {"signature": signature, "orders": {b["_orderNo"]}}
        uniq_bom.append({key_name: value for key_name, value in b.items() if key_name != "_orderNo"})

    team_cfg = prof.get("team") or {}
    teams = [{
        "code": team_cfg.get("code") or "T-CG-ASSY",
        "name": team_cfg.get("name") or "城轨机构装配班组",
        "memberCount": max(station_count, 4),
        "supportOps": list(all_op_codes),
        "skillLevel": team_cfg.get("skillLevel") or "L3",
    }]
    cal_cfg = prof.get("calendar") or {}
    calendar = [{
        "shiftCode": cal_cfg.get("shiftCode") or "D",
        "startTime": cal_cfg.get("startTime") or "08:00",
        "endTime": cal_cfg.get("endTime") or "17:00",
        "breaks": cal_cfg.get("breaks") or [{"start": "12:00", "end": "13:00"}],
        "workdays": cal_cfg.get("workdays") or [1, 2, 3, 4, 5],
    }]
    # 去重推断文案
    uniq_inf = []
    for line in inferences:
        if line not in uniq_inf:
            uniq_inf.append(line)

    params = {
        "sortMode": "BOTTLENECK",
        "beforeDays": 0,
        "afterDays": 30,
        "rollingWindows": {"realtime": "60m", "long": "7d", "mid": "2d", "short": "2h"},
        "mrpControllerDays": 3,
        "weights": {"tardiness": 0.4, "cost": 0.3, "utilization": 0.2, "balance": 0.1},
        "siteProfile": source_mode,
        "siteSource": str(route_path),
        "siteInferences": uniq_inf,
        "demoDataCleared": True,
    }

    return {
        "flexZones": [zone],
        "flexOperations": list(ops_map.values()),
        "flexEquipment": equipment,
        "flexMolds": molds,
        "flexMaterials": list(materials.values()),
        "flexBom": uniq_bom,
        "flexRoutings": routings,
        "flexTeams": teams,
        "flexCalendar": calendar,
        "flexOrders": orders,
        "flexParams": params,
        "flexScheduleVersions": [],
        "flexVirtualLines": [],
        "flexWorkOrders": [],
        "flexConflicts": [],
        "_meta": {
            "orderCount": len(orders),
            "operationCount": len(ops_map),
            "routingRecordCount": routing_record_count,
            "bomCount": len(uniq_bom),
            "bomSourceRowCount": bom_source_row_count,
            "stdTimeSourceCounts": std_time_source_counts,
            "routingMappings": mapping_evidence.get("routing") or {},
            "bomMappings": mapping_evidence.get("bom") or {},
            "missingBomOrders": [
                order_no
                for order_no, mapping in (mapping_evidence.get("bom") or {}).items()
                if mapping.get("status") == "missing"
            ],
            "resourceQuality": resource_quality,
            "inferences": uniq_inf,
            "primaryOrder": primary["orderNo"],
            "source": str(route_path),
        },
    }


def build_flex_bundle(
    route_path: str | Path | None = None,
    data_dir: str | Path | None = None,
    *,
    include_sibling_orders: bool = True,
    station_count: int = _DEFAULT_STATION_COUNT,
    profile: dict[str, Any] | None = None,
) -> dict[str, Any]:
    """构建可写入 world 的 flex* 包 + 推断说明。"""
    prof = profile if profile is not None else _P
    infer_map = prof.get("inferStdMin") or None
    route_path = Path(route_path) if route_path else DEFAULT_ROUTE_XLSX
    data_dir = Path(data_dir) if data_dir else DEFAULT_DATA_DIR

    std_time_map = load_std_time_map(data_dir)
    std_route_map = load_std_route_map(data_dir)
    primary = parse_complete_route_xlsx(route_path, infer_map)
    _apply_std_time_map(primary, std_time_map, override_existing=True)
    packages = [primary]
    mapping_evidence: dict[str, Any] = {
        "routing": {
            primary["orderNo"]: {
                "orderNo": primary["orderNo"],
                "status": "matched",
                "matchMode": "complete-route",
                "matchedSheet": route_path.name,
                "matchedSheetCandidates": [route_path.name],
                "operationCount": len(primary.get("operations") or []),
                "canonicalSource": f"工时.xlsx/{primary['orderNo']}",
            },
        },
        "bom": {
            primary["orderNo"]: {
                "orderNo": primary["orderNo"],
                "status": "matched" if primary.get("bom") else "missing",
                "matchMode": "complete-route",
                "matchedSheet": route_path.name if primary.get("bom") else "",
                "matchedSheetCandidates": [route_path.name] if primary.get("bom") else [],
                "sourceRowCount": len(primary.get("bom") or []),
                "outputRowCount": len(primary.get("bom") or []),
                "deduplicatedRows": 0,
            },
        },
        "sourceFiles": {},
    }
    if include_sibling_orders and data_dir.exists():
        packages, mapping_evidence = _collect_kangni_packages(
            primary,
            route_path,
            data_dir,
            infer_map,
            std_time_map,
            std_route_map,
        )
    return _build_flex_bundle_from_packages(
        packages,
        route_path,
        data_dir,
        station_count=station_count,
        profile=prof,
        mapping_evidence=mapping_evidence,
        source_mode="complete-route",
    )


def _collect_kangni_packages_from_data_dir(
    data_dir: Path,
    infer_map: dict[str, float] | None,
    std_time_map: dict[str, dict[str, float]],
    std_route_map: dict[str, list[dict[str, Any]]],
) -> tuple[list[dict[str, Any]], dict[str, Any]]:
    """仅从标准工作簿收集全部订单包；任何路线/BOM不确定性均失败关闭。"""
    orders_xlsx = _find_file(data_dir, "orders")
    routing_xlsx = _find_file(data_dir, "routing")
    stdtime_xlsx = _find_file(data_dir, "stdtime")
    bom_xlsx = _find_file(data_dir, "bom")
    missing = [
        name
        for name, path in (
            ("订单.xlsx", orders_xlsx),
            ("工艺路线.xlsx", routing_xlsx),
            ("工时.xlsx", stdtime_xlsx),
            ("BOM.xlsx", bom_xlsx),
        )
        if not path
    ]
    if missing:
        raise KangniDataMappingError(f"data-dir-only 缺少核心工作簿：{missing}")

    source_orders = parse_orders_workbook(orders_xlsx)
    if not source_orders:
        raise KangniDataMappingError("订单.xlsx 未读到生产订单")
    order_numbers = [order["orderNo"] for order in source_orders]
    duplicates = sorted({order_no for order_no in order_numbers if order_numbers.count(order_no) > 1})
    if duplicates:
        raise KangniDataMappingError(f"订单表存在重复工单编号 {duplicates}，拒绝导入")

    packages: list[dict[str, Any]] = []
    routing_mappings: dict[str, dict[str, Any]] = {}
    bom_mappings: dict[str, dict[str, Any]] = {}
    for order in source_orders:
        order_no = order["orderNo"]
        canonical_operations = std_route_map.get(order_no)
        std_times = std_time_map.get(order_no)
        if not canonical_operations or not std_times:
            raise KangniDataMappingError(
                f"工时.xlsx 缺少订单 {order_no} 的规范工序序列或分钟值"
            )
        route_diag: dict[str, Any] = {}
        operations = parse_routing_sheet(
            routing_xlsx,
            order_no,
            infer_map,
            std_times=std_times,
            canonical_operations=canonical_operations,
            diagnostics=route_diag,
        )
        if _operation_signature(operations, full=False) != _operation_signature(
            canonical_operations,
            full=False,
        ):
            raise KangniDataMappingError(
                f"订单 {order_no} 的 routing 与工时表规范工序序列不一致"
            )
        non_table_sources = [
            operation["operationCode"]
            for operation in operations
            if operation.get("stdTimeSource") != "工时表"
        ]
        if non_table_sources:
            raise KangniDataMappingError(
                f"订单 {order_no} 存在未由工时表提供分钟值的工序 {non_table_sources}"
            )
        bom_diag: dict[str, Any] = {}
        bom = parse_bom_sheet(bom_xlsx, order_no, diagnostics=bom_diag)
        if not bom or bom_diag.get("status") != "matched":
            raise KangniDataMappingError(f"订单 {order_no} 未唯一匹配结构化 BOM")
        routing_mappings[order_no] = route_diag
        bom_mappings[order_no] = bom_diag
        packages.append({
            **order,
            "kitStatus": "未知",
            "operations": operations,
            "bom": bom,
            "source": str(orders_xlsx),
            "routingSource": str(routing_xlsx),
        })

    return packages, {
        "routing": routing_mappings,
        "bom": bom_mappings,
        "sourceFiles": {
            "orders": orders_xlsx.name,
            "routing": routing_xlsx.name,
            "stdtime": stdtime_xlsx.name,
            "bom": bom_xlsx.name,
            "workbooks": [path.name for path in sorted(data_dir.glob("*.xlsx"))],
        },
    }


def _canonicalize_payload_source_refs(value: Any) -> Any:
    """移除 payload 中的机器/临时目录绝对路径，仅保留稳定逻辑文件名。"""
    if isinstance(value, dict):
        return {key: _canonicalize_payload_source_refs(item) for key, item in value.items()}
    if isinstance(value, list):
        return [_canonicalize_payload_source_refs(item) for item in value]
    if isinstance(value, tuple):
        return [_canonicalize_payload_source_refs(item) for item in value]
    if isinstance(value, Path):
        return value.name
    if isinstance(value, str):
        candidate = Path(value)
        if candidate.is_absolute():
            return candidate.name
    return value


def build_site_payload_from_data_dir(
    data_dir: str | Path,
    *,
    station_count: int = _DEFAULT_STATION_COUNT,
    profile: dict[str, Any] | None = None,
) -> dict[str, Any]:
    """仅凭标准工作簿构建 fixed+flex+meta 纯 JSON payload，不依赖完整路线文件。"""
    data_dir = Path(data_dir)
    if not data_dir.is_dir():
        raise KangniDataMappingError(f"康尼数据目录不存在：{data_dir}")
    prof = profile if profile is not None else _P
    infer_map = prof.get("inferStdMin") or None
    std_time_map = load_std_time_map(data_dir)
    std_route_map = load_std_route_map(data_dir)
    packages, mapping_evidence = _collect_kangni_packages_from_data_dir(
        data_dir,
        infer_map,
        std_time_map,
        std_route_map,
    )
    fixed = build_fixed_master(packages, station_count=station_count, profile=prof)
    source_path = mapping_evidence["sourceFiles"]["orders"]
    flex_bundle = _build_flex_bundle_from_packages(
        packages,
        source_path,
        data_dir,
        station_count=station_count,
        profile=prof,
        mapping_evidence=mapping_evidence,
        source_mode="data-dir-only",
    )
    meta = flex_bundle.pop("_meta")
    meta.update({
        "payloadSchemaVersion": 1,
        "sourceMode": "data-dir-only",
        "sourceWorkbookCount": len(mapping_evidence["sourceFiles"]["workbooks"]),
        "sourceFiles": deepcopy(mapping_evidence["sourceFiles"]),
        "fixedSalesOrderCount": len(fixed.get("salesOrders") or []),
        "fixedRoutingRecordCount": len(fixed.get("routingSteps") or []),
        "projectedBomCount": len(flex_bundle.get("flexBom") or []),
    })
    return _canonicalize_payload_source_refs({"fixed": fixed, "flex": flex_bundle, "meta": meta})


def build_fixed_master(
    packages: list[dict[str, Any]],
    *,
    station_count: int = _DEFAULT_STATION_COUNT,
    profile: dict[str, Any] | None = None,
) -> dict[str, Any]:
    """把现场订单包映射到主数据页/订单池读取的固定轨表（materials/operations/salesOrders…）。"""
    from server.timeutil import add_minutes, fmt_date, today0

    if not packages:
        raise ValueError("无订单包可写入主数据")
    primary = packages[0]
    prof = profile if profile is not None else _P
    f_cfg = prof.get("factory") or {}
    w_cfg = prof.get("workshop") or {}
    l_cfg = prof.get("line") or {}
    ws_prefix = prof.get("stationCodePrefix") or "WS-CG-"
    ws_name = prof.get("stationNamePrefix") or "城轨机构装配工位"
    eq_prefix = prof.get("equipmentCodePrefix") or "EQ-CG-"
    avail = float(prof.get("availabilityRate") or 0.95)
    setup_cfg = prof.get("setupMin") or {"first": 15.0, "rest": 10.0}
    lead_days = int(prof.get("rawMaterialLeadTimeDays") or 7)
    family = prof.get("productFamily") or "CG-ASSY"

    factories = [{
        "id": 1, "code": f_cfg.get("code") or "CG-F01", "name": f_cfg.get("name") or "城轨机构装配工厂",
        "timezone": f_cfg.get("timezone") or "Asia/Shanghai", "address": "现场导入", "status": "ACTIVE",
    }]
    workshops = [{
        "id": 1, "factoryId": 1, "code": w_cfg.get("code") or "CG-WS01",
        "name": w_cfg.get("name") or "城轨机构装配车间", "status": "ACTIVE",
    }]
    lines = [{
        "id": 1, "workshopId": 1, "code": l_cfg.get("code") or "CG-L01",
        "name": l_cfg.get("name") or "城轨机构装配线",
        "capacityPerDay": max(4, station_count), "taktTime": float(l_cfg.get("taktTime") or 30.0),
        "efficiencyFactor": float(l_cfg.get("efficiencyFactor") or 0.95),
        "status": "ACTIVE", "alternativeLineIds": [],
    }]
    workstations = []
    equipment = []
    for i in range(station_count):
        wsid = i + 1
        code = f"{ws_prefix}{i + 1:02d}"
        workstations.append({
            "id": wsid, "lineId": 1, "code": code,
            "name": f"{ws_name}#{i + 1}", "sequenceNo": i + 1, "status": "ACTIVE",
        })
        equipment.append({
            "id": wsid, "code": f"{eq_prefix}{i + 1:02d}", "name": f"装配工位设备#{i + 1}",
            "model": "SITE-ASSY", "workstationId": wsid, "capacityPerHour": 2,
            "efficiencyFactor": 0.95, "availabilityRate": avail, "status": "RUNNING",
        })

    # 工序库（全订单并集）
    ops_map: dict[str, dict] = {}
    for pkg in packages:
        for op in pkg["operations"]:
            code = op["operationCode"]
            if code not in ops_map:
                ops_map[code] = {
                    "code": code,
                    "name": op["operationName"],
                    "type": "INTERNAL",
                    "standardTime": float(op["stdTimePerUnit"]),
                    "seq": op["seq"],
                }
    operations = []
    for i, (_code, op) in enumerate(sorted(ops_map.items(), key=lambda x: x[1]["seq"])):
        operations.append({
            "id": i + 1, "code": op["code"], "name": op["name"],
            "type": op["type"], "standardTime": op["standardTime"],
        })
    op_id_by_code = {o["code"]: o["id"] for o in operations}

    materials: list[dict] = []
    mat_id_by_code: dict[str, int] = {}
    boms: list[dict] = []
    bom_items: list[dict] = []
    routings: list[dict] = []
    routing_steps: list[dict] = []
    line_products: list[dict] = []
    sales_orders: list[dict] = []
    mid = 1
    bom_id = 1
    rid = 1
    step_id = 1
    item_id = 1
    lp_id = 1

    for pkg in packages:
        pc = pkg["productCode"] or f"P-{pkg['orderNo']}"
        pn = pkg.get("productName") or pc
        if pc not in mat_id_by_code:
            materials.append({
                "id": mid, "code": pc, "name": pn,
                "spec": pkg.get("drawingNo") or "",
                "type": "FINISHED_PRODUCT", "unit": "套",
                "productFamily": family,
                "safetyStock": 0, "procurementLeadTime": 0,
                "stock": 0, "inTransit": 0, "status": "ACTIVE",
            })
            mat_id_by_code[pc] = mid
            mid += 1
        product_id = mat_id_by_code[pc]

        kit_ready = "已完成" in (pkg.get("kitStatus") or "")
        for b in pkg["bom"]:
            mc = b["materialCode"]
            need = float(b["quantity"]) * float(pkg["quantity"])
            stock = max(need * 5.0, need + 10.0) if kit_ready else max(need * 2.0, 10.0)
            if mc not in mat_id_by_code:
                materials.append({
                    "id": mid, "code": mc, "name": b["materialName"],
                    "spec": "", "type": "RAW_MATERIAL", "unit": "件",
                    "productFamily": "",
                    "safetyStock": max(1.0, need * 0.1),
                    "procurementLeadTime": lead_days,
                    "stock": stock, "inTransit": 0, "status": "ACTIVE",
                })
                mat_id_by_code[mc] = mid
                mid += 1
            else:
                # 同物料库存取较大
                mrow = next(m for m in materials if m["id"] == mat_id_by_code[mc])
                mrow["stock"] = max(float(mrow.get("stock") or 0), stock)

        # BOM 头 + 明细（每产品一版）
        boms.append({
            "id": bom_id, "productId": product_id, "version": "V1.0",
            "versionName": f"{pn} BOM（现场）", "isDefault": True, "status": "ACTIVE",
        })
        for b in pkg["bom"]:
            consume = b.get("consumeOp") or ""
            oid = op_id_by_code.get(consume) or (operations[0]["id"] if operations else None)
            bom_items.append({
                "id": item_id, "bomId": bom_id,
                "materialId": mat_id_by_code[b["materialCode"]],
                "quantity": float(b["quantity"]),
                "operationId": oid,
                "isKeyMaterial": bool(b.get("isKey")),
            })
            item_id += 1
        bom_id += 1

        # 工艺路线
        routings.append({
            "id": rid, "productId": product_id, "version": "V1.0",
            "versionName": f"{pn} 工艺（现场）", "isDefault": True, "status": "ACTIVE",
        })
        prev_step = None
        for seq_i, op in enumerate(sorted(pkg["operations"], key=lambda x: x["seq"]), start=1):
            oid = op_id_by_code[op["operationCode"]]
            routing_steps.append({
                "id": step_id, "routingId": rid, "operationId": oid,
                "sequenceNo": seq_i, "prevStepId": prev_step,
                "setupTime": float(setup_cfg.get("first", 15.0)) if seq_i == 1 else float(setup_cfg.get("rest", 10.0)),
                "runTimePerUnit": float(op["stdTimePerUnit"]),
                "waitTime": 0, "transferTime": 0, "isExternal": False,
                "stdTimeSource": op.get("stdTimeSource") or (
                    "推断" if op.get("stdTimeInferred") else "实测"
                ),
            })
            prev_step = step_id
            step_id += 1
        rid += 1

        line_products.append({
            "id": lp_id, "lineId": 1, "productId": product_id,
            "standardCapacity": max(4, station_count), "priority": 1, "setupTime": 30,
        })
        lp_id += 1

        due = pkg.get("dueDate") or fmt_date(add_minutes(today0(), 14 * 24 * 60))
        order_date = pkg.get("planStart") or fmt_date(today0())
        so_id = len(sales_orders) + 1
        sales_orders.append({
            "id": so_id,
            "orderNo": str(pkg["orderNo"]),
            "customerId": "SITE-001",
            "customerName": pkg.get("project") or "现场生产订单",
            "customerLevel": "A",
            "orderDate": order_date, "deliveryDate": due,
            "priority": 1 if pkg is primary or pkg.get("orderNo") == primary["orderNo"] else 2,
            "manualPriority": None, "status": "APPROVED",
            "source": "SITE_XLSX",
            "specialRequirements": f"WBS={pkg.get('wbs') or ''}",
            "totalAmount": 0,
            "isRush": False, "rushStrategy": None,
            "kitStatus": pkg.get("kitStatus") or "",
            "requiredSkillLevel": (prof.get("team") or {}).get("skillLevel") or "L3",
            "changes": [], "createdBy": "site-import",
            "createdAt": order_date + " 08:00", "updatedAt": order_date + " 08:00",
            "wbs": pkg.get("wbs") or "",
            "items": [{
                "id": so_id * 10 + 1, "orderId": so_id, "lineNo": 1,
                "productId": product_id, "productName": pn, "productCode": pc,
                "quantity": int(pkg["quantity"]) if float(pkg["quantity"]).is_integer() else float(pkg["quantity"]),
                "unit": "套", "bomVersion": "V1.0", "routingVersion": "V1.0",
                "deliveryDate": due, "status": "OPEN",
            }],
        })

    # 工位可执行全部工序
    wso = []
    wid = 1
    for ws in workstations:
        for op in operations:
            wso.append({
                "id": wid, "workstationId": ws["id"], "operationId": op["id"],
                "setupTime": 10, "runTimePerUnit": op["standardTime"], "isPrimary": True,
            })
            wid += 1

    team_cfg = prof.get("team") or {}
    teams = [{
        "id": 1, "code": team_cfg.get("code") or "T-CG-ASSY",
        "name": team_cfg.get("name") or "城轨机构装配班组",
        "workshopId": 1, "memberCount": max(station_count, 4),
        "skillLevel": team_cfg.get("skillLevel") or "L3", "status": "ACTIVE",
    }]
    cal_cfg = prof.get("calendar") or {}
    shifts = [{
        "id": 1, "code": cal_cfg.get("shiftCode") or "D", "name": "早班",
        "startTime": cal_cfg.get("startTime") or "08:00", "endTime": cal_cfg.get("endTime") or "17:00",
        "breakPeriods": cal_cfg.get("breaks") or [{"start": "12:00", "end": "13:00"}],
        "isOvertime": False, "status": "ACTIVE",
    }]
    base = today0()
    shift_calendar = []
    for i in range(int(prof.get("calendarDays") or 45)):
        date = add_minutes(base, i * 24 * 60)
        date_str = fmt_date(date)
        is_weekend = date.weekday() >= 5
        shift_calendar.append({
            "id": i + 1, "lineId": 1, "date": date_str, "shiftId": 1,
            "isWorking": not is_weekend, "teamId": 1, "maxWorkers": max(station_count, 4),
        })

    return {
        "factories": factories,
        "workshops": workshops,
        "lines": lines,
        "workstations": workstations,
        "equipment": equipment,
        "operations": operations,
        "routings": routings,
        "routingSteps": routing_steps,
        "materials": materials,
        "boms": boms,
        "bomItems": bom_items,
        "lineProducts": line_products,
        "workstationOperations": wso,
        "teams": teams,
        "shifts": shifts,
        "shiftCalendar": shift_calendar,
        "maintenance": [],
        "salesOrders": sales_orders,
        "productionOrders": [],
        "workOrders": [],
        "purchaseOrders": [],
        "outsourceOrders": [],
        "forecastOrders": [],
        "changeoverMatrix": [],
        "scheduleVersions": [],
        "conflicts": [],
        "logs": [],
    }


def apply_flex_bundle(world: World, bundle: dict[str, Any], *, replace: bool = True) -> dict[str, Any]:
    """将 flex 包写入 world；replace=True 时清空演示 flex*。"""
    if replace:
        for k in _FLEX_CLEAR_KEYS:
            world[k] = [] if k != "flexParams" else {}
    meta = bundle.pop("_meta", {})
    # 订单补 id
    orders = bundle.get("flexOrders") or []
    for i, o in enumerate(orders):
        o["id"] = i + 1
        o.setdefault("status", "RELEASED")
    for k, v in bundle.items():
        if k.startswith("_"):
            continue
        world[k] = v
    world.setdefault("flexParams", {})["demoDataCleared"] = True
    return meta


def clear_demo_world(world: World) -> None:
    """清空固定轨 + 柔性轨演示/残留数据。"""
    for k in _FIXED_CLEAR_KEYS:
        world[k] = []
    for k in _FLEX_CLEAR_KEYS:
        world[k] = [] if k != "flexParams" else {}


def apply_site_payload_to_world(
    world: World,
    payload: dict[str, Any],
    *,
    clear_all: bool = True,
) -> dict[str, Any]:
    """确定性写入 data-dir-only payload；始终深拷贝，绝不变异 payload 输入。"""
    if not isinstance(payload, dict):
        raise ValueError("site payload 必须是 dict")
    fixed = deepcopy(payload.get("fixed"))
    flex = deepcopy(payload.get("flex"))
    meta = deepcopy(payload.get("meta"))
    if not isinstance(fixed, dict) or not isinstance(flex, dict) or not isinstance(meta, dict):
        raise ValueError("site payload 必须包含 dict 类型的 fixed、flex、meta")
    if clear_all:
        clear_demo_world(world)
    for key, value in fixed.items():
        world[key] = value
    flex_with_meta = {**flex, "_meta": meta}
    applied_meta = apply_flex_bundle(world, flex_with_meta, replace=False)
    world.setdefault("flexParams", {})["siteProfile"] = "data-dir-only"
    world["flexParams"]["fixedMasterSynced"] = True
    applied_meta["clearedDemo"] = clear_all
    return applied_meta


def load_site_into_world(
    world: World,
    *,
    route_path: str | Path | None = None,
    data_dir: str | Path | None = None,
    include_sibling_orders: bool = False,
    station_count: int = _DEFAULT_STATION_COUNT,
    clear_all: bool = True,
    profile: dict[str, Any] | None = None,
) -> dict[str, Any]:
    """一键：清空演示 → 写入固定轨主数据+订单池 + flex* → 返回摘要。"""
    prof = profile if profile is not None else _P
    infer_map = prof.get("inferStdMin") or None
    route_path = Path(route_path) if route_path else DEFAULT_ROUTE_XLSX
    data_dir = Path(data_dir) if data_dir else DEFAULT_DATA_DIR

    std_time_map = load_std_time_map(data_dir)
    std_route_map = load_std_route_map(data_dir)
    primary = parse_complete_route_xlsx(route_path, infer_map)
    _apply_std_time_map(primary, std_time_map, override_existing=True)
    packages = [primary]
    if include_sibling_orders and data_dir.exists():
        packages, _ = _collect_kangni_packages(
            primary,
            route_path,
            data_dir,
            infer_map,
            std_time_map,
            std_route_map,
        )

    if clear_all:
        clear_demo_world(world)

    fixed = build_fixed_master(packages, station_count=station_count, profile=prof)
    for k, v in fixed.items():
        world[k] = v

    # flex 包：用同一 packages，避免再扫 siblings
    bundle = build_flex_bundle(
        route_path, data_dir,
        include_sibling_orders=False,
        station_count=station_count,
        profile=prof,
    )
    # 若带了 siblings，重建 flex 订单集以与 packages 对齐
    if len(packages) > 1:
        bundle = build_flex_bundle(
            route_path, data_dir,
            include_sibling_orders=True,
            station_count=station_count,
            profile=prof,
        )
    meta = apply_flex_bundle(world, bundle, replace=False)  # 已 clear_all
    meta["fixedMaterials"] = len(world.get("materials") or [])
    meta["fixedOperations"] = len(world.get("operations") or [])
    meta["salesOrders"] = len(world.get("salesOrders") or [])
    meta["clearedDemo"] = clear_all
    # 工厂名写入审计友好字段
    world.setdefault("flexParams", {})["siteProfile"] = "complete-route-full"
    world["flexParams"]["fixedMasterSynced"] = True
    return meta


def confirmation_for_site_load(meta: dict[str, Any]) -> tuple[str, list[str]]:
    title = "加载现场完整生产路线（清空演示并写入主数据+订单）"
    lines = [
        f"主订单：{meta.get('primaryOrder')}",
        f"订单数：{meta.get('orderCount')} · 工序：{meta.get('operationCount')} · BOM：{meta.get('bomCount')}",
        f"主数据物料：{meta.get('fixedMaterials')} · 工序库：{meta.get('fixedOperations')} · 销售订单：{meta.get('salesOrders')}",
        f"来源：{meta.get('source')}",
        "将清空演示工厂全部垃圾数据，写入现场订单/物料/BOM/工艺/产线/柔性资源。",
    ]
    for line in (meta.get("inferences") or [])[:6]:
        lines.append(f"推断：{line}")
    if len(meta.get("inferences") or []) > 6:
        lines.append(f"…另有 {len(meta['inferences']) - 6} 条推断说明")
    return title, lines