simplecadapi 2.2.4__tar.gz → 2.2.5__tar.gz

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplecadapi
-Version: 2.2.4
+Version: 2.2.5
 Summary: A simplified OCP-native CAD modeling Python API
 Project-URL: Homepage, https://github.com/PhySpace/SimpleCADAPI
 Project-URL: Repository, https://github.com/PhySpace/SimpleCADAPI
@@ -412,18 +412,21 @@ the full crank cycle sweeps clean in the same sim ·
 
 ---
 
-## Update Notes (2.2.4)
+## Update Notes (2.2.5)
 
 > Validate generated definitions, assembly constraints, and manufacturing
 > geometry before production use.
 
-- **The editor tells you why no model is coming.** A failed build is reported on every run you or
-  an agent asks for (rerun, `sca cell`, a file change, a module reload), and to a page that opens
-  or refreshes afterwards — the "building the model" veil lifts with the reason instead of
-  waiting out its fallback.
-- **The header's jump-to-marimo button is gone.**
+- **`sca cell` works behind container proxies.** The editor's discovery record is loopback and
+  proxy-proof, an unreachable record is reported instead of silently ignored, and file
+  fallbacks say so on stderr.
+- **Cell feedback carries the chain.** put/insert/run return console output and every cell
+  left unhealthy, stale dependents are run, and a failing cell names its upstream.
+- **Validate a stage headlessly.** `sca run --through N / --no-product / --timeout`.
+- **Quieter output, shorter prints.** Cache and VTK chatter is gone; a printed
+  `BRepInspection` is a one-line summary.
 
-Full notes for this version: [`docs/updates/2.2.4.md`](docs/updates/2.2.4.md).
+Full notes for this version: [`docs/updates/2.2.5.md`](docs/updates/2.2.5.md).
 Earlier versions: the [changelog](CHANGELOG.md) and [`docs/updates/`](docs/updates/).
 
 ---
@@ -444,7 +447,7 @@ in a compact public API for creating solids, applying features, tagging semantic
 intent, querying topology, exporting manufacturing files, and translating recorded
 models into FreeCAD workflows.
 
-Current release: `simplecadapi==2.2.4`.
+Current release: `simplecadapi==2.2.5`.
 
 ## What It Provides
 
