npm - lingshu-solver - Versions diffs - 1.0.9 → 1.0.11 - Mend

lingshu-solver 1.0.9 → 1.0.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md CHANGED Viewed

@@ -1,312 +1,109 @@
 # 灵数求解器 · Lingshu Solver
-[![License](https://img.shields.io/github/license/genesis-plan/lingshu-solver)](LICENSE)
-[![Stars](https://img.shields.io/github/stars/genesis-plan/lingshu-solver?style=social)](https://github.com/genesis-plan/lingshu-solver/stargazers)
-[![Last Commit](https://img.shields.io/github/last-commit/genesis-plan/lingshu-solver)](https://github.com/genesis-plan/lingshu-solver/commits)
-[![MCP](https://img.shields.io/badge/MCP-Streamable%20HTTP-blue)](https://modelcontextprotocol.io)
-[![Deterministic](https://img.shields.io/badge/core-deterministic%20%2F%20non--LLM-green)](https://genesis-plan.github.io/lingshu-solver/)
+[![License](https://img.shields.io/badge/license-非商业免费%20%2F%20商业须书面授权-blue)](LICENSE)
+[![MCP](https://img.shields.io/badge/MCP-Streamable%20HTTP%20%2B%20stdio-blue)](https://modelcontextprotocol.io)
+[![Deterministic](https://img.shields.io/badge/core-deterministic%20%2F%20non--LLM-green)](docs/03-设计思想.md)
+[![npm](https://img.shields.io/npm/v/lingshu-solver)](https://www.npmjs.com/package/lingshu-solver)
-> **确定性**实数方程组求解引擎 · 面向 AI 智能体与普通用户的 MCP 工具
-> 同样的题永远得到同样的答案，没有大模型的随机与幻觉，每个解都能回代验证。免费、网页打开即用、也能被 AI 智能体直接调用。
+> **确定性**实数方程组求解器 —— 同样的题永远得到同样的答案，不含大模型、无随机、无幻觉。
+> 每个找到的解都经 **Krawczyk 区间认证**（`certified: true`），可复现、可回代验证、可进审计链。
-灵数求解器（代号 Epsilon，V4.1）是一个**离线、确定性、零数据**的实数方程组求解器，
-覆盖 ≤6 个变量、实数解、轻量数值定位。它不要求用户提供初值，采用区间算术做保守收缩 +
-Krawczyk 算子做解认证，并尽力穷尽多解。
+**它给两种对象用**：普通用户（网页打开即用）与 AI Agent（标准 MCP 工具，一行接入）。
-👉 **给用户看的产品介绍（大白话，帮你看懂它能干嘛、适不适合你）**：[点这里](intro.html) ｜ [国内 COS 在线版](https://hclj-1409755229.cos.ap-guangzhou.myqcloud.com/lingshu-solver/intro.html)
+| | 说明 |
+|---|---|
+| **是** | 确定性（非大模型）的实数方程组**数值**求解引擎；代数方程与常见超越函数（`sin/cos/tan/log/exp/sqrt/abs`）均可 |
+| **不是** | 符号 CAS（不输出解析推导）、微分方程求解器、整数规划求解器，也不是"保证不漏解"的完备判定器 |
 ---
-## 🚀 快速上手（30 秒）
-### 如果你完全不懂技术 —— 直接用网页版
-**打开这个链接就能用，不用安装任何东西：**
-👉 **https://genesis-plan.github.io/lingshu-solver/** （GitHub Pages，海外/通用）
+## 30 秒上手
-**国内用户（更快，腾讯云 COS 托管）：**
-👉 **https://hclj-1409755229.cos.ap-guangzhou.myqcloud.com/lingshu-solver/index.html**
+**① 网页版（零安装，永久免费）**
-在输入框写方程（例如 `x^2 + y^2 = 25` 和 `x + y = 7`），点求解即可。
-页面里有 6 个示例按钮，点一下就知道它能解什么。
+- 主站：<https://hongchenlingjing.com/>
+- 备用镜像：<https://genesis-plan.github.io/lingshu-solver/> ｜ <https://hclj-1409755229.cos.ap-guangzhou.myqcloud.com/lingshu-solver/index.html>
-### 如果你是 AI 用户（Claude / Cursor / Cline 等）
+在输入框写方程（如 `x^2 + y^2 = 25` 与 `x + y = 7`），点求解。计算全部在浏览器内完成，方程不出设备。
-**方式 A · 远程托管（已上线，开箱即用）**
-常驻公网服务已开放，**HTTPS 端点：`https://hongchenlingjing.com/mcp`**（开机自启、崩溃自动拉起，任何支持 Streamable HTTP 的 MCP 客户端可直接连）。
+**② AI Agent 接入（MCP，两种形态任选）**
 ```json
-{
-  "mcpServers": {
-    "lingshu-solver": {
-      "type": "http",
-      "url": "https://hongchenlingjing.com/mcp"
-    }
-  }
-}
+// 本地 stdio —— 永久免费、不限次数、离线，推荐
+{ "mcpServers": { "lingshu-solver": { "command": "npx", "args": ["-y", "lingshu-solver"] } } }
 ```
-> **不付钱也能用。** 这个端点按次计费（**固定 ¥0.01 / 次**），但走「**信任制**」：`solve` 入参加
-> `"honorPaid": true`（声明本次为个人/评估用途）即**免费放行，不验证、不扣余额**。
-> 不想付费请直接用方式 B / 网页版（永久免费、不限次）；愿意支持就走
-> [付款页](https://hongchenlingjing.com/pay/)（对公账户，**付款后自助入账，立即生效**，无需任何人审核）。
-**方式 B · 本地 stdio（需本机 Node）**
 ```json
-{
-  "mcpServers": {
-    "lingshu-solver": {
-      "command": "npx",
-      "args": ["-y", "lingshu-solver"]
-    }
-  }
-}
+// 远程托管端点 —— 免安装、常驻、公网直连（固定 ¥0.01/次；传 honorPaid 即免费放行）
+{ "mcpServers": { "lingshu-solver": { "type": "http", "url": "https://hongchenlingjing.com/mcp" } } }
 ```
-> `npx` 版已发布到 npm，现在即可一键 `npx -y lingshu-solver`。如需最新源码也可 `git clone` 后用方式 C。
-**方式 C · 本地 clone + 指定路径**
-```bash
-git clone https://github.com/genesis-plan/lingshu-solver.git
-cd lingshu-solver
-node mcp-server.js
-```
-MCP 配置：
-```json
-{ "mcpServers": { "lingshu-solver": { "command": "node", "args": ["本地绝对路径/灵数求解器/mcp-server.js"] } } }
-```
+> **不想付费也照常用**：远程端点走**信任制** —— `solve` 入参加 `"honorPaid": true` 即免费放行（不验证、不扣余额）；
+> 本地 `npx` 版与网页版永久免费。愿意支持请看[付款页](https://hongchenlingjing.com/pay/)（对公账户，付款后自助入账、立即生效，无需任何人审核）。
+**③ 开发者**
-### 如果你是开发者
 ```bash
 git clone https://github.com/genesis-plan/lingshu-solver.git
 cd lingshu-solver
-node mcp-server.js        # 启动 MCP 服务端
-node test/regression.js   # 跑回归测试（28 用例）
+node mcp-server.js          # 启动本地 MCP（stdio）服务端
+node test/regression.js     # 常驻考卷回归
 ```
 ---
-本仓库包含：
-- `index.html` —— 单文件产品（浏览器内 UI + 已验证核心脚本 `<script id="solver-core">`）
-- `solver-core.js` —— Node 引擎加载器（读取 index.html 核心脚本，零依赖，供 MCP/测试复用）
-- `mcp-server.js` —— 零依赖 MCP stdio 服务端（手工 JSON-RPC 2.0 + 换行符分隔 JSON，与官方 MCP SDK 线格式对齐）
-- `package.json` —— 标准元数据，`node mcp-server.js` 本地启动即作为 MCP 工具（发布 npm 后亦可 `npx lingshu-solver`）
-- `test/` —— 回归套件 + 冒烟测试 + 三套常驻考卷
----
 ## 能力边界（诚实声明）
 | 维度 | 说明 |
 |---|---|
-| 已验证解 | 每个找到的解都经 Krawczyk 认证（`tier=proven`），误差 ≤ 认证半径，数学保真 |
-| 穷尽性 | **尽力穷尽多解**；极端病态（雅可比高度奇异、解簇极近）在预算内可能遗漏个别解，此时显式标记 `truncated=true`，**绝不谎称已穷尽** |
-| `truncated` 语义 | 仅表示「全局分支未在预算内完全判定所有盒子（无法证明已穷尽）」，**不等于一定遗漏**；绝大多数情况全部真解已找到 |
-| 变量数 | ≤6 |
-| 数值范围 | 默认搜索域 ±1e6；对快增长函数（exp/sinh）或大域，建议显式给定 `domain` 以避免剪枝失效 |
-| 确定性 | 无随机分支，同输入永远同输出 |
-| 部署 | 纯本地、离线、零数据（无网络、无存储、无第三方依赖） |
-**不保证**：对一切输入 100% 穷尽；对高度病态系统在预算内必收敛。这些是诚实边界，不是缺陷。
+| 已验证解 | 每个找到的解经 Krawczyk 认证（`tier=proven`），误差 ≤ 认证半径，数学保真 |
+| 穷尽性 | **尽力穷尽多解**；预算内未证明穷尽时显式标 `truncated=true`，**绝不谎称已完备** |
+| `truncated` 语义 | 仅表示「全局分支未在预算内完全判定」，**不等于一定漏解**；多数情况下全部真解已找到 |
+| 变量数 | ≤ 6 |
+| 方程数 | 1–64 条（服务端护栏），且须 ≥ 变量数 |
+| 数值范围 | 默认搜索域 ±1e6；对快增长函数（`exp/sinh`）建议显式给定 `domain` |
+| 输出精度 | 固定 6 位小数（不提供位数切换） |
+| 确定性 | 无随机分支，同输入永远同输出，可安全缓存 |
+| 数据 | 网页端零上行；本地版离线；托管端点不落盘方程内容 |
+| 依赖 | 零第三方依赖（只用 Node 内置模块与浏览器标准 API） |
+**不保证**：对一切输入 100% 穷尽；对高度病态系统在预算内必收敛。
+这是数值数学的诚实下界（'保证找到全部解'在一般情形下不可判定），不是待修缺陷。
 ---
-## 作为 MCP 工具使用
-### 1. 三种接入形态
-| 形态 | 端点 / 命令 | 适用 |
-|---|---|---|
-| **远程 HTTP（已上线）** | `https://hongchenlingjing.com/mcp`（常驻、HTTPS、崩溃自动拉起） | 任何支持 Streamable HTTP 的 MCP 客户端，零安装 |
-| 本地 stdio（npx） | `npx -y lingshu-solver` | 本机已装 Node，npm 已发布，直接可用 |
-| 本地 stdio（clone） | `node mcp-server.js` | 开发者 / 离线自托管 |
-**远程 HTTP 服务端代码**：`http-mcp-server.js`（零依赖，仅用 Node 内置模块；与 `mcp-server.js` 共享 `solver-core.js` 求解核心，结果同源一致）。如需自托管远程服务：
-```bash
-PORT=3000 node http-mcp-server.js
-```
-### 2. 计费（**仅限「托管远程端点」**）
-**本地 stdio（npx / clone）与网页版永久免费、无次数限制、离线不外传，且以后也不会收费。**
-只有**我们自托管的远程 HTTP 端点**按次收费 —— 买的是「免安装、常驻、公网可直连、带账单台账」这份运维，不是数学能力。
+## 文档
-| 项 | 值 |
+| 文档 | 内容 |
 |---|---|
-| 单价 | **固定 ¥0.01 / 次**（每次 `solve` 1 分钱）—— **不预充、无套餐、无其他档位、不设折扣** |
-| 计费时机 | **仅在成功产出求解结果时扣费** |
-| 不扣费 | 输入不合法、方程无法解析（响应里 `diagnostics.inputError` 非空）、内部错误、余额不足 |
-| **免费路径** | `solve` 传 `"honorPaid": true` → **免费放行**（不验证、不扣余额）。本服务按**信任制**运转：愿意支持的付费，不愿意的照常使用 |
-| 免费工具 | `initialize` / `tools/list` / `give_feedback` / 余额查询 / 价格查询 |
-| 凭证 | 请求头 `Authorization: Bearer <key>`（亦支持 `x-api-key` 或 `?key=<key>`） |
-| 注册账号 | **不需要**。凭证即身份（不设用户名、不设密码、不收邮箱手机号） |
-| 个人信息 | **不收集、不存储**。服务端只留凭证的 SHA-256 与订单/余额元数据；你提交的联系方式与自由文本一律被丢弃 |
-| 入账 | **付款后自助入账**：调 MCP `pay` 工具传 `{"orderId":"<订单号>","selfReportPaid":true}` → 立即入账、立即放行。**无需等待任何人工审核** |
-| 传输安全 | 接入请用 `https://hongchenlingjing.com/mcp`：Bearer 凭证走明文 HTTP 会在公网裸奔 |
-托管端点自带价格与下单接口（**域名为 `hongchenlingjing.com`**）：
-```bash
-curl  https://hongchenlingjing.com/pricing                                 # 价格表（无需凭证）
-curl -X POST https://hongchenlingjing.com/pay/order \
-      -H 'Content-Type: application/json' -d '{}'                          # 下单（每次恒为 1 次 = 1 分），响应给出 orderId 与 apiKey
-curl  https://hongchenlingjing.com/credit -H 'Authorization: Bearer <key>'  # 查余额（免费）
-```
-人工付款入口（对公账户 + 聚合码，**付款后自助入账，立即生效**）：<https://hongchenlingjing.com/pay/>
-**我们自己怎么核对营收**（诚实分栏，不把「凭声明的额度」当收入）：
-`/admin/ledger` 同时给出 `verifiedRevenueCents`（对公流水核对过的**真营收**）与 `selfReportedCents`
-（凭付款方声明的额度）；`/health` 给出 `selfReportClaims` 与 `honorClaims` 两个独立计数。
-**声明类额度不计入营收** —— 这一步是为了不虚报。
-> **自托管者不受此计费约束。** `http-mcp-server.js` 的计费默认**关闭**（`LS_METERING=off`），
-> 只有显式 `LS_METERING=on` 才启用 —— clone 出去自己跑，全免费，不会被我们收钱。
-> 相关环境变量：`LS_METERING` / `LS_PRICE_CENTS`（默认 1 分）/ `LS_ADMIN_TOKEN`（管理端点凭证，
-> **未设置时管理端点整体返回 503**，fail-closed，不存在「无凭证即可加钱」的口子）/
-> `LS_ADMIN_LOOPBACK_ONLY`（默认开：管理端点只接受本机回环，运维走 SSH 隧道，管理令牌绝不经公网）/
-> `LS_REQUIRE_TLS`（默认关；置 on 后携带凭证的调用必须是 HTTPS，否则拒绝并提示改用 HTTPS）/
-> `LS_PAY_TO`（收款方式，未配置时订单会明确标注「不可付款」）。
->
-> **到账走「对公收款」——对公静态收款 + 付款方自助入账，不接任何支付平台商户 API。**
-> 下单返回结构化付款意图（`payIntent` 块：订单号、对公码、备注、Agent 可机读步骤）；付款人向公司对公账户
-> （`LS_PAY_TO`，运行时与代码内钉死的广州市红尘灵境数字科技有限公司·工行户 `3602026809201658423` 比对）付款后，
-> **再调一次 `pay` 传 `{"orderId":"<订单号>","selfReportPaid":true}` 即立即入账、立即放行** ——
-> 全程**零人工**：收款方不需要跑任何对账脚本、不需要看任何流水。
-> 为什么敢不验证：同一道门的 `honorPaid:true` 本来就免费 ⇒ 「声明已付」不会造成额外损失，只是让诚实付款的人不必等。
-> 自助入账的单在账本里标注 `amountVerified:false` / `creditedBy:self_report`；真营收仍以对公流水核对为准
-> （可选跑 `reconcile-bank.js`，非必经流程）。
-> **收款账号防替换护栏**：`LS_PAY_TO` 被改成别的账号即 fail-closed 拒绝生成付款意图（防收款账号被换）；
-> 收款码链接被指向非银联官方址同样拒绝。
->
-> 凭证在服务端只存 **SHA-256**（不存明文）；每次扣费写入只增审计流水 `credits.json.ledger.jsonl`。
-### 3. 在 MCP 客户端（Claude Desktop / Cursor / Cline / VS Code 等）配置
-**推荐 · 本地 stdio 零安装（npm 已发布，现在即可用）：**
-```json
-{
-  "mcpServers": {
-    "lingshu-solver": {
-      "command": "npx",
-      "args": ["-y", "lingshu-solver"]
-    }
-  }
-}
-```
-> **远程 HTTP 端点（零安装，已上线）：**
-> ```json
-> { "mcpServers": { "lingshu-solver": { "type": "http", "url": "https://hongchenlingjing.com/mcp" } } }
-> ```
-> 该端点按次计费（固定 ¥0.01/次），但**不付费也能用**：`solve` 传 `"honorPaid": true` 即免费放行。
-> 愿意支持请见[付款页](https://hongchenlingjing.com/pay/)（付款后自助入账，立即生效）。
-**本地 stdio · 一行命令（npm 已发布，直接可用）：**
-```json
-{
-  "mcpServers": {
-    "lingshu-solver": {
-      "command": "npx",
-      "args": ["-y", "lingshu-solver"]
-    }
-  }
-}
-```
-> 注：`npx -y lingshu-solver` 已发布到 npm，直接可用。如需指定本地路径，用下方「手动指定本地路径」版（先 clone 仓库）。
-**备选 · 手动指定本地路径（已 clone 仓库时）：**
-```json
-{
-  "mcpServers": {
-    "lingshu-solver": {
-      "command": "node",
-      "args": ["把这里替换成你本地的绝对路径/灵数求解器/mcp-server.js"]
-    }
-  }
-}
-```
-> 手动版需将 `args` 中的路径替换为你本机的 `mcp-server.js` 绝对路径（例如 `C:/Users/你的用户名/Desktop/灵数求解器/mcp-server.js`）。npx 版无需此步。
-### 工具一：`solve`
-输入：
-```json
-{
-  "equations": ["x^2 + y^2 = 25", "x + y = 7"],
-  "variables": ["x", "y"],
-  "domain": { "x": [-30, 30], "y": [-30, 30] }
-}
-```
-- `equations`：方程字符串数组（必填），支持 `+ - * / ^ sqrt log sin cos tan exp abs`，以及 in-text 域约束 `"x ∈ [-30,30]"`。
-- `variables`：变量名数组（可选，不填则按出现顺序自动识别，最多 6 个）。
-- `domain`：显式搜索域（可选）。**对"有限解·部分"演示或快增长函数建议给定**，否则默认 ±1e6 可能剪枝失效并触发 `truncated`。
-> 输出精度固定 6 位小数（产品规格「6位小数有限网格」），不提供位数切换；解点 `values` 经网格吸附，实际残差通常 ≤ 1e-9。
-输出（节选）：
-```json
-{
-  "resultType": 2,
-  "resultTypeName": "finite",
-  "certified": true,
-  "truncated": false,
-  "precisionDecimals": 6,
-  "solutionCount": 2,
-  "summary": "找到 2 个实数解（全部经 Krawczyk 区间认证）。",
-  "recommended": { "values": [3, 4], "tier": "proven", "certified": true, "text": "x=3.000000, y=4.000000", "internals": { "residual": 0, "certifiedRadius": 0.00001 } },
-  "solutions": [ { "values": [3, 4], "tier": "proven", "certified": true, "text": "x=3.000000, y=4.000000", "internals": { "residual": 0, "certifiedRadius": 0.00001 } }, ... ],
-  "warnings": []
-}
-```
-- `resultType`：`1=empty(无解)` / `2=finite(有限解)` / `3=infinite(无限解集，仅给距原点最近的推荐解)`。
-- `summary`：中文一句话总览，适合直接展示给用户或日志。
-- 每解字段：`values`（6 位小数数值数组）、`tier`、`certified`、`text`（人类可读，如 `"x=3.000000, y=4.000000"`）；残差等内部数值收在 `internals` 子块，机器可整块跳过以降低 token 噪音。
-- `tier`：`proven`（Krawczyk 认证）/ `candidate`（未证但可能为解）/ `structural`（结构推导）。
-### 工具二：`give_feedback`
-AI 智能体遇到卡点/错误/疑似问题时主动回报，仅落本地 `feedback.log`，不外传：
-```json
-{ "name": "give_feedback", "arguments": { "message": "x^2=4 期望2解", "context": "批量求解场景" } }
-```
+| [01 · 产品作用](docs/01-产品作用.md) | 它是什么、解决什么问题、给谁用、能力与边界、对外口径 |
+| [02 · 使用指南](docs/02-使用指南.md) | 三种形态上手、MCP 工具契约（入参/出参/错误）、自托管部署、常见问题 |
+| [03 · 设计思想](docs/03-设计思想.md) | 六条设计原则、为什么可信、为什么不用大模型、有意不做的事 |
+| [04 · 技术参考](docs/04-技术参考.md) | 数学框架、算法流水线、49 个算子全表、规格硬约束、测试体系 |
+| [05 · 应用场景](docs/05-应用场景.md) | 七类可落地场景（Agent 后端 / 多 Agent / 链下计算 / 财税风控 / 私有化 / 教育 / 审计）与不适用场景 |
+| [06 · 商业授权与收费](docs/06-商业授权与收费.md) | 许可模型、免费范围、托管端点计费、企业年授权、发票与收款 |
+| [07 · 授权合同](docs/07-授权合同.md) | 商业授权合同模板、关键条款说明、签署流程 |
+| [08 · 版本管理](docs/08-版本管理.md) | 版本号语义、发布流程与一致性清单、兼容性承诺、版本历史 |
+| [09 · 项目历史](docs/09-项目历史.md) | 从起因到当前的阶段沿革与定位 |
+> 隐私与安全承诺另见：[privacy.html](privacy.html)（对外页面）。
 ---
-## 本地验证
+## 许可（摘要）
-```bash
-node verify_core.js                    # 引擎加载 + 6 个代表性用例
-node test/regression.js                # 三套常驻考卷回归（28 用例，known 命中率统计）
-node test/verify_paste.js              # 粘贴容错专项（7 例）
-node test/verify_issueA.js             # 周期/高频单变量多解专项（15 例）
-node test/verify_compliance.js         # 输入门禁专项（20 例）
-```
----
+**非商业免费 + 商业须书面授权**（自有《灵数求解器商业授权许可协议》，非开源协议）：
-## 示例（6 类结果覆盖）
+- **非商业用途免费**：个人学习/研究/教学/评测；非营利组织与教育机构内部使用；年营收 ≤ 100 万元的团队内部评估（≤ 3 实例）。
+- **商业用途须事先取得书面授权**：任何以营利为目的的产品/服务/业务、SaaS/云/API 转售、集成嵌入、再分发托管，均须取得《商业授权协议》。
+- **版本适用**：`1.0.4` 起适用本协议；`1.0.3` 及更早版本按其发布时的 Apache License 2.0 提供（历史事实，不可撤回，但不延伸至新版本）。
-| 标题 | 方程 | 预期 |
-|---|---|---|
-| 最少 1 变量 | `x^2 = 4` | 2 解 |
-| 最多 6 变量 | 6 元三对角线性 | 唯一解 |
-| 空集无解 | `x+y=3` 与 `x+y=5` | 空集（sound 证无解） |
-| 有限解·全部 | 圆 × 双曲线 `x²+y²=4, xy=1` | 4 解全认证 |
-| 有限解·部分 | `sin(20x)=0.5, sin(20y)=0.5`（域 [-30,30]） | 多解 + `truncated` 横幅 |
-| 无限解·推荐 | `x+y=3` | 无限集，推荐 (1.5,1.5) |
+完整条款见 [LICENSE](LICENSE) ｜ 授权范围与报价见 [06 · 商业授权与收费](docs/06-商业授权与收费.md) ｜ 合同见 [07 · 授权合同](docs/07-授权合同.md)
 ---
-## 文档
-- [docs/ARCHITECTURE.md](./docs/ARCHITECTURE.md) —— 产品现状：数学框架 / 结构框架 / 代码框架 / 算法框架 / 处理流程（忠实于真实实现）
-- [CHANGELOG.md](./CHANGELOG.md) —— 能力、边界与修复记录
-- 发明专利申请书系列（已提交）
-## 许可
-**非商业免费 + 商业须书面授权**（自有《灵数求解器商业授权许可协议》，非开源协议）：
-- **非商业用途免费**：个人学习/研究/教学/评测，非营利组织与教育机构内部使用，小团队（年营收 ≤100 万元）内部评估（≤3 实例）。
-- **商业用途须事先取得书面授权**：任何以营利为目的的产品/服务/业务、SaaS/云/API 转售、集成嵌入、再分发托管，均须联系版权方（553420544@qq.com）取得《商业授权协议》。
-- **版本适用**：1.0.4 起适用本协议；1.0.3 及更早版本按其发布时的 Apache License 2.0 提供（历史事实，不可撤回，但不延伸至新版本）。
+## 联系
-完整条款见 [LICENSE](./LICENSE)。
+- 商务 / 授权 / 反馈：553420544@qq.com（亦可用仓库 Issues）
+- 版权方：广州市红尘灵境数字科技有限公司
+- 备案：粤ICP备2026031206号-3 ｜ 粤公网安备44011402001444号

package/http-mcp-server.js CHANGED Viewed

@@ -19,7 +19,7 @@
  *   - 开关：LS_METERING=on 才启用（默认 off —— 自建部署者不被强行收费，
  *           开源工具保持诚实；我们自己的托管端点用 systemd Environment 打开）
  *   - 单价：LS_PRICE_CENTS，默认 1（分）
- *   - 凭证：Authorization: Bearer <key>，或 ?key=<key>（x-api-key 亦可）
+ *   - 凭证：Authorization: Bearer <key>（或 x-api-key 请求头）
  *   - 账本：credits.json（0600，原子写）+ credits.json.ledger.jsonl（只增审计流水）
  *   - 只在「成功返回结果」时扣费：输入不合法 / 内部异常 / 余额不足 一律不扣
  *   - 免计费：initialize / tools/list / give_feedback / GET /credit / GET /pricing；
@@ -47,7 +47,7 @@ const solverCore = require('./solver-core');
 const { solve } = solverCore;
 const SERVER_NAME = 'lingshu-solver';
-const SERVER_VERSION = '1.0.8';
+const SERVER_VERSION = '1.0.11';
 const PORT = parseInt(process.env.PORT || '3000', 10);
 // ---- 护栏常量（防畸形/恶意输入耗尽资源，与 stdio 版一致）----
@@ -177,7 +177,6 @@ function guardProblems() {
 }
 const GUARD_PROBLEMS = guardProblems();
 const RECEIPT_TAMPERED = GUARD_PROBLEMS.length > 0;  // 收款去向被换 → 硬失败（fail-closed）
-const RECEIPT_QR_WARN = false;                       // 码址问题已并入上面的硬判定
 function receiptPinHash() {
   return crypto.createHash('sha256').update(PINNED_ACCOUNT + '|' + PINNED_ACCOUNT_NAME + '|' + PINNED_QR_URL, 'utf8').digest('hex');
 }
@@ -200,7 +199,6 @@ const ORDER_WINDOW_MS = 60 * 60 * 1000;
 const ORDER_RATE_MAX = parseInt(process.env.LS_ORDER_RATE_MAX || '10', 10);
 // 按次计费：固定 1 分钱/次（¥0.01/call）。对公收款：下单 = 1 次 = 1 分钱的付费凭证，
 // 不预充、无套餐、无其他金额；付款人向对公聚合码付任意正金额，按实收折算 N' = 实收/¥0.01 次入账（多付多得）。
-const PER_CALL_CENTS = PRICE_CENTS; // 恒为 1
 const ORDER_TTL_DAYS = 365;
 let ledger = { version: 1, priceCents: PRICE_CENTS, createdAt: new Date().toISOString(), keys: {}, orders: {} };
@@ -313,8 +311,7 @@ function extractKey(req, query) {
   if (m) return m[1].trim();
   const xa = (req.headers['x-api-key'] || '').toString().trim();
   if (xa) return xa;
-  const q = query ? (query.get('key') || '').trim() : '';
-  if (q) return q;
+  // 凭证不再走 URL 查询串：?key= 会被反代写进访问日志（泄露即可盗刷余额）
   return null;
 }
@@ -398,23 +395,23 @@ function paymentInfo(orderId, amountCents) {
     payToName: PINNED_ACCOUNT_NAME,
     payToQr: PAY_TO_QR || null,        // 已由上方护栏保证：非钉死码址一律 fail-closed，走到这里必是可信码
     receiptVerified: true,           // 账号已与钉死值比对一致，客户端可据此信任
-    qrTampered: RECEIPT_QR_WARN || undefined,
     rateNote: '本服务按次计费 ' + yuan(PRICE_CENTS) + '/次。对公静态收款不强制每笔恰收 1 分（银行也不支持 1 分转账），' +
       '实际可付任意「自愿支持额」，我们将按 ' + yuan(PRICE_CENTS) + '/次 折算调用次数入账（收到 ' + yuan(500) + ' 即入账 500 次）。',
     instructions: [
-      '1. POST /pay/order 创建订单，响应给出订单号（形如 LS-YYYYMMDD-xxxxxx）与专属 key（key 只出现这一次，请立即保存）',
-      '2. 向对公账户（payTo / payToQr）转账任意支持额，务必在付款备注中填写订单号',
-      '3. 作者拿对公流水跑 reconcile-bank.js，按「订单号 + 金额」批量入账（按 ' + yuan(PRICE_CENTS) + '/次 折算），通常数日内到账；期间可先用 honorPaid:true 免费调用',
-      '4. 之后每次调用带上 Authorization: Bearer <key> 即可'
+      '1. POST /pay/order 创建订单，响应给出订单号（形如 LS-YYYYMMDD-xxxxxx）、专属 key（key 只出现这一次，请立即保存）与 payUrl',
+      '2. 打开 payUrl 让付款人扫码（微信 / 支付宝 / 银联均可），或向对公账户转账；付款备注**建议**填写订单号（不填也能付款与入账，只是无法自动对应到订单）',
+      '3. ★ 付款完成后**自助入账、立即生效、零人工**：调 MCP pay 工具，入参 {"orderId":"<订单号>","selfReportPaid":true} → 按订单面值入账（' + yuan(PRICE_CENTS) + '/次），**不需要等任何人确认、不需要发邮件**',
+      '4. 之后每次调用带上 Authorization: Bearer <key> 即可',
+      '5. 不想付款也行：任一 solve 传 honorPaid:true 即免费放行 —— 本服务不做强制收费'
     ]
   };
-  // 带订单号的直达付款链接：只有付款页拿到有效订单号才会展示收款码
+  // 带订单号的直达付款链接：付款页打开即展示收款码（未带订单号也照样出码，带订单号只是为了能自动对应）
   if (PAY_PAGE && orderId) {
     info.payUrl = PAY_PAGE +
       (PAY_PAGE.indexOf('?') >= 0 ? '&' : '?') +
       'order=' + encodeURIComponent(orderId) +
       (amountCents > 0 ? '&amount=' + amountCents : '');
-    info.payUrlNotice = '打开此链接按提示付款；付款备注必须填写订单号 ' + orderId + '。';
+    info.payUrlNotice = '打开此链接即可扫码付款。付款备注建议填写订单号 ' + orderId + '（不填也能入账，只是无法自动对应）。';
   }
   return info;
 }
@@ -442,6 +439,7 @@ function payIntent(orderId, calls, amountCents) {
   return {
     protocol: PAY_INTENT_PROTOCOL,
     orderId: orderId,
+    payUrl: info.payUrl || null,        // 带订单号的付款页：Agent 优先把这个给付款人（打开即出收款码）
     payTo: info.payTo || null,
     payToQr: info.payToQr || null,
     ratePerCallCents: PRICE_CENTS,
@@ -451,9 +449,9 @@ function payIntent(orderId, calls, amountCents) {
     suggestedAmountDisplay: yuan(amountCents),
     memo: orderId,                // 付款备注建议含订单号，便于需要时与银行流水交叉核对
     agentSteps: [
-      '1. 向钱包持有者展示 payToQr（或 payTo 账户信息）。',
-      '2. 请持有者向该对公聚合码转账（建议 ' + yuan(amountCents) + '）；备注建议含订单号 ' + orderId + '。',
-      '3. 持有者付款完成后：用 orderId 调 MCP pay 工具，入参 {"orderId":"' + orderId + '","selfReportPaid":true} → **立即入账、立即放行**（服务端不验证，信任制）。',
+      '1. 把 payUrl（若存在）展示给付款人 —— 那是带订单号的付款页，打开即显示收款码；无 payUrl 时展示 payTo 账户信息。',
+      '2. 请付款人扫码或转账（本单面值 ' + yuan(amountCents) + '）；备注建议含订单号 ' + orderId + '（不填也能入账，只是无法自动对应）。',
+      '3. 付款完成后：用 orderId 调 MCP pay 工具，入参 {"orderId":"' + orderId + '","selfReportPaid":true} → **立即入账、立即放行**（服务端不验证，信任制）。不需要等任何人、不需要发邮件。',
       '4. 入账后用 apiKey 调 solve 即不再走信任制：Authorization: Bearer <key>。',
       '5. 若不便付款或缺凭证：直接用 honorPaid:true 免费调用，效果相同（本服务不做强制验证）。'
     ],
@@ -462,15 +460,6 @@ function payIntent(orderId, calls, amountCents) {
   };
 }
-/**
- * 组装付款信息（对公收款）。
- * 只有「对公静态收款」一种通道，不接任何支付平台商户 API——无回调、无异步、无平台依赖。
- * 保留回调式签名（cb）仅为兼容 createOrder 的调用点；内部直接同步返回 paymentInfo。
- */
-function buildPayment(req, pref, orderId, amountCents, calls, cb) {
-  return cb({ payment: paymentInfo(orderId, amountCents) });
-}
 function paywallError(reason, ctx) {
   const k = (ctx && ctx.keyHash) ? ledger.keys[ctx.keyHash] : null;
   const msgMap = {
@@ -482,7 +471,7 @@ function paywallError(reason, ctx) {
   };
   const extra = (reason === 'insecure_transport')
     ? { secureEndpointHint: '请把客户端里的端点从 http://... 换成 https://<你的域名>/mcp（X-Forwarded-Proto 必须是 https）。' }
-    : { authHeader: 'Authorization: Bearer <key>（亦支持 x-api-key 或 ?key=<key>）' };
+    : { authHeader: 'Authorization: Bearer <key>（亦支持 x-api-key 请求头）' };
   // 付款入口必须直达：调用方撞到「余额不足」时，不应还得再问一次「那我去哪付」。
   // 只列已配置的收款方式；未配置就明说，绝不给出死链。
@@ -496,7 +485,7 @@ function paywallError(reason, ctx) {
       '3. ★ 付款完成后自助入账：调 MCP pay 工具，入参 {"orderId":"<订单号>","selfReportPaid":true} → 立即入账、立即放行（零人工，不用等任何人）',
       '4. 之后带 Authorization: Bearer <key> 调用即可（不再走信任制，也不再需要 honorPaid）',
       '5. 说明：自助入账不做验证（信任制）；账本会标注 amountVerified:false，真营收仍以银行流水核对为准',
-      '6. 对公来款若无法对应到任何订单/无法核对的，一律原路退回（资金处理承诺）'
+      '6. 对公来款若无法对应到任何订单：不会被自动折算成额度；需要核对 / 开票 / 退回，请邮件联系（联系方式见 paymentPage）'
     ];
   } else {
     pay.adminTodo = '服务端未配置 LS_PAY_TO：订单可创建但无法付款，请先在服务端配置收款方式。';
@@ -623,7 +612,7 @@ function readBody(req, cb) {
   req.on('data', (c) => {
     n += c.length;
     // 超限必须立刻回调，否则 req.destroy() 后 'end' 不再触发 → 响应永不返回（客户端挂死）
-    if (n > 64 * 1024) { try { req.destroy(); } catch (_e) {} return finish({ err: 'body_too_large' }); }
+    if (n > MAX_BODY_BYTES) { try { req.destroy(); } catch (_e) {} return finish({ err: 'body_too_large' }); }
     raw += c;
   });
   req.on('end', () => {
@@ -659,7 +648,7 @@ function pricingDoc(req) {
     },
     model: '按次付费：每次 solve 固定收费 ' + PRICE_CENTS + ' 分钱（' + yuan(PRICE_CENTS) + '），不预充、无其他金额、无其他档位。',
     freeTools: ['initialize', 'tools/list', 'give_feedback', 'GET /credit', 'GET /pricing'],
-    auth: 'Authorization: Bearer <key>（亦支持 x-api-key 或 ?key=<key>）',
+    auth: 'Authorization: Bearer <key>（亦支持 x-api-key 请求头）',
     howToBuy: [
       'POST ' + base + '/pay/order   （每次一笔 1 分钱订单；body 不支持 calls/plan 预购，下单恒为 1 次）',
       '响应给出 orderId 与 apiKey（apiKey 只出现一次，请立即保存）',
@@ -668,6 +657,12 @@ function pricingDoc(req) {
       'GET  ' + base + '/pay/order?orderId=<id>  查询订单状态',
       'GET  ' + base + '/credit  携带 key 查询余额（免费）'
     ],
+    legal: {
+      positioning: '本服务定性为「软件授权 / 技术服务」的计算工具，非经营性互联网信息服务。',
+      privacy: 'https://hclj-1409755229.cos.ap-guangzhou.myqcloud.com/lingshu-solver/privacy.html',
+      terms: 'https://hclj-1409755229.cos.ap-guangzhou.myqcloud.com/lingshu-solver/terms.html',
+      pricing: 'https://hclj-1409755229.cos.ap-guangzhou.myqcloud.com/lingshu-solver/pricing.html'
+    },
     payment: paymentInfo(),
     paymentChannels: availableChannels(),
     creditModes: {
@@ -1060,7 +1055,7 @@ function handleRpc(msg, ip, ctx) {
             apiKeyNotice: '此 key 仅在本响应出现一次，请立即保存；付款后凭它调用 solve 即不再走信任制。',
             amountCents: o.amountCents,
             amountDisplay: yuan(o.amountCents),
-            payable: !!(o.payment && (o.payment.configured || o.payment.payUrl || o.payment.codeUrl || o.payment.mode === 'auto')),
+            payable: !!(o.payment && (o.payment.configured || o.payment.payUrl)),
             payment: o.payment,
             // ⭐ 零人工闭环：付款完再调一次 pay 传 orderId + selfReportPaid:true 即立即入账。
             // 这样收款方（作者）不需要跑任何对账脚本、不需要看任何流水。
@@ -1330,7 +1325,7 @@ const server = http.createServer((req, res) => {
       return sendJson(res, 200, { metering: 'off', note: '本端点未启用计费，调用免费。', freeAlternatives: freeAlternatives() });
     }
     if (!ctx.key) {
-      return sendJson(res, 401, { error: { type: 'missing_key', message: '缺少凭证：请带 Authorization: Bearer <key> 或 ?key=<key>。', howToGetKey: paywallError('missing_key', ctx).howToGetKey } });
+      return sendJson(res, 401, { error: { type: 'missing_key', message: '缺少凭证：请带 Authorization: Bearer <key> 请求头。', howToGetKey: paywallError('missing_key', ctx).howToGetKey } });
     }
     const k = ledger.keys[ctx.keyHash];
     if (!k) {
@@ -1374,7 +1369,7 @@ const server = http.createServer((req, res) => {
         amountDisplay: yuan(r.amountCents),
         priceCentsPerCall: PRICE_CENTS,
         status: 'pending',
-        payable: !!(payment && (payment.configured || payment.payUrl || payment.codeUrl || payment.mode === 'auto')),
+        payable: !!(payment && (payment.configured || payment.payUrl)),
         payment: payment,
         paymentChannels: availableChannels(),
         payIntent: payIntent(orderId, r.calls, r.amountCents),

package/index.html CHANGED Viewed

@@ -2709,6 +2709,57 @@ function gaussianSolve(A, b) {
     return { solution: x, rank: rank };
 }
+// 秩感知矩形高斯消元（过定/欠定线性系统通用）：sound 判定一致性与解数
+// 返回 { consistent, unique, solution }；consistent=false 表示无公共实解（已严格证明）；
+// unique=false 表示欠定（无穷多解），solution 为一组特解（自由变量取 0）。
+function gaussianSolveRect(A, b) {
+    const m = A.length;
+    if (m === 0) return null;
+    const n = A[0].length;
+    const EPS = 1e-9;
+    // 构造增广矩阵 [A | b]
+    const aug = A.map((row, i) => row.slice().concat([b[i]]));
+    let rank = 0;
+    const pivCol = [];
+    for (let col = 0; col < n; col++) {
+        // 部分选主元（在已确定秩以下的行中找最大绝对值）
+        let sel = -1, maxVal = EPS;
+        for (let r = rank; r < m; r++) {
+            if (Math.abs(aug[r][col]) > maxVal) { maxVal = Math.abs(aug[r][col]); sel = r; }
+        }
+        if (sel === -1) continue;            // 本列在余下行全为 0，跳过
+        if (sel !== rank) { const t = aug[rank]; aug[rank] = aug[sel]; aug[sel] = t; }
+        const pv = aug[rank][col];
+        // 消去其他所有行（含上方），使本列仅 pivot 行非零 → 直达行最简形
+        for (let r = 0; r < m; r++) {
+            if (r === rank) continue;
+            const f = aug[r][col] / pv;
+            if (Math.abs(f) < EPS) continue;
+            for (let c = col; c <= n; c++) aug[r][c] -= f * aug[rank][c];
+        }
+        pivCol.push(col);
+        rank++;
+    }
+    // 一致性：存在"A 全零但 b 非零"的行 → 不相容（无公共实解）
+    for (let r = 0; r < m; r++) {
+        let allZero = true;
+        for (let c = 0; c < n; c++) { if (Math.abs(aug[r][c]) > EPS) { allZero = false; break; } }
+        if (allZero && Math.abs(aug[r][n]) > 1e-7) return { consistent: false };
+    }
+    // 构造特解（自由变量取 0）
+    const x = new Array(n).fill(0);
+    for (let r = 0; r < rank; r++) {
+        const pc = pivCol[r];
+        const coeff = aug[r][pc];
+        if (Math.abs(coeff) < EPS) continue;
+        x[pc] = aug[r][n] / coeff;
+    }
+    if (rank < n) {
+        return { consistent: true, unique: false, solution: x };   // 欠定：无穷多解
+    }
+    return { consistent: true, unique: true, solution: x };        // 满列秩：唯一解
+}
 function extractVarCoefficient(node, varName) {
     if (!hasVariable(node, [varName])) {
         return { coeff: { type: 'num', value: 0 }, rest: node };
@@ -4689,7 +4740,13 @@ function suan7(state) {
             // 跳过已从前提取过值的方程，避免浮点噪声误判
             if (unknownVars.length === 0) {
                 if (!resolvedEqs[ei]) {
-                    var val = evalAST(eq, known);
+                    // 用网格精度求值：known 经前向传播/二分可能带 ~1e-10 浮点噪声，
+                    // 若直接用 1e-12 阈值会把这个噪声误判为"矛盾"（unsound，丢真解）。
+                    // 网格精度与求解器输出精度一致，是 sound 的判定基准：真矛盾残差在
+                    // 网格尺度下仍远大于 0，数值噪声在网格下归零。
+                    var _knownGrid = {};
+                    for (var _kk in known) _knownGrid[_kk] = roundToGrid(known[_kk]);
+                    var val = evalAST(eq, _knownGrid);
                     if (isFinite(val) && Math.abs(val) > 1e-12) {
                         state.done = true;
                         var msg = "前向传播检测到矛盾：代入已知值后方程不成立（残差=" + val.toExponential(2) + "）";
@@ -5285,7 +5342,9 @@ function suan16(state) {
 // suan17: 线性方程组高斯消元 → 全线性系统直接求解
 function suan17(state) {
     if (!state.eqFeatures.allLinear) return;
-    if (state.equations.length !== state.varNames.length) return;
+    // 放开过定(m>n)与欠定(m<n)的"全线性"统一处理；仅当方程数 < 变量数 时此处不强行处理
+    // （交其他路径），以最小化改动面并保留既有欠定逻辑。
+    if (state.equations.length < state.varNames.length) return;
     var A = [], b = [];
     for (var ei = 0; ei < state.equations.length; ei++) {
@@ -5294,9 +5353,45 @@ function suan17(state) {
         b.push(-lc.constant);
     }
-    var result = gaussianSolve(A, b);
+    var result = (state.equations.length === state.varNames.length)
+        ? gaussianSolve(A, b)                  // 方阵：原 sound 路径
+        : gaussianSolveRect(A, b);             // 过定：秩感知判定（sound）
     if (!result) return;
+    // 过定且不相容 → sound 地报"无实数解"（绝非"漏解"）
+    if (result.consistent === false) {
+        state.done = true;
+        state.result = {
+            solutions: [], error: "NO_SOLUTION", provenEmpty: true,
+            message: "过定线性方程组不相容：经高斯消元 + 秩判定严格确认无实数公共解",
+            executionPath: "高斯消元(秩判定)",
+            timeMs: performance.now() - state.startTime,
+            confidence: "high", varNames: state.varNames,
+            resultType: 1, resultTypeName: "空结果", resultTypeDesc: "过定系统秩判定无实解"
+        };
+        return;
+    }
+    // 欠定(秩 < 变量数，尽管 m>=n 但方程线性相关) → 无穷多解，给一组特解
+    if (result.unique === false) {
+        var pSol = {};
+        state.varNames.forEach(function(v, i) { pSol[v] = roundToGrid(result.solution[i]); });
+        var pVals = state.varNames.map(function(v) { return pSol[v]; });
+        var pVars = {};
+        state.varNames.forEach(function(v, i) { pVars[v] = pSol[v]; });
+        var pRes = state.equations.map(function(eq) { return Math.abs(evalAST(eq, pVars)); });
+        var pMax = Math.max.apply(null, pRes);
+        state.done = true;
+        state.result = {
+            solutions: [{ values: pVals, residual: pMax }],
+            message: "线性方程组无穷多解（秩 < 变量数，方程线性相关）：给出一组特解（自由变量取 0），任意线性组合均满足",
+            executionPath: "高斯消元(秩判定)",
+            timeMs: performance.now() - state.startTime,
+            confidence: "high", varNames: state.varNames,
+            resultType: 3, resultTypeName: "无限解集(推荐解)", resultTypeDesc: "欠定线性系统，无穷多实解"
+        };
+        return;
+    }
     var solution = {};
     state.varNames.forEach(function(v, i) { solution[v] = roundToGrid(result.solution[i]); });
     var values = state.varNames.map(function(v) { return solution[v]; });
@@ -11097,7 +11192,7 @@ function _runTail(state) {
 // —— 可审计结构化溯源（切片A）：每个结果附带完整证据链元数据 ——
 // 设计目标：Agent / 上层系统拿到的不只是裸数字，而是"为什么是这个解"的可读证据链。
-var SOLVER_VERSION = "lingshu-solver/1.0.8-auditable";
+var SOLVER_VERSION = "lingshu-solver/1.0.11-auditable";
 // Movability 完整读取（切片B）：每变量携带 status + width，供 Agent 读懂"为何是这个解"
 function _movabilityFull(state) {

package/mcp-server.js CHANGED Viewed

@@ -19,7 +19,7 @@ const path = require('path');
 const { solve } = require('./solver-core');
 const SERVER_NAME = 'lingshu-solver';
-const SERVER_VERSION = '4.1.0';
+const SERVER_VERSION = '1.0.11';
 // ---- 护栏常量（防畸形/恶意输入耗尽资源）----
 const MAX_TOTAL_CHARS = 100 * 1024;   // 单次请求方程文本总长上限 100KB

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "lingshu-solver",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "灵数求解器 · 确定性实数方程组求解 MCP 工具（≤6变量）：区间收缩 + Krawczyk 认证，离线零依赖零数据，诚实标记 truncated。本地 stdio 永久免费；另有常驻托管端点 https://hongchenlingjing.com/mcp（按次 ¥0.01/次，支持 honorPaid 免费放行）。",
   "homepage": "https://genesis-plan.github.io/lingshu-solver/",
   "repository": {

package/solver-core.js CHANGED Viewed

@@ -1,117 +1,116 @@
-/**
- * 灵数求解器 · 引擎加载器（零依赖）
- *
- * 单一事实来源：桌面真源 index.html 里的 <script id="solver-core">。
- * 本文件不重写任何求解逻辑——它把那段已验证的脚本在 vm 沙箱里实跑，
- * 取出其中的 solve() 暴露给 Node / MCP 服务端复用，从而保证
- * 「浏览器内 UI」与「MCP 服务端」调用的是同一份核心代码（同源、零分叉、零新 bug）。
- *
- * 用法：
- *   const { solve } = require('./solver-core');
- *   const r = solve(['x^2 = 4'], [], 6);
- */
-'use strict';
-const fs = require('fs');
-const vm = require('vm');
-const path = require('path');
-const { performance } = require('perf_hooks');
-/**
- * 递归 no-op 桩：任意属性访问 / 调用 / 赋值都安全。
- * 用于顶层的 document / window 等浏览器对象，避免 UI 初始化代码在 Node 下崩溃。
- */
-function makeNoop() {
-  const fn = function () { return p; };
-  const p = new Proxy(fn, {
-    get(_t, prop) {
-      if (prop === 'value' || prop === 'textContent' || prop === 'innerHTML') return '';
-      if (prop === 'style' || prop === 'classList') return {};
-      if (prop === Symbol.toPrimitive) return function () { return ''; };
-      if (prop === 'length') return 0;
-      return p;
-    },
-    set() { return true; },
-    apply() { return p; },
-    construct() { return p; }
-  });
-  return p;
-}
-function resolveHtmlPath() {
-  if (process.env.LINGSHU_HTML && fs.existsSync(process.env.LINGSHU_HTML)) {
-    return process.env.LINGSHU_HTML;
-  }
-  const candidates = [
-    path.resolve(__dirname, 'index.html'),
-    path.resolve(__dirname, '..', 'index.html'),
-    'C:/Users/Administrator/Desktop/灵数求解器/index.html'
-  ];
-  for (const c of candidates) {
-    if (fs.existsSync(c)) return c;
-  }
-  throw new Error('灵数求解器 index.html 未找到；请设置环境变量 LINGSHU_HTML 指向它。');
-}
-let _sandbox = null;
-function loadSandbox() {
-  const htmlPath = resolveHtmlPath();
-  const html = fs.readFileSync(htmlPath, 'utf8');
-  const m = html.match(/<script id="solver-core">([\s\S]*?)<\/script>/);
-  if (!m) throw new Error('未在 index.html 中找到 <script id="solver-core">。');
-  const code = m[1];
-  const sandbox = {};
-  const noop = makeNoop();
-  // 让 window/self/globalThis 都指向 sandbox 自身，
-  // 这样顶层 function solve(){} 与 window.xxx= 赋值都落到 sandbox，可被取到。
-  sandbox.window = sandbox;
-  sandbox.self = sandbox;
-  sandbox.globalThis = sandbox;
-  // 浏览器对象桩
-  sandbox.document = noop;
-  sandbox.navigator = { serviceWorker: null, userAgent: 'node-lingshu' };
-  sandbox.localStorage = {
-    _d: {},
-    getItem(k) { return this._d[k] != null ? this._d[k] : null; },
-    setItem(k, v) { this._d[k] = String(v); },
-    removeItem(k) { delete this._d[k]; }
-  };
-  sandbox.location = { href: 'file://' + htmlPath };
-  sandbox.performance = performance;
-  sandbox.console = console;
-  sandbox.setTimeout = setTimeout;
-  sandbox.clearTimeout = clearTimeout;
-  sandbox.addEventListener = function () {};
-  sandbox.removeEventListener = function () {};
-  sandbox.requestAnimationFrame = function (cb) { return setTimeout(cb, 0); };
-  sandbox.cancelAnimationFrame = function () {};
-  vm.createContext(sandbox);
-  // 实跑整段核心脚本（顶层 UI 初始化靠 noop 桩安全通过）
-  vm.runInContext(code, sandbox, { filename: 'solver-core.js' });
-  if (typeof sandbox.solve !== 'function') {
-    throw new Error('核心脚本中未找到 solve() 函数；可能 index.html 结构已变更。');
-  }
-  return sandbox;
-}
-function getSandbox() {
-  if (!_sandbox) _sandbox = loadSandbox();
-  return _sandbox;
-}
-module.exports = {
-  /** @returns {Function} 求解入口 solve(equationStrs, varNames, decimals, initialD0, fastMode, opts) */
-  solve: function () {
-    const sb = getSandbox();
-    return sb.solve.apply(sb, arguments);
-  },
-  /** 取原始沙箱（高级用法：访问 EXAMPLES 等） */
-  raw: function () { return getSandbox(); },
-  /** 仅用于测试：重置缓存，强制重新加载 */
-  _reset: function () { _sandbox = null; }
-};
+/**
+ * 灵数求解器 · 引擎加载器（零依赖）
+ *
+ * 单一事实来源：桌面真源 index.html 里的 <script id="solver-core">。
+ * 本文件不重写任何求解逻辑——它把那段已验证的脚本在 vm 沙箱里实跑，
+ * 取出其中的 solve() 暴露给 Node / MCP 服务端复用，从而保证
+ * 「浏览器内 UI」与「MCP 服务端」调用的是同一份核心代码（同源、零分叉、零新 bug）。
+ *
+ * 用法：
+ *   const { solve } = require('./solver-core');
+ *   const r = solve(['x^2 = 4'], [], 6);
+ */
+'use strict';
+const fs = require('fs');
+const vm = require('vm');
+const path = require('path');
+const { performance } = require('perf_hooks');
+/**
+ * 递归 no-op 桩：任意属性访问 / 调用 / 赋值都安全。
+ * 用于顶层的 document / window 等浏览器对象，避免 UI 初始化代码在 Node 下崩溃。
+ */
+function makeNoop() {
+  const fn = function () { return p; };
+  const p = new Proxy(fn, {
+    get(_t, prop) {
+      if (prop === 'value' || prop === 'textContent' || prop === 'innerHTML') return '';
+      if (prop === 'style' || prop === 'classList') return {};
+      if (prop === Symbol.toPrimitive) return function () { return ''; };
+      if (prop === 'length') return 0;
+      return p;
+    },
+    set() { return true; },
+    apply() { return p; },
+    construct() { return p; }
+  });
+  return p;
+}
+function resolveHtmlPath() {
+  if (process.env.LINGSHU_HTML && fs.existsSync(process.env.LINGSHU_HTML)) {
+    return process.env.LINGSHU_HTML;
+  }
+  const candidates = [
+    path.resolve(__dirname, 'index.html'),
+    path.resolve(__dirname, '..', 'index.html')
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  throw new Error('灵数求解器 index.html 未找到；请设置环境变量 LINGSHU_HTML 指向它。');
+}
+let _sandbox = null;
+function loadSandbox() {
+  const htmlPath = resolveHtmlPath();
+  const html = fs.readFileSync(htmlPath, 'utf8');
+  const m = html.match(/<script id="solver-core">([\s\S]*?)<\/script>/);
+  if (!m) throw new Error('未在 index.html 中找到 <script id="solver-core">。');
+  const code = m[1];
+  const sandbox = {};
+  const noop = makeNoop();
+  // 让 window/self/globalThis 都指向 sandbox 自身，
+  // 这样顶层 function solve(){} 与 window.xxx= 赋值都落到 sandbox，可被取到。
+  sandbox.window = sandbox;
+  sandbox.self = sandbox;
+  sandbox.globalThis = sandbox;
+  // 浏览器对象桩
+  sandbox.document = noop;
+  sandbox.navigator = { serviceWorker: null, userAgent: 'node-lingshu' };
+  sandbox.localStorage = {
+    _d: {},
+    getItem(k) { return this._d[k] != null ? this._d[k] : null; },
+    setItem(k, v) { this._d[k] = String(v); },
+    removeItem(k) { delete this._d[k]; }
+  };
+  sandbox.location = { href: 'file://' + htmlPath };
+  sandbox.performance = performance;
+  sandbox.console = console;
+  sandbox.setTimeout = setTimeout;
+  sandbox.clearTimeout = clearTimeout;
+  sandbox.addEventListener = function () {};
+  sandbox.removeEventListener = function () {};
+  sandbox.requestAnimationFrame = function (cb) { return setTimeout(cb, 0); };
+  sandbox.cancelAnimationFrame = function () {};
+  vm.createContext(sandbox);
+  // 实跑整段核心脚本（顶层 UI 初始化靠 noop 桩安全通过）
+  vm.runInContext(code, sandbox, { filename: 'solver-core.js' });
+  if (typeof sandbox.solve !== 'function') {
+    throw new Error('核心脚本中未找到 solve() 函数；可能 index.html 结构已变更。');
+  }
+  return sandbox;
+}
+function getSandbox() {
+  if (!_sandbox) _sandbox = loadSandbox();
+  return _sandbox;
+}
+module.exports = {
+  /** @returns {Function} 求解入口 solve(equationStrs, varNames, decimals, initialD0, fastMode, opts) */
+  solve: function () {
+    const sb = getSandbox();
+    return sb.solve.apply(sb, arguments);
+  },
+  /** 取原始沙箱（高级用法：访问 EXAMPLES 等） */
+  raw: function () { return getSandbox(); },
+  /** 仅用于测试：重置缓存，强制重新加载 */
+  _reset: function () { _sandbox = null; }
+};