dsh-origin-bridge 0.4.1 → 0.4.3

package/originlab.py

@@ -9,10 +9,13 @@ by a registry, because parsing Origin's own [Book]Sheet! range strings back and
 forth is the most common source of silent failures.
 """
 
+import atexit
+import math
 import os
 import queue
 import re
 import struct
+import subprocess
 import sys
 import threading
 import time
@@ -28,17 +31,23 @@ PLOT_CODES = {"line": 200, "scatter": 201, "line_symbol": 202, "column": 203}
 PLOT_LETTERS = {"line": "l", "scatter": "s", "line_symbol": "y", "column": "c"}
 # originpro passes this integer straight to layadd, and the layer's own name is the
 # proof: read back as BottomXLeftY/TopX/RightY/LeftY/TopXRightY/BottomXRightY/Inset.
-LAYER_TYPES = {"bottom_left": 0, "top": 1, "right": 2, "left": 3,
+# Humans say "bottom" for the plain below-axis layer, which is code 0 (BottomXLeftY).
+LAYER_TYPES = {"bottom": 0, "bottom_left": 0, "top": 1, "right": 2, "left": 3,
                "top_right": 4, "bottom_right": 5, "inset": 6}
 # What Origin itself calls each layer, read back from layer.name after add_layer.
 LAYER_NAME_BY_CODE = {0: "BottomXLeftY", 1: "TopX", 2: "RightY", 3: "LeftY",
                       4: "TopXRightY", 5: "BottomXRightY", 6: "Inset"}
 # originpro's scale setter takes a name but the getter returns the int.
-SCALE_TYPES = {"linear": 1, "log10": 2, "probability": 3, "probit": 4, "reciprocal": 5,
-               "offset_reciprocal": 6, "logit": 7, "ln": 8, "log2": 9}
+SCALE_TYPES = {"linear": 1, "log10": 2, "log": 2, "probability": 3, "probit": 4,
+               "reciprocal": 5,
+               "offset_reciprocal": 6, "logit": 7, "ln": 8, "natural_log": 8, "log2": 9}
+# originpro's setter only understands its own names, so a friendly alias such as
+# "log" has to be translated back before it reaches layer.xscale.
+SCALE_NAMES = {1: "linear", 2: "log10", 3: "probability", 4: "probit", 5: "reciprocal",
+               6: "offset_reciprocal", 7: "logit", 8: "ln", 9: "log2"}
 # new_graph(template=NAME) accepts these OriginPro 2024 template stems (extension
 # optional) and returns None for an unknown one, which is how they get validated.
-GRAPH_TEMPLATES = ("line", "scatter", "linesymb", "column", "doubley", "dply",
+GRAPH_TEMPLATES = ("line", "scatter", "linesymb", "column", "doubley",
                    "heat_map", "cmap", "mesh", "contline", "contgray", "3d",
                    "glwireface", "pie", "box", "histdist", "polar", "ternary",
                    "vector", "errbar")
@@ -46,8 +55,9 @@ GRAPH_TEMPLATES = ("line", "scatter", "linesymb", "column", "doubley", "dply",
 # these were each constructed successfully on OriginPro 2024 SR1.
 FIT_PRESETS = {"gauss": "Gauss", "gaussian": "Gauss", "lorentz": "Lorentz",
                "voigt": "Voigt", "expdec1": "ExpDec1", "expdec2": "ExpDec2",
-               "sine": "Sine", "power": "Power", "logistic": "Logistic",
-               "boltzmann": "Boltzmann", "doseresp": "DoseResp", "cubic": "Cubic"}
+               "expdecay": "ExpDec1", "sine": "Sine", "power": "Power",
+               "logistic": "Logistic", "boltzmann": "Boltzmann", "doseresp": "DoseResp",
+               "cubic": "Cubic", "poly3": "Cubic"}
 # Legend anchors are layer DATA coordinates (Legend.x/.y read back exactly), so a
 # position is a fraction of the axis span rather than a page measurement.
 LEGEND_POSITIONS = {
@@ -59,6 +69,7 @@ LEGEND_POSITIONS = {
     "inside": (0.75, 0.80),
 }
 IMAGE_MAGIC = {".png": b"\x89PNG\r\n\x1a\n", ".tif": b"II*\x00", ".tiff": b"II*\x00",
+               ".jpg": b"\xff\xd8\xff", ".jpeg": b"\xff\xd8\xff",
                ".pdf": b"%PDF", ".svg": b"<", ".emf": b"\x01\x00\x00\x00"}
 ASCII_EXTS = (".dat", ".csv", ".txt", ".tsv")
 
@@ -78,6 +89,7 @@ _q = queue.Queue()
 _thread = None
 _thread_lock = threading.Lock()
 _op = None
+_suspect = False
 
 
 def _worker():
@@ -91,22 +103,78 @@ def _worker():
 
 
 def call(fn, *args, timeout=240, **kwargs):
-    global _thread
+    global _thread, _suspect
     with _thread_lock:
         if _thread is None or not _thread.is_alive():
             _thread = threading.Thread(target=_worker, daemon=True, name="origin-com")
             _thread.start()
-    box = {"done": threading.Event()}
-    _q.put((fn, args, kwargs, box))
-    if not box["done"].wait(timeout):
-        raise OriginError(
-            "com_timeout",
-            "Origin 在 %d 秒内没有响应" % timeout,
-            ["看 Origin 窗口是否卡在对话框或许可证弹窗", "任务管理器结束 Origin64.exe 后重试"],
-        )
-    if "error" in box:
-        raise box["error"]
-    return box["value"]
+    if _suspect:
+        # A previous call left Origin's COM channel in a bad state (a destroyed page
+        # keeps a C-level error pending, which then surfaces from an unrelated call).
+        # Re-attach once, lazily, so one wedge does not poison the whole session.
+        _suspect = False
+        _reset_connection()
+    for attempt in (0, 1):
+        box = {"done": threading.Event()}
+        _q.put((fn, args, kwargs, box))
+        if not box["done"].wait(timeout):
+            raise OriginError(
+                "com_timeout",
+                "Origin 在 %d 秒内没有响应" % timeout,
+                ["看 Origin 窗口是否卡在对话框或许可证弹窗", "任务管理器结束 Origin64.exe 后重试"],
+            )
+        if "error" not in box:
+            return box["value"]
+        exc = box["error"]
+        # Once per call: Origin's cached COM pointer can go stale when the process
+        # dies (user closed it, instance limit, exit tool). Every later call then
+        # fails identically, so drop the pointer and let origin() re-attach.
+        if attempt == 0 and _dead_app(exc) and _reset_connection():
+            continue
+        raise exc
+
+
+_DEAD_APP_MARKS = ("returned a result with an exception set", "ApplicationBase_",
+                   "-2147417851", "-2147023170", "RPC 服务器不可用",
+                   "The object invoked has disconnected from its clients",
+                   "com_error", "Pywintypes.com_error")
+
+
+def _dead_app(exc):
+    """True when Origin's COM connection itself is gone, not when an argument was bad."""
+    if isinstance(exc, OriginError):
+        # server.py flattens a raw SystemError into code="internal_error" before it
+        # reaches here, so judge by the message text rather than the code.
+        return any(m in exc.message for m in _DEAD_APP_MARKS)
+    text = "%s: %s" % (type(exc).__name__, exc)
+    return isinstance(exc, SystemError) or any(m in text for m in _DEAD_APP_MARKS)
+
+
+def _reset_connection():
+    """Forget the cached originpro module and its dangling Application pointer."""
+    global _op, _suspect
+    _op = None
+    _suspect = False
+    # Page wrappers belong to the Origin process we just lost: keeping them would
+    # let the next call fail with a mystery error instead of "句柄无效，请重新导入".
+    _handles.clear()
+    _names.clear()
+    mod = sys.modules.get("originpro")
+    if mod is None:
+        return False
+    po = getattr(mod, "po", None)
+    if po is not None and "_app" in getattr(po, "__dict__", {}):
+        try:
+            po.__dict__["_app"] = None
+        except Exception:
+            return False
+    return True
+
+
+def mark_suspect():
+    """Flag the COM channel as damaged: the next call re-attaches before running."""
+    global _suspect
+    _suspect = True
 
 
 def origin():