@@ -959,6 +962,7 @@ and the [STEP reconstruction workflow](docs/skill/references/workflows/step-reco
 
 ## Documentation
 
+- 2.2.5 update notes: [`docs/updates/2.2.5.md`](docs/updates/2.2.5.md)
 - 2.2.4 update notes: [`docs/updates/2.2.4.md`](docs/updates/2.2.4.md)
 - 2.2.3 update notes: [`docs/updates/2.2.3.md`](docs/updates/2.2.3.md)
 - 2.2.2 update notes: [`docs/updates/2.2.2.md`](docs/updates/2.2.2.md)

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/README.md

@@ -149,18 +149,21 @@ the full crank cycle sweeps clean in the same sim ·
 
 ---
 
-## Update Notes (2.2.4)
+## Update Notes (2.2.5)
 
 > Validate generated definitions, assembly constraints, and manufacturing
 > geometry before production use.
 
-- **The editor tells you why no model is coming.** A failed build is reported on every run you or
-  an agent asks for (rerun, `sca cell`, a file change, a module reload), and to a page that opens
-  or refreshes afterwards — the "building the model" veil lifts with the reason instead of
-  waiting out its fallback.
-- **The header's jump-to-marimo button is gone.**
+- **`sca cell` works behind container proxies.** The editor's discovery record is loopback and
+  proxy-proof, an unreachable record is reported instead of silently ignored, and file
+  fallbacks say so on stderr.
+- **Cell feedback carries the chain.** put/insert/run return console output and every cell
+  left unhealthy, stale dependents are run, and a failing cell names its upstream.
+- **Validate a stage headlessly.** `sca run --through N / --no-product / --timeout`.
+- **Quieter output, shorter prints.** Cache and VTK chatter is gone; a printed
+  `BRepInspection` is a one-line summary.
 
-Full notes for this version: [`docs/updates/2.2.4.md`](docs/updates/2.2.4.md).
+Full notes for this version: [`docs/updates/2.2.5.md`](docs/updates/2.2.5.md).
 Earlier versions: the [changelog](CHANGELOG.md) and [`docs/updates/`](docs/updates/).
 
 ---
@@ -181,7 +184,7 @@ in a compact public API for creating solids, applying features, tagging semantic
 intent, querying topology, exporting manufacturing files, and translating recorded
 models into FreeCAD workflows.
 
-Current release: `simplecadapi==2.2.4`.
+Current release: `simplecadapi==2.2.5`.
 
 ## What It Provides
 
@@ -696,6 +699,7 @@ and the [STEP reconstruction workflow](docs/skill/references/workflows/step-reco
 
 ## Documentation
 
+- 2.2.5 update notes: [`docs/updates/2.2.5.md`](docs/updates/2.2.5.md)
 - 2.2.4 update notes: [`docs/updates/2.2.4.md`](docs/updates/2.2.4.md)
 - 2.2.3 update notes: [`docs/updates/2.2.3.md`](docs/updates/2.2.3.md)
 - 2.2.2 update notes: [`docs/updates/2.2.2.md`](docs/updates/2.2.2.md)

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/docs/skill/SKILL.md

@@ -4,9 +4,9 @@ description: Build, assemble, inspect, reconstruct, and export parametric CAD mo
 license: Apache-2.0
 metadata:
   project: simplecadapi
-  version: 2.2.4
+  version: 2.2.5
   package-name: simplecadapi
-  package-version: 2.2.4
+  package-version: 2.2.5
 ---
 
 # SimpleCAD SDK Skill
@@ -50,9 +50,10 @@ Paths are relative to this file's directory.
   selected, and you MUST read
   `references/domains/editor-collaboration.md` first to see what they
   see (selection cell, `sca snapshot`, cell references) and how to
-  hand the work back. While the editor runs, change its notebooks with
-  `sca cell` (or the file; never both blindly): the editor is the
-  file's writer.
+  hand the work back. While the editor runs, `sca cell` is the only way to
+  change a regular cell; edit the file only when no editor is running, or
+  for the setup / `@app.function` cells `sca cell` refuses: the editor is
+  the file's writer.
 - Creating, installing, updating, or removing a SimpleCADAPI addon (a
   third-party skill+tooling package around `.scadpkg`) enters no
   workflow; you MUST use `references/domains/addon-development.md`
@@ -147,6 +148,13 @@ it and stop that route; never invent an alternative route.
     them in the editor for a person); never enable
     marimo's `[tool.marimo.runtime] cache_cells` in the editor, and
     never commit the generated `__marimo__/` directory.
+12. Manage the modeling project the way software is managed: put the
+    workspace under git from the first file, commit at verified
+    milestones (a passed verification, not a wall clock) with messages
+    that say what changed and why, and use a branch per design
+    direction when alternatives are on the table. Generated state —
+    `__marimo__/`, `.sca-editor/`, `out/` — belongs in `.gitignore`,
+    never in a commit.
 
 ## Boundaries
 

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/docs/skill/references/domains/editor-collaboration.md

@@ -12,11 +12,17 @@ tuned value) is also something you can read from disk. Never rely on what the
 person says they selected when the file or the snapshot can tell you.
 
 The editor holds the open notebook in memory and is the one writer of its
-file. You have two safe ways to change it while it runs; use the first:
-
-1. **`sca cell` (preferred).** It edits through the editor: the page shows the
+file. While it runs, **`sca cell` is the only way to change a regular cell**:
+writing the file behind the editor's back races its next save, and the page's
+version or yours is lost. Edit the file directly only when no editor is
+running (then nothing else holds it), or for the cells `sca cell` refuses
+(the setup cell and `@app.function` cells): the editor takes those file
+changes in.
+
+1. **`sca cell` (always, for regular cells).** It edits through the editor: the page shows the
    change live (no reload, no flicker), the cell runs, and you get its state back.
-2. **Edit the file.** The editor notices a saved change within a second, compares
+2. **Edit the file** — only with no editor running, or for a setup / `@app.function` cell. The
+   editor notices a saved change within a second, compares
    it with its cells and applies only what differs (changed cells are edited in
    place and run again, added or removed cells appear or go away). A change to the
    setup cell or an `@app.function` cell restarts the kernel instead. A file that

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/docs/skill/references/domains/sketch-and-features.md

@@ -81,6 +81,10 @@ Read the exact page under `references/docs/api/` for every API used:
 ## Validation gates
 
 - Record plane mapping, closure, solve status, and remaining DOF in the brief.
