simplecadapi 2.2.7__tar.gz → 2.2.8__tar.gz

simplecadapi-2.2.8/CHANGELOG.md

@@ -0,0 +1,538 @@
+# Changelog
+
+All notable changes to SimpleCADAPI are documented here. Per-version
+user-facing notes live in [`docs/updates/`](docs/updates/) (English and
+中文).
+
+## Unreleased
+
+## 2.2.8 — 2026-11-09
+
+User-facing notes: [`docs/updates/2.2.8.md`](docs/updates/2.2.8.md).
+
+### Added
+- Editing existing curves and surfaces as recorded operations (the SDK half of NURBS control-point editing):
+  `inspect_curve_rcurvedata` / `inspect_surface_rsurfacedata` read degree, poles, weights, knots and trimming;
+  `set_*_poles`, `move_*_poles`, `set_*_weights`, `insert_*_knot`, `elevate_*_degree` (curves `_redge`, surfaces
+  `_rface`), `convert_to_bspline_redge/rface` (the explicit step for lines, circles, planes, cylinders) and
+  `rebuild_curve_redge/rface` return a new shape, record a topology delta (tags and references follow the face and
+  its edges) and replay from model JSON. A trimmed face keeps its trimming. `sample_curve_rcurvature` and
+  `sample_surface_risocurves` give an editor a curvature comb and clipped isocurves.
+
+### Changed
+- The editor offers its code mode only. Manual modelling (features, sketches, assemblies by buttons and dialogs) is built
+  but switched off (`editor-web/src/lib/manual-mode.ts`) until it has a plan of its own: no mode switch, command bar or
+  manual keys (`/`, `W`, Space, Ctrl+Z on features, `6`). The viewport keeps what was made for it: three's WebGPURenderer
+  (WebGL 2 as the fallback), level of detail (a part seen up close is tessellated again by the kernel from the in-memory
+  BREP, `POST /api/preview/refine`), instanced parts, BVH picking, and smooth shading from exact surface normals.
+
+### Fixed
+- A stable reference into a face or shell body (no solid) resolves; it raised `cannot resolve QL selector scope`.
+
+## 2.2.7 — 2026-10-30
+
+### Fixed
+- The editor starts with whatever model file is on disk: a model kept by an older build that leaves parts out, or a damaged
+  one, is not restored (and no longer stops the kernel from starting, which showed as "starting the kernel" for ever), and
+  a model that leaves parts out is not filed.
+- A cache entry that names classes which no longer exist (written by an older build: `No module named
+  'simplecadapi._native'`) is deleted and written again. marimo restores such a value as a stub; the runner dropped the
+  cache for the run and ran again without it, which neither read nor wrote entries, so the same stubs came back on every
+  later run and every cell ran every time. A notebook with such entries (a child run through `use`, the six-axis arm's
+  gripper) now takes 0.8 s instead of 3.3-6 s once the entries are replaced. A stub for any other reason (a value that
+  cannot be pickled) keeps the old behaviour.
+- A cell whose value is cached but whose lineage record is missing now runs once and writes both again. It used to
+  run on every call and never repair the record (the cell stayed active nowhere, so nothing was saved), which showed as
+  a notebook that never hit its cache, such as a child notebook run through `use`.
+- Editor: a slider drag that pauses and is then released no longer rebuilds twice. The page sends the value when the
+  drag pauses and again on release; the server now skips a value the model already has (unless the last run failed,
+  when the same value is a retry).
+- A cached cell whose lineage record belongs to another graph is a cache miss and runs again. A part-family member
+  (`use("child.py", id="member")`) with such a record used to fail with `value contains graph node '...' not owned by
+  active graph 'member'`. A restored cell no longer overwrites its record, and a record is only written under the id
+  its cache belongs to.
+- A failed fillet or chamfer, and a ql cardinality error, carry their diagnostic picture again (as in 2.2.6): the
+  failing edge(s) as orange lines, or the matched faces orange and the near misses purple. 2.2.7b1 drew pictures for
+  failed booleans only. Highlighted faces are shaded with the standard material, so the palette colours read as before.
+- A refused preview post names what the editor server said (`HTTP 400: damaged preview: ...`) instead of only the status line.
+
+### Changed
+- `Var` and `Expr` behave like numbers where Python asks for one: `int`, `round`, `floor`/`ceil`, comparisons
+  (`r > 3`), `max`/`min`/`sorted`, `range(n)`, `[0] * n`, `lst[n - 1]`, `//`, `%`, `f"{r:.2f}"`, `str`, and numpy
+  scalars as operands now work, and `r == 5.0` is `True` (it was `False`). Arithmetic still builds the formula; these
+  decisions read the value the expression has now. A ql predicate with a Var-derived value
+  (`ql.prop("geom.length", ">=", 2 * math.pi * radius)`) matches, where 2.2.6 matched nothing. `bool(var)` and
+  `json.dumps(var)` still raise. See `src/cpp/docs/DEVIATIONS.md`; the matrix test is
+  `src/cpp/tests/python/test_expr_numeric_protocol.py`.
+- A handled failure that used to leave no trace now prints a `[sca] ...` line on stderr: the preview warm-up, an
+  unreadable lineage record, a cache entry that could not be deleted, a preview frame that could not be built, a
+  notebook that could not be signed, and a kept model that is damaged and is built again.
+- `shape.wrapped` is an OCP shape when OCP is installed (the `verify` extra), of the class of its kind (`TopoDS_Solid`,
+  `TopoDS_Face`, ...), as it is in CadQuery: the OCCT code an agent writes for verifier scripts runs as written
+  (`BRepGProp.VolumeProperties_s(solid.wrapped, props)`). It is a copy made through BinTools, with its location and
+  orientation: every access makes a new one (`s.wrapped is s.wrapped` is false), so a change made to it (a
+  `BRepBuilderAPI_Transform`, `BRepTools.Clean`) does not reach the SDK's shape, which is unlike CadQuery's live handle
+  and unlike 2.2.6, where `.wrapped` was the shape itself. To use a result, convert it back with
+  `simplecadapi._glue.bridge.ocp_to_native`. Without OCP it stays the SDK's own OCCT shape. `SCA_WRAPPED=native|ocp`
+  chooses, and is read on each access. The SDK's own Python layers take `shape._native_wrapped`, which
+  is always the native one, and the functions that take a raw shape (the `inspect.brep` queries, the STEP export, the
+  geometry helpers of `simplecadapi.kernel`) accept either.
+- Editor kernel: the cells keep what they made (`simplecadapi.runtime.cache._CellMemory`, 12 results; `SCA_NO_CELL_MEMORY=1`
+  turns it off). marimo unpickles an entry while it answers the cache lookup, which is about a second for each of the
+  six-axis arm's assemblies; the kernel now asks its memory right after the cell's key is hashed and before the disk,
+  and hands out the same objects when the entry is one this process holds. Only plain data and the SDK's value types are
+  kept. They are functional except for the semantic state of a shape: `apply_tag`, `set_metadata` and `auto_tag_faces`
+  change the shape they are called on and return the same object, so a later cell that tags a shape it received would
+  change what the producing cell has kept (the disk copy has none of it). Every root of shapes now counts its writes
+  (`AnyShape._semantic_revision`); an entry whose counts moved since it was kept is dropped and the next restore reads
+  the disk copy as before. Reading a shape or consuming it in an operator does not count. Parts and assemblies are
+  followed to their bodies and components.
+  The limit is twelve entries, not a number of bytes, and costs about 300 MB on the six-axis arm; only the editor's
+  kernel has a memory (`sca run` and the tests do not). With a marimo whose `cache_attempt_from_hash` has another
+  signature than the one this was written for, a line on stderr says so and the memory is off. `SCA_EDITOR_TRACE=1` with
+  `SCA_EDITOR_TRACE_FILE=<path>` writes what the cache did with each cell and how long each part took.
+- The saved parameter values in a cell's digest follow what the cell reads. A value the notebook's parameter cell
+  defines used to be part of the digest of every cell below that cell, so changing one joint angle changed the digest
+  of the cell that builds the parts and every cell after it. It is now part of the digest of the cell that defines it,
+  of the cells that read it, and of the cells that read from those. On the six-axis arm a joint angle that has not been
+  seen before takes 2.3-2.7 s to show instead of 5.7-6.5 s, and one that has been seen takes 0.6 s instead of 5.5 s.
+  The digests of cells of a notebook that has saved parameter values are not those of the previous version, so the
+  first run after the upgrade builds those notebooks again once.
+- Editor: the preview is incremental. A model's parts are identified by the content of their geometry, so the kernel
+  posts only the parts the server does not hold, the server sends each page only the parts that page lacks (a page that
+  joins late, or asks with `preview.resync`, is given the whole model), and the page builds geometry only for new
+  parts and reuses the rest. On the six-axis arm a joint angle now moves 115 KB instead of 6.26 MB: the kernel's post
+  takes 17 ms instead of 285-610 ms, the page handles the frame in 2-5 ms with no long task, and from the last cell
+  to the model on screen it takes 0.36-0.41 s instead of 1.3-3.2 s. `simplecadapi.scene.preview.encode_preview` takes
+  `omit=` for the parts to leave out; a post that is not a readable preview is answered `400` (`409` is only for parts
+  the server does not hold), and the server replaces the model it holds as one value; the editor keeps parts in `simplecadapi.editor.preview_parts.PartStore`.
+- Editor: the signature that files a model on disk is taken beside the build, not before it, and the server replies to
+  the kernel's post before filing the model and writing the snapshot. `SCA_EDITOR_TRACE=1` prints how long each step
+  of a settle takes.
+- `use` keeps the product of the last run of each child notebook in the process and hands it out again while the
+  child's static digest (source, header, local modules, input files, the children it uses) and the overrides are
+  unchanged (`simplecadapi.runtime.usememo`; `SCA_NO_USE_MEMO=1` turns it off). One entry per (notebook, id): the run's
+  nodes are registered by graph id, so the entry is the last run's, and two notebooks that run under one graph id
+  replace each other's entry. The editor's kernel is a long-lived process, so a
+  new `OPEN_STROKE` on the six-axis arm rebuilds in 4.2 s instead of 6.4 s. Children with a computed `use` path and
+  overrides that are not plain data are not kept. Prefetch no longer starts workers for what is kept.
+- Editor: the model is pushed over the WebSocket with the `preview` event, in one binary frame
+  (`<u32 big-endian N><N bytes of JSON envelope><SCAPREV1 preview>`), and a page that joins late is given it on
+  connect: no second HTTP request for it. A model already on screen still travels as the bare notice
+  (`unchanged: true`). `GET /api/preview/latest` stays for agents and tools.
+- Editor: the model reaches the page sooner after the last cell. A settle makes one call into the kernel instead of
+  three (the cells are listed in the call that publishes the preview), the duplicate settle a boot used to run is gone,
+  and the settle debounce is 0.12 s. On the six-axis arm the time from the last cell to the preview event went from
+  about 0.83 s (plus a second, redundant round of 0.27 s) to about 0.36 s.
+- Editor: parts are tessellated in the background while the next cell computes (`simplecadapi.scene.prewarm`;
+  `SCA_NO_PREVIEW_WARM=1` turns it off). `cached_mesh` runs without the interpreter lock for that; a failure is
+  recorded on the shape back under the lock.
+- Preview edge polylines are keyed with one numpy pass instead of one `struct.pack` per point; the bytes are identical.
+
+### Added
+- `simplecadapi.verify` (`to_ocp`, `from_ocp`) and the `verify` extra (`pip install "simplecadapi[verify]"`, OCP 7.9
+  without VTK) for verifier scripts. With OCP installed `shape.wrapped` is an OCP shape itself (see Changed), so both
+  routes work; `to_ocp` / `from_ocp` are the explicit ones. The SDK itself still never imports OCP. The skill gains
+  `references/discipline/verifier-scripts.md` with the recipes (volume, bounds, validity, point in solid, distance,
+  overlap) and a verifier skeleton.
+
+### Removed
+- The `fem` extra (`gmsh` and `ccx2paraview[VTK]`) and the README steps that used it; the `gmsh` extra stays. VTK is no
+  longer in the lock file at all.
+
+## 2.2.7b1 — 2026-10-24
+
+### Added
+- `cut_rsolid_list(base, *tools)`: the boolean cut that keeps every piece. A slot through a bar returns both halves, a
+  tool that encloses the body returns an empty list. Recorded as `make_cut_rsolid_list` and replayable.
+- Prebuilt wheels for Linux x86_64, Linux aarch64, macOS arm64 and Windows x86_64, each for Python 3.10-3.13,
+  built by the release workflow against one static OpenCASCADE 7.9.3.
+
+### Changed
+- `simplecadapi.inspect.brep` is part of the default install and renders with the built-in software renderer: VTK is no
+  longer needed, `matplotlib` is a core dependency, and the `inspect` extra is an empty alias.
+- The geometry engine is C++ on OpenCASCADE, shipped in the wheel as `simplecadapi._cpp`; one distribution, one
+  import package. The public API is unchanged, and the previous test suite passes (three tests that relied on a dropped
+  sliver of a tangent cut now use a tool clear of the wall).
+- Every message the library writes is English; the tag-validation and semantic-query errors render in full with
+  possible causes and fixes.
+- macOS wheels require macOS 14 or later.
+
+### Fixed
+- `cut_rsolid` no longer drops pieces silently. When a cut split the body it returned only the first piece (a slot
+  through a 100x20x10 bar reported half the volume); it now raises and points to `cut_rsolid_list`. A tool that only
+  touches a wall tangentially (a cylinder of radius 2 at (3, 3) in a 10x10 block) leaves a separate sliver and now
+  raises too.
+
+### Removed
+- Dependencies `cadquery-ocp`, `ocp-gordon` and `py-slvs`; the `SCA_BACKEND` switch.
+
+## 2.2.6.post2 — 2026-10-21
+
+### Changed
+
+- Operators: `scale_rsolid` and `transform_rsolid` are implemented in `operators/transform.py`,
+  `boolean_rsolidlist` in `operators/boolean.py`, and `offset_rsolid`, `draft_rsolid`,
+  `extrude_taper_rsolid`, `extrude_until_rsolid` and `sweep_multisection_rsolid` in
+  `operators/features.py`, next to the operators of their family. `from simplecadapi import ...`
+  is unchanged. The one-feature modules they were first written in (`operators.deformation`,
+  `draft`, `section_features`, `limited_extrusion`) remain as aliases: importing a name from
+  them still works and raises a `DeprecationWarning` that names the new place.
+
+### Fixed
+
+- Skill API docs: the documentation generator listed its source files and public functions by
+  hand and had never been told about those four modules, so the docs of the eight operators
+  above were kept by hand and deleted by the generator's clean-up. `operators/` is now
+  discovered, a function the package exports is public, the content of the hand-written docs
+  (examples, error conditions, replay notes) is in the docstrings, and tests check that every
+  public operator has a doc and that the committed docs are exactly what the generator writes.
+  `boolean_rsolidlist` had no doc at all.
+- Skill API docs of `NotebookRun`, `run_notebook` and `add_bspline_rsketch` caught up with the
+  code (`through`, `product` and `timeout`; a partial run's `product` is `None`; closed
+  B-splines).
+
+## 2.2.6.post1 — 2026-10-21
+
+### Fixed
+
+- Editor: the parameter panel reads `scad.var(name="j1", default=0.0, ...)` — the keyword
+  form — as well as `scad.var("j1", 0.0, ...)`. Before, only the second positional argument
+  was taken as the default, so keyword declarations never showed up as parameters.
+- Add-ons: `[compat] sca` ranges and the add-on commands accept a post-release version such as
+  `2.2.6.post1` (it sorts after `2.2.6` and before `2.2.7`); the parser rejected it.
+
+### Changed
+
+Cache and runtime speed, measured on the desktop six-axis arm (cold 80.5 s to 34.6 s, no
+change 23.6 s to 4.0 s, one joint edited 18.2 s to 3.0 s, cache 1.7 GB to 96 MB):
+
+- Restoring a cached shape is cheaper: adding a child to a shape no longer refreshes its
+  whole subtree's tag cache unless a tag can pass down, and a restore finds entities by
+  position and refreshes each tag cache once. A restored shape is then built when something
+  first uses it, so a cached value that no running cell reads is never built; pickling it
+  again hands back what it was restored from.
+- The cell cache stores less and compresses it: no values for a cell's private (`_name`)
+  variables, geometry bytes and cache entries zlib-compressed (level 1). Entries written
+  before are still read.
+- `scad.var(...)` values and the expressions made from them are keyed by content, so a cell
+  that reads one parameter is no longer redone because another one, defined in the same cell,
+  changed (marimo keyed any object it cannot hash by the code of the cell that made it).
+- A cell that does `from lib.dims import A` depends on the definition of `A` (and what it
+  reads, across local modules), not on the whole file. A module the analysis cannot prove
+  (calls or loops at top level, star imports, a name defined twice, a plain
+  `import lib.dims`) still depends on the whole file.
+- A cell that runs a notebook with `use("child.py")` (a literal path) is keyed by what that
+  child is (its text, the modules it imports, the notebooks it uses in turn) instead of by
+  everything a run recorded: editing one child redoes the cell that uses it and not those
+  that use its siblings, and the editor kernel caches such cells too (it ran them live
+  before). A path computed at run time still depends on what a run recorded.
+- The `use` calls a cell is about to make (literal path; arguments made of values it reads,
+  `float(...)`, `notebook_id()`) are started together in worker processes, which fill the
+  notebooks' caches; the cell then finds them built. OpenCASCADE keeps the interpreter lock,
+  so these are processes, not threads. `SCA_JOBS` sets how many (default: the smaller of 4
+  and the cores; 1 turns it off). Workers are only started when the builds they take off the
+  cell's hands are worth the seconds a worker takes to start (a notebook remembers how long
+  it last took to build), and a notebook that has not changed since it last ran is not
+  started at all. A notebook's state directory is locked between processes while it runs.
+- Editor: a slider drag is sent when it pauses (250 ms) or ends, not step by step; clicks and
+  number-box commits still go at once.
+
+## 2.2.6 — 2026-10-19
+
+### Added
+
+- Editor: `sca cell open NOTEBOOK` switches the running editor to another notebook of the
+  workspace and waits for its kernel, so the following `sca cell` writes go through instead
+  of refusing. The write commands take `--open` to switch and write in one step
+  (`--wait`, or `SCA_EDITOR_OPEN_WAIT`, raises the boot wait; default 120s). `/api/cells`
+  reports `kernel` so a caller can tell a booted notebook from one still opening.
+- Editor: `sca viewport [WORKSPACE] [--out PATH]` reports where the viewport image lives
+  (path, age, size) and copies it out, instead of reading `.sca-editor/viewport.png` by hand.
+
+### Changed
+
+- Cache: `cryptography` ships as a dependency, so the notebook cache keeps marimo's
+  manifest signing and verification on instead of silently degrading to unsigned,
+  unverified entries (the "LazyLoader verification='on' degraded to 'off'" warning).
+- Editor: a refused write now names `sca cell open NOTEBOOK` (or `--open`) as the way out,
+  and the bundled skill's editor-collaboration reference says so.
+
+## 2.2.5 — 2026-10-15
+
+### Fixed
+
+- Editor: `sca cell` finds the editor through a container's proxy environment: the recorded
+  url is always the loopback (`--host 0.0.0.0` included), the health check and the editor
+  calls bypass `http_proxy`, and a record whose server does not answer is an error naming
+  the record and the url instead of a silent "no editor is running". A record whose pid is
+  gone reports the stale record and the remedy. A fallback to reading the file says so on
+  stderr.
+
+### Added
+
+- Run: `sca run --through N` runs the first N cells only (a stage, numbered the way the
+  editor numbers cells), `--no-product` runs a work-in-progress notebook that has no product
+  yet, and `--timeout SECONDS` fails a run that takes longer (off by default).
+- Editor: a failing or blocked cell's report names its upstream cells (failing ones first),
+  with marimo's own dependency semantics.
+
+### Changed
+
+- Editor: `sca cell put/insert/run` report the console output and every cell left unhealthy
+  by the change, and the dependents a write made stale are run, not left stale. A write whose
+  rerun outlives the call says the edit was applied and names `sca cell ls`
+  (`SCA_EDITOR_CALL_TIMEOUT` raises the wait, default 300s).
+- Inspect: printing a `BRepInspection` shows a one-line summary; the full record is
+  `to_dict()` / `.faces` / `.edges`.
+- Runs are quieter: the cache loaders' degraded-state warnings no longer print at WARNING,
+  and the render paths switch VTK's warning display off process-wide (this also hides VTK
+  chatter from code run in the same process); a real failure is still raised and named.
+- Skill: while an editor runs, `sca cell` is the only way to change a regular cell; `dof=0`
+  says the constraint system closed, not that the shape is right (mirror solutions); modeling
+  projects are version-controlled with git.
+
+## 2.2.4 — 2026-10-15
+
+### Fixed
+
+- Editor: a failed publish is reported again on every run someone asked for — a page rerun, an
+  agent `sca cell` command, a change to the notebook file, a module reload, a parameter commit —
+  so the page's "building the model" veil lifts with the reason instead of waiting out its
+  fallback. The once-per-identical-message dedup stays for the parameter burst. A page that
+  connects after the failure is told the last error at the end of the connection handshake.
+
+### Changed
+
+- Editor: the header's button that opened the raw marimo editor is gone.
+- Skill: the editor docs state which notebooks the workspace scan lists — subfolders of any
+  depth are scanned; names starting with `.` or `_` and `node_modules`, `venv`, `site-packages`,
+  `build`, `dist` are skipped.
+
+## 2.2.3 — 2026-10-14
+
+### Added
+
+- Editor: `sca cell ls|get|put|insert|rm|run` edits the open notebook's cells through the
+  running editor (found by `<workspace>/.sca-editor/server.json`): the page shows the change live,
+  with no reload, the cell runs, and the command prints its status, errors and output. `sca new
+  NAME [--kind part|assembly]` writes a notebook the editor then lists, leaving the person's view
+  alone. The routes behind them are `GET /api/cells` and `POST /api/cells/{edit,insert,delete,run}`.
+- Editor: a change to the open notebook's file made by someone else (an agent) is noticed
+  within a second and applied cell by cell (edited cells are updated and run again, added or
+  removed cells appear or go), without a reload; a changed setup or `@app.function` cell restarts
+  the kernel. Notebooks added to or removed from the workspace appear in the list by themselves.
+
+### Fixed
+
+- Editor: an edit made in the editor no longer writes over what an agent saved to the same
+  notebook file. If a cell was edited in both places, the file's version is kept and the
+  editor's unsaved text goes to the log.
+
+## 2.2.2 — 2026-10-14
+
+### Added
+
+- Editor: code completion from the SDK itself. `scad.` (and `scad.ql.`, `scad.std.gear.`, `ql.`)
+  lists the real functions with their signatures and docstrings; accepting one, or typing `(`
+  after a known name, writes the call with every required parameter as `name=` and Tab moves
+  between them; inside a call the parameters not given yet complete as `name=` (required first).
+  The names come from the running package (`GET /api/sdk`), so they cannot drift from the code.
+- Editor: a **new** action in the workspace tab starts a notebook from the SDK's template (a part,
+  or an assembly that uses the first two parts of the workspace), with the name checked as you
+  type. An empty workspace opens on that form, so `sca edit` on an empty directory is usable.
+
+### Fixed
+
+- Editor: the cell editors rebuilt their configuration on every render (a new `onChange` and
+  `basicSetup` each time), which dropped any snippet in progress and could disturb typing; both
+  are stable now.
+
+## 2.2.1 — 2026-10-13
+
+The first stable release of the 2.2 line (2.2.0b1 was a pre-release): everything
+below was added since 2.1.4, the notebook runtime of 2.2.0b1 included.
+
+### Removed
+
+- Re-Studio, the reverse-engineering studio (the `Re-mode` workspace of the
+  standalone sca-web-editor), and its skill workflow
+  `reverse-engineering-studio.md`. `sca edit` replaces the standalone editor;
+  STEP reconstruction continues through the inspection API and the
+  `step-reconstruction` workflow.
+
+### Added
+
+- Modeling: `scale`, affine `transform`, signed `offset`, `draft`, tapered and
+  until-limited extrusions and multisection sweeps are recorded features, and
+  boolean results can keep every output of a set operation; graph nodes keep
+  ordered input references so a replay selects the same entities.
+- `tools/research/build123dftc`: an execution-based build123d to FTC converter
+  (isolated tracing, exact profile reconstruction, generated notebooks and
+  assemblies) with independent geometry and STEP acceptance. It is research
+  tooling, not part of the installed package.
+- Editor: light mode. The editor follows the system theme and a button in the
+  header cycles system, light and dark (remembered); the 3D viewport, edges,
+  grid, axes and the code editor switch with it, in place, without reloading
+  the model or losing the camera and selection.
+- `sca edit [WORKSPACE]`: the web editor, now part of the SDK
+  (`simplecadapi.editor`, UI sources in `editor-web/`; needs the `editor`
+  extra). It runs a workspace's notebooks in a marimo kernel with the SDK's
+  own cell executor, so the editor, `sca run` and `run_notebook` share one
+  runtime, and marimo's dataflow decides what a parameter change reruns.
+- Editor: picking in the viewport writes a selection cell of `scad.ql`
+  selectors (`selected_<kind>[_<i>]`, `selected_item`); edits autosave to the
+  notebook file; `sca snapshot` and `.sca-editor/snapshot.json` + `viewport.png`
+  tell a coding agent what is selected and shown. Ground grid and axis gizmo in
+  a Z-up CAD frame; cells fold to their step name and can run all cells above.
+- Editor: a log dock along the bottom replaces the error line in the header.
+  It lists what happened and what failed (with the time), and while cells are
+  re-evaluated shows how many of them are done, which one is running and for
+  how long; each cell shows running/queued/blocked. A module that does not
+  compile is reported as the cause ("setup failed — SyntaxError ...").
+- Editor: models reach the viewport as a live preview straight from the
+  solids (`simplecadapi.scene.preview`, wire format `SCAPREV1`), without
+  building a package; a picked entity's details are fetched on demand.
+  Solids no longer carry an eagerly built mesh (modeling is about 20% faster).
+- Editor: the local modules a notebook imports (shared dimensions, helpers)
+  are listed in the workspace, with the notebooks that use them, and open in a
+  module view: source (autosaved) plus the dataclass fields (and top-level
+  constants with a `# ui:` comment) as parameter controls. Editing a module,
+  there or on disk, reloads it in the kernel and reruns the open notebook; the
+  notebooks it `use`s are rerun from their files. `sca ls` reports each
+  notebook's modules.
+- Notebook parameters: the numbers, bools and `scad.var`s of a
+  `# ---- params ----` cell are discoverable (`sca params`,
+  `simplecadapi.runtime.params.list_parameters`) with an optional trailing
+  `# ui: slider(min, max, step=, unit=, label=)` comment to pick the control.
+  Existing notebooks need no change.
+- `sca ls [DIR]` lists the SimpleCAD notebooks under a directory (id, part or
+  assembly, the notebooks each uses); `simplecadapi.runtime.workspace` also
+  parses `# ---- feature: ... ----` headers.
+- `simplecadapi.runtime.live`: project the running kernel's product to a
+  `.scadpkg` (`live_package`, `publish_live`).
+
+- Editor: a cell's run button is a stop button while the kernel runs the cell (the header's run-all too);
+  stopping interrupts the kernel. Switching back to a notebook shows its last model and cells at once
+  when nothing it depends on changed (the editor remembers each notebook's last published package,
+  keyed by a digest of its files), while the kernel boots.
+
+### Changed
+
+- Volumes and centres of mass integrate NURBS by knot spans (Gauss-Kronrod)
+  instead of the fixed-order routine: exact for rational patches (a sewn
+  80 mm cube measures 512000 mm3, the old routine overshot by ~19 mm3) and
+  safe on affine-transformed trims. A degenerate blend result now measures 0
+  and is still reported as `BlendVolumeViolation`.
+- The cell cache is per cell: an entry is stored under a digest of the local
+  modules, child notebooks and input files *that cell* depends on (and what the
+  cells it reads from depend on), no longer one digest for the whole notebook. A
+  changed module recomputes the cells that read it and restores the rest; going
+  back to an earlier value restores everything. The editor kernel uses the same
+  cache. `sca run` reports the same cell statuses; caches written by earlier
+  versions are ignored and removed.
+- Building a package is about twice as fast: the render mesh of a face is
+  computed with numpy in the profile's fixed operation order (the bytes, and so
+  every content hash, are unchanged).
+- Editor: parameters of local modules and `inputs` data files are watched.
+
+### Fixed
+
+- Editor: switching notebooks quickly no longer ends on the wrong one or
+  reports `open failed: Connection refused`: opens are ordered, a superseded
+  open stops its kernel quietly, and the list highlights the notebook being
+  opened at once. A kernel for a notebook with inline dependencies no longer
+  waits for marimo's sandbox prompt ("marimo not ready after 60s"); opening a
+  notebook no longer publishes its model before its cells ran; a page
+  refreshed after an unchanged publish shows the model; the viewport redraws
+  after a panel resize; edges stay visible where a coarse mesh would hide them.
+- `ql.vertices()` resolves through solids, faces and wires (it found nothing
+  unless the scope was an edge).
+- The editor no longer rewrites a notebook when a cell is run unchanged, and
+  keeps `return` statements inside the functions a cell defines.
+- The notebook executor no longer fails on cells that are not part of the
+  notebook (the editor's scratch cell raised `KeyError`).
+
+### Changed
+
+- pymupdf is no longer a default-install dependency: it is optional under
+  the new `drawing` extra. The engineering-drawing family is the only user:
+  vector-PDF drawing inspection, and DXF -> PNG rendering (via ezdxf's
+  drawing backend). `import simplecadapi`, modeling, STEP export, and VTK
+  rendering all work without it. Drawing functions without pymupdf raise an
+  ImportError naming the extra: `pip install 'simplecadapi[drawing]'`.
+
+## 2.1.3 — 2026-09-18
+
+The addon ecosystem leaves the beta line: one stable `sca` CLI, addon
+runtime state that survives updates, structured error guidance, and a
+wheel that ships the Agent Skill source for installation on any machine.
+
+### Added
+
+- `sca skill targets|install` (#4): compile the bundled Agent Skill for a
+  harness target and install it into the skills directory. The wheel
+  ships the uncompiled skill source tree (`docs/skill` +
+  `skillproj.toml`) and compilation happens at install time, so pip
+  users no longer need a repository checkout. `install` resolves the
+  destination through the addon config/env chain (default
+  `~/.agents/skills`, no `sca init` required), refuses to overwrite an
+  existing directory, and `--force` only permits replacing a directory
+  whose `SKILL.md` declares the same skill name.
+- Addon runtime state outside the payload (#3): provisioned environments
+  and caches live under `~/.sca/runtimes/<name>`, survive addon updates,
+  and are removed with the addon; the `{runtime_dir}` placeholder now
+  resolves in both `command_prefix` and `check_cmd`. New
+  `sca addon check [name]` re-probes a runtime immediately and refreshes
+  the cached registry state.
+- Addon v2 standard (#2): the repository name, the descriptor, and the
+  skill frontmatter must share one name; `[runtime].command_prefix`
+  (with `{addon_dir}` / `{runtime_dir}` placeholders) is prepended to
+  commands; new `sca addon use <name> <cmd>` runs a command inside the
+  addon's declared environment.
+- `sca init` (#2): creates the addon home and wires a `sca` shim plus a
+  PATH block into new shells (`--no-shell` skips the wiring).
+- Error guidance overhaul (#1): all SDK exceptions share one
+  `SimpleCADError` root, and failures across sketch solve, assembly
+  solve, boolean, blend, sweep/loft, and QL selection report structured,
+  measured, repairable diagnostics with evidence rendering (edge
+  highlights, four-iso views); zero-hit highlight guards name the tags
+  that are actually available.
+
+### Changed
+
+- One command line: the historical `simplecad-cache` /
+  `simplecad-export` entry points are gone; the same commands live under
+  `sca cache` and `sca export` (#2).
+
+### Fixed
+
+- Diagnostic evidence rendering no longer crashes the process or vanishes
+  silently: GL work is kept out of the failure path's render thread (the
+  crash-isolated worker subprocess is used on every platform there), a
+  render that cannot finish within its budget is reported as a named
+  `render-unavailable` evidence entry instead of silently missing, and the
+  budget is tunable via `SCA_DIAGNOSTIC_RENDER_BUDGET` (tests use 60 s; the
+  agent-facing default stays 15 s).
+- Windows build blockers: binary file opens, guarded directory fsync,
+  and evidence-based stale-lock handling.
+- Translator: unified geometry signatures and SolidWorks 2023 support.
+
+## 2.1.2 — 2026-09-10
+
+Script-anchored part cache: the `@scad.part` / `@scad.assemble` anchor is
+the builder's source directory (`.simplecad/` beside the script); no
+`pyproject.toml` required for standalone scripts. histjson emitter
+keyword-only arguments. See [2.1.2 update notes](docs/updates/2.1.2.md).
+
+## 2.1.1 — 2026-09-09
+
+Tooling patch; the SDK public API is unchanged. See
+[2.1.1 update notes](docs/updates/2.1.1.md).
+
+## 2.1.0 — 2026-09-07
+
+The SDK becomes an agent-first CAD toolkit: the QL selection language,
+persistent tagging, durable `.scadpkg` product packages, standard parts,
+multi-backend translation (FreeCAD, SolidWorks, Fusion), and the Agent
+Skill. See [2.1.0 update notes](docs/updates/2.1.0.md).