@@ -119,6 +187,10 @@ def origin():
     except ImportError as exc:
         raise OriginError("missing_originpro", "这个 Python 环境里没有 originpro：%s" % exc,
                           ["pip install originpro"])
+    # Record who was already running: anything that appears after we connect was
+    # started by us, and anything windowless that predates us is an orphan left by
+    # a client that exited without releasing its Origin.
+    before = _process_rows()
     try:
         op.path()
     except Exception as exc:
@@ -128,12 +200,152 @@ def origin():
             ["确认装了 Origin/OriginPro 2021 或更高（originpro 的硬性下限）",
              "确认 Origin 与 Python 都是 64 位",
              "若任务管理器里有多个 Origin64.exe，只保留一个",
-             "长会话攒页面后桥会坏：先 origin_exit 让插件重启 Origin"],
+             "长会话攒页面后桥会坏：先 origin_exit 让插件重启 Origin",
+             "实例数到上限时：origin_reclaim 会关掉没有窗口的残留实例"],
         )
+    existing = {row["pid"] for row in before} if before is not None else set()
+    after = _process_rows()
+    if after is not None:
+        _started_pids.update(row["pid"] for row in after if row["pid"] not in existing)
     _op = op
     return op
 
 
+# ------------------------------------------------------- instance lifecycle
+
+ORIGIN_EXE = "Origin64.exe"
+_started_pids = set()   # instances that appeared because WE connected
+
+
+def _process_rows():
+    """List Origin64 processes as {pid, started, window}, or None if unknown.
+
+    MainWindowHandle is what separates an instance the human can see from an
+    orphan a departing client left behind: originpro launches Origin on demand
+    and Origin does not quit when its client process exits.
+
+    A failed probe returns None, never an empty list: an empty list reads as
+    "there is nothing to reclaim", which is the one thing a caller must not be
+    told when we could not actually look.
+    """
+    if os.name != "nt":
+        return []
+    script = ("Get-Process Origin64 -ErrorAction SilentlyContinue | ForEach-Object {"
+              "\"$($_.Id)|\" + $(try { $_.StartTime.ToString('o') } catch { '' }) + "
+              "\"|$($_.MainWindowHandle)\"}")
+    try:
+        out = subprocess.run(["powershell", "-NoProfile", "-Command", script],
+                             capture_output=True, text=True, timeout=25).stdout
+    except Exception:
+        return None
+    rows = []
+    for line in out.splitlines():
+        parts = line.strip().split("|")
+        if len(parts) != 3:
+            continue
+        try:
+            rows.append({"pid": int(parts[0]), "started": parts[1], "window": int(parts[2] or 0)})
+        except ValueError:
+            continue
+    return rows
+
+
+def _terminate(pid, force=False):
+    args = ["taskkill"] + (["/F"] if force else []) + ["/PID", str(pid)]
+    return subprocess.run(args, capture_output=True, text=True, timeout=30)
+
+
+def _close_pid(pid):
+    """Ask for a polite exit first; escalate to a forced kill only if it survives."""
+    _terminate(pid)
+    for _ in range(6):
+        time.sleep(0.5)
+        rows = _process_rows()
+        if rows is None:
+            continue  # probe failed; keep polling rather than guessing "gone"
+        if pid not in {row["pid"] for row in rows}:
+            return "closed"
+    rows = _process_rows()
+    if rows is not None and pid not in {row["pid"] for row in rows}:
+        return "closed"
+    _terminate(pid, force=True)
+    return "force_closed"
+
+
+def instances():
+    """Report every Origin instance: background (reclaimable) vs foreground (the user's)."""
+    rows = _process_rows()
+    if rows is None:
+        return sanitize({"count": None, "probe": "unavailable",
+                         "error": "读不到进程表（powershell 不可用或超时），无法确定实例数量",
+                         "next_actions": ["重试 origin_instances", "或在任务管理器里看 Origin64.exe"]})
+    for row in rows:
+        row["foreground"] = bool(row["window"])
+        row["ours"] = row["pid"] in _started_pids
+    return sanitize({"count": len(rows), "probe": "ok",
+                     "background": [r for r in rows if not r["foreground"]],
+                     "foreground": [r for r in rows if r["foreground"]],
+                     "started_by_us": sorted(_started_pids)})
+
+
+def reclaim(close_background=True):
+    """Close windowless Origin instances; a visible window is reported, never killed.
+
+    An instance with no window has no client and no human in front of it. One with
+    a window may be the user's own unsaved work, so it is listed for them to close.
+    """
+    rows = _process_rows()
+    if rows is None:
+        return sanitize({"closed": [], "force_closed": [], "left_running": [],
+                         "probe": "unavailable",
+                         "error": "读不到进程表，没有动任何进程",
+                         "notify": "无法确认实例情况（进程探测失败），这次什么都没关。"})
+    back = [r for r in rows if not r["window"]]
+    front = [r for r in rows if r["window"]]
+    result = {"probe": "ok", "closed": [], "force_closed": [],
+              "left_running": [r["pid"] for r in front], "notify": ""}
+    if not close_background:
+        result["skipped"] = [r["pid"] for r in back]
+        return sanitize(result)
+
+    for row in back:
+        pid = row["pid"]
+        try:
+            outcome = _close_pid(pid)
+        except Exception as exc:
+            result["left_running"].append(pid)
+            result["notify"] += "PID %s 关不掉：%s；" % (pid, exc)
+            continue
+        result[outcome].append(pid)
+
+    if front:
+        result["notify"] += ("检测到 %d 个**有窗口**的 Origin 实例，没有动它们（可能是你自己开着的项目，"
+                            "含未保存工作）。要释放实例配额请自己关掉这些窗口，"
+                            "或先 origin_save_project 保存。") % len(front)
+    if not result["notify"]:
+        result["notify"] = "已回收全部后台实例，没有发现前台窗口。"
+    _started_pids.difference_update(result["closed"] + result["force_closed"])
+    return sanitize(result)
+
+
+def _release_on_exit():
+    """A client that exits must not leave its own Origin instance running."""
+    if not _started_pids:
+        return
+    try:
+        rows = _process_rows()
+        if rows is None:
+            return  # cannot tell which pids are ours; leaving Origin is the safe error
+        for row in rows:
+            if row["pid"] in _started_pids and not row["window"]:
+                _close_pid(row["pid"])
+    except Exception:
+        pass
+
+
+atexit.register(_release_on_exit)
+
+
 # ---------------------------------------------------------------- handles
 
 _handles = {}