+- `dof=0` says the constraint system closed, not that the shape is the intended
+  one: angle and symmetry constraints can solve to the mirror solution. Verify
+  the promoted geometry by measurement (bounding box, area, edge counts), never
+  by the solver status alone.
 - When sketch promotion may change measured geometry, build Wire and Sketch
   from one parameter source and compare closure/area/bounds/segmentation before
   promoting.

simplecadapi-2.2.5/docs/updates/2.2.5.md

@@ -0,0 +1,51 @@
+# 2.2.5 Update Notes
+
+From a container agent's field report: the editor now works the way agents actually use it,
+and says what happened instead of leaving silence.
+
+## `sca cell` works behind container proxies
+
+Before, a container's `http_proxy` swallowed the editor's health check and `sca cell`
+answered "no editor is running" while one was. Now the editor's discovery record always
+carries a loopback url (`--host 0.0.0.0` included), the checks bypass the proxy environment,
+and a record whose server does not answer is reported with its path and url instead of being
+skipped quietly. A record whose pid is gone says "stale record … delete it or restart the
+editor". When `sca cell ls`/`get` fall back to reading the file, they say so on stderr.
+
+## Cell feedback carries the chain
+
+`sca cell put/insert/run` now return the console output and every cell left unhealthy by the
+change, and the dependents a write made stale are run instead of waiting. A failing cell's
+report names its upstream cells (the failing ones first), so the error you see can be traced
+to its cause. A write whose rerun takes longer than the call now answers "the edit was
+applied and the rerun is still going; check `sca cell ls`" instead of a raw socket error
+(`SCA_EDITOR_CALL_TIMEOUT` raises the wait, default 300s).
+
+## Validate a stage headlessly
+
+```bash
+sca run stage.py --through 3 --no-product    # the first 3 cells, no product needed
+sca run stage.py --timeout 600               # a wall clock for heavy fillets
+```
+
+`--through N` runs the first N cells, numbered the way the editor numbers them; `--no-product`
+runs a work-in-progress notebook that has no product yet; `--timeout` fails a run that takes
+longer (off by default).
+
+## Quieter output, shorter prints
+
+The cache loaders' degraded-state warnings (unsigned entries, a value restored as a stub) no
+longer print at WARNING, and the render paths switch VTK's warning display off process-wide —
+this also hides VTK chatter from code you run in the same process. A real failure is still
+raised and named. Printing a `BRepInspection` shows a one-line summary; the per-face records
+are `to_dict()` / `.faces` / `.edges`.
+
+## Skill
+
+While an editor runs, `sca cell` is the only way to change a regular cell — the file only when
+no editor runs, or for the setup / `@app.function` cells `sca cell` refuses. `dof=0` says the
+constraint system closed, not that the shape is right (angle constraints can solve to the
+mirror solution): verify by measurement. And a modeling project is managed like software:
+git from the first file, commits at verified milestones.
+
+See the [changelog](../../CHANGELOG.md) for the complete list.

simplecadapi-2.2.5/docs/updates/2.2.5.zh-CN.md

@@ -0,0 +1,41 @@
+# 2.2.5 更新说明
+
+来自容器 agent 的实战复盘：编辑器现在按 agent 真实的使用方式工作，并且把发生的事说出来，而不是留下沉默。
+
+## `sca cell` 在容器代理后面也能找到编辑器
+
+以前容器的 `http_proxy` 会吞掉编辑器的健康检查，`sca cell` 在编辑器明明运行时回答"no editor is running"。
+现在编辑器的发现记录始终携带回环地址（`--host 0.0.0.0` 也是），检查绕过代理环境，应答不了的服务器记录会带着
+路径和 url 报出来，而不是被悄悄跳过。pid 已消失的记录会说"stale record … delete it or restart the editor"。
+`sca cell ls`/`get` 降级读文件时会在 stderr 上说明。
+
+## cell 反馈带着整条链
+
+`sca cell put/insert/run` 现在返回 console 输出和这次修改留下的每一个不健康的 cell，写操作导致的 stale 依赖
+会被运行而不是晾着。出错 cell 的报告会列出它的上游 cell（先列出同样在报错的），让错误能追溯到根因。重跑超出
+调用时长的写操作现在回答"the edit was applied and the rerun is still going; check `sca cell ls`"而不是裸的
+socket 错误（`SCA_EDITOR_CALL_TIMEOUT` 可加大等待，默认 300 秒）。
+
+## 按阶段做无头校验
+
+```bash
+sca run stage.py --through 3 --no-product    # 只跑前 3 个 cell，不需要产品
+sca run stage.py --timeout 600               # 给重 fillet 一个墙上时钟
+```
+
+`--through N` 只跑前 N 个 cell（按编辑器的编号方式计）；`--no-product` 运行还没有产品的半成品 notebook；
+`--timeout` 让超时的运行失败（默认不限时）。
+
+## 更安静的输出、更短的打印
+
+缓存加载器的降级警告（未签名的条目、以 stub 恢复的值）不再以 WARNING 打印，渲染路径进程级关闭 VTK 的警告
+显示——同一进程里你自己代码的 VTK 警告也会被隐藏。真正的失败仍然会大声报出并点名。打印 `BRepInspection`
+现在是一行摘要；逐面记录在 `to_dict()` / `.faces` / `.edges`。
+
+## Skill
+
+编辑器运行时，`sca cell` 是修改普通 cell 的唯一方式——直接改文件只在没有编辑器运行时，或用于 `sca cell`
+拒绝的 setup / `@app.function` cell。`dof=0` 说明约束系统闭合了，不说明形状是对的（角度约束可能解出镜像
+解）：用测量来验证。建模项目按软件工程的方式管理：从第一个文件就用 git，在验证通过的节点提交。
+
+完整列表见[更新日志](../../CHANGELOG.md)。

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplecadapi"
-version = "2.2.4"
+version = "2.2.5"
 description = "A simplified OCP-native CAD modeling Python API"
 readme = "README.md"
 license = { file = "LICENSE" }

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/src/simplecadapi/editor/cli.py

@@ -154,28 +154,79 @@ def _print_json(report: dict[str, Any]) -> None:
     print(json.dumps(report, indent=2, ensure_ascii=False))
 
 
+def _opener() -> Any:
+    """An opener that bypasses the proxy environment for the local editor.
+
+    The editor is on this machine (its url is 127.0.0.1); a container's
+    ``http_proxy`` does not know that and swallows the request, which once
+    read as "no editor is running" while one was.
+    """
+    import urllib.request
+
+    return urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
+
 def _find_editor(start: Path) -> tuple[Path, str] | None:
-    """The running editor whose workspace holds *start*: ``(workspace, base url)``."""
+    """The running editor whose workspace holds *start*: ``(workspace, base url)``.
+
+    A record whose server does not answer is an error, not a stale record to
+    skip quietly: "an editor was running here" is exactly the belief that
+    must not be dropped in silence.  The one definite stale case is a record
+    whose process is gone (a crashed editor leaves its server.json behind).
+    """
     import json
-    import urllib.request
+    import os
+    import urllib.error
 
     here = start.expanduser().resolve()
+    unreachable: list[str] = []
+    opener = _opener()
     for directory in (here, *here.parents):
         record = directory / ".sca-editor" / "server.json"
         if not record.is_file():
             continue
         try:
-            url = json.loads(record.read_text(encoding="utf-8"))["url"]
-            with urllib.request.urlopen(f"{url}/api/health", timeout=1.5):
+            body = json.loads(record.read_text(encoding="utf-8"))
+            url = body["url"]
+        except (OSError, ValueError, KeyError) as error:
+            unreachable.append(f"{record}: unreadable ({error})")
+            continue
+        pid = body.get("pid")
+        if isinstance(pid, int):
+            try:
+                os.kill(pid, 0)
+            except ProcessLookupError:
+                unreachable.append(
+                    f"stale record {record} (pid {pid} is gone); delete it or restart the editor"
+                )
+                continue
+            except OSError:
+                pass  # a live process we cannot signal
+        try:
+            with opener.open(f"{url}/api/health", timeout=1.5):
                 pass
-        except (OSError, ValueError, KeyError):
-            continue  # a stale record: the editor is gone
+        except urllib.error.HTTPError:
+            pass  # an editor that answers at all is running
+        except OSError as error:
+            unreachable.append(f"found {record} but {url} is unreachable: {error}")
+            continue
         return directory, str(url)
+    if unreachable:
+        raise ValueError("; ".join(unreachable))
     return None
 
 
-def _call(url: str, path: str, body: dict | None = None) -> dict[str, Any]:
+def _call_timeout() -> float:
+    """How long one editor call may take; a heavy downstream rerun is on the
+    clock of the write that triggered it. ``SCA_EDITOR_CALL_TIMEOUT`` seconds."""
+    import os
+
+    return float(os.environ.get("SCA_EDITOR_CALL_TIMEOUT", "300"))
+
+
+def _call(url: str, path: str, body: dict | None = None, timeout: float | None = None) -> dict[str, Any]:
     import json
+    import socket
     import urllib.error
     import urllib.request
 
@@ -183,20 +234,29 @@ def _call(url: str, path: str, body: dict | None = None) -> dict[str, Any]:
     request = urllib.request.Request(
         url + path, data=data, headers={"Content-Type": "application/json"}, method="GET" if body is None else "POST"
     )
+    seconds = _call_timeout() if timeout is None else timeout
     try:
-        with urllib.request.urlopen(request, timeout=300) as response:
+        with _opener().open(request, timeout=seconds) as response:
             return json.loads(response.read())
     except urllib.error.HTTPError as error:
         try:
             return json.loads(error.read())
         except ValueError:
             return {"error": f"editor answered {error.code}"}
+    except (socket.timeout, TimeoutError) as error:
+        raise TimeoutError(f"the editor did not answer {path} within {seconds:g}s") from error
 
 
 def _session(args: argparse.Namespace, *, write: bool) -> tuple[str | None, Path | None, str]:
     """``(editor url or None, notebook path or None, relative notebook name)`` for a cell command."""
     start = args.workspace or (args.notebook.parent if args.notebook else Path.cwd())
-    found = _find_editor(start)
+    try:
+        found = _find_editor(start)
+    except ValueError as error:
+        if write:
+            raise
+        _warn(f"editor not reached: {error}")
+        found = None
     notebook = args.notebook.expanduser().resolve() if args.notebook else None
     if found is None:
         if write:
@@ -206,6 +266,7 @@ def _session(args: argparse.Namespace, *, write: bool) -> tuple[str | None, Path
             )
         if notebook is None:
             raise ValueError("no editor is running here; name the notebook with --notebook")
+        _warn(f"no editor is running on this workspace; reading the file: {notebook.name}")
         return None, notebook, notebook.name
     workspace, url = found
     open_path = _call(url, "/api/cells").get("notebook")
@@ -221,9 +282,17 @@ def _session(args: argparse.Namespace, *, write: bool) -> tuple[str | None, Path
             f"the editor has {open_path} open, not {relative}: edit {relative} directly "
             "(the editor does not hold it), or open it in the editor first"
         )
+    _warn(f"the editor has {open_path} open; reading {relative} from the file")
     return None, notebook, relative
 
 
+def _warn(message: str) -> None:
+    """Say a fallback out loud: silence once read as "the editor agreed"."""
+    import sys
+
+    print(f"warning: {message}", file=sys.stderr)
+
+
 def _cells_from_file(notebook: Path) -> list[dict[str, Any]]:
     from ..runtime._marimo import parse_notebook
 
@@ -239,7 +308,7 @@ def _cells_from_file(notebook: Path) -> list[dict[str, Any]]:
 def _slim(report: dict[str, Any], *, code: bool) -> dict[str, Any]:
     if "cells" not in report:
         return report
-    keep = ("index", "key", "name", "title", "status", "errors", "output", "ref", "readonly")
+    keep = ("index", "key", "name", "title", "status", "errors", "output", "console", "upstream", "ref", "readonly")
     return {
         **report,
         "cells": [
@@ -285,13 +354,25 @@ def _read_code(args: argparse.Namespace) -> str:
 def _write_op(args: argparse.Namespace, op: str, body: dict[str, Any]) -> tuple[dict[str, Any], int]:
     url, _notebook, _name = _session(args, write=True)
     assert url is not None
-    report = _call(url, f"/api/cells/{op}", body)
+    try:
+        report = _call(url, f"/api/cells/{op}", body)
+    except TimeoutError:
+        # The server took the write and reruns on its own; the clock that ran
+        # out is this call's, not the editor's.
+        return {
+            "error": "the edit was applied and the rerun is still going; check "
+            "`sca cell ls` (SCA_EDITOR_CALL_TIMEOUT raises the wait)"
+        }, 1
     if "error" in report:
         return _slim(report, code=False), 1
     touched = set(report.get("touched", []))
     report = _slim(report, code=False)
-    # What the change did: the touched cells with their state; the rest as a count.
-    report["cells"] = [c for c in report["cells"] if c.get("index") in touched] or report["cells"]
+    # What the change did: the touched cells with their state, plus any cell
+    # that is not healthy after the run — a rerun dependent failing is the
+    # feedback the edit was after, hiding it once read as "the edit was fine".
+    report["cells"] = [
+        c for c in report["cells"] if c.get("index") in touched or c.get("errors") or c.get("blocked")
+    ] or report["cells"]
     return report, 0
 
 

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/src/simplecadapi/editor/server.py

@@ -37,6 +37,7 @@ from starlette.websockets import WebSocketDisconnect
 
 from ..runtime.cells import cell_keys
 from ..runtime.config import NotebookConfig, read_notebook_config
+from ..runtime._marimo import compile_cell
 from ..runtime.params import (
     ParamSpec,
     commit_field_value,
@@ -601,7 +602,7 @@ class WorkspaceState:
     # -- the same cell edits, for an agent (``sca cell``) -------------------------
 
     def _brief(self, number: int, cell: dict) -> dict:
-        return {
+        brief = {
             "index": number,
             "id": cell["id"],
             "key": cell.get("key"),
@@ -615,13 +616,34 @@ class WorkspaceState:
             "ref": cell.get("ref"),
             "code": cell["code"],
         }
+        if cell.get("blocked"):
+            # The cell did not itself fail: an ancestor did (its report says which).
+            brief["blocked"] = True
+        return brief
 
     def cells_report(self, *, refresh: bool = True) -> dict:
         if refresh and self.kernel is not None:
             self.push_cells()
+        upstream = _upstream_of(self.cells)
+        place = {cell["id"]: (number, cell) for number, cell in enumerate(self.cells, start=1)}
+        briefs = []
+        for number, cell in enumerate(self.cells, start=1):
+            brief = self._brief(number, cell)
+            if brief["errors"] or brief.get("blocked"):
+                # The cell the error names is often not the one at fault: say
+                # what it reads, the failing ancestors first.
+                brief["upstream"] = [
+                    {
+                        "index": place[dep][0],
+                        "name": place[dep][1].get("name"),
+                        "failing": bool(place[dep][1].get("errors")),
+                    }
+                    for dep in sorted(upstream.get(cell["id"], ()), key=lambda cid: place[cid][0])
+                ]
+            briefs.append(brief)
         return {
             "notebook": self.notebook.relative_to(self.workspace).as_posix() if self.notebook else None,
-            "cells": [self._brief(n, c) for n, c in enumerate(self.cells, start=1)],
+            "cells": briefs,
         }
 
     def _find_cell(self, ref: Any) -> dict:
@@ -654,9 +676,16 @@ class WorkspaceState:
                 if body.get("base") is not None and _module_code(str(body["base"])).strip() != _module_code(cell["code"]).strip():
                     return {"error": "conflict: the cell changed since you read it", "theirs": cell["code"]}
                 if code.strip() != _module_code(cell["code"]).strip():
-                    (kernel.edit_cell if body.get("run", True) else kernel.save_cell)(cell["id"], code)
+                    run = bool(body.get("run", True))
+                    (kernel.edit_cell if run else kernel.save_cell)(cell["id"], code)
+                    if run:
+                        # The edit runs the cell itself; the sweep adds the
+                        # dependents it made stale — their state is the
+                        # feedback the caller asked for.
+                        kernel.wait_idle()
+                        kernel.run_until_settled([])
                 elif body.get("run", True):
-                    kernel.run_cells([cell["id"]])
+                    kernel.run_until_settled([cell["id"]])
                 touched = [cell["id"]]
             elif op == "insert":
                 after = body.get("after")
@@ -668,9 +697,11 @@ class WorkspaceState:
                     anchor = self._find_cell(after)["id"]
                 code = _module_code(str(body.get("code", ""))) or "# new cell"
                 name = str(body["name"]) if body.get("name") else None
-                created = _created_id(kernel.create_cell_after(anchor, code, name, run=bool(body.get("run", True))))
+                created = _created_id(kernel.create_cell_after(anchor, code, name, run=False))
                 if created is None:
                     return {"error": "the kernel did not create the cell"}
+                if body.get("run", True):
+                    kernel.run_until_settled([created])
                 touched = [created]
             elif op == "delete":
                 cell = self._find_cell(body.get("cell"))
@@ -1430,8 +1461,10 @@ class WorkspaceState:
             directory.mkdir(parents=True, exist_ok=True)
             import os
 
+            # The record is read on this machine, so the url is always the
+            # loopback: a 0.0.0.0 url is no address (and walks into proxies).
             (directory / "server.json").write_text(
-                json.dumps({"url": f"http://{host}:{self.port}", "pid": os.getpid(), "workspace": str(self.workspace)}),
+                json.dumps({"url": f"http://127.0.0.1:{self.port}", "pid": os.getpid(), "workspace": str(self.workspace)}),
                 encoding="utf-8",
             )
         except OSError:
@@ -1486,6 +1519,36 @@ class WorkspaceState:
         self.hub.broadcast({"type": "status", "exported": str(target)})
 
 
+def _upstream_of(cells: list[dict]) -> dict[str, set[str]]:
+    """Per cell id: the ids of the cells it (transitively) reads.
+
+    Compiled with marimo's own cell compiler, so a name is a dependency
+    exactly when marimo's dataflow says so; a cell mid-edit (its code does
+    not compile) contributes no edges rather than wrong ones.
+    """
+    owner: dict[str, str] = {}
+    refs: dict[str, frozenset[str]] = {}
+    for cell in cells:
+        try:
+            impl = compile_cell(_module_code(cell["code"]), cell["id"])
+        except Exception:
+            refs[cell["id"]] = frozenset()
+            continue
+        refs[cell["id"]] = impl.refs
+        for name in impl.defs:
+            owner.setdefault(name, cell["id"])
+    direct = {cid: {owner[name] for name in names if name in owner and owner[name] != cid} for cid, names in refs.items()}
+    closure: dict[str, set[str]] = {}
+
+    def walk(cid: str) -> set[str]:
+        if cid not in closure:
+            closure[cid] = set()  # marimo forbids cycles; the placeholder guards one anyway
+            closure[cid] = set().union(*(walk(dep) | {dep} for dep in direct.get(cid, ()))) if direct.get(cid) else set()
+        return closure[cid]
+
+    return {cid: walk(cid) for cid in refs}
+
+
 def _module_code(code: str) -> str:
     """marimo's code_mode compiles cell code as a MODULE: a ``return`` in the
     cell's own scope (normal in marimo's file format) is a SyntaxError there.

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/src/simplecadapi/inspect/brep/inspect.py

@@ -46,6 +46,23 @@ class BRepInspection:
     def to_dict(self) -> dict[str, Any]:
         return asdict(self)
 
+    def summary(self) -> str:
+        """One digest line: the facts an agent checks first, no per-face dump.
+
+        The full record (tens of thousands of characters on a real part) is
+        ``.to_dict()`` / the ``faces`` / ``edges`` lists.
+        """
+        box = self.bounding_box
+        size = [round(box[i + 3] - box[i], 3) for i in range(3)]
+        return (
+            f"<BRepInspection {self.source or '?'}: valid={self.valid} "
+            f"counts={self.counts} volume={self.volume:.6g} area={self.surface_area:.6g} "
+            f"size(xyz)={size} surfaces={self.surface_type_counts} edges={self.edge_type_counts}>"
+        )
+
+    def __repr__(self) -> str:
+        return self.summary()
+
     def write_json(self, path: str | Path, *, indent: int = 2) -> Path:
         output = Path(path)
         output.parent.mkdir(parents=True, exist_ok=True)

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/src/simplecadapi/inspect/brep/render.py

@@ -67,6 +67,9 @@ def _vtk_modules():
         from vtk.util.numpy_support import numpy_to_vtk, numpy_to_vtkIdTypeArray
     except ImportError as error:
         raise ImportError("BREP rendering requires VTK") from error
+    # VTK's own chatter (a missing X server, driver notes) reads as a render
+    # failure; a real one is raised and named here.
+    vtk.vtkObject.GlobalWarningDisplayOff()
     return vtk, numpy_to_vtk, numpy_to_vtkIdTypeArray
 
 _OFFSCREEN_WINDOW: Any | None = None

{simplecadapi-2.2.4 → simplecadapi-2.2.5}/src/simplecadapi/inspect/brep/render_worker.py

@@ -14,6 +14,9 @@ from typing import Any, Mapping
 def _read_polydata(path: Path):
     import vtk
 
+    # VTK's own chatter (a missing X server, driver notes) reads as a render
+    # failure; a real one fails the worker and is named by the caller.
+    vtk.vtkObject.GlobalWarningDisplayOff()
     reader = vtk.vtkXMLPolyDataReader()
     reader.SetFileName(str(path))
     reader.Update()