@@ -210,11 +422,23 @@ def _round2(v):
 
 def _col_index(ws, col):
     ncol = int(_safe(lambda: ws.cols, 0) or 0)
+    if ncol == 0:
+        # A handle that resolves to a page with no columns is always either stale
+        # (the project was closed underneath us) or an empty book. Saying "列号超出
+        # 范围（共 0 列）" would send the model to re-count columns.
+        raise OriginError("sheet_empty", "这张工作表没有任何列，句柄可能已失效：%s"
+                          % (_safe(lambda: ws.name, "?"),),
+                          ["origin_inspect 看当前页面", "重新 origin_import 或 origin_write 拿新句柄"])
     idx = int(col) if isinstance(col, float) and float(col).is_integer() else (
         int(col) if isinstance(col, int) else None)
     if idx is not None:
-        idx = idx - 1 if idx >= 1 else idx
-        if 0 <= idx < ncol:
+        # Column numbers are 1-based everywhere in this API. Passing the internal
+        # 0-based index straight through would silently rewrite the first column.
+        if idx < 1:
+            raise OriginError("bad_column", "列号从 1 开始，收到 %s" % col,
+                              ["想操作第 1 列就传 1，或改用列名字符串"])
+        idx = idx - 1
+        if idx < ncol:
             return idx
         raise OriginError("bad_column", "列号 %s 超出范围（共 %d 列）" % (col, ncol),
                           ["列号从 1 开始，或用列名字符串"])
@@ -247,6 +471,16 @@ def _extend_to(ws, col):
     return want - 1
 
 
+def _numeric_columns(ws):
+    """Column indices that hold at least one real number (0-based)."""
+    out = []
+    for i in range(int(_safe(lambda: ws.cols, 0) or 0)):
+        vals = _safe(lambda i=i: ws.to_list(i), []) or []
+        if any(isinstance(v, (int, float)) and not isinstance(v, bool) for v in vals):
+            out.append(i)
+    return out
+
+
 def _sheet_info(ws):
     rows = int(_safe(lambda: ws.rows, 0) or 0)
     cols = int(_safe(lambda: ws.cols, 0) or 0)
@@ -263,13 +497,13 @@ def _sheet_info(ws):
     }
 
 
-def _verify_file(path, must_be_image=True):
+def _verify_file(path, must_be_image=True, min_bytes=1024):
     size = os.path.getsize(path)
     ext = os.path.splitext(path)[1].lower()
     with open(path, "rb") as fh:
         head = fh.read(24)
     magic = IMAGE_MAGIC.get(ext) if must_be_image else None
-    ok = size > 1024 and (magic is None or head.startswith(magic))
+    ok = size > min_bytes and (magic is None or head.startswith(magic))
     dims = None
     if ext == ".png" and head[12:16] == b"IHDR":
         dims = list(struct.unpack(">II", head[16:24]))
@@ -400,7 +634,16 @@ def import_file(path, book_name=""):
             raise OriginError("import_empty", "读进来了但是 0 行：%s" % path,
                               ["自研解析器也失败了：%s" % (parsed or {}).get("fallback_reason", "见上"),
                                "确认文件里有数值行，或改用 origin_read_file 先看结构"])
-        info.update({"source": path, "format": ext, "channel": "origin_from_file"})
+        warns = []
+        if not _numeric_columns(ws):
+            # Origin happily turns prose into a one-row text sheet; saying rows=1
+            # and calling it a success is how a bad file reaches a plot step.
+            warns.append("导进来的列里没有一列是数值（共 %d 列 %d 行），这张表画不出图：%s"
+                         % (info.get("cols"), info.get("rows"), path))
+        info.update({"source": path, "format": ext, "channel": "origin_from_file",
+                     "warnings": info.get("warnings", []) + warns})
+        if warns:
+            info["next_actions"] = ["用 origin_read_file 看文件真实结构，确认它是不是数据文件"]
         return sanitize(info)
 
     return call(run)
@@ -418,7 +661,9 @@ def write_columns(columns, book_name=""):
         ws = op.new_sheet(lname=book_name or "")
         for i, (name, values) in enumerate(columns.items()):
             try:
-                nums = [float(v) for v in values]
+                # None is a documented missing value, not a non-numeric cell: it has
+                # to reach Origin as an empty cell instead of killing the write.
+                nums = [None if v is None else float(v) for v in values]
             except (TypeError, ValueError) as exc:
                 raise OriginError("bad_arguments", "列 %r 里有非数值项：%s" % (name, exc),
                                   ["数值列只接受数字或 null；文本请放 Notes 页，或先把分类编码成数字"])
@@ -433,6 +678,10 @@ def write_block(headers, rows, book_name=""):
     which is why a 40-column sheet is slow; from_list2 writes the block at once."""
     if not rows or not isinstance(rows, (list, tuple)):
         raise OriginError("bad_arguments", "rows 必须是非空的二维列表")
+    if any(not isinstance(r, (list, tuple)) for r in rows):
+        raise OriginError("bad_arguments",
+                          "rows 得是二维的（每行一个列表），收到 %r" % (rows[0],),
+                          [['[["x","y"],[1,2],[3,4]] 这种形状']])
     ncol = max(len(r) for r in rows)
     if headers and len(headers) != ncol:
         raise OriginError("bad_arguments", "headers 有 %d 项，但 rows 最宽 %d 列" % (len(headers), ncol))
@@ -469,6 +718,8 @@ def column_formula(worksheet, col, formula, label="", units=""):
 
     def run():
         idx = _col_index(ws, col) if _col_exists(ws, col) else _extend_to(ws, col)
+        prev_formula = _safe(lambda: str(ws.get_formula(idx)), "")
+        before = [v for v in _safe(lambda: list(ws.to_list(idx)), []) if v is not None]
         # originpro 1.1.15 documents set_formula's column as 1-offset, but it is
         # 0-based here: passing idx+1 grabs a non-existent column and the library
         # dies inside SetStrProp on a None object.
@@ -485,13 +736,56 @@ def column_formula(worksheet, col, formula, label="", units=""):
                               ["LabTalk 里底 10 对数是 log() 不是 log10()",
                                "跨列引用要先绑定 range，不能内联 [Book]Sheet!col(N)",
                                "列号用 Col(1) 这种当前表写法试试"])
+        warns = []
+        proof = "verified"
+        if before and before == vals and prev_formula.strip() != str(formula).strip():
+            # A bogus LabTalk formula on a column that already had data leaves the
+            # old numbers in place, so "computed_rows > 0" alone cannot prove much.
+            warns.append("改了公式但这一列的数值一个都没变（%d 行原样保留）：Origin 可能没有执行它"
+                         % len(vals))
+            proof = "unverified"
         return sanitize({"column": idx + 1, "formula": str(formula),
                          "computed_rows": len(vals), "first": vals[0], "last": vals[-1],
-                         "columns": info["columns"], "proof_level": "verified"})
+                         "columns": info["columns"], "warnings": warns, "proof_level": proof,
+                         **({} if proof == "verified"
+                            else {"next_actions": ["origin_inspect 看这一列现在到底是什么值"]})})
 
     return call(run)
 
 
+def _decade_span(values):
+    """How many orders of magnitude the positive values cover (0 if not measurable)."""
+    pos = [v for v in (values or []) if isinstance(v, (int, float)) and v > 0]
+    if len(pos) < 2:
+        return 0.0
+    lo, hi = min(pos), max(pos)
+    return math.log10(hi / lo) if hi > lo else 0.0
+
+
+def _axis_review(lay, xvals):
+    """Flag a plot whose X axis is linear across several orders of magnitude.
+
+    A Bode/EIS sweep spans 1e5..1e-2 Hz: on a linear axis every point piles up
+    against the y axis and the exported PNG is unreadable, yet nothing about the
+    call failed. The bridge cannot decide for the user whether they want a log
+    axis, a zoomed range or a Nyquist view, so it says so and hands the choice
+    back.
+    """
+    scale = _safe(lambda: lay.xscale)
+    decades = _decade_span(xvals)
+    if scale not in (None, 1) or decades < 3:
+        return None
+    return ("X 轴是线性刻度但数据跨了 %.1f 个数量级（%g..%g），点会全挤在最左边，"
+            "图基本没法看。这不算出错，但要让用户决定怎么处理，别自己改轴"
+            % (decades, min(v for v in xvals if v > 0), max(v for v in xvals if v > 0)))
+
+
+REVIEW_OPTIONS = ["origin_style 把 x_scale 设成 log10（对数横轴，Bode 图常用）",
+                  "只画其中一段：origin_style 用 xlim 限定范围",
+                  "换成别的 X 轴：如阻抗用 Z' 对 Z'' 画 Nyquist 图",
+                  "保持现状（用户就是想看线性轴）"]
+
+
 def plot(worksheet, x=1, y=2, plot_type="line", graph_name="", title="",
          graph="", layer=0, template=""):
     """Draw one or more series.
@@ -589,6 +883,10 @@ def plot(worksheet, x=1, y=2, plot_type="line", graph_name="", title="",
             raise OriginError("plot_incomplete",
                               "要求 %d 条曲线，层里只有 %d 条" % (len(yis), drawn),
                               ["origin_inspect 看该层，或改用 origin_view 目视确认"])
+        review = _axis_review(lay, xvals)
+        if review:
+            span["warnings"] = [review]
+            span["next_actions"] = list(REVIEW_OPTIONS)
         return sanitize({"graph": _bind("gr", gr, gr.name), "plot_type": plot_type,
                          "channel": channel, "template": tpl,
                          "source_sheet": _safe(lambda: ws.name, ""),
@@ -647,13 +945,15 @@ def style(graph, layer=0, series=None, x_title="", y_title="", x_scale="", y_sca
             if want is None:
                 raise OriginError("bad_scale", "未知刻度类型：%r" % x_scale,
                                   ["可选 %s" % sorted(SCALE_TYPES)])
-            attempt("x_scale", lambda: setattr(lay, "xscale", x_scale), lambda: lay.xscale, want)
+            attempt("x_scale", lambda: setattr(lay, "xscale", SCALE_NAMES[want]),
+                    lambda: lay.xscale, want)
         if y_scale:
             want = SCALE_TYPES.get(str(y_scale).lower())
             if want is None:
                 raise OriginError("bad_scale", "未知刻度类型：%r" % y_scale,
                                   ["可选 %s" % sorted(SCALE_TYPES)])
-            attempt("y_scale", lambda: setattr(lay, "yscale", y_scale), lambda: lay.yscale, want)
+            attempt("y_scale", lambda: setattr(lay, "yscale", SCALE_NAMES[want]),
+                    lambda: lay.yscale, want)
         if xlim:
             attempt("xlim", lambda: lay.set_xlim(*_pair(xlim)), lambda: lay.xlim)
         if ylim:
@@ -718,16 +1018,60 @@ def _pair(v):
     return vals[:3]
 
 
+def _axis_span(lay, which):
+    """(begin, end) of an axis, via the layer's xlim/ylim — axis.from_ is not readable here."""
+    limits = _safe(lambda: getattr(lay, "%slim" % which))
+    try:
+        lo, hi = float(limits[0]), float(limits[1])
+    except (TypeError, ValueError, IndexError):
+        return None, None
+    return (lo, hi) if lo <= hi else (hi, lo)
+
+
+def _line_coords(lay, item):
+    """Reference lines are usually given as one coordinate: x=12 is a vertical line."""
+    if all(k in item for k in ("x1", "y1", "x2", "y2")):
+        return [item[k] for k in ("x1", "y1", "x2", "y2")]
+    has_x, has_y = "x" in item, "y" in item
+    if has_x and not has_y:
+        lo, hi = _axis_span(lay, "y")
+        if lo is None or hi is None:
+            raise OriginError("bad_arguments", "读不到 Y 轴范围，竖参考线请给 x1/y1/x2/y2")
+        return [item["x"], lo, item["x"], hi]
+    if has_y and not has_x:
+        lo, hi = _axis_span(lay, "x")
+        if lo is None or hi is None:
+            raise OriginError("bad_arguments", "读不到 X 轴范围，横参考线请给 x1/y1/x2/y2")
+        return [lo, item["y"], hi, item["y"]]
+    raise OriginError("bad_arguments",
+                      "lines 的每一项要有 x 或 y（单坐标=参考线），或 x1/y1/x2/y2（线段）：收到 %r" % (item,),
+                      ['竖线 {"x": 12}，横线 {"y": 50}，任意线段 {"x1":0,"y1":0,"x2":1,"y2":2}'])
+
+
 def annotate(graph, labels=(), lines=(), layer=0):
     """Text labels and reference lines in data coordinates."""
     if not labels and not lines:
         raise OriginError("bad_arguments", "labels 和 lines 至少给一个")
+    for name, items in (("labels", labels or ()), ("lines", lines or ())):
+        if isinstance(items, str) or not isinstance(items, (list, tuple)):
+            raise OriginError("bad_arguments", "%s 要是列表，收到 %r" % (name, type(items).__name__))
+        for item in items:
+            if not isinstance(item, dict):
+                raise OriginError("bad_arguments",
+                                  "%s 的每一项要是对象，如 {\"text\":..,\"x\":..,\"y\":..}；收到 %r"
+                                  % (name, item),
+                                  ["labels: [{\"text\":\"峰值\",\"x\":1.2,\"y\":30}]"])
 
     def run():
         gr = _graph_of(origin(), graph)
         if gr is None:
             raise OriginError("graph_not_found", "图页句柄无效：%s" % graph)
-        lay = gr[layer]
+        try:
+            lay = gr[layer]
+        except Exception:
+            raise OriginError("bad_layer", "图页 %s 没有第 %d 层（共 %d 层）"
+                              % (_safe(lambda: gr.name, "?"), layer, _layer_count(gr)),
+                              ["先用 origin_inspect 看层数"])
         done = []
         for item in labels or ():
             text = str(item.get("text", ""))
@@ -735,8 +1079,8 @@ def annotate(graph, labels=(), lines=(), layer=0):
             lab = _safe(lambda: lay.add_label(text, x, y))
             done.append({"kind": "label", "text": text, "at": [x, y], "ok": lab is not None})
         for item in lines or ():
-            coords = [item.get(k) for k in ("x1", "y1", "x2", "y2")]
-            ln = _safe(lambda: lay.add_line(*coords))
+            coords = _line_coords(lay, item)
+            ln = _safe(lambda c=coords: lay.add_line(*c))
             done.append({"kind": "line", "coords": coords, "ok": ln is not None,
                          "width": _safe(lambda: ln.width) if ln is not None else None,
                          "type": _safe(lambda: ln.type) if ln is not None else None})
@@ -839,6 +1183,8 @@ def add_layer(graph, layer_type="right"):
     right-Y layer reads back as 'RightY'. Filling it is left to origin_plot with
     layer=<index>, which is the only path measured to draw into a chosen layer.
     """
+    if isinstance(layer_type, str) and layer_type.strip().isdigit():
+        layer_type = int(layer_type.strip())   # "2" from a model is still the code 2
     if isinstance(layer_type, str) and layer_type.lower() in LAYER_TYPES:
         code = LAYER_TYPES[layer_type.lower()]
     elif isinstance(layer_type, int) and layer_type in LAYER_TYPES.values():
@@ -914,7 +1260,8 @@ def view(graph, width=900):
     return call(run)
 
 
-LABTALK_DENY = ("doc -s", "doc -c", "saveas", "quit", "exitloop", "type -m", "openb", "run.x")
+LABTALK_DENY = ("doc -s", "doc -c", "saveas", "quit", "exitloop", "type -m", "openb", "run.x",
+                "close;", "close ", "system ", "shell ", "run.section", "run.open", "fopen")
 
 
 def labtalk(script, readback=(), numeric=()):
@@ -943,7 +1290,15 @@ def labtalk(script, readback=(), numeric=()):
             strs[str(name)] = _safe(lambda n=name: op.get_lt_str(n), None)
         nums = {}
         for name in numeric or ():
-            nums[str(name)] = _safe(lambda n=name: op.lt_float(n), None)
+            def read(n=name):
+                # lt_float returns nan for integer-typed LabTalk variables
+                # (layer.showlegend, Legend.Show), which would make a successful
+                # change look unverifiable.
+                value = op.lt_float(n)
+                if isinstance(value, float) and math.isnan(value):
+                    return op.lt_int(n)
+                return value
+            nums[str(name)] = _safe(read, None)
         return sanitize({"script": str(script), "returned": bool(ret),
                          "readback": strs, "numeric": nums,
                          "proof_level": "verified" if (ret and (strs or nums)) else
@@ -994,7 +1349,14 @@ def fit(worksheet, x=1, y=2, kind="linear", func="", fixed=None, starts=None,
     ws = _resolve("ws", worksheet)
     if ws is None:
         raise OriginError("worksheet_not_found", "工作表句柄无效：%s" % worksheet)
-    kind = str(kind).lower()
+    kind = str(kind or "").lower()
+    switched = False
+    if func and kind in ("", "linear"):
+        # Naming a fitting function means a nonlinear fit: running the linear one
+        # anyway returned slope/intercept for a caller who asked for Gauss.
+        kind, switched = "nlfitsing", True
+    if not kind:
+        kind = "linear"
     if kind in FIT_PRESETS:
         func, kind = FIT_PRESETS[kind], "nlfitsing"
     if kind not in ("linear", "nlfitsing", "nlfit"):
@@ -1027,9 +1389,11 @@ def fit(worksheet, x=1, y=2, kind="linear", func="", fixed=None, starts=None,
         try:
             nl = op.NLFit(func)
         except Exception as exc:
-            raise OriginError("fit_function_unavailable", "函数 %r 不可用：%s" % (func, exc),
-                              ["NLFit 需要 OriginPro 授权",
-                               "本机实测可用的名字：%s" % ", ".join(sorted(set(FIT_PRESETS.values())))])
+            raise OriginError("fit_function_unavailable",
+                              "函数 %r 不是 Origin 里已定义的拟合函数：%s" % (func, exc),
+                              ["func 只能是 Origin 内置函数名，自定义表达式（如 a*exp(-b*x)+c）不支持",
+                               "本机实测可用的预设：%s" % ", ".join(sorted(set(FIT_PRESETS))),
+                               "NLFit 需要 OriginPro 授权"])
         nl.set_data(ws, xi, yi)
         notes = []
         for name, val in (starts or {}).items():
@@ -1053,6 +1417,8 @@ def fit(worksheet, x=1, y=2, kind="linear", func="", fixed=None, starts=None,
         return sanitize({"kind": "nlfitsing", "func": func, "r_squared": r2,
                          "fit_status": res.get("fitstatus") if isinstance(res, dict) else None,
                          "constraints": notes, "trimmed": not full,
+                         **({"note": "你给了 func，所以按非线性拟合执行（kind 省略时默认 linear）"}
+                            if switched else {}),
                          **({"result": body} if full else {"fit": body})})
 
     return call(run, timeout=300)
@@ -1060,8 +1426,11 @@ def fit(worksheet, x=1, y=2, kind="linear", func="", fixed=None, starts=None,
 
 def export(graph, path="", fmt="png", width=1600):
     fmt = str(fmt).lstrip(".").lower()
-    if fmt not in ("png", "tif", "tiff", "svg", "pdf", "emf"):
-        raise OriginError("bad_format", "fmt 只支持 png/tif/svg/pdf/emf，收到 %s" % fmt)
+    # Origin's export filter only recognises the short names: asking for a.tiff
+    # leaves no file behind, which reads as a failed export.
+    fmt = {"tiff": "tif", "jpeg": "jpg"}.get(fmt, fmt)
+    if fmt not in ("png", "tif", "jpg", "svg", "pdf", "emf"):
+        raise OriginError("bad_format", "fmt 只支持 png/tif/jpg/svg/pdf/emf，收到 %s" % fmt)
 
     def run():
         op = origin()
@@ -1069,7 +1438,12 @@ def export(graph, path="", fmt="png", width=1600):
         if page is None:
             raise OriginError("graph_not_found", "找不到图页：%s（项目里可能还没有图）" % (graph or ""))
         name = _safe(lambda: page.name, "Graph1")
-        target_path = os.path.abspath(path or os.path.join(os.getcwd(), "%s.%s" % (name, fmt)))
+        # No path is not an invitation to write into the process CWD: under dsh
+        # that is the plugin's node_modules folder. Origin's User Files wins.
+        folder = _safe(lambda: op.path("u"), "") or os.getcwd()
+        target_path = os.path.abspath(path or os.path.join(folder, "%s.%s" % (name, fmt)))
+        if os.path.splitext(target_path)[1].lower().lstrip(".") != fmt:
+            target_path = os.path.splitext(target_path)[0] + "." + fmt
         os.makedirs(os.path.dirname(target_path) or ".", exist_ok=True)
         _safe(lambda: page.save_fig(target_path))
         if not os.path.isfile(target_path):
@@ -1119,13 +1493,18 @@ def _save_project(path=""):
             raise OriginError("save_failed", "保存工程失败：%s (ok=%s)" % (target, ok),
                               ["该文件可能正被 Origin 占用（工程绑定后会加锁）",
                                "换一个不冲突的文件名，或省略 path 用自动时间戳命名"])
-        info = _verify_file(target, must_be_image=False)
+        info = _verify_file(target, must_be_image=False, min_bytes=256)
         if not info["ok"]:
-            raise OriginError("save_suspect", "工程文件过小：%s" % info,
+            raise OriginError("save_suspect", "工程文件异常：%s" % info,
                               ["项目里得先有工作表或图页再保存"])
+        pages_now = len(list(_safe(lambda: op.pages(), []) or []))
         _project_file = target
-        out = dict(info, editable=True, saved=bool(ok),
+        out = dict(info, editable=True, saved=bool(ok), pages=pages_now,
                    note="可在 Origin 里继续编辑的 .opju，不是图片快照")
+        if not pages_now:
+            # An empty project really is a few hundred bytes: calling that
+            # "文件过小" was a false alarm on origin_exit(save_to=...).
+            out["warnings"] = ["工程里一个页面都没有，存下来的 .opju 打开是空的"]
         if same_file and not ok:
             out["unchanged"] = True
             out["note"] = "项目已绑定在该文件上且无待写变更，文件保持原样"
@@ -1163,6 +1542,11 @@ def inspect(graph=""):
                   "lname": _safe(lambda p=p: p.lname, "")} for p in op.pages()]
         out = {"pages": pages, "handles": sorted(_handles)}
         page = _graph_of(op, graph)
+        if page is None and str(graph or "").strip():
+            # A handle that no longer exists must not degrade into "here are the
+            # other pages", which reads as a successful inspection of nothing.
+            raise OriginError("graph_not_found", "图页句柄无效或已关闭：%s" % graph,
+                              ["origin_inspect 不带 graph 先看页面清单", "或重新 origin_plot 拿句柄"])
         if page is not None:
             layers = []
             i = 0
@@ -1190,7 +1574,7 @@ def exit_origin(save_to=""):
         _handles.clear()
         _names.clear()
         _project_file = ""
-        _op = None
+        _reset_connection()
         return sanitize({"exited": True, "saved": saved})
 
     return call(run)
@@ -1221,6 +1605,9 @@ def figure(source="", columns=None, x=1, y=1, plot_type="line", title="",
     p = plot(info["worksheet"], x=x, y=y, plot_type=plot_type, title=title, template=template)
     steps.append({"step": "plot", "graph": p["graph_page"], "type": plot_type,
                   "channel": p.get("channel", ""), "plots": p.get("plots_in_layer")})
+    warns = list(p.get("warnings") or [])
+    if warns:
+        steps.append({"step": "review", "why": str(warns[0])[:90]})
     if x_title or y_title:
         st = style(p["graph"], x_title=x_title, y_title=y_title)
         steps.append({"step": "style", **st})
@@ -1232,6 +1619,11 @@ def figure(source="", columns=None, x=1, y=1, plot_type="line", title="",
         steps.append({"step": "legend", "proof_level": lg.get("proof_level")})
 
     out = {"data": info, "plot": p, "style": st, "legend": lg}
+    if warns:
+        # Top level, because a delivered-but-unreadable PNG is exactly the kind of
+        # thing the model must raise with the user rather than quietly hand over.
+        out["warnings"] = warns
+        out["next_actions"] = list(p.get("next_actions") or []) + ["origin_view 目视确认后再决定"]
     deliver = {}
     if export_path or output_dir:
         base = export_path or os.path.join(output_dir, "%s.%s" % (p["graph_page"], fmt))
@@ -1394,7 +1786,9 @@ def close_pages(kind="graph", names=None, dry_run=False):
     targets, had = call(collect)
     wanted = [_safe(lambda p=p: p.name, "?") for p in targets]
     if not targets:
-        return sanitize({"closed": [], "asked": [], "note": "没有匹配的页面"})
+        # Stable shape: a dry run always answers with would_close, empty or not.
+        return sanitize({"closed": [], "asked": [], "would_close": [],
+                         "note": "没有匹配的页面"})
     if dry_run:
         return sanitize({"would_close": wanted, "dry_run": True})
     errors = call(destroy, targets)
@@ -1435,10 +1829,13 @@ def _catalog():
 
 def chart_presets(category=""):
     cat = _catalog()
-    items = cat.list_templates(category or None)
-    return sanitize({"n_templates": len(items),
-                     "categories": sorted({t["category"] for t in cat.TEMPLATES}),
-                     "templates": items})
+    known = sorted({t["category"] for t in cat.TEMPLATES})
+    want = str(category or "").strip().lower()
+    if want and want not in {c.lower() for c in known}:
+        raise OriginError("bad_category", "没有这个图表预设分类：%r" % category,
+                          ["可用分类：%s" % ", ".join(known)])
+    items = cat.list_templates(want or None)
+    return sanitize({"n_templates": len(items), "categories": known, "templates": items})
 
 
 def chart_preset(name):
@@ -1457,7 +1854,26 @@ def chart_check(name, data=None, columns=None):
     if tpl is None:
         raise OriginError("preset_not_found", "没有这个图表预设：%r" % name)
     if data and not columns:
-        columns = [c["name"] for c in read_file(data)["columns"]]
+        # `data` is documented as a file path, but models hand us dicts and lists
+        # here constantly; accept those as column sources instead of dying with a
+        # raw TypeError, and say so when the value is neither.
+        if isinstance(data, dict):
+            columns = list(data)
+        elif isinstance(data, (list, tuple)):
+            columns = [str(c) for c in data]
+        elif isinstance(data, str):
+            try:
+                parsed = read_file(data)
+            except OriginError:
+                raise
+            except Exception as exc:
+                raise OriginError("bad_arguments",
+                                  "data 要的是数据文件路径，或者列名列表/字典：%s" % exc,
+                                  ["origin_chart_check 传 columns=[...] 更直接"]) from exc
+            columns = [c["name"] for c in parsed["columns"]]
+        else:
+            raise OriginError("bad_arguments", "data 只能是文件路径字符串、列名字典或列表",
+                              ["origin_chart_check 传 columns=[...] 更直接"])
     detected = list(columns or [])
     issues = []
     for req in tpl["required_columns"] or ():
@@ -1484,6 +1900,15 @@ def chart_render(name, source="", columns=None, x=1, y=2, output_dir="",
     throw away whatever project the user has open in Origin.
     """
     checked = chart_check(name, data=source) if not columns else chart_check(name, columns=columns)
+    if checked["issues"]:
+        # Drawing a preset over data that does not carry its columns produced a
+        # chart with the wrong axis labels and no hint anything was off.
+        raise OriginError("preset_columns_mismatch",
+                          "%s 预设的列对不上：%s（识别到的列：%s）"
+                          % (name, "；".join(checked["issues"]), checked["columns_detected"] or "无"),
+                          ["把数据列名改成预设要求的名字（见 required_columns）",
+                           "换一个匹配数据的预设：origin_chart_presets",
+                           "不套预设只是画图：用 origin_figure"])
     preset = chart_preset(name)
     kind = str(plot_type or preset.get("default_plot_kind") or "line").lower()
     if kind not in PLOT_CODES: