Rename SolveCraft to SolidCraft everywhere, with compatibility shims (#389)

* WIP deep rename (not for push) * WIP2 * WIP3 * WIP4 wxs fix * rustfmt * Rename the remaining identifiers in merged crash-report code Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01RjGw4gA5ZvKrU8MQP6sBgT --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-12 17:17:01 -04:00
1 parent 27415e4dd7
commit 296683229d
@@ -7,15 +7,15 @@
 # Keep this list in sync with docs/book/src/dev/testing.md and CONTRIBUTING.md.
 default-filter = """
 not (
-    (package(solvecraft-engine) & (
+    (package(solidcraft-engine) & (
        test(=tests::hostile_params_never_panic)
        | test(/^tests::robustness::/)
        | test(=pattern_suppress_tests::enclosure_arc_extinction_keeps_a_real_sharp_inner_lip_after_resize_and_reopen)
        | test(=pattern_suppress_tests::enclosure_datums_follow_wall_height_and_board_depth_with_material_proofs)
        | test(=cmd::plastic::tests::enclosure_snap_fit_follows_resized_front_wall)
    ))
-    | (package(solvecraft-kernel) & test(=tests::boolean_identity_on_tangent_primitives))
-    | (package(solvecraft-ui-egui) & binary(scenarios) & test(=acceptance_sensor_enclosure))
+    | (package(solidcraft-kernel) & test(=tests::boolean_identity_on_tangent_primitives))
+    | (package(solidcraft-ui-egui) & binary(scenarios) & test(=acceptance_sensor_enclosure))
 )
 """
 fail-fast = false
@@ -1,6 +1,6 @@
 ---
 name: Bug report
-about: Help reproduce and fix a SolveCraft problem
+about: Help reproduce and fix a SolidCraft problem
 title: ''
 labels: ''
 assignees: ''
@@ -12,7 +12,7 @@ What did you expect, and what happened instead?

 ## Reproduction

-Include steps, SolveCraft version/commit and relevant environment details. Prefer a small example without private design data.
+Include steps, SolidCraft version/commit and relevant environment details. Prefer a small example without private design data.

 ## Screenshots of the behavior (when observable)

@@ -5,15 +5,26 @@ parameter to watch the timeline rebuild. [Documentation](https://bherbruck.githu
 [issues](https://github.com/bherbruck/solidcraft/issues). AI agents can model with it over MCP:
 `solidcraft-cli mcp` ([how](https://bherbruck.github.io/solidcraft/guide/mcp.html)).

-**Renamed to SolidCraft.** Downloads, installers and programs now carry the SolidCraft name:
-the desktop app is `solidcraft`, the command line `solidcraft-cli`. `solvecraft-cli` is still
-installed as a deprecated alias that forwards to `solidcraft-cli` (it prints a one-line note on
-stderr), so scripts and MCP setups such as `claude mcp add solvecraft -- solvecraft-cli mcp`
-keep working; new setups use `claude mcp add solidcraft -- solidcraft-cli mcp`. Existing designs
-open as before. Upgrades: the `.msi` upgrades an earlier install in place (it now installs to
-`Program Files\SolidCraft`); the `solidcraft` `.deb`/`.rpm` replaces the old `solvecraft`
-package; the Flatpak app ID `ai.storyteller.solvecraft` is unchanged, so Flatpak updates
-continue; earlier AppImages still find updates.
+**Renamed to SolidCraft.** Everything now uses the new name: the `solidcraft` and
+`solidcraft-cli` programs, `.solidcraft` designs, `SOLIDCRAFT_*` environment variables,
+settings folders, package names and the `solidcraft` MCP server. Upgrading from SolveCraft:
+- `.solvecraft` designs still open (double-click, Open, drag-drop, the CLI and MCP); new saves
+  are `.solidcraft`. Builds older than this one can't open files saved by it.
+- Settings, preferences and recovery files are copied to the new folders on first launch; the
+  old folders are left in place. `SOLVECRAFT_*` environment variables are still read.
+- `solvecraft-cli` remains as a deprecated alias for one release; it forwards to
+  `solidcraft-cli` and prints a note. Agents: `claude mcp add solidcraft -- solidcraft-cli mcp`;
+  an existing `claude mcp add solvecraft -- solvecraft-cli mcp` setup keeps working.
+- Windows: the `.msi` upgrades the existing installation in place (now in
+  `Program Files\SolidCraft`). Linux: the `solidcraft` `.deb`/`.rpm` replaces the `solvecraft`
+  package. The Flatpak app ID stays `ai.storyteller.solvecraft`, so `flatpak update` just works,
+  and existing AppImages find the update.
+- macOS: quit the app, move the old `SolveCraft.app` to the Trash (your designs and settings
+  stay), then drag `SolidCraft.app` from the DMG onto Applications and pin it in the Dock.
+- Details: [compatibility notes](https://github.com/bherbruck/solidcraft/blob/main/docs/compatibility.md).
+
+Documentation, the browser app and the Flatpak feed use the SolidCraft project Pages URLs;
+old-name Pages addresses are not permanent aliases.

 **Which file?**
 - **Windows:** `SolidCraft-{version}-windows-x64.exe` runs as is. Or install the `.msi`, or unzip the
@@ -26,12 +37,6 @@ continue; earlier AppImages still find updates.
 - **Web:** `solidcraft-web-{version}.zip` is a static site to host yourself.
 - `SHA256SUMS.txt`: `sha256sum -c SHA256SUMS.txt --ignore-missing`.

-**Updating macOS from SolveCraft.app:** quit the app, rename the existing app in
-Applications to `SolidCraft.app`, then drag the new app from the DMG onto Applications
-and choose **Replace**. If both names are already installed, move the old `SolveCraft.app`
-to the Trash. Remove any Dock shortcut with the old name and pin the new app. Designs
-and settings are unchanged. The DMG includes these instructions.
-
 For Flatpak feed installation and updates, add Flathub for the required runtime before
 installing SolidCraft; keep both remotes in the same user installation:

@@ -48,7 +48,7 @@ jobs:
      - name: Build the book
        run: cargo xtask book
      - name: Build the web app
-        working-directory: apps/solvecraft-web
+        working-directory: apps/solidcraft-web
        run: trunk build --release --public-url /solidcraft/app/
      - name: Assemble the site
        run: |
@@ -6,13 +6,13 @@ kernel, and a desktop UI that agents can drive. Projects published by
 [storytold](https://github.com/storytold) can serve as references for implementation conventions.
 Any code adapted from other projects (MIT OR Apache-2.0) is noted in ATTRIBUTION.md.

-## Product name and compatibility
-SolidCraft is the displayed product name; `solidcraft` is the repository name. Keep existing
-`solvecraft` crate/binary names, `.solvecraft` files, format markers, environment variables,
-settings/recovery paths and package IDs compatible. Published SolveCraft release artifacts
-and attribution records keep their historical names. Public docs/web/Flatpak deployments
-use project Pages `/solidcraft/`; do not add permanent old-name Pages aliases. See README's
-compatibility notes.
+## Product name
+SolidCraft everywhere: crates `solidcraft-*`, binaries `solidcraft` and `solidcraft-cli`,
+`.solidcraft` designs, the `solidcraft/N` format tag, `SOLIDCRAFT_*` environment variables,
+settings and recovery folders, the MCP server name, docs, CI and packaging. The old name
+survives only in the explicit compatibility shims listed in `docs/compatibility.md`; don't add
+new uses of it anywhere else. Public docs/web/Flatpak deployments use project Pages
+`/solidcraft/`; do not add permanent old-name Pages aliases.

 ## Start every session here
 1. Read `plan/STATUS.md` (current milestone, next task), then the task in `plan/execution-plan.md`
@@ -33,15 +33,15 @@ People trust SolidCraft with their designs; a crash loses their work. **This out
 - **Input-derived numbers are hostile** (command parameters, design files, control-channel
  input): `get()` not `[i]`, finite checks, caps on sizes and loop counts.
 - **Third-party kernel calls are guarded:** everything that calls `truck` goes through
-  `solvecraft_kernel::guard`, which turns a panic into `KernelError::Internal`.
+  `solidcraft_kernel::guard`, which turns a panic into `KernelError::Internal`.
 - **Last-resort guard:** `Session::execute` runs every command under `catch_unwind`; an escaped
  panic restores the design and reports `EngineError::Internal`.
 - **Crash reports:** the desktop app writes every panic and every unclean exit to a local crash folder,
-  with the design and the commands that reproduce it (`solvecraft_engine::crash`, docs/crash-reports.md).
+  with the design and the commands that reproduce it (`solidcraft_engine::crash`, docs/crash-reports.md).
  When someone says the app crashed, look there first: `solidcraft-cli crashes`, `crashes show <id>`,
  `crashes replay <id>` (or the `diagnostics.crash_reports` command / MCP `crash_reports` tool).
 - **Prove it:** every crash fix lands with a regression test (see `hostile_params_never_panic`); a
-  crash report's `design.solvecraft` + `replay.json` is the test's starting point.
+  crash report's `design.solidcraft` + `replay.json` is the test's starting point.
 - Every production crate root carries
  `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`.

@@ -127,9 +127,9 @@ before the draft is verified.
  - `{"id":2,"method":"ui.start","params":{"command":"sketch.create"}}` then `ui.click {x, y}`
  - `{"id":3,"method":"ui.screenshot","params":{"path":"/tmp/shot.png"}}` then read the PNG.
 - **For UI work, look at the result** (screenshot, read the PNG). Without a window use
-  `ui.render` or `solvecraft-cli snapshot`.
- Headless: `solvecraft-cli run script.json --out part.step`, `solvecraft-cli eval design.solvecraft`,
-  `solvecraft-cli snapshot script.json --out shot.png`, `solvecraft-cli commands`.
+  `ui.render` or `solidcraft-cli snapshot`.
+- Headless: `solidcraft-cli run script.json --out part.step`, `solidcraft-cli eval design.solidcraft`,
+  `solidcraft-cli snapshot script.json --out shot.png`, `solidcraft-cli commands`.
 - Reference tests: `cargo xtask oracle` replays `tests/oracle/*/recipe.json` and compares with
  each case's `expected.json` (analytic or FreeCAD values; writes `docs/oracle.md`). Expected
  values never come from a commercial CAD product.
@@ -4,8 +4,8 @@ Every non-code asset in this repository (images, icons, fonts, example parts) is
 its author, source and licence. `cargo xtask assets` (part of `cargo xtask ci`) fails if an asset
 file is missing from this table.

-**Policy (mandatory):** SolveCraft contains **no Autodesk iconography, images, artwork, fonts,
-templates, materials or help text.** Every asset is original work by SolveCraft contributors or
+**Policy (mandatory):** SolidCraft contains **no Autodesk iconography, images, artwork, fonts,
+templates, materials or help text.** Every asset is original work by SolidCraft contributors or
 third-party material under an open licence. Screenshots of Autodesk software are never committed.

 Generated-in-code assets are original and have no file to list:
@@ -36,16 +36,16 @@ Generated-in-code assets are original and have no file to list:
 | assets/icon.iconset/icon_256x256@2x.png | SolidCraft contributors | native sips export from assets/icon.png | MIT OR Apache-2.0 |
 | assets/icon.iconset/icon_512x512.png | SolidCraft contributors | native sips export from assets/icon.png | MIT OR Apache-2.0 |
 | assets/icon.iconset/icon_512x512@2x.png | SolidCraft contributors | native sips export from assets/icon.png | MIT OR Apache-2.0 |
-| docs/screenshots/sample-plate.png | SolveCraft contributors | screenshot of SolveCraft itself (`solvecraft --sample`) | MIT OR Apache-2.0 |
-| docs/screenshots/enclosure-demo-0.2.1.gif | SolveCraft contributors | original electronics enclosure screen recording of the actual SolveCraft 0.2.1 English desktop UI, generated with examples/demo/record_ui.sh and its original animated pointer overlay (4× playback) | MIT OR Apache-2.0 |
-| docs/screenshots/enclosure-demo-0.2.1.mp4 | SolveCraft contributors | original electronics enclosure screen recording of the actual SolveCraft 0.2.1 English desktop UI, generated with examples/demo/record_ui.sh and its original animated pointer overlay (4× playback) | MIT OR Apache-2.0 |
-| docs/book/src/generated/sample-plate.png | SolveCraft contributors | copy of docs/screenshots/sample-plate.png made by `cargo xtask book` (gitignored) | MIT OR Apache-2.0 |
-| docs/book/src/generated/bracket.png | SolveCraft contributors | rendered by `cargo xtask book` (`solvecraft-cli snapshot examples/bracket.json`; gitignored) | MIT OR Apache-2.0 |
-| docs/book/src/generated/enclosure.png | SolveCraft contributors | rendered by `cargo xtask book` (`solvecraft-cli snapshot docs/book/scripts/enclosure.json`; gitignored) | MIT OR Apache-2.0 |
-| docs/book/src/generated/revolve.png | SolveCraft contributors | rendered by `cargo xtask book` (`solvecraft-cli snapshot docs/book/scripts/revolve.json`; gitignored) | MIT OR Apache-2.0 |
-| docs/book/src/generated/sheet-metal.png | SolveCraft contributors | rendered by `cargo xtask book` (`solvecraft-cli snapshot docs/book/scripts/sheet-metal.json`; gitignored) | MIT OR Apache-2.0 |
+| docs/screenshots/sample-plate.png | SolidCraft contributors | screenshot of SolidCraft itself (`solidcraft --sample`) | MIT OR Apache-2.0 |
+| docs/screenshots/enclosure-demo-0.2.1.gif | SolidCraft contributors | original electronics enclosure screen recording of the actual SolidCraft 0.2.1 English desktop UI, generated with examples/demo/record_ui.sh and its original animated pointer overlay (4× playback) | MIT OR Apache-2.0 |
+| docs/screenshots/enclosure-demo-0.2.1.mp4 | SolidCraft contributors | original electronics enclosure screen recording of the actual SolidCraft 0.2.1 English desktop UI, generated with examples/demo/record_ui.sh and its original animated pointer overlay (4× playback) | MIT OR Apache-2.0 |
+| docs/book/src/generated/sample-plate.png | SolidCraft contributors | copy of docs/screenshots/sample-plate.png made by `cargo xtask book` (gitignored) | MIT OR Apache-2.0 |
+| docs/book/src/generated/bracket.png | SolidCraft contributors | rendered by `cargo xtask book` (`solidcraft-cli snapshot examples/bracket.json`; gitignored) | MIT OR Apache-2.0 |
+| docs/book/src/generated/enclosure.png | SolidCraft contributors | rendered by `cargo xtask book` (`solidcraft-cli snapshot docs/book/scripts/enclosure.json`; gitignored) | MIT OR Apache-2.0 |
+| docs/book/src/generated/revolve.png | SolidCraft contributors | rendered by `cargo xtask book` (`solidcraft-cli snapshot docs/book/scripts/revolve.json`; gitignored) | MIT OR Apache-2.0 |
+| docs/book/src/generated/sheet-metal.png | SolidCraft contributors | rendered by `cargo xtask book` (`solidcraft-cli snapshot docs/book/scripts/sheet-metal.json`; gitignored) | MIT OR Apache-2.0 |
 | crates/sketch/fonts/LiberationSans-Regular.ttf | Red Hat, Inc. (Liberation Fonts 2.x; digitized data Google) | https://github.com/liberationfonts (Debian fonts-liberation), unmodified; licence text in crates/sketch/fonts/OFL.txt; used for sketch Text outlines | SIL OFL 1.1 |
-| apps/solvecraft-web/fonts/BIZUDPGothic-Regular.ttf | The BIZ UDGothic Project Authors | https://github.com/googlefonts/morisawa-biz-ud-gothic (Google Fonts), unmodified; licence text in apps/solvecraft-web/fonts/OFL.txt; used for web UI Japanese font | SIL OFL 1.1 |
+| apps/solidcraft-web/fonts/BIZUDPGothic-Regular.ttf | The BIZ UDGothic Project Authors | https://github.com/googlefonts/morisawa-biz-ud-gothic (Google Fonts), unmodified; licence text in apps/solidcraft-web/fonts/OFL.txt; used for web UI Japanese font | SIL OFL 1.1 |
 | tests/oracle/17-loft/reference.stl | SolidCraft contributors | triangulation of our own recipe (tests/oracle/17-loft/recipe.json) built with FreeCAD as an external tool by tools/freecad-oracle | MIT OR Apache-2.0 |
 | tests/oracle/23-bracket-multifeature/reference.stl | SolidCraft contributors | triangulation of our own recipe (tests/oracle/23-bracket-multifeature/recipe.json) built with FreeCAD as an external tool by tools/freecad-oracle | MIT OR Apache-2.0 |
 | tests/oracle/28-blind-pocket-fillets/reference.stl | SolidCraft contributors | triangulation of our own recipe (tests/oracle/28-blind-pocket-fillets/recipe.json) built with FreeCAD as an external tool by tools/freecad-oracle | MIT OR Apache-2.0 |
@@ -69,25 +69,25 @@ Generated-in-code assets are original and have no file to list:

 ## Code adapted from sibling projects

-| SolveCraft file | Adapted from | Licence |
+| SolidCraft file | Adapted from | Licence |
 |---|---|---|
 | xtask/src/layers.rs | CADCraft `xtask/src/layers.rs` (dependency layering rules and tests) | MIT OR Apache-2.0 |
-| apps/solvecraft/src/control_server.rs | CADCraft `apps/cadcraft/src/control_server.rs` (loopback JSON-lines server) | MIT OR Apache-2.0 |
+| apps/solidcraft/src/control_server.rs | CADCraft `apps/cadcraft/src/control_server.rs` (loopback JSON-lines server) | MIT OR Apache-2.0 |
 | crates/ui-egui/src/lib.rs (screenshot queue, synthetic input) | CADCraft `crates/ui-egui/src/lib.rs` | MIT OR Apache-2.0 |
 | crates/ui-egui/src/control.rs (method dispatch and screenshot saving) | CADCraft `crates/ui-egui/src/control.rs` | MIT OR Apache-2.0 |
 | crates/ui-egui/src/gpu.rs (paint-callback structure) | CADCraft `crates/ui-egui/src/gpu.rs` | MIT OR Apache-2.0 |
 | crates/mcp/src/server.rs, crates/mcp/src/backend.rs (JSON-RPC framing, MCP lifecycle, control-port bridge) | CADCraft `crates/mcp/src/{server,backend}.rs` | MIT OR Apache-2.0 |
 | crates/mcp/src/tools.rs (tool schema helpers and argument checking) | CADCraft `crates/mcp/src/tools.rs`, GridCraft `crates/mcp/src/tools.rs` | MIT OR Apache-2.0 |
 | crates/io/src/threemf.rs (bounded zip part reading and writing) | GridCraft `crates/xlsx/src/package.rs` | MIT OR Apache-2.0 |
-| crates/ui-egui/src/titlebar.rs (title bar drag, caption buttons, resize zones, their tests) and the window setup in apps/solvecraft/src/main.rs | VectorCraft `crates/ui-egui/src/titlebar.rs`, `apps/vectorcraft/src/main.rs` | MIT OR Apache-2.0 |
+| crates/ui-egui/src/titlebar.rs (title bar drag, caption buttons, resize zones, their tests) and the window setup in apps/solidcraft/src/main.rs | VectorCraft `crates/ui-egui/src/titlebar.rs`, `apps/vectorcraft/src/main.rs` | MIT OR Apache-2.0 |
 | LICENSE-MIT, LICENSE-APACHE (licence text) | CADCraft | — |
 | .github/workflows/release.yml, .github/workflows/packaging-lint.yml and packaging/ (release pipeline: Linux AppImage/deb/rpm/Flatpak/tar.gz, FreeBSD, macOS dmg, Windows MSI/portable zip, web zip; AppRun, nfpm, Flatpak, WiX and Info.plist templates) | PhotoCraft (https://github.com/storytold/photocraft) `.github/workflows/{release,packaging-lint}.yml`, `packaging/` | Apache-2.0 |

 ## Recovered contributions

-| SolveCraft file | Original contribution | Licence |
+| SolidCraft file | Original contribution | Licence |
 |---|---|---|
-| crates/ui-egui/src/viewport.rs (`nearest_quarter_turn`, `axis_view_orbit`) | N3MI-DG's [PR #101](https://github.com/bherbruck/solvecraft/pull/101): [minimal TOP/BOTTOM turns](https://github.com/bherbruck/solvecraft/commit/c28e780f52490784ef5886f094b9d3f6d10c3e3f) and [drag-to-orbit](https://github.com/bherbruck/solvecraft/commit/f30b30be6ecc4e2e6544a851243137c01a354934), adapted to the axis gizmo | MIT OR Apache-2.0 |
+| crates/ui-egui/src/viewport.rs (`nearest_quarter_turn`, `axis_view_orbit`) | N3MI-DG's [PR #101](https://github.com/bherbruck/solidcraft/pull/101): [minimal TOP/BOTTOM turns](https://github.com/bherbruck/solidcraft/commit/c28e780f52490784ef5886f094b9d3f6d10c3e3f) and [drag-to-orbit](https://github.com/bherbruck/solidcraft/commit/f30b30be6ecc4e2e6544a851243137c01a354934), adapted to the axis gizmo | MIT OR Apache-2.0 |

 ## Vendored third-party code

@@ -6,13 +6,13 @@ kernel, and a desktop UI that agents can drive. Projects published by
 [storytold](https://github.com/storytold) can serve as references for implementation conventions.
 Any code adapted from other projects (MIT OR Apache-2.0) is noted in ATTRIBUTION.md.

-## Product name and compatibility
-SolidCraft is the displayed product name; `solidcraft` is the repository name. Keep existing
-`solvecraft` crate/binary names, `.solvecraft` files, format markers, environment variables,
-settings/recovery paths and package IDs compatible. Published SolveCraft release artifacts
-and attribution records keep their historical names. Public docs/web/Flatpak deployments
-use project Pages `/solidcraft/`; do not add permanent old-name Pages aliases. See README's
-compatibility notes.
+## Product name
+SolidCraft everywhere: crates `solidcraft-*`, binaries `solidcraft` and `solidcraft-cli`,
+`.solidcraft` designs, the `solidcraft/N` format tag, `SOLIDCRAFT_*` environment variables,
+settings and recovery folders, the MCP server name, docs, CI and packaging. The old name
+survives only in the explicit compatibility shims listed in `docs/compatibility.md`; don't add
+new uses of it anywhere else. Public docs/web/Flatpak deployments use project Pages
+`/solidcraft/`; do not add permanent old-name Pages aliases.

 ## Start every session here
 1. Read `plan/STATUS.md` (current milestone, next task), then the task in `plan/execution-plan.md`
@@ -33,15 +33,15 @@ People trust SolidCraft with their designs; a crash loses their work. **This out
 - **Input-derived numbers are hostile** (command parameters, design files, control-channel
  input): `get()` not `[i]`, finite checks, caps on sizes and loop counts.
 - **Third-party kernel calls are guarded:** everything that calls `truck` goes through
-  `solvecraft_kernel::guard`, which turns a panic into `KernelError::Internal`.
+  `solidcraft_kernel::guard`, which turns a panic into `KernelError::Internal`.
 - **Last-resort guard:** `Session::execute` runs every command under `catch_unwind`; an escaped
  panic restores the design and reports `EngineError::Internal`.
 - **Crash reports:** the desktop app writes every panic and every unclean exit to a local crash folder,
-  with the design and the commands that reproduce it (`solvecraft_engine::crash`, docs/crash-reports.md).
+  with the design and the commands that reproduce it (`solidcraft_engine::crash`, docs/crash-reports.md).
  When someone says the app crashed, look there first: `solidcraft-cli crashes`, `crashes show <id>`,
  `crashes replay <id>` (or the `diagnostics.crash_reports` command / MCP `crash_reports` tool).
 - **Prove it:** every crash fix lands with a regression test (see `hostile_params_never_panic`); a
-  crash report's `design.solvecraft` + `replay.json` is the test's starting point.
+  crash report's `design.solidcraft` + `replay.json` is the test's starting point.
 - Every production crate root carries
  `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`.

@@ -104,9 +104,9 @@ before the draft is verified.
  - `{"id":2,"method":"ui.start","params":{"command":"sketch.create"}}` then `ui.click {x, y}`
  - `{"id":3,"method":"ui.screenshot","params":{"path":"/tmp/shot.png"}}` then read the PNG.
 - **For UI work, look at the result** (screenshot, read the PNG). Without a window use
-  `ui.render` or `solvecraft-cli snapshot`.
- Headless: `solvecraft-cli run script.json --out part.step`, `solvecraft-cli eval design.solvecraft`,
-  `solvecraft-cli snapshot script.json --out shot.png`, `solvecraft-cli commands`.
+  `ui.render` or `solidcraft-cli snapshot`.
+- Headless: `solidcraft-cli run script.json --out part.step`, `solidcraft-cli eval design.solidcraft`,
+  `solidcraft-cli snapshot script.json --out shot.png`, `solidcraft-cli commands`.
 - Reference tests: `cargo xtask oracle` replays `tests/oracle/*/recipe.json` and compares with
  each case's `expected.json` (analytic or FreeCAD values; writes `docs/oracle.md`). Expected
  values never come from a commercial CAD product.
@@ -22,14 +22,14 @@ cargo xtask test                                   # unit, engine and UI-scenari
 cargo xtask ci                                     # everything a PR must pass (see below)
 ```

-SolidCraft is the product and repository name. Cargo packages and executables retain
-their `solvecraft` names for compatibility with existing scripts and MCP clients.
+SolidCraft is the product, repository, Cargo package and executable name.
 Build the desktop app with `cargo build --release -p solidcraft`, or the CLI with
 `cargo build --release -p solidcraft-cli`. Run the CLI with
 `cargo run --release -p solidcraft-cli -- commands` (or `target/release/solidcraft-cli commands`
-after building). There is no Cargo package named `solidcraft`.
+after building). The old name appears only in the compatibility shims listed in
+[docs/compatibility.md](docs/compatibility.md); don't add new uses of it.

-Web: `cd apps/solvecraft-web && trunk serve --release`, then open the printed URL (`?sample`
+Web: `cd apps/solidcraft-web && trunk serve --release`, then open the printed URL (`?sample`
 opens the sample part, `?webgl` forces WebGL2). Saving and opening files in the browser needs
 HTTPS or localhost, because it uses the Origin Private File System.

@@ -43,7 +43,7 @@ loader wgpu renders through, and libdbus-1, which rfd's file dialogs reach xdg-d
 through (a dialog then never appears and the pick returns no path):

 ```
-ERROR solvecraft: winit EventLoopError: ... The wayland library could not be loaded
+ERROR solidcraft: winit EventLoopError: ... The wayland library could not be loaded
 ERROR eframe::native::run: Exiting because of error: WGPU error: Failed to create surface for any enabled backend: {}
 ERROR rfd::backend::xdg_desktop_portal::portal::libdbus: Can't connect to a portal: libdbus-1.so not found
 ```
@@ -59,8 +59,8 @@ The default development shell retains the Rust/C toolchain already on `PATH`;
 To launch, use `nix run .#solidcraft -- --sample`. To install the app's terminal
 commands, desktop entry and generated icons, use `nix profile install .#solidcraft`.
 `nix build` alone creates a build result; it does not install a launcher in your
-desktop menu. The installed `solidcraft` command and compatible `solvecraft`
-command run the same wrapped app; `solvecraft-cli` is included as well. See
+desktop menu. The installed `solidcraft` command runs the wrapped app; `solidcraft-cli` is included as
+well. See
 [Nix installation and troubleshooting](docs/nix.md) for remote-flake commands,
 desktop integration and how to distinguish an old executable on `PATH`.

@@ -82,7 +82,7 @@ The [README](README.md#architecture) has the layer table. The short version:
  commands.
 - `crates/ui-egui`: the desktop/web front end (egui + wgpu). It's swappable; nothing below it
  depends on egui.
- `crates/mcp`, `apps/solvecraft`, `apps/solvecraft-cli`, `apps/solvecraft-web`.
+- `crates/mcp`, `apps/solidcraft`, `apps/solidcraft-cli`, `apps/solidcraft-web`.

 `cargo xtask layers` fails the build if a lower layer depends on a higher one.

@@ -107,7 +107,7 @@ The [README](README.md#architecture) has the layer table. The short version:
   - Non-test code never uses `unwrap`, `expect`, `panic!` or indexing on input-derived data.
     There's no `unsafe`, and clippy denies it.
   - An unsupported case returns an error ("not supported yet: …"); it never panics.
-   - Every call into truck goes through `solvecraft_kernel::guard`.
+   - Every call into truck goes through `solidcraft_kernel::guard`.
   - Every crash fix comes with a regression test.
 5. **Everything is a command, with a test.** A new feature means a `CommandSpec` in
   `crates/engine/src/cmd/`, engine tests that measure the result (volume, area,
@@ -159,12 +159,12 @@ Pull requests skip a few heavy tests (one to four minutes each), which run on ev
 `main` and nightly; check the `main` run after merging. They are listed in
 `.config/nextest.toml` and the [testing page](docs/book/src/dev/testing.md):

- `solvecraft-engine`: `tests::hostile_params_never_panic`, everything in `tests::robustness`,
+- `solidcraft-engine`: `tests::hostile_params_never_panic`, everything in `tests::robustness`,
  `pattern_suppress_tests::enclosure_arc_extinction_keeps_a_real_sharp_inner_lip_after_resize_and_reopen`,
  `pattern_suppress_tests::enclosure_datums_follow_wall_height_and_board_depth_with_material_proofs`,
  `cmd::plastic::tests::enclosure_snap_fit_follows_resized_front_wall`
- `solvecraft-kernel`: `tests::boolean_identity_on_tangent_primitives`
- `solvecraft-ui-egui` scenarios: `acceptance_sensor_enclosure`
+- `solidcraft-kernel`: `tests::boolean_identity_on_tangent_primitives`
+- `solidcraft-ui-egui` scenarios: `acceptance_sensor_enclosure`

 **The reference tests** are 76 parts in [`tests/oracle/`](tests/oracle/), each a `recipe.json`
 in our own format with an `expected.json` beside it. SolidCraft rebuilds the recipe and compares
@@ -3300,8 +3300,8 @@ dependencies = [
 "quick-xml 0.38.4",
 "rfd",
 "serde_json",
- "solvecraft-engine",
- "solvecraft-ui-egui",
+ "solidcraft-engine",
+ "solidcraft-ui-egui",
 "winit",
 ]

@@ -3310,43 +3310,43 @@ name = "solidcraft-cli"
 version = "0.5.0"
 dependencies = [
 "serde_json",
- "solvecraft-engine",
- "solvecraft-mcp",
+ "solidcraft-engine",
+ "solidcraft-mcp",
 ]

 [[package]]
-name = "solvecraft-doc"
+name = "solidcraft-doc"
 version = "0.5.0"
 dependencies = [
 "log",
 "serde",
 "serde_json",
 "sha2",
- "solvecraft-geom",
- "solvecraft-kernel",
- "solvecraft-sketch",
+ "solidcraft-geom",
+ "solidcraft-kernel",
+ "solidcraft-sketch",
 "thiserror 2.0.21",
 "web-time",
 ]

 [[package]]
-name = "solvecraft-engine"
+name = "solidcraft-engine"
 version = "0.5.0"
 dependencies = [
 "log",
 "serde",
 "serde_json",
- "solvecraft-doc",
- "solvecraft-geom",
- "solvecraft-io",
- "solvecraft-kernel",
- "solvecraft-render",
- "solvecraft-sketch",
+ "solidcraft-doc",
+ "solidcraft-geom",
+ "solidcraft-io",
+ "solidcraft-kernel",
+ "solidcraft-render",
+ "solidcraft-sketch",
 "thiserror 2.0.21",
 ]

 [[package]]
-name = "solvecraft-geom"
+name = "solidcraft-geom"
 version = "0.5.0"
 dependencies = [
 "serde",
@@ -3355,24 +3355,24 @@ dependencies = [
 ]

 [[package]]
-name = "solvecraft-io"
+name = "solidcraft-io"
 version = "0.5.0"
 dependencies = [
 "quick-xml 0.38.4",
- "solvecraft-doc",
- "solvecraft-geom",
- "solvecraft-kernel",
+ "solidcraft-doc",
+ "solidcraft-geom",
+ "solidcraft-kernel",
 "thiserror 2.0.21",
 "zip",
 ]

 [[package]]
-name = "solvecraft-kernel"
+name = "solidcraft-kernel"
 version = "0.5.0"
 dependencies = [
 "log",
 "serde",
- "solvecraft-geom",
+ "solidcraft-geom",
 "thiserror 2.0.21",
 "truck-meshalgo",
 "truck-modeling",
@@ -3382,36 +3382,36 @@ dependencies = [
 ]

 [[package]]
-name = "solvecraft-mcp"
+name = "solidcraft-mcp"
 version = "0.5.0"
 dependencies = [
 "serde_json",
- "solvecraft-engine",
+ "solidcraft-engine",
 ]

 [[package]]
-name = "solvecraft-render"
+name = "solidcraft-render"
 version = "0.5.0"
 dependencies = [
 "image",
 "serde",
 "serde_json",
- "solvecraft-geom",
+ "solidcraft-geom",
 ]

 [[package]]
-name = "solvecraft-sketch"
+name = "solidcraft-sketch"
 version = "0.5.0"
 dependencies = [
 "serde",
 "serde_json",
- "solvecraft-geom",
+ "solidcraft-geom",
 "thiserror 2.0.21",
 "ttf-parser",
 ]

 [[package]]
-name = "solvecraft-ui-egui"
+name = "solidcraft-ui-egui"
 version = "0.5.0"
 dependencies = [
 "egui",
@@ -3420,13 +3420,13 @@ dependencies = [
 "log",
 "serde",
 "serde_json",
- "solvecraft-engine",
+ "solidcraft-engine",
 "ttf-parser",
 "web-time",
 ]

 [[package]]
-name = "solvecraft-web"
+name = "solidcraft-web"
 version = "0.5.0"
 dependencies = [
 "eframe",
@@ -3434,8 +3434,8 @@ dependencies = [
 "js-sys",
 "log",
 "serde_json",
- "solvecraft-engine",
- "solvecraft-ui-egui",
+ "solidcraft-engine",
+ "solidcraft-ui-egui",
 "wasm-bindgen",
 "wasm-bindgen-futures",
 "web-sys",
@@ -14,15 +14,15 @@ repository = "https://github.com/bherbruck/solidcraft"

 [workspace.dependencies]
 # internal
-solvecraft-geom = { path = "crates/geom" }
-solvecraft-sketch = { path = "crates/sketch" }
-solvecraft-kernel = { path = "crates/kernel" }
-solvecraft-render = { path = "crates/render" }
-solvecraft-doc = { path = "crates/doc" }
-solvecraft-io = { path = "crates/io" }
-solvecraft-engine = { path = "crates/engine" }
-solvecraft-ui-egui = { path = "crates/ui-egui" }
-solvecraft-mcp = { path = "crates/mcp" }
+solidcraft-geom = { path = "crates/geom" }
+solidcraft-sketch = { path = "crates/sketch" }
+solidcraft-kernel = { path = "crates/kernel" }
+solidcraft-render = { path = "crates/render" }
+solidcraft-doc = { path = "crates/doc" }
+solidcraft-io = { path = "crates/io" }
+solidcraft-engine = { path = "crates/engine" }
+solidcraft-ui-egui = { path = "crates/ui-egui" }
+solidcraft-mcp = { path = "crates/mcp" }

 # foundation
 thiserror = "2"
@@ -96,7 +96,7 @@ codegen-units = 16
 # binary). See docs/crash-reports.md.
 debug = "line-tables-only"

-# truck-shapeops with SolveCraft fixes (Apache-2.0, see vendor/truck-shapeops and ATTRIBUTION.md).
+# truck-shapeops with SolidCraft fixes (Apache-2.0, see vendor/truck-shapeops and ATTRIBUTION.md).
 [patch.crates-io]
 truck-shapeops = { path = "vendor/truck-shapeops" }
 truck-stepio = { path = "vendor/truck-stepio" }
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2026 SolveCraft contributors
+Copyright (c) 2026 SolidCraft contributors

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -1,5 +1,5 @@
-SolveCraft
-Copyright (c) 2026 SolveCraft contributors.
+SolidCraft
+Copyright (c) 2026 SolidCraft contributors.
 Licensed under the MIT License or the Apache License, Version 2.0, at your option
 (LICENSE-MIT, LICENSE-APACHE).

@@ -7,10 +7,10 @@ Third-party material

 Software dependencies are listed in Cargo.lock; their licences are in THIRD-PARTY-LICENSES.txt
 (`cargo xtask licences`), which the programs also carry (Help > About > Licences,
-`solvecraft-cli licences`). The geometry kernel builds on the truck crates
+`solidcraft-cli licences`). The geometry kernel builds on the truck crates
 (truck-modeling, truck-shapeops, truck-meshalgo, truck-stepio, truck-topology and their
 dependencies, https://github.com/ricosjp/truck), licensed under the Apache License 2.0 and used
-as libraries. truck-shapeops 0.4.0 is vendored in vendor/truck-shapeops with SolveCraft
+as libraries. truck-shapeops 0.4.0 is vendored in vendor/truck-shapeops with SolidCraft
 modifications (listed in vendor/README.md and marked in the source); its licence is in
 vendor/truck-shapeops/LICENSE. Copyright (c) RICOS Co. Ltd.

@@ -23,6 +23,6 @@ Most bundled assets are drawn in code or contributed originally; third-party fon
 for sketch text, BIZ UDPGothic for web Japanese display) are licensed under SIL OFL 1.1. The
 per-file list is in ATTRIBUTION.md.

-SolveCraft is an independent project and is not affiliated with, sponsored by or endorsed by
+SolidCraft is an independent project and is not affiliated with, sponsored by or endorsed by
 Autodesk, Inc. Autodesk and Fusion are trademarks of Autodesk, Inc.; they are used here only to
 describe compatibility goals.
@@ -27,14 +27,12 @@ and help is welcome: see [CONTRIBUTING.md](CONTRIBUTING.md).

 ## Name and compatibility

-SolidCraft was previously called SolveCraft. The product display name and repository are
-changing; existing identifiers remain compatible: `.solvecraft` designs, `solvecraft-cli`,
-Cargo package names, settings/recovery locations and package IDs keep their existing names.
-Published 0.2.0 and 0.2.1 packages and demo recordings retain their original SolveCraft branding
-and filenames.
-
-On macOS, the DMG contains `SolidCraft.app`. To replace an older `SolveCraft.app`
-without installing a second copy, follow the [macOS upgrade instructions](https://bherbruck.github.io/solidcraft/guide/getting-started.html#macos).
+SolidCraft was renamed from an earlier working name. Since 0.5.0 everything uses the new
+name: the `solidcraft` and `solidcraft-cli` programs, `.solidcraft` designs, `SOLIDCRAFT_*`
+environment variables, settings folders and the `solidcraft` MCP server. Upgrading keeps
+working: designs, settings, recovery files, environment variables and CLI/MCP setups from
+earlier builds carry over. Every compatibility shim is listed in
+[docs/compatibility.md](docs/compatibility.md).

 Use the SolidCraft documentation and web-app URLs above. GitHub redirects links to the
 renamed repository; old-name Pages and Flatpak URLs are not maintained as permanent aliases.
@@ -77,7 +75,7 @@ renamed repository; old-name Pages and Flatpak URLs are not maintained as perman
  retained shallow prismatic pockets, exact line/arc/circle DXF outlines and bend tables;
  plastic enclosure features and rules. Pocket depth and side survive unfold/refold and appear
  separately from through-hole outlines in the flat preview and DXF.
- **Files**: designs as JSON (`.solvecraft`), export to STEP (AP242 with body names, colours and
+- **Files**: designs as JSON (`.solidcraft`), export to STEP (AP242 with body names, colours and
  components as assemblies; revolved faces as native planes, cylinders, cones, spheres and tori),
  IGES 5.3 (manifold solid B-reps with names and colours), 3MF, STL (binary/ASCII) and OBJ;
  3MF, STL and OBJ import as mesh bodies (they render, measure, move and export; solid features
@@ -92,9 +90,9 @@ renamed repository; old-name Pages and Flatpak URLs are not maintained as perman
  control channel so agents and tests can drive it.
  Feature errors and Help can open an editable **Create Issue** draft with relevant context
  and an optional reviewed screenshot; opening GitHub does not submit the report.
- **Headless CLI** `solvecraft-cli`: run command scripts, measure (volume, area, centre of mass,
+- **Headless CLI** `solidcraft-cli`: run command scripts, measure (volume, area, centre of mass,
  face/edge/vertex counts), export, render PNG snapshots and replay reference recipes.
- **MCP server** `solvecraft-cli mcp`: AI agents model, measure and look at parts headless or
+- **MCP server** `solidcraft-cli mcp`: AI agents model, measure and look at parts headless or
  in the running app (see below).

 ## Build and run
@@ -130,7 +128,7 @@ sandbox does not expose hidraw devices, so the 3D mouse only works with native b
 Devices that send all six axes in HID report 1 (some homemade ones do) are recognised from their
 report descriptor, so they work as well.

-In the browser: `cd apps/solvecraft-web && trunk build --release --public-url ./` (WebGPU, or
+In the browser: `cd apps/solidcraft-web && trunk build --release --public-url ./` (WebGPU, or
 WebGL2 with `?webgl`; `?sample` opens the sample part).

 ## Scripts
@@ -148,12 +146,12 @@ A script is a JSON list of commands, the same ones the UI runs:

 ## AI agents (MCP)

-`solvecraft-cli mcp` is a [Model Context Protocol](https://modelcontextprotocol.io) server on
+`solidcraft-cli mcp` is a [Model Context Protocol](https://modelcontextprotocol.io) server on
 stdio. Headless it runs its own design session; with `--connect 127.0.0.1:PORT` it drives the app
-started with `solvecraft --control PORT`, so you can watch the agent model. Tools:
+started with `solidcraft --control PORT`, so you can watch the agent model. Tools:
 `list_commands`, `execute`, `batch`, `inspect_design`, `measure`, `body_topology`,
 `set_parameter`, `screenshot` (returns the image), `export`, `undo`, `redo`, `new_design`, `open`,
-`save`. Claude Code: `claude mcp add solvecraft -- solvecraft-cli mcp`. Details, client
+`save`. Claude Code: `claude mcp add solidcraft -- solidcraft-cli mcp`. Details, client
 configuration and an example session: [docs/mcp.md](docs/mcp.md).

 ## Architecture
@@ -167,7 +165,7 @@ configuration and an example session: [docs/mcp.md](docs/mcp.md).
 | L3 | `io` | design files, STL/OBJ/STEP/3MF export, STEP and 3MF/STL import features |
 | L4 | `engine` | the session and the command registry (everything is a command) |
 | L5 | `ui-egui`, `mcp` | the swappable desktop front end; the MCP server (headless or bridged to the app) |
-| apps | `solvecraft`, `solvecraft-cli` | desktop app, headless CLI |
+| apps | `solidcraft`, `solidcraft-cli` | desktop app, headless CLI |
 <!-- ANCHOR_END: architecture -->

 ## Contributing
@@ -57,7 +57,7 @@ PCB / Package, Render, Animation, Simulation, Manufacture/CAM, Drawings.
 | M11 | 2D drawings | deferred | — |
 | M12 | Release: cross-platform packages, verification and deliberate publication implemented; original current-UI demo refreshed. Trusted distribution signing and broader performance work remain | in progress | 16 |
 | M14 | Configurations: a table of rows (parameter expressions and feature suppressions per row) switched with config.activate (undoable, all or nothing), kept through parameter renames and feature deletes (config.configure, config.table, config.column/row/activate). Per-row body materials and appearances (library looks, custom colour/opacity and clearing overrides), undoable activation and save/reopen: done. Ordered typed configuration rules, atomic validation and structured rule editing: done. Component appearance and certified semantic face style columns, atomic preview/apply and independent-copy remapping: done. Exact constructed sketch-side and immutable imported-face lineage now preserve legacy names and reject retargeting. Left: ambiguous shifted/two-sided caps | in progress | 4 |
-| M13 | Never lose work: atomic saves (temporary file, flush, rename; a crash at any moment leaves the old file or the new one) with the replaced version kept as `<file>.bak`; autosave of unsaved changes to the recovery folder every 5 minutes (preference) and after big operations, only when something changed; "Recover unsaved design?" on the next launch (`doc.recovery_list`, `doc.recover`, `doc.recovery_discard`); a kill-mid-save test (process killed while saving a 0.5 MB design 25 times). File format: `"format": "solvecraft/12"`, older formats upgraded step by step (`doc::format`), newer ones refused with a message, out-of-range numbers and broken placements refused; a corpus of designs saved by M0, components-era, joints-era and current builds (apps/solvecraft-cli/tests/corpus) that must open and evaluate as saved; damaged and hostile variants (truncation, bit flips, hostile values, removed keys, repeated features, deep nesting) never panic | done | 6 |
+| M13 | Never lose work: atomic saves (temporary file, flush, rename; a crash at any moment leaves the old file or the new one) with the replaced version kept as `<file>.bak`; autosave of unsaved changes to the recovery folder every 5 minutes (preference) and after big operations, only when something changed; "Recover unsaved design?" on the next launch (`doc.recovery_list`, `doc.recover`, `doc.recovery_discard`); a kill-mid-save test (process killed while saving a 0.5 MB design 25 times). File format: `"format": "solidcraft/12"`, older formats upgraded step by step (`doc::format`), newer ones refused with a message, out-of-range numbers and broken placements refused; a corpus of designs saved by M0, components-era, joints-era and current builds (apps/solidcraft-cli/tests/corpus) that must open and evaluate as saved; damaged and hostile variants (truncation, bit flips, hostile values, removed keys, repeated features, deep nesting) never panic | done | 6 |

 ## Dimensioning and error reporting

@@ -1,6 +1,6 @@
 Third-party software in SolidCraft

-SolidCraft (the desktop app, solvecraft-cli and the web app) is built from the 454 crates below.
+SolidCraft (the desktop app, solidcraft-cli and the web app) is built from the 454 crates below.
 Generated by `cargo xtask licences` from Cargo.lock and the crates' own licence files.
 SolidCraft's own licence is in LICENSE-MIT and LICENSE-APACHE, and NOTICE.

@@ -13354,7 +13354,7 @@ Bundled fonts (SIL Open Font License, Version 1.1)
  Copyright 2012 Red Hat, Inc. (Liberation Fonts 2.x; digitized data Google)
  Source: https://github.com/liberationfonts

- BIZUDPGothic-Regular.ttf (apps/solvecraft-web/fonts/BIZUDPGothic-Regular.ttf)
+- BIZUDPGothic-Regular.ttf (apps/solidcraft-web/fonts/BIZUDPGothic-Regular.ttf)
  Copyright 2022 The BIZ UDGothic Project Authors (https://github.com/googlefonts/morisawa-biz-ud-mincho)
  Source: https://github.com/googlefonts/morisawa-biz-ud-gothic

@@ -20,6 +20,6 @@ name = "solvecraft-cli"
 path = "src/alias.rs"

 [dependencies]
-solvecraft-engine = { workspace = true }
-solvecraft-mcp = { workspace = true }
+solidcraft-engine = { workspace = true }
+solidcraft-mcp = { workspace = true }
 serde_json = { workspace = true }
@@ -4,7 +4,7 @@
 use std::sync::Mutex;

 use serde_json::{Value, json};
-use solvecraft_engine::crash;
+use solidcraft_engine::crash;

 const USAGE: &str = "usage: solidcraft-cli crashes [list [--json] | show <id> | replay <id> | dir | clear [<id>]]";

@@ -58,7 +58,7 @@ fn replay(report: &Value) -> Result<(), String> {
    let commands = script["commands"].as_array().cloned().unwrap_or_default();
    let mut s = match report["design_path"].as_str() {
        Some(d) => super::load(d)?,
-        None => solvecraft_engine::Session::default(),
+        None => solidcraft_engine::Session::default(),
    };
    std::panic::set_hook(Box::new(|info| {
        let loc = info.location().map_or_else(|| "(unknown)".to_string(), |l| format!("{}:{}", l.file(), l.line()));
@@ -9,8 +9,8 @@ use std::process::{Command, Stdio};
 use std::time::{Duration, Instant};

 use serde_json::{Value, json};
-use solvecraft_engine::fuzz;
-use solvecraft_engine::fuzz::boolean_case;
+use solidcraft_engine::fuzz;
+use solidcraft_engine::fuzz::boolean_case;

 fn flag<T: std::str::FromStr>(args: &[String], name: &str, default: T) -> T {
    args.iter().position(|a| a == name).and_then(|i| args.get(i + 1)).and_then(|v| v.parse().ok()).unwrap_or(default)
@@ -45,7 +45,7 @@ pub fn one(args: &[String]) -> Result<(), String> {
            design["minimal"] = json!({"outcome": m.outcome, "steps": m.steps.iter().map(|s| s.kind).collect::<Vec<_>>(), "script": m.script()});
        }
    }
-    let (a, b) = solvecraft_engine::fuzz::boolean_shapes(seed);
+    let (a, b) = solidcraft_engine::fuzz::boolean_shapes(seed);
    eprintln!("boolean {seed} {} {}", serde_json::to_string(&a).unwrap_or_default(), serde_json::to_string(&b).unwrap_or_default());
    let b = boolean_case(seed);
    let bp = PANICS.swap(0, std::sync::atomic::Ordering::SeqCst);
@@ -1,16 +1,16 @@
-//! SolveCraft headless command line.
+//! SolidCraft headless command line.
 //!
 //! ```text
-//! solidcraft-cli run <script.json|design.solvecraft|part.step|mesh.3mf> [--in design|part.step|mesh.3mf] [--out FILE]... [--save FILE] [--quiet]
-//! solidcraft-cli eval <script.json|design.solvecraft|part.step> (alias: inspect) measurements as JSON
-//! solidcraft-cli bench-open <design.solvecraft | part.step> [--parse-only] loading timings as JSON lines
+//! solidcraft-cli run <script.json|design.solidcraft|part.step|mesh.3mf> [--in design|part.step|mesh.3mf] [--out FILE]... [--save FILE] [--quiet]
+//! solidcraft-cli eval <script.json|design.solidcraft|part.step> (alias: inspect) measurements as JSON
+//! solidcraft-cli bench-open <design.solidcraft | part.step> [--parse-only] loading timings as JSON lines
 //! solidcraft-cli snapshot <script|design> --out shot.png [--width W] [--height H] [--view iso|front|top|…]
 //! solidcraft-cli exec <command> [json-params]                 run one command on an empty design
 //! solidcraft-cli commands                                     the command registry as JSON
 //! solidcraft-cli recipe <recipe.json>                         translate an oracle recipe to a script
 //! solidcraft-cli oracle <case-dir>...                         replay recipes and compare with expected.json
 //! solidcraft-cli mcp [--in design|script] [--connect HOST:PORT] MCP server on stdio (docs/mcp.md)
-//! solidcraft-cli licences                                     SolveCraft's licence and the third-party licences
+//! solidcraft-cli licences                                     SolidCraft's licence and the third-party licences
 //! solidcraft-cli icon --out F.png|F.ico [--size N]             the app icon (packaging; drawn, not a file)
 //! ```
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
@@ -28,21 +28,21 @@ use serde_json::{Value, json};
 #[path = "../../app_icon.rs"]
 mod app_icon;

-use solvecraft_engine::Session;
-use solvecraft_engine::render::{StandardView, render_png};
+use solidcraft_engine::Session;
+use solidcraft_engine::render::{StandardView, render_png};

 const USAGE: &str = "usage:
-  solidcraft-cli run <script.json|design.solvecraft|part.step> [--in design.solvecraft|part.step] [--out FILE]... [--save FILE] [--quiet] [--results]
-  solidcraft-cli run --in <design.solvecraft|part.step> [--out FILE]...
-  solidcraft-cli eval <script.json|design.solvecraft|part.step>     (alias: inspect; or --in FILE)
-  solidcraft-cli bench-open <design.solvecraft | part.step> [--parse-only]
+  solidcraft-cli run <script.json|design.solidcraft|part.step> [--in design.solidcraft|part.step] [--out FILE]... [--save FILE] [--quiet] [--results]
+  solidcraft-cli run --in <design.solidcraft|part.step> [--out FILE]...
+  solidcraft-cli eval <script.json|design.solidcraft|part.step>     (alias: inspect; or --in FILE)
+  solidcraft-cli bench-open <design.solidcraft | part.step> [--parse-only]
  solidcraft-cli snapshot <script|design> --out shot.png [--width W] [--height H] [--view iso|front|back|top|bottom|left|right]
  solidcraft-cli exec <command> [json-params]
  solidcraft-cli commands
  solidcraft-cli recipe <recipe.json>
  solidcraft-cli oracle <case-dir>... [--json]
  solidcraft-cli fuzz [--from N] [--count N] [--jobs J] [--timeout S] [--steps N] [--minimise] [--out DIR] [--report FILE]
-  solidcraft-cli mcp [--in design.solvecraft|script.json] [--connect 127.0.0.1:PORT]
+  solidcraft-cli mcp [--in design.solidcraft|script.json] [--connect 127.0.0.1:PORT]
  solidcraft-cli crashes [list [--json] | show <id> | replay <id> | dir | clear [<id>]]
  solidcraft-cli licences
  solidcraft-cli icon --out icon.png [--size 256] | --out icon.ico
@@ -81,7 +81,7 @@ fn main() -> ExitCode {
        Some("licences" | "licenses") => {
            // Written, not print!ed: a closed pipe (`| head`) is not a crash.
            use std::io::Write as _;
-            let _ = std::io::stdout().lock().write_all(solvecraft_engine::licences::all().as_bytes());
+            let _ = std::io::stdout().lock().write_all(solidcraft_engine::licences::all().as_bytes());
            Ok(())
        }
        // Hidden, for the kill-mid-save test: save a large design over and over.
@@ -111,19 +111,19 @@ fn pretty(v: &Value) -> String {
 pub fn read_json(path: &str) -> Result<Value, String> {
    // Through the engine's file access, which refuses anything that is not a regular file and
    // reads no more than the cap: a character device or a FIFO would otherwise never end.
-    let s = solvecraft_engine::io::vfs::read_to_string(path, solvecraft_engine::io::MAX_DESIGN_BYTES).map_err(|e| format!("{path}: {e}"))?;
+    let s = solidcraft_engine::io::vfs::read_to_string(path, solidcraft_engine::io::MAX_DESIGN_BYTES).map_err(|e| format!("{path}: {e}"))?;
    serde_json::from_str(&s).map_err(|e| format!("{path}: {e}"))
 }

 /// A session from a design file, a STEP/3MF/STL file, a command script, or an oracle recipe.
 pub fn load(path: &str) -> Result<Session, String> {
    let mut s = Session::default();
-    if solvecraft_engine::io::is_step_path(path) || solvecraft_engine::io::is_mesh_path(path) {
+    if solidcraft_engine::io::is_step_path(path) || solidcraft_engine::io::is_mesh_path(path) {
        s.execute("doc.open", &json!({"path": path})).map_err(|e| e.to_string())?;
        return Ok(s);
    }
    let v = read_json(path)?;
-    if v.get("format").and_then(Value::as_str).is_some_and(|f| f.starts_with("solvecraft")) {
+    if v.get("format").and_then(Value::as_str).is_some_and(|f| solidcraft_engine::doc::format::version_of(f).is_some()) {
        s.execute("doc.open", &json!({"path": path})).map_err(|e| e.to_string())?;
    } else if v.get("features").is_some() && v.get("commands").is_none() {
        let script = recipe::to_script(&v)?;
@@ -220,11 +220,11 @@ fn cmd_snapshot(args: &[String]) -> Result<(), String> {
    let w = flag(args, "--width").and_then(|x| x.parse().ok()).unwrap_or(1280usize);
    let h = flag(args, "--height").and_then(|x| x.parse().ok()).unwrap_or(800usize);
    let s = load(path)?;
-    let mut cam = solvecraft_engine::view::home_camera(&s);
+    let mut cam = solidcraft_engine::view::home_camera(&s);
    if let Some(v) = flag(args, "--view") {
        cam.set_view(StandardView::parse(v).ok_or_else(|| format!("unknown view `{v}`"))?);
    }
-    let scene = solvecraft_engine::view::scene(&s, &cam);
+    let scene = solidcraft_engine::view::scene(&s, &cam);
    let png = render_png(&scene, &cam, w, h).ok_or("render failed")?;
    std::fs::write(out, &png).map_err(|e| format!("{out}: {e}"))?;
    println!("{}", pretty(&json!({"path": out, "width": w, "height": h, "bytes": png.len()})));
@@ -249,7 +249,7 @@ fn cmd_icon(args: &[String]) -> Result<(), String> {
 }

 fn icon_png(size: usize) -> Result<Vec<u8>, String> {
-    solvecraft_engine::render::png(size, size, app_icon::rgba(size)?).ok_or_else(|| "icon: PNG encoding failed".to_string())
+    solidcraft_engine::render::png(size, size, app_icon::rgba(size)?).ok_or_else(|| "icon: PNG encoding failed".to_string())
 }

 /// A Windows icon file holding PNG images (Vista and later read these).
@@ -287,21 +287,21 @@ fn cmd_exec(args: &[String]) -> Result<(), String> {
 /// MCP server on stdio: headless (optionally starting from a design or script) or bridged to
 /// a running app's control port. stdout carries only protocol messages.
 fn cmd_mcp(args: &[String]) -> Result<(), String> {
-    let backend: Box<dyn solvecraft_mcp::Backend> = match (flag(args, "--connect"), flag(args, "--in")) {
+    let backend: Box<dyn solidcraft_mcp::Backend> = match (flag(args, "--connect"), flag(args, "--in")) {
        (Some(_), Some(_)) => return Err("mcp: use either --connect or --in, not both".into()),
-        (Some(addr), None) => Box::new(solvecraft_mcp::Remote::connect(addr).map_err(|e| {
+        (Some(addr), None) => Box::new(solidcraft_mcp::Remote::connect(addr).map_err(|e| {
            let port = addr.rsplit(':').next().filter(|p| p.parse::<u16>().is_ok()).unwrap_or("PORT");
            format!(
                "cannot connect to {addr}: {e}\nno SolidCraft app is listening there; start it with \
-                 `solvecraft --control {port}` (or SOLVECRAFT_CONTROL_PORT={port}) and retry"
+                 `solidcraft --control {port}` (or SOLIDCRAFT_CONTROL_PORT={port}) and retry"
            )
        })?),
-        (None, Some(path)) => Box::new(solvecraft_mcp::Headless::new(load(path)?)),
-        (None, None) => Box::new(solvecraft_mcp::Headless::default()),
+        (None, Some(path)) => Box::new(solidcraft_mcp::Headless::new(load(path)?)),
+        (None, None) => Box::new(solidcraft_mcp::Headless::default()),
    };
    let stdin = std::io::stdin();
    let stdout = std::io::stdout();
-    solvecraft_mcp::Server::new(backend).serve(stdin.lock(), stdout.lock()).map_err(|e| e.to_string())
+    solidcraft_mcp::Server::new(backend).serve(stdin.lock(), stdout.lock()).map_err(|e| e.to_string())
 }

 /// `save-stress <path> <rounds>`: save a design of a few hundred kilobytes `rounds` times, its
@@ -311,7 +311,7 @@ fn cmd_save_stress(args: &[String]) -> Result<(), String> {
        return Err("usage: solidcraft-cli save-stress <path> <rounds>".into());
    };
    let mut s = Session::default();
-    let filler = (0..3000).map(|i| solvecraft_engine::doc::Param {
+    let filler = (0..3000).map(|i| solidcraft_engine::doc::Param {
        name: format!("p{i}"),
        expr: format!("{i} mm + 0.5 mm"),
        unit: "mm".into(),
@@ -358,21 +358,21 @@ fn cmd_bench_edit(args: &[String]) -> Result<(), String> {

 /// Separate file reading, JSON decoding/repair, timeline evaluation and display meshing.
 fn cmd_bench_open(args: &[String]) -> Result<(), String> {
-    let path = args.first().ok_or("usage: solidcraft-cli bench-open <design.solvecraft | part.step> [--parse-only]")?;
+    let path = args.first().ok_or("usage: solidcraft-cli bench-open <design.solidcraft | part.step> [--parse-only]")?;
    let t = std::time::Instant::now();
-    let step = solvecraft_engine::io::is_step_path(path);
-    let limit = if step { solvecraft_engine::io::MAX_STEP_BYTES } else { solvecraft_engine::io::MAX_DESIGN_BYTES };
-    let bytes = solvecraft_engine::io::vfs::read(path, limit).map_err(|e| format!("{path}: {e}"))?;
+    let step = solidcraft_engine::io::is_step_path(path);
+    let limit = if step { solidcraft_engine::io::MAX_STEP_BYTES } else { solidcraft_engine::io::MAX_DESIGN_BYTES };
+    let bytes = solidcraft_engine::io::vfs::read(path, limit).map_err(|e| format!("{path}: {e}"))?;
    let read_ms = t.elapsed().as_secs_f64() * 1000.0;
    println!("{}", json!({"step": "read", "ms": read_ms, "bytes": bytes.len()}));
    let t = std::time::Instant::now();
    let doc = if step {
-        let imported = solvecraft_engine::io::step_import_feature(&bytes, path).map_err(|e| e.to_string())?;
-        let mut doc = solvecraft_engine::doc::Document::new(&imported.name);
+        let imported = solidcraft_engine::io::step_import_feature(&bytes, path).map_err(|e| e.to_string())?;
+        let mut doc = solidcraft_engine::doc::Document::new(&imported.name);
        doc.add_feature(imported.kind, Some(&imported.name)).map_err(|e| e.to_string())?;
        doc
    } else {
-        solvecraft_engine::io::read_design(&bytes).map_err(|e| e.to_string())?
+        solidcraft_engine::io::read_design(&bytes).map_err(|e| e.to_string())?
    };
    let parse_ms = t.elapsed().as_secs_f64() * 1000.0;
    println!("{}", json!({"step": "parse", "ms": parse_ms, "features": doc.features.len()}));
@@ -5,7 +5,7 @@
 #![allow(clippy::needless_range_loop)]

 use serde_json::{Value, json};
-use solvecraft_engine::geom::Vec3;
+use solidcraft_engine::geom::Vec3;

 use crate::spatial::{self, Tri};
 use crate::{read_json, recipe};
@@ -88,7 +88,7 @@ fn check_case(dir: &str) -> Value {
        Ok(s) => s,
        Err(e) => return json!({"case": name, "pass": false, "skipped": true, "error": e}),
    };
-    let mut s = solvecraft_engine::Session::default();
+    let mut s = solidcraft_engine::Session::default();
    if let Err(e) = s.run_script(&script) {
        return json!({"case": name, "pass": false, "error": e.to_string(), "source": want.as_ref().map(|w| w["source"].clone())});
    }
@@ -148,27 +148,27 @@ fn check_case(dir: &str) -> Value {
 }

 /// Export the session's bodies as STEP, validate the file and import it again.
-fn step_export_check(s: &solvecraft_engine::Session, volume: f64) -> (bool, String) {
+fn step_export_check(s: &solidcraft_engine::Session, volume: f64) -> (bool, String) {
    let st = s.model.state();
-    let bytes = match solvecraft_engine::io::export(&st, &[], solvecraft_engine::io::Format::Step, "oracle") {
+    let bytes = match solidcraft_engine::io::export(&st, &[], solidcraft_engine::io::Format::Step, "oracle") {
        Ok(b) => b,
        Err(e) => return (false, format!("export: {e}")),
    };
    let text = String::from_utf8_lossy(&bytes);
-    if let Err(e) = solvecraft_engine::kernel::step_validate(&text) {
+    if let Err(e) = solidcraft_engine::kernel::step_validate(&text) {
        return (false, format!("invalid: {e}"));
    }
-    match solvecraft_engine::kernel::step_orientation_errors(&text) {
+    match solidcraft_engine::kernel::step_orientation_errors(&text) {
        Ok(errs) if !errs.is_empty() => return (false, format!("faces inside out: {}", errs.join("; "))),
        Err(e) => return (false, format!("orientation check: {e}")),
        Ok(_) => {}
    }
-    match solvecraft_engine::kernel::step_import(&text) {
+    match solidcraft_engine::kernel::step_import(&text) {
        Ok(imp) if !imp.warnings.is_empty() => (false, format!("warnings: {}", imp.warnings.join("; "))),
        Ok(imp) if imp.bodies.len() != st.bodies.len() => (false, format!("{} bodies back of {}", imp.bodies.len(), st.bodies.len())),
        Ok(imp) => {
-            let m: Vec<_> = imp.bodies.iter().filter_map(|b| solvecraft_engine::kernel::measure(&b.body).ok()).collect();
-            let m0: Vec<_> = st.bodies.iter().filter_map(|b| solvecraft_engine::kernel::measure(&b.body).ok()).collect();
+            let m: Vec<_> = imp.bodies.iter().filter_map(|b| solidcraft_engine::kernel::measure(&b.body).ok()).collect();
+            let m0: Vec<_> = st.bodies.iter().filter_map(|b| solidcraft_engine::kernel::measure(&b.body).ok()).collect();
            let v: f64 = m.iter().map(|x| x.volume).sum();
            let (a, a0): (f64, f64) = (m.iter().map(|x| x.area).sum(), m0.iter().map(|x| x.area).sum());
            let faces: usize = imp.bodies.iter().map(|b| b.file_faces).sum();
@@ -184,7 +184,7 @@ fn step_export_check(s: &solvecraft_engine::Session, volume: f64) -> (bool, Stri
 }

 /// Our part as a triangle soup (curved faces refined onto the surface).
-fn our_mesh(s: &solvecraft_engine::Session) -> Result<Vec<Tri>, String> {
+fn our_mesh(s: &solidcraft_engine::Session) -> Result<Vec<Tri>, String> {
    let mut ours: Vec<Tri> = Vec::new();
    for b in &s.world_state().bodies {
        let m = b.body.tessellate_with(MESH_TOL, true).map_err(|e| e.to_string())?;
@@ -201,7 +201,7 @@ fn our_mesh(s: &solvecraft_engine::Session) -> Result<Vec<Tri>, String> {
 /// Compare our part with the reference triangulation: the symmetric surface distance, and the
 /// principal second moments of volume of both meshes (the shape's inertia, independent of how it
 /// sits in space).
-fn reference_checks(s: &solvecraft_engine::Session, stl: &str, tol: f64, c: &mut Checks) {
+fn reference_checks(s: &solidcraft_engine::Session, stl: &str, tol: f64, c: &mut Checks) {
    let (ours, reference) = match (our_mesh(s), spatial::read_stl(stl)) {
        (Ok(o), Ok(r)) if !r.is_empty() => (o, r),
        (Err(e), _) | (_, Err(e)) => return c.push("surface_distance_mm", json!(e), json!(format!("<= {tol}")), false),
@@ -1,8 +1,8 @@
 # Design file corpus

-Designs saved by older SolveCraft builds. `tests/design_corpus.rs` opens each one with the
+Designs saved by older SolidCraft builds. `tests/design_corpus.rs` opens each one with the
 current build and checks that it evaluates as it did when saved (the `.expected.json` next to
-it is `solvecraft-cli eval` of that file by the build that saved it: bodies, volumes, areas,
+it is `solidcraft-cli eval` of that file by the build that saved it: bodies, volumes, areas,
 world bounding boxes), that it is upgraded to the current file format, and that damaged and
 hostile variants of it never panic.

@@ -1,5 +1,5 @@
 {
-  "format": "solvecraft/1",
+  "format": "solidcraft/1",
  "name": "Untitled",
  "units": "mm",
  "params": [],
@@ -1,5 +1,5 @@
 {
-  "format": "solvecraft/1",
+  "format": "solidcraft/1",
  "name": "Untitled",
  "units": "mm",
  "params": [
@@ -1,5 +1,5 @@
 {
-  "format": "solvecraft/1",
+  "format": "solidcraft/1",
  "name": "Untitled",
  "units": "mm",
  "params": [
@@ -1,5 +1,5 @@
 {
-  "format": "solvecraft/1",
+  "format": "solidcraft/1",
  "name": "Untitled",
  "units": "mm",
  "params": [],
@@ -1,5 +1,5 @@
 {
-  "format": "solvecraft/1",
+  "format": "solidcraft/1",
  "name": "Untitled",
  "units": "mm",
  "params": [],
@@ -1,5 +1,5 @@
 {
-  "format": "solvecraft/1",
+  "format": "solidcraft/1",
  "name": "Untitled",
  "units": "mm",
  "params": [
@@ -1,5 +1,5 @@
 {
-  "format": "solvecraft/1",
+  "format": "solidcraft/1",
  "name": "Untitled",
  "units": "mm",
  "params": [],
@@ -1,5 +1,5 @@
 {
-  "format": "solvecraft/13",
+  "format": "solidcraft/13",
  "name": "Untitled",
  "units": "mm",
  "params": [],
@@ -1,5 +1,5 @@
 {
-  "format": "solvecraft/13",
+  "format": "solidcraft/13",
  "name": "Untitled",
  "units": "mm",
  "params": [],
@@ -1,15 +1,15 @@
-//! Designs saved by older SolveCraft builds (tests/corpus, see its README) open and evaluate as
+//! Designs saved by older SolidCraft builds (tests/corpus, see its README) open and evaluate as
 //! they did when they were saved; damaged and hostile design files never panic.

 use std::path::{Path, PathBuf};

 use serde_json::{Value, json};
-use solvecraft_engine::Session;
+use solidcraft_engine::Session;

 fn corpus() -> Vec<PathBuf> {
    let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/corpus");
    let mut v: Vec<PathBuf> =
-        std::fs::read_dir(&dir).unwrap().flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "solvecraft")).collect();
+        std::fs::read_dir(&dir).unwrap().flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "solidcraft")).collect();
    v.sort();
    assert!(v.len() >= 7, "corpus files in {}", dir.display());
    v
@@ -56,7 +56,7 @@ fn old_designs_open_and_evaluate_as_saved() {
                problems.push(format!("{name}: feature {}: {e}", r.id));
            }
        }
-        assert_eq!(s.doc.format, solvecraft_engine::doc::format::format_string(solvecraft_engine::doc::format::FORMAT), "{name}: upgraded");
+        assert_eq!(s.doc.format, solidcraft_engine::doc::format::format_string(solidcraft_engine::doc::format::FORMAT), "{name}: upgraded");
        let got = s.execute("inspect.measure", &json!({})).unwrap();
        if got["body_count"] != want["body_count"] && !known(&name, "body_count") {
            problems.push(format!("{name}: {} bodies, saved with {}", got["body_count"], want["body_count"]));
@@ -84,7 +84,7 @@ fn old_designs_open_and_evaluate_as_saved() {
            }
        }
        // Saved again, it reads back the same.
-        let again = solvecraft_engine::doc::Document::from_json(&s.doc.to_json()).unwrap();
+        let again = solidcraft_engine::doc::Document::from_json(&s.doc.to_json()).unwrap();
        assert_eq!(again, *s.doc, "{name}: round trip");
    }
    assert!(problems.is_empty(), "{}", problems.join("\n"));
@@ -95,7 +95,7 @@ fn old_designs_open_and_evaluate_as_saved() {
 /// they are found as the build that saved them found them, without new notes.
 #[test]
 fn names_saved_before_exact_history_find_the_faces_they_named() {
-    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/corpus/naming-split-pieces.solvecraft");
+    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/corpus/naming-split-pieces.solidcraft");
    let s = open(&path);
    let feature = |name: &str| s.doc.features.iter().find(|f| f.name == name).unwrap_or_else(|| panic!("{name}"));
    assert_eq!(feature("Round").edge_names, vec!["?F2:side:l2|F2:top#2".to_string()]);
@@ -106,7 +106,7 @@ fn names_saved_before_exact_history_find_the_faces_they_named() {
    }
    // The raised piece is the left one, as saved (the stored point is on it).
    let state = s.model.state();
-    let solid = |p: [f64; 3]| state.bodies.iter().any(|b| b.body.contains(solvecraft_engine::geom::Vec3::new(p[0], p[1], p[2])));
+    let solid = |p: [f64; 3]| state.bodies.iter().any(|b| b.body.contains(solidcraft_engine::geom::Vec3::new(p[0], p[1], p[2])));
    assert!(solid([7.0, 15.0, 11.0]) && !solid([32.0, 15.0, 11.0]));
 }

@@ -115,7 +115,7 @@ fn names_saved_before_exact_history_find_the_faces_they_named() {
 /// the far one stays `Body1` (chamfered), the near one `Body1 (1)` (filleted, coloured).
 #[test]
 fn body_names_saved_before_exact_history_keep_their_pieces() {
-    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/corpus/split-body-pieces.solvecraft");
+    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/corpus/split-body-pieces.solidcraft");
    let s = open(&path);
    assert!(s.doc.features.iter().all(|f| f.shell_piece_order), "every saved feature keeps the shell order");
    for r in &s.model.results {
@@ -123,7 +123,7 @@ fn body_names_saved_before_exact_history_keep_their_pieces() {
    }
    let state = s.model.state();
    let piece = |name: &str| state.bodies.iter().find(|b| b.name == name).unwrap_or_else(|| panic!("{name}"));
-    let solid = |name: &str, p: [f64; 3]| piece(name).body.contains(solvecraft_engine::geom::Vec3::new(p[0], p[1], p[2]));
+    let solid = |name: &str, p: [f64; 3]| piece(name).body.contains(solidcraft_engine::geom::Vec3::new(p[0], p[1], p[2]));
    assert!(solid("Body1", [20.0, 24.0, 5.0]) && solid("Body1 (1)", [20.0, 6.0, 5.0]));
    assert!(s.doc.appearances.bodies.contains_key("Body1 (1)"));
 }
@@ -181,7 +181,7 @@ fn at_mut<'a>(v: &'a mut Value, path: &[Value]) -> Option<&'a mut Value> {

 /// Open a file's bytes as File → Open does and evaluate them; any panic is a failure.
 fn try_bytes(bytes: &[u8]) {
-    if let Ok(doc) = solvecraft_engine::io::read_design(bytes) {
+    if let Ok(doc) = solidcraft_engine::io::read_design(bytes) {
        let mut s = Session::new(doc);
        let _ = s.execute("inspect.measure", &json!({}));
        let _ = s.execute("document.inspect", &json!({}));
@@ -197,7 +197,7 @@ fn generated() -> Vec<(String, Vec<u8>)> {
               "plane": {"type": "midplane", "a": side, "b": {"type": "plane", "plane": {"type": "origin", "name": "XZ"}}}})
    };
    let design = |name: &str, features: Value| {
-        json!({"format": "solvecraft/11", "name": name, "units": "mm", "params": [], "next_id": 9, "features": features}).to_string().into_bytes()
+        json!({"format": "solidcraft/11", "name": name, "units": "mm", "params": [], "next_id": 9, "features": features}).to_string().into_bytes()
    };
    // A sketch past the caps interactive editing enforces: solving it would size dense matrices
    // by the point count and abort on the allocation.
@@ -6,17 +6,17 @@ use std::time::Duration;

 fn round_of(path: &std::path::Path) -> Option<String> {
    let bytes = std::fs::read(path).ok()?;
-    let doc = solvecraft_engine::io::read_design(&bytes).ok()?;
+    let doc = solidcraft_engine::io::read_design(&bytes).ok()?;
    doc.params.iter().find(|p| p.name == "save_round").map(|p| p.expr.clone())
 }

 #[test]
 fn killed_mid_save_the_old_file_survives() {
    let exe = env!("CARGO_BIN_EXE_solidcraft-cli");
-    let dir = std::env::temp_dir().join(format!("solvecraft-kill-mid-save-{}", std::process::id()));
+    let dir = std::env::temp_dir().join(format!("solidcraft-kill-mid-save-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
-    let path = dir.join("design.solvecraft");
+    let path = dir.join("design.solidcraft");
    let ok = Command::new(exe).args(["save-stress", &path.to_string_lossy(), "1"]).status().unwrap();
    assert!(ok.success());
    assert_eq!(round_of(&path).as_deref(), Some("0"));
@@ -44,7 +44,7 @@ fn killed_mid_save_the_old_file_survives() {
        let round = round_of(&path);
        assert!(round.is_some(), "after kill {i} the design file is torn or missing");
        seen.insert(round);
-        let bak = solvecraft_engine::io::backup_path(&path);
+        let bak = solidcraft_engine::io::backup_path(&path);
        if bak.exists() {
            assert!(round_of(&bak).is_some(), "after kill {i} the backup is torn");
        }
@@ -12,7 +12,7 @@ struct Scratch(PathBuf);

 impl Scratch {
    fn new() -> Self {
-        let dir = std::env::temp_dir().join(format!("solvecraft-run-results-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
+        let dir = std::env::temp_dir().join(format!("solidcraft-run-results-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
        std::fs::create_dir(&dir).unwrap();
        Self(dir)
    }
@@ -46,7 +46,7 @@ fn body_count(path: &Path) -> Value {
 #[test]
 fn results_still_save_and_export_the_script_once() {
    let dir = Scratch::new();
-    let saved = dir.0.join("box.solvecraft");
+    let saved = dir.0.join("box.solidcraft");
    let stl = dir.0.join("box.stl");
    let obj = dir.0.join("box.obj");
    let result = json_output(
@@ -64,8 +64,8 @@ fn results_still_save_and_export_the_script_once() {
 fn results_with_base_design_and_quiet_still_report_and_save() {
    let dir = Scratch::new();
    let script = dir.script();
-    let base = dir.0.join("base.solvecraft");
-    let saved = dir.0.join("combined.solvecraft");
+    let base = dir.0.join("base.solidcraft");
+    let saved = dir.0.join("combined.solidcraft");
    json_output(cli().arg("run").arg(&script).arg("--save").arg(&base).output().unwrap());
    let result = json_output(cli().args(["run", "--results", "--quiet", "--in"]).arg(&base).arg(&script).arg("--save").arg(&saved).output().unwrap());
    assert_eq!(result.as_array().unwrap().len(), 1);
@@ -77,7 +77,7 @@ fn results_with_base_design_and_quiet_still_report_and_save() {
 fn results_propagate_output_errors() {
    let dir = Scratch::new();
    for flag in ["--save", "--out"] {
-        let path = dir.0.join("missing").join(if flag == "--save" { "box.solvecraft" } else { "box.stl" });
+        let path = dir.0.join("missing").join(if flag == "--save" { "box.solidcraft" } else { "box.stl" });
        let output = cli().arg("run").arg(dir.script()).arg("--results").arg(flag).arg(&path).output().unwrap();
        assert_eq!(output.status.code(), Some(1));
        assert!(!output.stderr.is_empty());
@@ -89,9 +89,27 @@ fn results_propagate_output_errors() {
 #[test]
 fn results_without_script_still_fail() {
    let dir = Scratch::new();
-    let base = dir.0.join("base.solvecraft");
+    let base = dir.0.join("base.solidcraft");
    json_output(cli().arg("run").arg(dir.script()).arg("--save").arg(&base).output().unwrap());
    let output = cli().args(["run", "--results", "--in"]).arg(&base).output().unwrap();
    assert_eq!(output.status.code(), Some(1));
    assert!(String::from_utf8_lossy(&output.stderr).contains("--results needs a script"));
 }
+
+/// Compatibility shim (docs/compatibility.md): a design saved before the rename, with the
+/// legacy extension and format tag, still opens; re-saving writes the current tag.
+#[test]
+fn legacy_extension_and_format_tag_still_open() {
+    let dir = Scratch::new();
+    let saved = dir.0.join("box.solidcraft");
+    json_output(cli().arg("run").arg(dir.script()).arg("--save").arg(&saved).output().unwrap());
+    let text = std::fs::read_to_string(&saved).unwrap();
+    assert!(text.contains("\"solidcraft/"), "new designs carry the current tag");
+    let legacy = dir.0.join("old.solvecraft");
+    std::fs::write(&legacy, text.replace("\"solidcraft/", "\"solvecraft/")).unwrap();
+    assert_eq!(body_count(&legacy), 1);
+    let resaved = dir.0.join("resaved.solidcraft");
+    json_output(cli().args(["run", "--in"]).arg(&legacy).arg(dir.script()).arg("--save").arg(&resaved).output().unwrap());
+    assert_eq!(body_count(&resaved), 2);
+    assert!(std::fs::read_to_string(&resaved).unwrap().contains("\"solidcraft/"));
+}
@@ -1,5 +1,5 @@
 [package]
-name = "solvecraft-web"
+name = "solidcraft-web"
 description = "SolidCraft in the browser (eframe web runner, WebGPU with WebGL2 fallback)"
 version.workspace = true
 edition.workspace = true
@@ -10,12 +10,12 @@ publish = false
 workspace = true

 [[bin]]
-name = "solvecraft-web"
+name = "solidcraft-web"
 path = "src/main.rs"

 [dependencies]
-solvecraft-engine = { workspace = true }
-solvecraft-ui-egui = { workspace = true }
+solidcraft-engine = { workspace = true }
+solidcraft-ui-egui = { workspace = true }
 egui = { workspace = true }
 log = { workspace = true }

@@ -1,4 +1,4 @@
-# Build with: trunk build --release   (from apps/solvecraft-web)
+# Build with: trunk build --release   (from apps/solidcraft-web)
 [build]
 target = "index.html"
 dist = "../../dist/web"
@@ -4,18 +4,18 @@
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
  <title>SolidCraft</title>
-  <link data-trunk rel="rust" data-bin="solvecraft-web" data-wasm-opt="z" data-weak-refs />
+  <link data-trunk rel="rust" data-bin="solidcraft-web" data-wasm-opt="z" data-weak-refs />
  <link data-trunk rel="copy-file" href="fonts/BIZUDPGothic-Regular.ttf" data-target-path="fonts" />
  <link data-trunk rel="copy-file" href="fonts/OFL.txt" data-target-path="fonts" />
  <style>
    html, body { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; background: #e8ebf0; }
-    #solvecraft_canvas { position: absolute; inset: 0; width: 100%; height: 100%; display: block; }
-    #solvecraft_loading { position: absolute; inset: 0; display: flex; flex-direction: column; align-items: center; justify-content: center;
+    #solidcraft_canvas { position: absolute; inset: 0; width: 100%; height: 100%; display: block; }
+    #solidcraft_loading { position: absolute; inset: 0; display: flex; flex-direction: column; align-items: center; justify-content: center;
      color: #4a5060; font: 14px system-ui, sans-serif; pointer-events: none; }
  </style>
 </head>
 <body>
-  <canvas id="solvecraft_canvas"></canvas>
-  <div id="solvecraft_loading">Loading SolidCraft&hellip;</div>
+  <canvas id="solidcraft_canvas"></canvas>
+  <div id="solidcraft_loading">Loading SolidCraft&hellip;</div>
 </body>
 </html>
@@ -1,5 +1,5 @@
 //! Files in the browser. Designs are kept in the origin private file system (OPFS): read into
-//! the engine's in-memory files (`solvecraft_engine::io::vfs`) at start, written back whenever a
+//! the engine's in-memory files (`solidcraft_engine::io::vfs`) at start, written back whenever a
 //! command writes one. Files come in from the computer through a file picker (the File System
 //! Access API where the browser has it, an `<input type=file>` otherwise) or a drop on the page,
 //! and go out as downloads (exports, and "Download design"). An autosave of unsaved work is kept
@@ -9,7 +9,7 @@ use std::cell::{Cell, RefCell};
 use std::rc::Rc;

 use js_sys::{Array, Function, Object, Reflect, Uint8Array};
-use solvecraft_engine::io::vfs;
+use solidcraft_engine::io::vfs;
 use wasm_bindgen::{JsCast as _, JsValue, closure::Closure};
 use wasm_bindgen_futures::{JsFuture, spawn_local};
 use web_sys::{FileSystemDirectoryHandle, FileSystemFileHandle, FileSystemGetFileOptions, FileSystemWritableFileStream};
@@ -20,8 +20,11 @@ pub const OPFS: &str = "/opfs/";
 pub const DOWNLOADS: &str = "/downloads/";
 /// Files brought in from the computer.
 pub const UPLOAD: &str = "/upload/";
-/// The autosave of unsaved work (in OPFS: `recovery.solvecraft` and `recovery.json`).
-const RECOVERY: &str = "recovery.solvecraft";
+/// The autosave of unsaved work (in OPFS: `recovery.solidcraft` and `recovery.json`).
+const RECOVERY: &str = "recovery.solidcraft";
+/// The autosave earlier releases kept (compatibility shim, docs/compatibility.md): recovered
+/// when there is no current one.
+const LEGACY_RECOVERY: &str = "recovery.solvecraft";
 const RECOVERY_META: &str = "recovery.json";

 /// What to do with a file brought in from the computer.
@@ -87,7 +90,10 @@ thread_local! {
 }

 /// Local storage keys of stored files.
-const LOCAL_PREFIX: &str = "solvecraft.file.";
+const LOCAL_PREFIX: &str = "solidcraft.file.";
+/// Local-storage files kept by earlier releases (compatibility shim, docs/compatibility.md):
+/// still listed and opened; removing one removes either key.
+const LEGACY_LOCAL_PREFIX: &str = "solvecraft.file.";

 fn local() -> Result<web_sys::Storage, String> {
    web_sys::window().and_then(|w| w.local_storage().ok().flatten()).ok_or_else(|| "this browser keeps no local storage".to_string())
@@ -177,7 +183,9 @@ async fn write_file(name: &str, bytes: &[u8]) -> Result<(), String> {

 async fn remove_file(name: &str) -> Result<(), String> {
    if local_only() {
-        return local()?.remove_item(&format!("{LOCAL_PREFIX}{name}")).map_err(err);
+        let st = local()?;
+        st.remove_item(&format!("{LEGACY_LOCAL_PREFIX}{name}")).map_err(err)?;
+        return st.remove_item(&format!("{LOCAL_PREFIX}{name}")).map_err(err);
    }
    let dir = root().await?;
    JsFuture::from(dir.remove_entry(name)).await.map_err(err)?;
@@ -190,7 +198,7 @@ fn read_local() -> Result<Vec<(String, Vec<u8>, f64)>, String> {
    let mut out = Vec::new();
    for i in 0..st.length().unwrap_or(0).min(10_000) {
        let Some(k) = st.key(i).ok().flatten() else { continue };
-        let Some(name) = k.strip_prefix(LOCAL_PREFIX) else { continue };
+        let Some(name) = k.strip_prefix(LOCAL_PREFIX).or_else(|| k.strip_prefix(LEGACY_LOCAL_PREFIX)) else { continue };
        if let Some(v) = st.get_item(&k).ok().flatten() {
            out.push((name.to_string(), decode(&v), 0.0));
        }
@@ -251,7 +259,14 @@ pub fn start(files: &Rc<Files>) {
                    files.say("This page can't use the browser's file storage (it needs https or localhost): designs are kept in local storage, a few MB at most.", false);
                }
                let mut entries = Vec::new();
+                let has_recovery = all.iter().any(|(n, _, _)| n == RECOVERY);
                for (name, bytes, modified) in all {
+                    if name == LEGACY_RECOVERY {
+                        if !has_recovery {
+                            vfs::insert(&format!("{OPFS}{RECOVERY}"), bytes);
+                        }
+                        continue;
+                    }
                    if name == RECOVERY_META {
                        let meta: serde_json::Value = serde_json::from_slice(&bytes).unwrap_or_default();
                        let n = meta["name"].as_str().unwrap_or("Untitled").to_string();
@@ -349,7 +364,7 @@ pub fn rename(files: &Rc<Files>, from: &str, to: &str) -> Result<(), String> {
    if files.entries.borrow().iter().any(|e| e.name == to) {
        return Err(format!("there is already a file named {to}"));
    }
-    let bytes = vfs::read(&format!("{OPFS}{from}"), solvecraft_engine::io::MAX_DESIGN_BYTES).map_err(|e| e.to_string())?;
+    let bytes = vfs::read(&format!("{OPFS}{from}"), solidcraft_engine::io::MAX_DESIGN_BYTES).map_err(|e| e.to_string())?;
    vfs::write(&format!("{OPFS}{to}"), &bytes).map_err(|e| e.to_string())?;
    delete(files, from);
    flush(files);
@@ -357,11 +372,11 @@ pub fn rename(files: &Rc<Files>, from: &str, to: &str) -> Result<(), String> {
 }

 /// Keep (or drop) the autosave of the open design.
-pub fn autosave(files: &Rc<Files>, doc: Option<(&solvecraft_engine::doc::Document, Option<&str>)>) {
+pub fn autosave(files: &Rc<Files>, doc: Option<(&solidcraft_engine::doc::Document, Option<&str>)>) {
    let files = files.clone();
    match doc {
        Some((d, path)) => {
-            let bytes = solvecraft_engine::io::write_design(d);
+            let bytes = solidcraft_engine::io::write_design(d);
            let meta = serde_json::json!({"name": d.name, "path": path, "saved_at": js_sys::Date::now()}).to_string();
            spawn_local(async move {
                let r = async {
@@ -375,6 +390,7 @@ pub fn autosave(files: &Rc<Files>, doc: Option<(&solvecraft_engine::doc::Documen
        }
        None => spawn_local(async move {
            let _ = remove_file(RECOVERY).await;
+            let _ = remove_file(LEGACY_RECOVERY).await;
            let _ = remove_file(RECOVERY_META).await;
        }),
    }
@@ -436,7 +452,7 @@ fn input_picker(files: &Rc<Files>, intent: Intent) {
    let Some(doc) = web_sys::window().and_then(|w| w.document()) else { return };
    let Ok(input) = doc.create_element("input").map(|e| e.unchecked_into::<web_sys::HtmlInputElement>()) else { return };
    input.set_type("file");
-    input.set_accept(".solvecraft,.step,.stp,.3mf,.stl");
+    input.set_accept(".solidcraft,.solvecraft,.step,.stp,.3mf,.stl");
    // Attached (hidden) while it is open: some browsers ignore a click on a detached input.
    let _ = input.set_attribute("style", "display:none");
    if let Some(body) = doc.body() {
@@ -1,6 +1,6 @@
-//! SolveCraft in the browser.
+//! SolidCraft in the browser.
 //!
-//! Runs the same [`solvecraft_ui_egui::SolveApp`] as the desktop app through eframe's web runner
+//! Runs the same [`solidcraft_ui_egui::SolveApp`] as the desktop app through eframe's web runner
 //! (wgpu: WebGPU where available, WebGL2 otherwise). Build with `trunk build --release` from this
 //! directory (output in `dist/web`). URL flags: `?webgl` forces WebGL2, `?sample` opens the
 //! sample part.
@@ -13,15 +13,15 @@ mod files;
 mod web {
    use std::rc::Rc;

-    use solvecraft_engine::Session;
-    use solvecraft_engine::io::vfs;
-    use solvecraft_ui_egui::{Services, SolveApp};
+    use solidcraft_engine::Session;
+    use solidcraft_engine::io::vfs;
+    use solidcraft_ui_egui::{Services, SolveApp};
    use wasm_bindgen::JsCast as _;

    use crate::files::{self, Files, Intent};

-    const CANVAS_ID: &str = "solvecraft_canvas";
-    const LOADING_ID: &str = "solvecraft_loading";
+    const CANVAS_ID: &str = "solidcraft_canvas";
+    const LOADING_ID: &str = "solidcraft_loading";
    const DEPTH_BITS: u8 = 24;

    /// Seconds between autosaves of unsaved work.
@@ -63,7 +63,7 @@ mod web {
        /// The start page's recent designs were filled from the stored ones.
        recents_synced: bool,
        /// On-demand CJK font: fetched only when a CJK language is selected.
-        font: solvecraft_ui_egui::fonts::CjkFontLoader,
+        font: solidcraft_ui_egui::fonts::CjkFontLoader,
        font_result: FontLoadResult,
    }

@@ -79,7 +79,7 @@ mod web {
            }
            let incoming: Vec<_> = self.files.incoming.borrow_mut().drain(..).collect();
            for (name, bytes, intent) in incoming {
-                let design = name.ends_with(&format!(".{}", solvecraft_engine::io::DESIGN_EXT));
+                let design = solidcraft_engine::io::is_design_path(&name);
                let path = if design && intent == Intent::Open {
                    // A design from the computer is kept in the browser (a copy), so Save works.
                    let path = files::free_name(&name);
@@ -133,13 +133,13 @@ mod web {
            entries.sort_by(|a, b| b.modified.total_cmp(&a.modified));
            let recent = &mut self.app.home.recent;
            recent.retain(|p| vfs::exists(p));
-            for e in entries.iter().filter(|e| e.name.ends_with(&format!(".{}", solvecraft_engine::io::DESIGN_EXT))) {
+            for e in entries.iter().filter(|e| solidcraft_engine::io::is_design_path(&e.name)) {
                let p = format!("{}{}", files::OPFS, e.name);
                if !recent.contains(&p) {
                    recent.push(p);
                }
            }
-            recent.truncate(solvecraft_ui_egui::home::MAX_RECENT);
+            recent.truncate(solidcraft_ui_egui::home::MAX_RECENT);
        }

        /// The stored designs: open, insert, rename, delete, download; open from the computer.
@@ -206,7 +206,7 @@ mod web {
                                    if ui.small_button("Open").clicked() {
                                        act = Some(("open", e.name.clone()));
                                    }
-                                    let design = e.name.ends_with(&format!(".{}", solvecraft_engine::io::DESIGN_EXT));
+                                    let design = solidcraft_engine::io::is_design_path(&e.name);
                                    if !design && ui.small_button("Insert").on_hover_text("Into the open design (STEP, 3MF, STL)").clicked() {
                                        act = Some(("insert", e.name.clone()));
                                    }
@@ -241,7 +241,7 @@ mod web {
                    self.app.insert_path(&path);
                    self.files.panel.set(false);
                }
-                "download" => match vfs::read(&path, solvecraft_engine::io::MAX_DESIGN_BYTES) {
+                "download" => match vfs::read(&path, solidcraft_engine::io::MAX_DESIGN_BYTES) {
                    Ok(b) => {
                        if let Err(e) = files::download(&name, &b) {
                            self.app.set_status(e, true);
@@ -251,8 +251,8 @@ mod web {
                },
                "download_open" => {
                    let d = &self.app.session.doc;
-                    let bytes = solvecraft_engine::io::write_design(d);
-                    if let Err(e) = files::download(&format!("{}.{}", d.name, solvecraft_engine::io::DESIGN_EXT), &bytes) {
+                    let bytes = solidcraft_engine::io::write_design(d);
+                    if let Err(e) = files::download(&format!("{}.{}", d.name, solidcraft_engine::io::DESIGN_EXT), &bytes) {
                        self.app.set_status(e, true);
                    }
                }
@@ -318,7 +318,7 @@ mod web {
            let done = self.font_result.borrow_mut().take();
            if let Some(res) = done {
                let installed = match res {
-                    Ok(bytes) => solvecraft_ui_egui::fonts::install_cjk_font(ctx, bytes),
+                    Ok(bytes) => solidcraft_ui_egui::fonts::install_cjk_font(ctx, bytes),
                    Err(err) => {
                        log::warn!("failed to fetch CJK font from {JAPANESE_FONT_PATH}: {err}");
                        false
@@ -349,7 +349,7 @@ mod web {
            self.tick_font(ctx);
            self.app.logic(ctx);
            self.files_tick(ctx);
-            UNSAVED.with(|u| u.set(solvecraft_ui_egui::documents::any_dirty(&self.app)));
+            UNSAVED.with(|u| u.set(solidcraft_ui_egui::documents::any_dirty(&self.app)));
        }
        fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {
            files::take_drops(&self.files, raw);
@@ -365,14 +365,11 @@ mod web {
            // Persist the user's own language, not a session-only English fallback.
            let saved = self.font.persisted_language(&self.app.preferences.language).to_owned();
            let live = std::mem::replace(&mut self.app.preferences.language, saved);
-            storage.set_string(PREFS_KEY, self.app.prefs());
+            storage.set_string(solidcraft_ui_egui::prefs::STORAGE_KEY, self.app.prefs());
            self.app.preferences.language = live;
        }
    }

-    /// Where the preferences (theme) are kept (the browser's local storage).
-    const PREFS_KEY: &str = "solvecraft.prefs";
-
    fn query() -> String {
        web_sys::window().and_then(|w| w.location().search().ok()).unwrap_or_default()
    }
@@ -411,7 +408,7 @@ mod web {
                    canvas,
                    options,
                    Box::new(move |cc| {
-                        solvecraft_ui_egui::fonts::setup_fonts(&cc.egui_ctx);
+                        solidcraft_ui_egui::fonts::setup_fonts(&cc.egui_ctx);
                        let files = Rc::new(Files::default());
                        files::start(&files);
                        let panel = files.clone();
@@ -423,13 +420,13 @@ mod web {
                            })),
                            // Designs are kept in the browser; everything else is downloaded.
                            pick_save: Some(Box::new(|name: &str, exts: &[&str]| {
-                                let design = exts.contains(&solvecraft_engine::io::DESIGN_EXT);
+                                let design = exts.contains(&solidcraft_engine::io::DESIGN_EXT);
                                Some(format!("{}{name}", if design { files::OPFS } else { files::DOWNLOADS }))
                            })),
                            ..Default::default()
                        };
                        let mut app = SolveApp::new(Session::default(), services);
-                        if let Some(p) = cc.storage.and_then(|s| s.get_string(PREFS_KEY)) {
+                        if let Some(p) = cc.storage.and_then(|s| solidcraft_ui_egui::prefs::stored(|k| s.get_string(k))) {
                            app.load_prefs(&p);
                        }
                        if let Some(rs) = &cc.wgpu_render_state {
@@ -437,7 +434,7 @@ mod web {
                            app.set_wgpu(rs, DEPTH_BITS, 0, 1);
                        }
                        if query().contains("sample") {
-                            if let Err(e) = app.session.run_script(&solvecraft_engine::sample::script()) {
+                            if let Err(e) = app.session.run_script(&solidcraft_engine::sample::script()) {
                                app.set_status(format!("sample: {e}"), true);
                            }
                            app.session.doc_mut().name = "Sample Plate".into();
@@ -480,5 +477,5 @@ fn main() {

 #[cfg(not(target_arch = "wasm32"))]
 fn main() {
-    eprintln!("solvecraft-web only runs in the browser: build it with `trunk build --release` in apps/solvecraft-web");
+    eprintln!("solidcraft-web only runs in the browser: build it with `trunk build --release` in apps/solidcraft-web");
 }
@@ -11,8 +11,8 @@ default-run = "solidcraft"
 workspace = true

 [dependencies]
-solvecraft-engine = { workspace = true }
-solvecraft-ui-egui = { workspace = true }
+solidcraft-engine = { workspace = true }
+solidcraft-ui-egui = { workspace = true }
 eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "wayland", "x11", "links"] }
 egui = { workspace = true }
 serde_json = { workspace = true }
@@ -8,8 +8,8 @@ use std::sync::mpsc::{Receiver, Sender, channel};
 use std::time::Duration;

 use serde_json::{Value, json};
-use solvecraft_engine::MAX_LINE;
-use solvecraft_ui_egui::ControlRequest;
+use solidcraft_engine::MAX_LINE;
+use solidcraft_ui_egui::ControlRequest;

 /// Connections served at once. The channel has no authentication beyond being bound to
 /// loopback, so a flood must not be able to spawn threads without end.
@@ -24,11 +24,11 @@ pub fn start(port: u16, ctx: egui::Context) -> Receiver<ControlRequest> {
    let listener = match TcpListener::bind(("127.0.0.1", port)) {
        Ok(l) => l,
        Err(e) => {
-            eprintln!("solvecraft: control server failed to bind 127.0.0.1:{port}: {e}");
+            eprintln!("solidcraft: control server failed to bind 127.0.0.1:{port}: {e}");
            return rx;
        }
    };
-    eprintln!("solvecraft: control server listening on 127.0.0.1:{port}");
+    eprintln!("solidcraft: control server listening on 127.0.0.1:{port}");
    std::thread::spawn(move || {
        for stream in listener.incoming().flatten() {
            if OPEN.fetch_add(1, Ordering::Relaxed) >= MAX_CONNECTIONS {
@@ -1,13 +1,13 @@
-//! SolveCraft desktop app.
+//! SolidCraft desktop app.
 //!
-//! Usage: `solvecraft [--control <port>] [--sample] [--crash-log] [design.solvecraft | part.step]`
+//! Usage: `solidcraft [--control <port>] [--sample] [--crash-log] [design.solidcraft | part.step]`
 //!
 //! A `.step`/`.stp` file opens as a new design holding the file's bodies (an Import feature); a
 //! `.3mf`/`.stl` file as a new design holding mesh bodies.
 //!
-//! `--control <port>` (or `SOLVECRAFT_CONTROL_PORT`) starts a localhost JSON-lines control
+//! `--control <port>` (or `SOLIDCRAFT_CONTROL_PORT`) starts a localhost JSON-lines control
 //! server: `{"id":1,"method":"engine.execute","params":{"command":"solid.box","params":{…}}}`.
-//! See `solvecraft_ui_egui::control` and docs/control-protocol.md.
+//! See `solidcraft_ui_egui::control` and docs/control-protocol.md.
 #![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")]
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 #![forbid(unsafe_code)]
@@ -19,8 +19,8 @@ mod control_server;
 #[cfg(any(target_os = "windows", target_os = "linux"))]
 mod space_mouse;

-use solvecraft_engine::Session;
-use solvecraft_ui_egui::{Services, SolveApp};
+use solidcraft_engine::Session;
+use solidcraft_ui_egui::{Services, SolveApp};

 struct App {
    solve: SolveApp,
@@ -31,12 +31,12 @@ struct App {
 impl eframe::App for App {
    fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // The design on screen is the one whose commands a crash report replays.
-        self.solve.session.crash_journal = solvecraft_engine::crash::enabled();
+        self.solve.session.crash_journal = solidcraft_engine::crash::enabled();
        // The OS closing the window (Alt+F4, Cmd+Q, the window manager): ask about unsaved
        // designs first; the window closes once they are answered (`quit_requested`).
        if ctx.input(|i| i.viewport().close_requested()) && !self.solve.quit_requested {
            ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
-            solvecraft_ui_egui::documents::request_quit(&mut self.solve);
+            solidcraft_ui_egui::documents::request_quit(&mut self.solve);
        }
        self.solve.logic(ctx);
        #[cfg(any(target_os = "windows", target_os = "linux"))]
@@ -52,26 +52,24 @@ impl eframe::App for App {
        self.solve.ui(ui);
    }
    fn save(&mut self, storage: &mut dyn eframe::Storage) {
-        storage.set_string(PREFS_KEY, self.solve.prefs());
+        storage.set_string(solidcraft_ui_egui::prefs::STORAGE_KEY, self.solve.prefs());
    }
    fn on_exit(&mut self) {
-        solvecraft_ui_egui::recovery_ui::close(&mut self.solve);
-        solvecraft_engine::crash::end_session();
+        solidcraft_ui_egui::recovery_ui::close(&mut self.solve);
+        solidcraft_engine::crash::end_session();
    }
 }

-/// Where the preferences (theme) are kept in eframe's storage.
-const PREFS_KEY: &str = "solvecraft.prefs";
-
 fn services() -> Services {
    Services {
        pick_open: Some(Box::new(|| {
            rfd::FileDialog::new()
                .add_filter(
                    "Designs, STEP, IGES and meshes",
-                    &["solvecraft", "step", "stp", "STEP", "STP", "igs", "iges", "IGS", "IGES", "3mf", "3MF", "stl", "STL"],
+                    &["solidcraft", "solvecraft", "step", "stp", "STEP", "STP", "igs", "iges", "IGS", "IGES", "3mf", "3MF", "stl", "STL"],
                )
-                .add_filter("SolidCraft design", &["solvecraft"])
+                // The legacy extension is a compatibility shim (docs/compatibility.md).
+                .add_filter("SolidCraft design", &solidcraft_engine::io::DESIGN_EXTS)
                .add_filter("STEP", &["step", "stp", "STEP", "STP"])
                .add_filter("IGES", &["igs", "iges", "IGS", "IGES"])
                .add_filter("Mesh (3MF, STL)", &["3mf", "3MF", "stl", "STL"])
@@ -104,10 +102,40 @@ fn services() -> Services {
    }
 }

+/// The per-user settings folder: eframe's storage (`app.ron`) and the anti-aliasing preference.
+fn settings_dir() -> Option<std::path::PathBuf> {
+    eframe::storage_dir("SolidCraft")
+}
+
 /// The anti-aliasing preference, kept next to eframe's storage (it is needed before the
 /// window opens).
 fn graphics_path() -> Option<std::path::PathBuf> {
-    eframe::storage_dir("SolveCraft").map(|d| d.join("graphics.json"))
+    settings_dir().map(|d| d.join("graphics.json"))
+}
+
+/// Compatibility shim (docs/compatibility.md): on the first launch after the rename, copy the
+/// settings of earlier releases into the new folder. They kept `graphics.json` (and, on Linux
+/// and macOS, the recovery folder) under the old product name, and eframe's `app.ron` under the
+/// window's app id. The old folders are never changed.
+fn adopt_legacy_settings() {
+    let (Some(current), Some(legacy)) = (settings_dir(), eframe::storage_dir("SolveCraft")) else { return };
+    let legacy_eframe = eframe::storage_dir(APP_ID);
+    if let Err(e) = adopt_settings(&current, &legacy, legacy_eframe.as_deref()) {
+        log::warn!("settings: could not copy the previous release's settings into {}: {e}", current.display());
+    }
+}
+
+fn adopt_settings(current: &std::path::Path, legacy: &std::path::Path, legacy_eframe: Option<&std::path::Path>) -> std::io::Result<()> {
+    let fresh = !current.exists();
+    solidcraft_engine::io::adopt_legacy_dir(current, legacy)?;
+    if let Some(old) = legacy_eframe.map(|d| d.join("app.ron")).filter(|p| fresh && p.is_file()) {
+        std::fs::create_dir_all(current)?;
+        let new = current.join("app.ron");
+        if !new.exists() {
+            std::fs::copy(old, new)?;
+        }
+    }
+    Ok(())
 }

 /// Anti-aliasing samples from Preferences (4 when unset).
@@ -122,7 +150,7 @@ fn msaa() -> u16 {
 }

 /// Windows and Linux: no OS title bar; the application bar is the title bar
-/// (`solvecraft_ui_egui::titlebar`). macOS keeps its traffic lights over the integrated bar.
+/// (`solidcraft_ui_egui::titlebar`). macOS keeps its traffic lights over the integrated bar.
 const CUSTOM_TITLEBAR: bool = !cfg!(target_os = "macos");

 const DEPTH_BITS: u8 = 24;
@@ -147,12 +175,17 @@ fn app_viewport() -> Result<egui::ViewportBuilder, eframe::Error> {
        .with_fullsize_content_view(true)
        .with_titlebar_shown(false)
        .with_title_shown(false)
-        .with_app_id("ai.storyteller.solvecraft"))
+        .with_app_id(APP_ID))
 }

+/// The window's app id: it names the desktop entry, so it stays the packages' reverse-DNS id,
+/// which is kept from before the rename (compatibility shim, docs/compatibility.md).
+const APP_ID: &str = "ai.storyteller.solvecraft";
+
 fn main() -> eframe::Result {
+    adopt_legacy_settings();
    let samples = msaa();
-    let mut control_port: Option<u16> = std::env::var("SOLVECRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok());
+    let mut control_port: Option<u16> = solidcraft_engine::geom::env::var("CONTROL_PORT").and_then(|p| p.parse().ok());
    let mut files = Vec::new();
    let mut sample = false;
    let mut args = std::env::args().skip(1);
@@ -165,10 +198,10 @@ fn main() -> eframe::Result {
                return Ok(());
            }
            "--crash-log" => {
-                match solvecraft_engine::crash::default_dir() {
+                match solidcraft_engine::crash::default_dir() {
                    Some(dir) => {
                        println!("crash reports: {}", dir.display());
-                        for r in solvecraft_engine::crash::list(&dir).iter().take(5) {
+                        for r in solidcraft_engine::crash::list(&dir).iter().take(5) {
                            println!("  {}  {}  {}", r.id, r.kind, r.message);
                        }
                        println!("more: solidcraft-cli crashes");
@@ -178,21 +211,21 @@ fn main() -> eframe::Result {
                return Ok(());
            }
            "--help" | "-h" => {
-                println!("usage: solidcraft [--control PORT] [--sample] [--crash-log] [design.solvecraft | part.step]");
+                println!("usage: solidcraft [--control PORT] [--sample] [--crash-log] [design.solidcraft | part.step]");
                return Ok(());
            }
            _ => files.push(a),
        }
    }
-    // Crashes leave a report in the crash folder (solvecraft_engine::crash, docs/crash-reports.md).
-    let crashed = solvecraft_engine::crash::default_dir()
+    // Crashes leave a report in the crash folder (solidcraft_engine::crash, docs/crash-reports.md).
+    let crashed = solidcraft_engine::crash::default_dir()
        .map(|dir| {
-            let build = solvecraft_engine::crash::Build {
-                version: solvecraft_ui_egui::help::VERSION,
-                commit: solvecraft_ui_egui::help::COMMIT,
-                built: solvecraft_ui_egui::help::BUILD_DATE,
+            let build = solidcraft_engine::crash::Build {
+                version: solidcraft_ui_egui::help::VERSION,
+                commit: solidcraft_ui_egui::help::COMMIT,
+                built: solidcraft_ui_egui::help::BUILD_DATE,
            };
-            solvecraft_engine::crash::install(dir, build)
+            solidcraft_engine::crash::install(dir, build)
        })
        .unwrap_or_default();
    let options = eframe::NativeOptions {
@@ -200,6 +233,8 @@ fn main() -> eframe::Result {
        depth_buffer: DEPTH_BITS,
        stencil_buffer: STENCIL_BITS,
        multisampling: samples,
+        // Kept with the other settings, not in a folder named after the app id.
+        persistence_path: settings_dir().map(|d| d.join("app.ron")),
        ..Default::default()
    };
    #[cfg(all(unix, not(target_os = "macos")))]
@@ -209,7 +244,7 @@ fn main() -> eframe::Result {
        std::env::var_os("DISPLAY").is_some(),
        std::env::var_os("WAYLAND_DISPLAY").is_some(),
        std::env::var("XDG_CURRENT_DESKTOP").ok().as_deref(),
-        std::env::var("SOLVECRAFT_WAYLAND").ok().as_deref(),
+        solidcraft_engine::geom::env::var("WAYLAND").as_deref(),
    ) {
        options.event_loop_builder = Some(Box::new(|b| {
            use winit::platform::x11::EventLoopBuilderExtX11;
@@ -220,20 +255,20 @@ fn main() -> eframe::Result {
        "SolidCraft",
        options,
        Box::new(move |cc| {
-            solvecraft_ui_egui::fonts::setup_fonts(&cc.egui_ctx);
+            solidcraft_ui_egui::fonts::setup_fonts(&cc.egui_ctx);
            let mut app = SolveApp::new(Session::default(), services());
            app.custom_titlebar = CUSTOM_TITLEBAR;
            app.integrated_titlebar = cfg!(target_os = "macos");
-            if let Some(p) = cc.storage.and_then(|s| s.get_string(PREFS_KEY)) {
+            if let Some(p) = cc.storage.and_then(|s| solidcraft_ui_egui::prefs::stored(|k| s.get_string(k))) {
                app.load_prefs(&p);
            }
            if let Some(rs) = &cc.wgpu_render_state {
                eprintln!("SolidCraft graphics: {:?}, MSAA {}x (requested {}x)", rs.adapter.get_info().backend, rs.msaa_samples, samples);
                app.set_wgpu(rs, DEPTH_BITS, STENCIL_BITS, rs.msaa_samples);
                // A saved anti-aliasing the device can't do: back to the default, with a notice.
-                solvecraft_ui_egui::prefs::check_msaa(&mut app, u32::from(samples));
+                solidcraft_ui_egui::prefs::check_msaa(&mut app, u32::from(samples));
                let info = rs.adapter.get_info();
-                solvecraft_engine::crash::set_environment(&format!(
+                solidcraft_engine::crash::set_environment(&format!(
                    "Renderer: {:?} {} ({}), MSAA {}x",
                    info.backend, info.name, info.driver, rs.msaa_samples
                ));
@@ -243,7 +278,7 @@ fn main() -> eframe::Result {
                app = app.with_control(rx);
            }
            if sample {
-                if let Err(e) = app.session.run_script(&solvecraft_engine::sample::script()) {
+                if let Err(e) = app.session.run_script(&solidcraft_engine::sample::script()) {
                    app.set_status(format!("sample: {e}"), true);
                }
                app.session.doc_mut().name = "Sample Plate".into();
@@ -260,12 +295,12 @@ fn main() -> eframe::Result {
                app.home.show(rev);
            }
            // Autosave, and offer what crashed sessions left behind.
-            if let Some(dir) = solvecraft_engine::recovery::default_dir() {
+            if let Some(dir) = solidcraft_engine::recovery::default_dir() {
                let every = if app.autosave_minutes > 0.0 { app.autosave_minutes * 60.0 } else { f64::MAX / 4.0 };
-                solvecraft_ui_egui::recovery_ui::start(&mut app, &dir, std::time::Duration::from_secs_f64(every.min(1e9)));
+                solidcraft_ui_egui::recovery_ui::start(&mut app, &dir, std::time::Duration::from_secs_f64(every.min(1e9)));
            }
            // Tell the user about crashes since the last start (after the recovery offer is set up).
-            solvecraft_ui_egui::crash_ui::announce(&mut app, &crashed);
+            solidcraft_ui_egui::crash_ui::announce(&mut app, &crashed);
            #[cfg(any(target_os = "windows", target_os = "linux"))]
            let space_mouse = space_mouse::SpaceMouse::start(&cc.egui_ctx);
            Ok(Box::new(App {
@@ -281,7 +316,7 @@ fn main() -> eframe::Result {
 /// on Wayland (only on X11), so dropping files from the file manager showed a "no" cursor: use
 /// XWayland when it's there. Except on niri, whose XWayland (xwayland-satellite) breaks window
 /// management (maximize/restore), so it stays on native Wayland and gives up file drops.
-/// `SOLVECRAFT_WAYLAND=1` keeps native Wayland, `SOLVECRAFT_WAYLAND=0` forces XWayland.
+/// `SOLIDCRAFT_WAYLAND=1` keeps native Wayland, `SOLIDCRAFT_WAYLAND=0` forces XWayland.
 #[cfg(all(unix, not(target_os = "macos")))]
 fn prefer_x11(display: bool, wayland_display: bool, desktop: Option<&str>, wayland_override: Option<&str>) -> bool {
    match wayland_override.map(str::trim) {
@@ -308,7 +343,7 @@ mod backend_tests {
        assert!(!prefer_x11(true, true, Some("niri:GNOME"), None));
        // niri without a Wayland socket (nested X session) still uses X11.
        assert!(prefer_x11(true, false, Some("niri"), None));
-        // SOLVECRAFT_WAYLAND: anything but 0 keeps Wayland, 0 forces XWayland (when present).
+        // SOLIDCRAFT_WAYLAND: anything but 0 keeps Wayland, 0 forces XWayland (when present).
        assert!(!prefer_x11(true, true, Some("GNOME"), Some("1")));
        assert!(!prefer_x11(true, true, Some("GNOME"), Some("")));
        assert!(prefer_x11(true, true, Some("niri"), Some("0")));
@@ -323,7 +358,7 @@ mod icon_tests {
    fn macos_preserves_the_bundle_icon_instead_of_setting_a_runtime_bitmap() {
        let viewport = super::app_viewport().expect("viewport");
        assert_eq!(viewport.icon.as_deref(), Some(&eframe::egui::IconData::default()));
-        assert_eq!(viewport.app_id.as_deref(), Some("ai.storyteller.solvecraft"));
+        assert_eq!(viewport.app_id.as_deref(), Some(super::APP_ID));
    }

    #[cfg(not(target_os = "macos"))]
@@ -333,12 +368,34 @@ mod icon_tests {
        let icon = viewport.icon.expect("running window must have an icon");
        assert_eq!((icon.width, icon.height), (64, 64));
        assert_eq!(icon.rgba, super::app_icon::rgba(64).expect("original mark"));
-        assert_eq!(viewport.app_id.as_deref(), Some("ai.storyteller.solvecraft"));
+        assert_eq!(viewport.app_id.as_deref(), Some(super::APP_ID));
    }
 }

 #[cfg(test)]
 mod msaa_tests {
+    #[test]
+    fn first_launch_adopts_the_previous_release_settings() {
+        let d = std::env::temp_dir().join(format!("solidcraft-adopt-settings-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&d);
+        let (current, legacy, legacy_eframe) = (d.join("solidcraft"), d.join("solvecraft"), d.join("ai.storyteller.solvecraft"));
+        std::fs::create_dir_all(&legacy).unwrap();
+        std::fs::create_dir_all(&legacy_eframe).unwrap();
+        std::fs::write(legacy.join("graphics.json"), r#"{"msaa":8}"#).unwrap();
+        std::fs::write(legacy_eframe.join("app.ron"), "(prefs)").unwrap();
+        super::adopt_settings(&current, &legacy, Some(&legacy_eframe)).unwrap();
+        assert_eq!(std::fs::read_to_string(current.join("graphics.json")).unwrap(), r#"{"msaa":8}"#);
+        assert_eq!(std::fs::read_to_string(current.join("app.ron")).unwrap(), "(prefs)");
+        assert!(legacy.join("graphics.json").is_file() && legacy_eframe.join("app.ron").is_file());
+        // Later launches leave the current settings alone.
+        std::fs::write(current.join("app.ron"), "(mine)").unwrap();
+        std::fs::remove_file(current.join("graphics.json")).unwrap();
+        super::adopt_settings(&current, &legacy, Some(&legacy_eframe)).unwrap();
+        assert_eq!(std::fs::read_to_string(current.join("app.ron")).unwrap(), "(mine)");
+        assert!(!current.join("graphics.json").exists());
+        let _ = std::fs::remove_dir_all(&d);
+    }
+
    #[test]
    fn saved_multisampling_uses_the_selected_backend_policy() {
        use eframe::wgpu::Backend;
@@ -15,8 +15,8 @@ use hid_descriptor::Layout;
 use hidapi::{DeviceInfo, HidApi};
 use quick_xml::Reader;
 use quick_xml::events::Event;
-use solvecraft_engine::render::Camera;
-use solvecraft_ui_egui::SolveApp;
+use solidcraft_engine::render::Camera;
+use solidcraft_ui_egui::SolveApp;

 const STALE_AFTER: Duration = Duration::from_millis(150);
 const RETRY_AFTER: Duration = Duration::from_secs(2);
@@ -185,7 +185,10 @@ fn parse_driver_mapping(xml: &[u8]) -> Option<DriverMapping> {
 }

 fn load_driver_mapping() -> Option<DriverMapping> {
-    let profile = std::path::PathBuf::from(std::env::var_os("APPDATA")?).join("3Dconnexion").join("3DxWare").join("Cfg").join("solvecraft-KMJ.xml");
+    let cfg = std::path::PathBuf::from(std::env::var_os("APPDATA")?).join("3Dconnexion").join("3DxWare").join("Cfg");
+    // The driver names the profile after the executable; one made for the pre-rename executable
+    // still applies until the driver writes a new one (compatibility shim).
+    let profile = ["solidcraft-KMJ.xml", "solvecraft-KMJ.xml"].into_iter().map(|n| cfg.join(n)).find(|p| p.is_file())?;
    if std::fs::metadata(&profile).ok()?.len() > MAX_PROFILE_BYTES {
        log::warn!("3D mouse: ignoring oversized 3DxWare profile {}", profile.display());
        return None;
@@ -371,7 +374,7 @@ impl SpaceMouse {
        let shared = Arc::new(Mutex::new(Reading::new(now)));
        let worker_state = Arc::clone(&shared);
        let worker_ctx = ctx.clone();
-        if let Err(error) = std::thread::Builder::new().name("solvecraft-3d-mouse".into()).spawn(move || reader(worker_ctx, worker_state)) {
+        if let Err(error) = std::thread::Builder::new().name("solidcraft-3d-mouse".into()).spawn(move || reader(worker_ctx, worker_state)) {
            log::warn!("3D mouse: reader could not start: {error}");
        }
        Self { shared, last_frame: now, driver_mapping: load_driver_mapping().unwrap_or_default(), mapping_checked_at: now }
@@ -1,5 +1,5 @@
 [package]
-name = "solvecraft-doc"
+name = "solidcraft-doc"
 description = "SolidCraft document model: parameters and expressions, sketches and features on a parametric timeline, incremental evaluation"
 version.workspace = true
 edition.workspace = true
@@ -9,9 +9,9 @@ license.workspace = true
 workspace = true

 [dependencies]
-solvecraft-geom = { workspace = true }
-solvecraft-sketch = { workspace = true }
-solvecraft-kernel = { workspace = true }
+solidcraft-geom = { workspace = true }
+solidcraft-sketch = { workspace = true }
+solidcraft-kernel = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
@@ -7,7 +7,7 @@ pub fn state_in_face_anchor_frame<'a>(doc: &Document, state: &'a ModelState, anc
    let raw = state.body(&anchor.target.body).ok_or_else(|| DocError::Unknown(format!("anchored body `{}`", anchor.target.body)))?;
    let relative = anchor.source_to_author(doc, author, raw)?;
    let mut output = crate::state_in_frame_at(doc, state, author, frame).into_owned();
-    let shape = if crate::is_identity(&relative) { raw.body.clone() } else { solvecraft_kernel::transform_matrix(&raw.body, relative)? };
+    let shape = if crate::is_identity(&relative) { raw.body.clone() } else { solidcraft_kernel::transform_matrix(&raw.body, relative)? };
    let mut body = ModelBody::new(raw.name.clone(), shape, raw.feature);
    body.component = raw.component;
    body.transferred = raw.transferred;
@@ -6,7 +6,7 @@
 use std::collections::BTreeMap;

 use serde::{Deserialize, Serialize};
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;

 use crate::Document;

@@ -9,7 +9,7 @@
 //! and the engine maps a new feature's geometry into the active component's frame.

 use serde::{Deserialize, Serialize};
-use solvecraft_geom::{Plane, Vec3};
+use solidcraft_geom::{Plane, Vec3};

 use crate::{AxisRef, DocError, Document, FeatureKind, PatternKind, PlaneRef, Result};

@@ -1,6 +1,6 @@
 //! Recorded ownership changes are evaluated at their timeline position.
 use crate::{DocError, Document, Mat, ModelBody, ModelState, Result};
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;
 use std::collections::BTreeSet;

 pub fn valid_transfer_matrix(m: &Mat) -> bool {
@@ -39,7 +39,7 @@ pub(crate) fn evaluate(doc: &Document, st: &mut ModelState, bodies: &[String], f
        if doc.model_body_component(old) != from {
            return Err(DocError::Invalid(format!("body `{name}` no longer belongs to transfer source component {from}")));
        }
-        let shape = if crate::is_identity(&transform) { old.body.clone() } else { solvecraft_kernel::transform_matrix(&old.body, transform)? };
+        let shape = if crate::is_identity(&transform) { old.body.clone() } else { solidcraft_kernel::transform_matrix(&old.body, transform)? };
        let mut body = ModelBody::new(old.name.clone(), shape, old.feature);
        body.component = to;
        body.transferred = true;
@@ -1,5 +1,5 @@
 //! World-frame metadata at a timeline body ownership boundary.
-use solvecraft_geom::Plane;
+use solidcraft_geom::Plane;

 use crate::{DocError, Mat, ModelState, Result, apply_point, apply_vector};

@@ -2,7 +2,7 @@
 //! The image bytes travel inside the design file (base64), so it reopens without the original.

 use serde::{Deserialize, Serialize};
-use solvecraft_geom::{Plane, Vec2, Vec3};
+use solidcraft_geom::{Plane, Vec2, Vec3};

 use crate::PlaneRef;

@@ -202,13 +202,13 @@ fn remap_plane(
 }

 fn remap_link(
-    source: &mut solvecraft_sketch::LinkSource,
+    source: &mut solidcraft_sketch::LinkSource,
    ids: &BTreeMap<u64, u64>,
    names: &BTreeMap<String, String>,
    bodies: &BTreeMap<String, String>,
    depth: usize,
 ) {
-    use solvecraft_sketch::LinkSource;
+    use solidcraft_sketch::LinkSource;
    if depth > 64 {
        return;
    }
@@ -441,11 +441,11 @@ fn checked_plane(p: &PlaneRef, depth: usize) -> crate::Result<()> {
    }
    Ok(())
 }
-fn checked_link(source: &solvecraft_sketch::LinkSource, depth: usize) -> crate::Result<()> {
+fn checked_link(source: &solidcraft_sketch::LinkSource, depth: usize) -> crate::Result<()> {
    if depth > 64 {
        return Err(crate::DocError::Invalid("copy link nesting exceeds 64".into()));
    }
-    if let solvecraft_sketch::LinkSource::Intersection { a, b } = source {
+    if let solidcraft_sketch::LinkSource::Intersection { a, b } = source {
        checked_link(a, depth + 1)?;
        checked_link(b, depth + 1)?;
    }
@@ -1,7 +1,7 @@
 //! Certificates are producer identities, never a nearest-surface selection.
 use crate::{DocError, Document, FeatureKind, ModelBody, Result, SolvedSketch};
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::Seg2;
+use solidcraft_geom::Seg2;

 fn valid_signature(outer: &[String], holes: &[Vec<String>]) -> bool {
    let valid = |ids: &[String]| {
@@ -68,11 +68,11 @@ pub(crate) fn cap_key(outer: &[String], holes: &[Vec<String>]) -> String {
    }
    format!("{:x}", hash.finalize())
 }
-fn exact_region_signature(curves: &ExactSketchCurves, region: &solvecraft_geom::Region2) -> Option<solvecraft_kernel::CapSignature> {
+fn exact_region_signature(curves: &ExactSketchCurves, region: &solidcraft_geom::Region2) -> Option<solidcraft_kernel::CapSignature> {
    if region.outer.segs.len() + region.holes.iter().map(|hole| hole.segs.len()).sum::<usize>() > 4096 || region.holes.len() > 128 {
        return None;
    }
-    let signature = |outline: &solvecraft_geom::Loop2| {
+    let signature = |outline: &solidcraft_geom::Loop2| {
        let mut ids = outline.segs.iter().map(|segment| curves.find(segment)).collect::<Option<Vec<_>>>()?;
        ids.sort();
        ids.dedup();
@@ -85,9 +85,9 @@ fn exact_region_signature(curves: &ExactSketchCurves, region: &solvecraft_geom::
 }

 /// Charge all source-curve comparisons before matching; over-budget tools stay usable but uncertified.
-type CapBindings = Vec<Vec<Option<solvecraft_kernel::CapSignature>>>;
-pub(crate) fn extrude_cap_bindings(sketch: &SolvedSketch, bodies: &[solvecraft_kernel::Body], budget: usize) -> Option<CapBindings> {
-    use solvecraft_kernel::FaceSource;
+type CapBindings = Vec<Vec<Option<solidcraft_kernel::CapSignature>>>;
+pub(crate) fn extrude_cap_bindings(sketch: &SolvedSketch, bodies: &[solidcraft_kernel::Body], budget: usize) -> Option<CapBindings> {
+    use solidcraft_kernel::FaceSource;
    if sketch.sketch.curves.len() > 2000 {
        return None;
    }
@@ -116,7 +116,7 @@ pub(crate) fn extrude_cap_bindings(sketch: &SolvedSketch, bodies: &[solvecraft_k
    let mut counts = std::collections::BTreeMap::new();
    let mut bindings = Vec::with_capacity(bodies.len());
    for body in bodies {
-        let mut cached: Option<(&solvecraft_geom::Region2, Option<solvecraft_kernel::CapSignature>)> = None;
+        let mut cached: Option<(&solidcraft_geom::Region2, Option<solidcraft_kernel::CapSignature>)> = None;
        let mut values = Vec::new();
        for source in body.face_sources().into_iter().flatten() {
            let signature = if let Some(FaceSource::ExtrudeCap { region, high, .. }) = source {
@@ -260,8 +260,8 @@ pub(crate) fn shell_certificate_role(source: &FaceCertificate, inner: bool) -> R
    Ok(format!("shell:{}:{role}", if inner { "inner" } else { "outer" }))
 }

-pub(crate) fn flat_source_certificate(source: &solvecraft_kernel::FaceSource) -> Option<(u64, FaceCertificate)> {
-    use solvecraft_kernel::FaceSource;
+pub(crate) fn flat_source_certificate(source: &solidcraft_kernel::FaceSource) -> Option<(u64, FaceCertificate)> {
+    use solidcraft_kernel::FaceSource;
    match source {
        FaceSource::Box { producer: Some(producer), axis, high, .. } => Some((*producer, FaceCertificate::Box { axis: *axis, high: *high })),
        FaceSource::CertifiedExtrudeSide { producer, sketch, curve, .. } => {
@@ -277,8 +277,8 @@ pub(crate) fn flat_source_certificate(source: &solvecraft_kernel::FaceSource) ->
    }
 }

-pub(crate) fn flat_source_matches(certificate: &FaceCertificate, source: &solvecraft_kernel::FaceSource, producer: u64) -> bool {
-    use solvecraft_kernel::FaceSource;
+pub(crate) fn flat_source_matches(certificate: &FaceCertificate, source: &solidcraft_kernel::FaceSource, producer: u64) -> bool {
+    use solidcraft_kernel::FaceSource;
    match (certificate, source) {
        (FaceCertificate::Box { axis, high }, FaceSource::Box { producer: Some(current), axis: current_axis, high: current_high, .. }) => {
            producer == *current && axis == current_axis && high == current_high
@@ -324,14 +324,14 @@ impl<'a> ExactSketchCurves<'a> {
            if curve.construction
                || !matches!(
                    curve.kind,
-                    solvecraft_sketch::CurveKind::Line { .. }
-                        | solvecraft_sketch::CurveKind::Arc { .. }
-                        | solvecraft_sketch::CurveKind::Circle { .. }
+                    solidcraft_sketch::CurveKind::Line { .. }
+                        | solidcraft_sketch::CurveKind::Arc { .. }
+                        | solidcraft_sketch::CurveKind::Circle { .. }
                )
            {
                continue;
            }
-            let originals = if let solvecraft_sketch::CurveKind::Circle { c, r } = curve.kind {
+            let originals = if let solidcraft_sketch::CurveKind::Circle { c, r } = curve.kind {
                sketch
                    .sketch
                    .point(c)
@@ -364,7 +364,7 @@ fn exact_segment_contains(original: &Seg2, generated: &Seg2) -> bool {
        (Seg2::Line { a, b }, Seg2::Line { a: c, b: d }) => {
            let direction = *b - *a;
            let scale = direction.len().max((*d - *c).len()).max(1.);
-            let interval = |point: solvecraft_geom::Vec2| {
+            let interval = |point: solidcraft_geom::Vec2| {
                let t = (point - *a).dot(direction) / direction.len2();
                (-1e-10..=1. + 1e-10).contains(&t)
            };
@@ -400,18 +400,18 @@ fn exact_segment_contains(original: &Seg2, generated: &Seg2) -> bool {
 }

 impl Document {
-    pub fn configuration_face_target(&self, body: &ModelBody, index: usize, point: solvecraft_geom::Vec3) -> Result<crate::config::ConfigFaceTarget> {
+    pub fn configuration_face_target(&self, body: &ModelBody, index: usize, point: solidcraft_geom::Vec3) -> Result<crate::config::ConfigFaceTarget> {
        let names = crate::naming::face_names(body);
        let mut name = names
            .get(index)
            .map(|name| crate::naming::strip_piece(name).to_string())
            .ok_or_else(|| DocError::Unknown("face source name missing".into()))?;
        let origin = match body.body.face_sources().and_then(|sources| sources.get(index)).and_then(Option::as_ref) {
-            Some(solvecraft_kernel::FaceSource::Imported { producer: Some(producer), .. })
-            | Some(solvecraft_kernel::FaceSource::CertifiedExtrudeSide { producer, .. })
-            | Some(solvecraft_kernel::FaceSource::CertifiedExtrudeCap { producer, .. })
-            | Some(solvecraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), .. })
-            | Some(solvecraft_kernel::FaceSource::Box { producer: Some(producer), .. }) => *producer,
+            Some(solidcraft_kernel::FaceSource::Imported { producer: Some(producer), .. })
+            | Some(solidcraft_kernel::FaceSource::CertifiedExtrudeSide { producer, .. })
+            | Some(solidcraft_kernel::FaceSource::CertifiedExtrudeCap { producer, .. })
+            | Some(solidcraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), .. })
+            | Some(solidcraft_kernel::FaceSource::Box { producer: Some(producer), .. }) => *producer,
            _ => name
                .strip_prefix('F')
                .and_then(|name| name.split_once(':'))
@@ -439,7 +439,7 @@ impl Document {
        let Some(source) = body.body.face_sources().and_then(|sources| sources.get(index)).and_then(Option::as_ref) else {
            return Ok(None);
        };
-        if let solvecraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), source, inner, .. } = source {
+        if let solidcraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), source, inner, .. } = source {
            if !self.feature(*producer).is_some_and(|feature| matches!(feature.kind, FeatureKind::Shell { .. })) {
                return Err(DocError::Invalid("shell source producer missing".into()));
            }
@@ -452,7 +452,7 @@ impl Document {
            certificate.validate()?;
            return Ok(Some(certificate));
        }
-        if let solvecraft_kernel::FaceSource::Imported { item, face, payload_sha256: Some(digest), producer: Some(producer) } = source {
+        if let solidcraft_kernel::FaceSource::Imported { item, face, payload_sha256: Some(digest), producer: Some(producer) } = source {
            if !self.feature(*producer).is_some_and(|feature| matches!(feature.kind, FeatureKind::Import { .. })) {
                return Err(DocError::Invalid("import source producer missing".into()));
            }
@@ -461,7 +461,7 @@ impl Document {
            return Ok(Some(certificate));
        }
        let certificate = match source {
-            solvecraft_kernel::FaceSource::CertifiedExtrudeSide { producer, sketch, curve, .. } => {
+            solidcraft_kernel::FaceSource::CertifiedExtrudeSide { producer, sketch, curve, .. } => {
                if !self.feature(*producer).is_some_and(|feature| matches!(feature.kind, FeatureKind::Extrude { .. })) {
                    return Err(DocError::Invalid("side source producer missing".into()));
                }
@@ -472,16 +472,16 @@ impl Document {
        certificate.validate()?;
        Ok(Some(certificate))
    }
-    pub fn strong_face_target(&self, body: &ModelBody, index: usize, point: solvecraft_geom::Vec3) -> Result<crate::config::ConfigFaceTarget> {
+    pub fn strong_face_target(&self, body: &ModelBody, index: usize, point: solidcraft_geom::Vec3) -> Result<crate::config::ConfigFaceTarget> {
        let mut target = self.configuration_face_target(body, index, point)?;
        match body.body.face_sources().and_then(|sources| sources.get(index)).and_then(Option::as_ref) {
-            Some(solvecraft_kernel::FaceSource::Box { producer: Some(producer), axis, high, .. }) => {
+            Some(solidcraft_kernel::FaceSource::Box { producer: Some(producer), axis, high, .. }) => {
                target.origin_feature = *producer;
                let axis_name = ["x", "y", "z"].get(*axis as usize).ok_or_else(|| DocError::Invalid("invalid box face axis".into()))?;
                target.name = format!("F{producer}:{}{axis_name}", if *high { "+" } else { "-" });
                target.certificate = Some(FaceCertificate::Box { axis: *axis, high: *high });
            }
-            Some(solvecraft_kernel::FaceSource::CertifiedExtrudeCap { producer, sketch, high, outer, holes, .. }) => {
+            Some(solidcraft_kernel::FaceSource::CertifiedExtrudeCap { producer, sketch, high, outer, holes, .. }) => {
                target.origin_feature = *producer;
                target.name = format!("F{producer}:cap:{}:{}", if *high { "high" } else { "low" }, cap_key(outer, holes));
                target.certificate = Some(FaceCertificate::ExtrudeCap { sketch: *sketch, high: *high, outer: outer.clone(), holes: holes.clone() });
@@ -507,15 +507,15 @@ mod tests {
    use super::*;
    use serde_json::json;

-    fn solved(mut sketch: solvecraft_sketch::Sketch) -> SolvedSketch {
-        let report = solvecraft_sketch::solve(&mut sketch);
-        SolvedSketch { feature: 1, name: "sources".into(), plane: solvecraft_geom::Plane::XY, sketch, report, profiles: Vec::new() }
+    fn solved(mut sketch: solidcraft_sketch::Sketch) -> SolvedSketch {
+        let report = solidcraft_sketch::solve(&mut sketch);
+        SolvedSketch { feature: 1, name: "sources".into(), plane: solidcraft_geom::Plane::XY, sketch, report, profiles: Vec::new() }
    }

    #[test]
    fn prepared_sources_keep_exact_identity_and_reject_ambiguity() {
-        use solvecraft_geom::Vec2;
-        let mut sketch = solvecraft_sketch::Sketch::new();
+        use solidcraft_geom::Vec2;
+        let mut sketch = solidcraft_sketch::Sketch::new();
        sketch.add_line(Vec2::ZERO, Vec2::new(10., 0.), None, None, Some("line")).unwrap();
        sketch.add_circle(Vec2::new(20., 0.), 2., None, Some("circle")).unwrap();
        let construction = sketch.add_line(Vec2::ZERO, Vec2::new(10., 0.), None, None, Some("construction")).unwrap();
@@ -532,7 +532,7 @@ mod tests {
        // A prepared pass borrows one immutable evaluated sketch, so an upstream edit
        // necessarily prepares fresh sources rather than retaining stale coordinates.
        let mut moved = sketch.clone();
-        moved.sketch = solvecraft_sketch::Sketch::new();
+        moved.sketch = solidcraft_sketch::Sketch::new();
        moved.sketch.add_line(Vec2::new(0., 1.), Vec2::new(10., 1.), None, None, Some("line")).unwrap();
        assert_eq!(ExactSketchCurves::new(&moved).find(&partial), None);
    }
@@ -540,8 +540,8 @@ mod tests {
    #[test]
    #[ignore = "manual optimized certification microbenchmark; no timing assertion"]
    fn benchmark_prepared_extrude_sources() {
-        use solvecraft_geom::Vec2;
-        let mut sketch = solvecraft_sketch::Sketch::new();
+        use solidcraft_geom::Vec2;
+        let mut sketch = solidcraft_sketch::Sketch::new();
        for i in 0..1000 {
            let y = i as f64;
            sketch.add_line(Vec2::new(0., y), Vec2::new(10., y), None, None, None).unwrap();
@@ -593,7 +593,7 @@ mod tests {
    #[test]
    fn analytic_arc_interval_refuses_unsampled_gaps_and_accepts_wrap_reversal() {
        let radians = |degrees: f64| degrees.to_radians();
-        let arc = |start, sweep| Seg2::Arc { center: solvecraft_geom::Vec2::default(), radius: 10., start: radians(start), sweep: radians(sweep) };
+        let arc = |start, sweep| Seg2::Arc { center: solidcraft_geom::Vec2::default(), radius: 10., start: radians(start), sweep: radians(sweep) };
        assert!(!exact_segment_contains(&arc(10., 350.), &arc(20., 360.)), "five point probes missed the missing ten-degree gap");
        assert!(!exact_segment_contains(&arc(10., 350.), &arc(20., -360.)));
        assert!(exact_segment_contains(&arc(350., 40.), &arc(355., 20.)));
@@ -142,7 +142,7 @@ mod tests {
                    body: "Old".into(),
                    origin_feature: 3,
                    name: "F3:+z".into(),
-                    point: solvecraft_geom::Vec3::new(1., 1., 2.),
+                    point: solidcraft_geom::Vec3::new(1., 1., 2.),
                    certificate: None,
                }),
            ],
@@ -199,7 +199,7 @@ mod tests {
                    body: "Foreign".into(),
                    origin_feature: 3,
                    name: "F3:+z".into(),
-                    point: solvecraft_geom::Vec3::ZERO,
+                    point: solidcraft_geom::Vec3::ZERO,
                    certificate: None,
                }),
            ],
@@ -1,7 +1,7 @@
 use super::*;
 use crate::{FeatureKind, Model, PlaneRef};
 use serde_json::json;
-use solvecraft_geom::{Vec2, Vec3};
+use solidcraft_geom::{Vec2, Vec3};

 fn shell_document() -> (Document, u64, u64) {
    let mut doc = Document::new("certified shell");
@@ -35,23 +35,23 @@ fn face_index(body: &ModelBody, inner: bool) -> usize {
        .unwrap()
        .iter()
        .position(|source| {
-            matches!(source, Some(solvecraft_kernel::FaceSource::ShellPlanar { inner: current, source, .. })
-            if *current == inner && matches!(source.as_ref(), solvecraft_kernel::FaceSource::Box { axis:0,high:true,.. }))
+            matches!(source, Some(solidcraft_kernel::FaceSource::ShellPlanar { inner: current, source, .. })
+            if *current == inner && matches!(source.as_ref(), solidcraft_kernel::FaceSource::Box { axis:0,high:true,.. }))
        })
        .unwrap()
 }

 #[test]
 fn shell_planar_raw_bounds_flat_identity_and_clone_remap() {
-    let plane = solvecraft_geom::Plane::XY;
-    let same = |planes: &[Option<solvecraft_geom::Plane>]| super::super::styles::shell_plane_family(planes.iter().copied());
+    let plane = solidcraft_geom::Plane::XY;
+    let same = |planes: &[Option<solidcraft_geom::Plane>]| super::super::styles::shell_plane_family(planes.iter().copied());
    assert!(same(&[Some(plane), Some(plane)]));
    assert!(!same(&[]));
    assert!(!same(&[Some(plane), None]));
    for different in [
-        solvecraft_geom::Plane { origin: Vec3::X, ..plane },
-        solvecraft_geom::Plane { x: -plane.x, y: -plane.y, ..plane },
-        solvecraft_geom::Plane { y: -plane.y, ..plane },
+        solidcraft_geom::Plane { origin: Vec3::X, ..plane },
+        solidcraft_geom::Plane { x: -plane.x, y: -plane.y, ..plane },
+        solidcraft_geom::Plane { y: -plane.y, ..plane },
    ] {
        assert!(!same(&[Some(plane), Some(different)]));
    }
@@ -82,15 +82,15 @@ fn shell_planar_anchor_rebuild_cold_geometry_and_missing_source_errors() {
    let body = state.body("Case").unwrap();
    let outer = doc.strong_face_target(body, face_index(body, false), Vec3::default()).unwrap();
    let outer_matches: Vec<_> = body.body.face_sources().unwrap().iter().enumerate().filter_map(|(index, source)| {
-        matches!(source, Some(solvecraft_kernel::FaceSource::ShellPlanar { inner: false, source, .. }) if matches!(source.as_ref(), solvecraft_kernel::FaceSource::Box { axis: 0, high: true, .. })).then_some((index, body.body.face_plane(index)))
+        matches!(source, Some(solidcraft_kernel::FaceSource::ShellPlanar { inner: false, source, .. }) if matches!(source.as_ref(), solidcraft_kernel::FaceSource::Box { axis: 0, high: true, .. })).then_some((index, body.body.face_plane(index)))
    }).collect();
    assert_eq!(outer_matches.len(), 1, "outer support must be one physical face: {outer_matches:?}");
    assert!(super::super::styles::shell_plane_family(outer_matches.iter().map(|(_, plane)| *plane)));
    let outer_plane = body.body.face_plane(face_index(body, false)).unwrap();
    let outer_anchor = doc.capture_face_anchor(body, face_index(body, false), &outer_plane, &[], 0, &[]).unwrap();
-    let projected = crate::project::resolve_anchored_face(&doc, &state, &outer_plane, solvecraft_sketch::LinkKind::Project, &outer_anchor).unwrap();
-    let mut linked = solvecraft_sketch::Sketch::new();
-    let link = linked.add_link(solvecraft_sketch::LinkKind::Project, projected.source, &projected.geom).unwrap();
+    let projected = crate::project::resolve_anchored_face(&doc, &state, &outer_plane, solidcraft_sketch::LinkKind::Project, &outer_anchor).unwrap();
+    let mut linked = solidcraft_sketch::Sketch::new();
+    let link = linked.add_link(solidcraft_sketch::LinkKind::Project, projected.source, &projected.geom).unwrap();
    assert!(!linked.update_link(&link, &projected.geom).unwrap());
    let inner_index = face_index(body, true);
    let inner = doc.strong_face_target(body, inner_index, Vec3::default()).unwrap();
@@ -100,7 +100,7 @@ fn shell_planar_anchor_rebuild_cold_geometry_and_missing_source_errors() {
    let picked = body.body.face_plane(inner_index).unwrap();
    assert!((picked.origin.x - 18.).abs() < 1e-8);
    let anchor = doc.capture_face_anchor(body, inner_index, &picked, &[], 0, &[]).unwrap();
-    let mut sketch = solvecraft_sketch::Sketch::new();
+    let mut sketch = solidcraft_sketch::Sketch::new();
    let points: Vec<_> =
        [(2., 2.), (4., 2.), (4., 4.), (2., 4.)].into_iter().map(|(x, y)| sketch.add_point(Vec2::new(x, y), None).unwrap()).collect();
    for edge in 0..4 {
@@ -136,11 +136,11 @@ fn shell_planar_anchor_rebuild_cold_geometry_and_missing_source_errors() {
    let plane = doc.resolve_face_anchor(&anchor, 0, &changed).unwrap();
    assert!((plane.origin.x - 27.).abs() < 1e-8);
    let after = changed.bodies.iter().find(|body| body.feature == boss).unwrap().mesh().bounds();
-    assert!((solvecraft_kernel::measure(&changed.bodies.iter().find(|body| body.feature == boss).unwrap().body).unwrap().volume - 8.).abs() < 1e-8);
+    assert!((solidcraft_kernel::measure(&changed.bodies.iter().find(|body| body.feature == boss).unwrap().body).unwrap().volume - 8.).abs() < 1e-8);
    assert!((doc.resolve_face_anchor(&outer_anchor, 0, &changed).unwrap().origin.x - 30.).abs() < 1e-8);
    let changed_outer_plane = doc.resolve_face_anchor(&outer_anchor, 0, &changed).unwrap();
    let refreshed =
-        crate::project::resolve_anchored_face(&doc, &changed, &changed_outer_plane, solvecraft_sketch::LinkKind::Project, &outer_anchor).unwrap();
+        crate::project::resolve_anchored_face(&doc, &changed, &changed_outer_plane, solidcraft_sketch::LinkKind::Project, &outer_anchor).unwrap();
    assert!(!linked.update_link(&link, &refreshed.geom).unwrap(), "same exterior boundary must retain projected IDs");
    assert!((after.min.x - before.min.x - 9.).abs() < 1e-8, "{before:?} -> {after:?}");
    assert!((after.max.x - before.max.x - 9.).abs() < 1e-8, "{before:?} -> {after:?}");
@@ -173,11 +173,11 @@ fn shell_planar_anchor_rebuild_cold_geometry_and_missing_source_errors() {
 fn shell_planar_format13_keeps_v12_documents_and_refuses_future() {
    let (doc, _, _) = shell_document();
    let mut legacy: serde_json::Value = serde_json::from_str(&doc.to_json()).unwrap();
-    legacy["format"] = json!("solvecraft/12");
+    legacy["format"] = json!("solidcraft/12");
    let loaded = crate::format::read(&legacy.to_string()).unwrap();
    let mut current: serde_json::Value = serde_json::from_str(&loaded.to_json()).unwrap();
    assert_eq!(current["format"], crate::format::format_string(crate::format::FORMAT));
-    current["format"] = json!("solvecraft/12");
+    current["format"] = json!("solidcraft/12");
    crate::format::pieces_in_shell_order(&mut legacy["features"]);
    assert_eq!(legacy, current, "the migration preserves every prior field");
    legacy["format"] = json!(crate::format::format_string(crate::format::FORMAT + 1));
@@ -199,7 +199,7 @@ fn regularized_shell_keeps_legacy_and_explicit_single_face_projections_closed()
            let body = state.body("Case").unwrap();
            let index = face_index(body, false);
            let mesh = body.mesh();
-            assert_eq!(body.body.face_sources().unwrap().iter().filter(|source|matches!(source,Some(solvecraft_kernel::FaceSource::ShellPlanar {inner:false,source,..}) if matches!(source.as_ref(),solvecraft_kernel::FaceSource::Box {axis:0,high:true,..}))).count(),1,"no physical outer-wall strip face may remain");
+            assert_eq!(body.body.face_sources().unwrap().iter().filter(|source|matches!(source,Some(solidcraft_kernel::FaceSource::ShellPlanar {inner:false,source,..}) if matches!(source.as_ref(),solidcraft_kernel::FaceSource::Box {axis:0,high:true,..}))).count(),1,"no physical outer-wall strip face may remain");
            let plane = body.body.face_plane(index).unwrap();
            let point = mesh
                .triangles
@@ -208,14 +208,14 @@ fn regularized_shell_keeps_legacy_and_explicit_single_face_projections_closed()
                .find_map(|(tri, face)| (*face as usize == index).then(|| mesh.tri(tri)).flatten())
                .map(|[a, b, c]| (a + b + c) / 3.)
                .unwrap();
-            let source = solvecraft_sketch::LinkSource::Face { body: "Case".into(), at: point };
+            let source = solidcraft_sketch::LinkSource::Face { body: "Case".into(), at: point };
            let (values, _) = doc.param_values();
-            let legacy = crate::project::resolve(&doc, &values, &state, &plane, solvecraft_sketch::LinkKind::Project, &source).unwrap();
-            let explicit = crate::project::resolve_face_indices(&state, &plane, solvecraft_sketch::LinkKind::Project, "Case", &[index]).unwrap();
+            let legacy = crate::project::resolve(&doc, &values, &state, &plane, solidcraft_sketch::LinkKind::Project, &source).unwrap();
+            let explicit = crate::project::resolve_face_indices(&state, &plane, solidcraft_sketch::LinkKind::Project, "Case", &[index]).unwrap();
            assert_eq!(legacy.geom, explicit.geom);
            assert_eq!(explicit.geom.len(), 4, "raw planar piece keeps all four edges");
-            let mut sketch = solvecraft_sketch::Sketch::new();
-            let link = sketch.add_link(solvecraft_sketch::LinkKind::Project, source, &legacy.geom).unwrap();
+            let mut sketch = solidcraft_sketch::Sketch::new();
+            let link = sketch.add_link(solidcraft_sketch::LinkKind::Project, source, &legacy.geom).unwrap();
            sketch.links[0].face_name = Some(crate::naming::face_names(body)[index].clone());
            let warnings = crate::project::refresh_links(&doc, &values, &state, &plane, &mut sketch);
            assert!(warnings.is_empty(), "{warnings:?}");
@@ -242,11 +242,11 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material
    // Legacy Shell did not propagate construction certificates. Omit transient
    // metadata here; operand paint also disables new wall-run coalescence so
    // this control retains the actual historical raw pieces.
-    let raw_source = solvecraft_kernel::box_solid(Vec3::ZERO, Vec3::new(20., 12., 10.)).unwrap().with_paint(Some(solvecraft_kernel::Paint {
+    let raw_source = solidcraft_kernel::box_solid(Vec3::ZERO, Vec3::new(20., 12., 10.)).unwrap().with_paint(Some(solidcraft_kernel::Paint {
        opacity: 1.,
-        faces: vec![solvecraft_kernel::FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }],
+        faces: vec![solidcraft_kernel::FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }],
    }));
-    let raw = solvecraft_kernel::shell(&raw_source, &[Vec3::new(5., 6., 10.)], 2.).unwrap();
+    let raw = solidcraft_kernel::shell(&raw_source, &[Vec3::new(5., 6., 10.)], 2.).unwrap();
    let mut old_body = ModelBody::new("Case".into(), raw, shell);
    old_body.names = crate::naming::NameCell::new(Some(std::sync::Arc::new(crate::naming::NamingOrigin {
        feature: doc.feature(shell).unwrap().clone(),
@@ -258,13 +258,13 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material
    assert_eq!(crate::naming::parent_piece(&captured), Some(stem.as_str()), "actual strip capture records a piece name");
    // What the builds before format 14 saved for that piece: its number by centroid order.
    let former = format!("{stem}#1");
-    let mut sketch = solvecraft_sketch::Sketch::new();
+    let mut sketch = solidcraft_sketch::Sketch::new();
    let corners = [Vec2::new(0., 0.), Vec2::new(12., 0.), Vec2::new(12., 2.), Vec2::new(0., 2.)];
-    let geometry: Vec<_> = (0..4).map(|i| solvecraft_sketch::LinkGeom::Line(corners[i], corners[(i + 1) % 4])).collect();
+    let geometry: Vec<_> = (0..4).map(|i| solidcraft_sketch::LinkGeom::Line(corners[i], corners[(i + 1) % 4])).collect();
    sketch
        .add_link(
-            solvecraft_sketch::LinkKind::Project,
-            solvecraft_sketch::LinkSource::Face { body: "Case".into(), at: Vec3::new(20., 6., 1.) },
+            solidcraft_sketch::LinkKind::Project,
+            solidcraft_sketch::LinkSource::Face { body: "Case".into(), at: Vec3::new(20., 6., 1.) },
            &geometry,
        )
        .unwrap();
@@ -289,7 +289,7 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material
        )
        .unwrap();
    let mut legacy: serde_json::Value = serde_json::from_str(&doc.to_json()).unwrap();
-    legacy["format"] = json!("solvecraft/12");
+    legacy["format"] = json!("solidcraft/12");
    let mut doc = crate::format::read(&legacy.to_string()).unwrap();
    for width in [20., 30.] {
        doc.set_param("width", &width.to_string(), Some("mm"), None).unwrap();
@@ -308,7 +308,7 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material
            assert_eq!(solved.sketch.points, original.points);
            let material = state.bodies.iter().find(|body| body.feature == boss).unwrap();
            assert!(
-                (solvecraft_kernel::measure(&material.body).unwrap().volume - 24.).abs() < 1e-8,
+                (solidcraft_kernel::measure(&material.body).unwrap().volume - 24.).abs() < 1e-8,
                "old24mm3 profile must not silently become120mm3 wall profile"
            );
            let bounds = material.mesh().bounds();
@@ -320,8 +320,8 @@ fn saved_former_strip_projection_reports_lost_without_expanding_healthy_material

 #[test]
 fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
-    use solvecraft_kernel::{FacePaint, Paint};
-    use solvecraft_sketch::{LinkKind, LinkSource, Sketch};
+    use solidcraft_kernel::{FacePaint, Paint};
+    use solidcraft_sketch::{LinkKind, LinkSource, Sketch};
    let mut doc = Document::new("saved curved strip");
    doc.set_param("width", "80", Some("mm"), None).unwrap();
    doc.set_param("wall", "2", Some("mm"), None).unwrap();
@@ -362,14 +362,14 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
        .body
        .clone()
        .with_paint(Some(Paint { opacity: 1., faces: vec![FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }] }));
-    let cavity_box = solvecraft_kernel::box_solid(Vec3::new(-38., -28., 2.), Vec3::new(38., 28., 35.)).unwrap();
-    let cavity = solvecraft_kernel::fillet(
+    let cavity_box = solidcraft_kernel::box_solid(Vec3::new(-38., -28., 2.), Vec3::new(38., 28., 35.)).unwrap();
+    let cavity = solidcraft_kernel::fillet(
        &cavity_box,
        &[Vec3::new(38., 28., 15.), Vec3::new(-38., 28., 15.), Vec3::new(-38., -28., 15.), Vec3::new(38., -28., 15.)],
        4.,
    )
    .unwrap();
-    let raw = solvecraft_kernel::boolean(&old_source, &cavity, solvecraft_kernel::BoolOp::Cut).unwrap().unwrap();
+    let raw = solidcraft_kernel::boolean(&old_source, &cavity, solidcraft_kernel::BoolOp::Cut).unwrap().unwrap();
    let mut old_body = ModelBody::new("Case".into(), raw, shell);
    old_body.names = crate::naming::NameCell::new(Some(std::sync::Arc::new(crate::naming::NamingOrigin {
        feature: doc.feature(shell).unwrap().clone(),
@@ -403,18 +403,18 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
            continue;
        }
        let points = &mesh.edges[index];
-        let a = solvecraft_geom::Plane::YZ.to_local(*points.first().unwrap());
-        let b = solvecraft_geom::Plane::YZ.to_local(*points.last().unwrap());
+        let a = solidcraft_geom::Plane::YZ.to_local(*points.first().unwrap());
+        let b = solidcraft_geom::Plane::YZ.to_local(*points.last().unwrap());
        let (a, b) = (Vec2::new(a.x, a.y), Vec2::new(b.x, b.y));
        assert!(a.dist(b) > 1e-6);
        for point in points {
-            let q = solvecraft_geom::Plane::YZ.to_local(*point);
+            let q = solidcraft_geom::Plane::YZ.to_local(*point);
            let q = Vec2::new(q.x, q.y);
            let direction = b - a;
            let t = ((q - a).dot(direction) / direction.dot(direction)).clamp(0., 1.);
            assert!(q.dist(a + direction * t) < 1e-7, "exact cylindrical quadrant projects to a straight support");
        }
-        geometry.push(solvecraft_sketch::LinkGeom::Line(a, b));
+        geometry.push(solidcraft_sketch::LinkGeom::Line(a, b));
    }
    assert_eq!(geometry.len(), 4, "historical curved strip has a complete four-edge rectangular projection");
    let mut sketch = Sketch::new();
@@ -422,7 +422,7 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
    sketch.links[0].face_name = Some(former);
    let original = sketch.clone();
    let sk = doc
-        .add_feature(FeatureKind::Sketch { plane: PlaneRef::Custom { plane: solvecraft_geom::Plane::YZ }, sketch }, Some("Saved corner strip"))
+        .add_feature(FeatureKind::Sketch { plane: PlaneRef::Custom { plane: solidcraft_geom::Plane::YZ }, sketch }, Some("Saved corner strip"))
        .unwrap();
    let boss = doc
        .add_feature(
@@ -454,7 +454,7 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {
            assert_eq!(solved.sketch.curves, original.curves);
            let material = state.bodies.iter().find(|body| body.feature == boss).unwrap();
            assert!(
-                (solvecraft_kernel::measure(&material.body).unwrap().volume - 12.).abs() < 1e-7,
+                (solidcraft_kernel::measure(&material.body).unwrap().volume - 12.).abs() < 1e-7,
                "two-mm strip cannot expand to a full thirty-mm wall"
            );
        }
@@ -463,8 +463,8 @@ fn saved_curved_strip_projection_is_lost_after_exact_wall_coalescence() {

 #[test]
 fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() {
-    use solvecraft_kernel::{BoolOp, FacePaint, Paint};
-    use solvecraft_sketch::{LinkKind, LinkSource, Sketch};
+    use solidcraft_kernel::{BoolOp, FacePaint, Paint};
+    use solidcraft_sketch::{LinkKind, LinkSource, Sketch};
    let mut doc = Document::new("public stepped tab case");
    doc.set_param("length", "40", Some("mm"), None).unwrap();
    doc.set_param("wall", "2", Some("mm"), None).unwrap();
@@ -508,7 +508,7 @@ fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() {
        .body
        .clone()
        .with_paint(Some(Paint { opacity: 1., faces: vec![FacePaint { face: 0, color: [1., 0., 0.], opacity: 1. }] }));
-    let old_cut = solvecraft_kernel::boolean(&old_stock, &before.body("Pocket tool").unwrap().body, BoolOp::Cut).unwrap().unwrap();
+    let old_cut = solidcraft_kernel::boolean(&old_stock, &before.body("Pocket tool").unwrap().body, BoolOp::Cut).unwrap().unwrap();
    let mut old_body = ModelBody::new("Case".into(), old_cut, cut);
    old_body.names = crate::naming::NameCell::new(Some(std::sync::Arc::new(crate::naming::NamingOrigin {
        feature: doc.feature(cut).unwrap().clone(),
@@ -522,7 +522,7 @@ fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() {
    let index = crate::naming::face_on_body(&old_body, &former, at).unwrap().0;
    let mut old_state = crate::ModelState::default();
    old_state.bodies.push(old_body);
-    let plane = solvecraft_geom::Plane::YZ;
+    let plane = solidcraft_geom::Plane::YZ;
    let resolved = crate::project::resolve_face_indices(&old_state, &plane, LinkKind::Project, "Case", &[index]).unwrap();
    let current_state = model.state();
    let current = current_state.body("Case").unwrap();
@@ -569,15 +569,15 @@ fn saved_stepped_tab_cut_piece_projection_is_lost_without_expanding_material() {
            assert_eq!(saved.sketch.curves, original.curves);
            let stock = state.bodies.iter().find(|b| b.feature == material).unwrap();
            assert!(
-                (solvecraft_kernel::measure(&stock.body).unwrap().volume - 200.).abs() < 1e-7,
+                (solidcraft_kernel::measure(&stock.body).unwrap().volume - 200.).abs() < 1e-7,
                "saved10x20 patch must not become30x20 wall; actualvolume={}, bounds={:?}, originalpoints={:?}",
-                solvecraft_kernel::measure(&stock.body).unwrap().volume,
+                solidcraft_kernel::measure(&stock.body).unwrap().volume,
                stock.mesh().bounds(),
                original.points
            );
            let case = state.body("Case").unwrap();
            let expected = length * 30. * 20. + 8. * 10. * 8. - (length - 2. * wall) * (30. - 2. * wall) * (20. - wall);
-            assert!((solvecraft_kernel::measure(&case.body).unwrap().volume - expected).abs() < 1e-6);
+            assert!((solidcraft_kernel::measure(&case.body).unwrap().volume - expected).abs() < 1e-6);
        }
    }
 }
@@ -3,9 +3,9 @@ use super::Column;
 use crate::{DocError, Document, FeatureKind, ModelState, Result};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;

-pub(crate) fn shell_plane_family(planes: impl IntoIterator<Item = Option<solvecraft_geom::Plane>>) -> bool {
+pub(crate) fn shell_plane_family(planes: impl IntoIterator<Item = Option<solidcraft_geom::Plane>>) -> bool {
    let mut planes = planes.into_iter();
    let Some(Some(first)) = planes.next() else { return false };
    first.origin.is_finite() && first.x.is_finite() && first.y.is_finite() && planes.all(|plane| plane == Some(first))
@@ -112,7 +112,7 @@ impl Document {
            (FaceCertificate::ExtrudeCap { sketch, .. }, FeatureKind::Extrude { sketch: current, extent, operation: crate::Operation::NewBody, .. }) => sketch == current && extent.taper.is_none(),
            (FaceCertificate::ExtrudeSide { sketch, curve }, FeatureKind::Extrude { sketch: current, extent, operation: crate::Operation::NewBody, .. }) => {
                sketch == current && extent.taper.is_none()
-                    && self.feature(*sketch).is_some_and(|feature| matches!(&feature.kind, FeatureKind::Sketch { sketch, .. } if sketch.curves.iter().any(|candidate| candidate.id == *curve && !candidate.construction && matches!(candidate.kind, solvecraft_sketch::CurveKind::Line { .. } | solvecraft_sketch::CurveKind::Circle { .. } | solvecraft_sketch::CurveKind::Arc { .. }))))
+                    && self.feature(*sketch).is_some_and(|feature| matches!(&feature.kind, FeatureKind::Sketch { sketch, .. } if sketch.curves.iter().any(|candidate| candidate.id == *curve && !candidate.construction && matches!(candidate.kind, solidcraft_sketch::CurveKind::Line { .. } | solidcraft_sketch::CurveKind::Circle { .. } | solidcraft_sketch::CurveKind::Arc { .. }))))
            }
            (FaceCertificate::Imported { .. }, FeatureKind::Import { .. }) => true,
            _ => false,
@@ -138,7 +138,7 @@ impl Document {
                }
                (super::FaceCertificate::ExtrudeSide { sketch, curve }, FeatureKind::Extrude { sketch: producer_sketch, extent, operation: crate::Operation::NewBody, .. }) => {
                    sketch == producer_sketch && extent.taper.is_none() && role == format!("side:{curve}")
-                        && self.feature(*sketch).is_some_and(|feature| matches!(&feature.kind, FeatureKind::Sketch { sketch, .. } if sketch.curves.iter().any(|candidate| candidate.id == *curve && !candidate.construction && matches!(candidate.kind, solvecraft_sketch::CurveKind::Line { .. } | solvecraft_sketch::CurveKind::Circle { .. } | solvecraft_sketch::CurveKind::Arc { .. }))))
+                        && self.feature(*sketch).is_some_and(|feature| matches!(&feature.kind, FeatureKind::Sketch { sketch, .. } if sketch.curves.iter().any(|candidate| candidate.id == *curve && !candidate.construction && matches!(candidate.kind, solidcraft_sketch::CurveKind::Line { .. } | solidcraft_sketch::CurveKind::Circle { .. } | solidcraft_sketch::CurveKind::Arc { .. }))))
                }
                (super::FaceCertificate::Imported { .. }, FeatureKind::Import { .. }) => role.strip_prefix("face:").is_some_and(|index| index.parse::<usize>().is_ok()),
                (super::FaceCertificate::ShellPlanar { source_producer, source, inner }, FeatureKind::Shell { .. }) => {
@@ -183,7 +183,7 @@ impl Document {
        }
        if let Some(super::FaceCertificate::ShellPlanar { source_producer, source, inner }) = &target.certificate {
            let indices: Vec<_> = body.body.face_sources().into_iter().flatten().enumerate().filter_map(|(index, current)| {
-                matches!(current, Some(solvecraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), source: current_source, inner: current_inner, .. }) if *producer == target.origin_feature && inner == current_inner && super::flat_source_matches(source, current_source, *source_producer)).then_some(index)
+                matches!(current, Some(solidcraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), source: current_source, inner: current_inner, .. }) if *producer == target.origin_feature && inner == current_inner && super::flat_source_matches(source, current_source, *source_producer)).then_some(index)
            }).collect();
            // A shell can split one original support into several pieces. All pieces
            // must retain the same canonical frame, not merely lie on a common plane.
@@ -203,11 +203,11 @@ impl Document {
                    let matched = match (&target.certificate, source) {
                        (
                            Some(super::FaceCertificate::Box { axis, high }),
-                            Some(solvecraft_kernel::FaceSource::Box { producer: Some(producer), axis: current_axis, high: current_high, .. }),
+                            Some(solidcraft_kernel::FaceSource::Box { producer: Some(producer), axis: current_axis, high: current_high, .. }),
                        ) => *producer == target.origin_feature && axis == current_axis && high == current_high,
                        (
                            Some(super::FaceCertificate::ExtrudeCap { sketch, high, outer, holes }),
-                            Some(solvecraft_kernel::FaceSource::CertifiedExtrudeCap {
+                            Some(solidcraft_kernel::FaceSource::CertifiedExtrudeCap {
                                producer,
                                sketch: current_sketch,
                                high: current_high,
@@ -234,7 +234,7 @@ impl Document {
        }
        if let Some(super::FaceCertificate::ExtrudeSide { sketch, curve }) = &target.certificate {
            let indices: Vec<_> = body.body.face_sources().into_iter().flatten().enumerate().filter_map(|(index, source)| {
-                matches!(source, Some(solvecraft_kernel::FaceSource::CertifiedExtrudeSide { producer, sketch: current_sketch, curve: current_curve, .. }) if *producer == target.origin_feature && current_sketch == sketch && current_curve == curve).then_some(index)
+                matches!(source, Some(solidcraft_kernel::FaceSource::CertifiedExtrudeSide { producer, sketch: current_sketch, curve: current_curve, .. }) if *producer == target.origin_feature && current_sketch == sketch && current_curve == curve).then_some(index)
            }).collect();
            if indices.is_empty() {
                return Err(DocError::Unknown("constructed side certificate no longer exists".into()));
@@ -243,7 +243,7 @@ impl Document {
        }
        if let Some(super::FaceCertificate::Imported { payload_sha256, item, face }) = &target.certificate {
            let indices: Vec<_> = body.body.face_sources().into_iter().flatten().enumerate().filter_map(|(index, source)| {
-                matches!(source, Some(solvecraft_kernel::FaceSource::Imported { item: current_item, face: current_face, payload_sha256: Some(digest), producer: Some(producer) }) if current_item == item && current_face == face && digest == payload_sha256 && *producer == target.origin_feature).then_some(index)
+                matches!(source, Some(solidcraft_kernel::FaceSource::Imported { item: current_item, face: current_face, payload_sha256: Some(digest), producer: Some(producer) }) if current_item == item && current_face == face && digest == payload_sha256 && *producer == target.origin_feature).then_some(index)
            }).collect();
            if indices.is_empty() {
                return Err(DocError::Unknown("immutable import face certificate no longer exists".into()));
@@ -8,8 +8,8 @@
 use std::collections::BTreeMap;

 use serde::{Deserialize, Serialize};
-use solvecraft_geom::{Plane, Vec2, Vec3};
-use solvecraft_kernel::{self as kernel, FaceSurface};
+use solidcraft_geom::{Plane, Vec2, Vec3};
+use solidcraft_kernel::{self as kernel, FaceSurface};

 use crate::eval::{ModelBody, ModelState};
 use crate::expr::{Kind, Value};
@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
-use solvecraft_geom::{Plane, Vec2, Vec3};
-use solvecraft_sketch::Sketch;
+use solidcraft_geom::{Plane, Vec2, Vec3};
+use solidcraft_sketch::Sketch;

 use crate::construct::{AxisDef, GeoRef, PointDef};
 use crate::expr::{self, Kind};
@@ -884,7 +884,7 @@ pub enum FeatureKind {
        step: String,
        /// The file's product/assembly tree, kept for components.
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
-        components: Vec<solvecraft_kernel::StepNode>,
+        components: Vec<solidcraft_kernel::StepNode>,
    },
    /// Rebuild an upstream constant-section mesh with analytic planar/cylindrical faces.
    MeshConvert {
@@ -1697,7 +1697,7 @@ pub struct Document {
 pub struct NamedView {
    #[serde(default)]
    pub name: String,
-    pub target: solvecraft_geom::Vec3,
+    pub target: solidcraft_geom::Vec3,
    pub yaw: f64,
    pub pitch: f64,
    pub distance: f64,
@@ -1774,13 +1774,13 @@ impl Document {
        let mut st = state.clone();
        for b in &mut st.bodies {
            let c = self.body_color(b);
-            let faces: Vec<solvecraft_kernel::FacePaint> = self
+            let faces: Vec<solidcraft_kernel::FacePaint> = self
                .face_colors(b)
                .into_iter()
-                .map(|(face, l)| solvecraft_kernel::FacePaint { face, color: l.rgb(), opacity: l.opacity as f32 })
+                .map(|(face, l)| solidcraft_kernel::FacePaint { face, color: l.rgb(), opacity: l.opacity as f32 })
                .collect();
            let opacity = self.model_body_opacity(b) as f32;
-            let paint = solvecraft_kernel::Paint { opacity, faces };
+            let paint = solidcraft_kernel::Paint { opacity, faces };
            if c != b.body.color() || b.body.paint() != Some(&paint) {
                b.body = b.body.clone().with_color(c).with_paint(Some(paint));
            }
@@ -2214,14 +2214,14 @@ impl Document {
        &self,
        vals: &std::collections::BTreeMap<String, expr::Value>,
        sk: &mut Sketch,
-        stored: &solvecraft_sketch::DrivingValues,
-    ) -> Result<solvecraft_sketch::SolveReport> {
+        stored: &solidcraft_sketch::DrivingValues,
+    ) -> Result<solidcraft_sketch::SolveReport> {
        self.apply_dimension_values(vals, sk)?;
-        let mut report = solvecraft_sketch::solve_after_value_edit(sk, stored);
+        let mut report = solidcraft_sketch::solve_after_value_edit(sk, stored);
        if !sk.offsets.is_empty() || !sk.freeform_offsets.is_empty() {
            // Source dimensions may have moved curves during the solve.
            sk.refresh_offsets()?;
-            report = if report.ok() { solvecraft_sketch::solve(sk) } else { solvecraft_sketch::solve_after_value_edit(sk, stored) };
+            report = if report.ok() { solidcraft_sketch::solve(sk) } else { solidcraft_sketch::solve_after_value_edit(sk, stored) };
        }
        Ok(report)
    }
@@ -5,9 +5,9 @@ use std::hash::{Hash, Hasher};
 use std::sync::{Arc, OnceLock};

 use serde::Serialize;
-use solvecraft_geom::{Mesh, Plane, Region2, Vec2, Vec3};
-use solvecraft_kernel::{self as kernel, Body, BoolOp};
-use solvecraft_sketch::{CurveKind, Profile, SolveReport, find_profiles};
+use solidcraft_geom::{Mesh, Plane, Region2, Vec2, Vec3};
+use solidcraft_kernel::{self as kernel, Body, BoolOp};
+use solidcraft_sketch::{CurveKind, Profile, SolveReport, find_profiles};

 use crate::expr::{self, Kind, Value};
 use crate::lineage::Traced;
@@ -79,7 +79,7 @@ pub struct SolvedSketch {
    pub feature: u64,
    pub name: String,
    pub plane: Plane,
-    pub sketch: solvecraft_sketch::Sketch,
+    pub sketch: solidcraft_sketch::Sketch,
    pub report: SolveReport,
    pub profiles: Vec<Profile>,
 }
@@ -217,7 +217,7 @@ fn thread_on(st: &ModelState, feature: u64, p: Vec3, designation: Option<&str>,
 /// profile, 60° flanks): cut from the shaft (external) or the hole wall (internal), running from
 /// `start` to `end` along the axis. `radius` is the face's own radius; `open` says which ends
 /// of the threaded length are free ends of the face.
-fn thread_groove(t: &ThreadInfo, radius: f64, open: (bool, bool)) -> Result<solvecraft_geom::Mesh> {
+fn thread_groove(t: &ThreadInfo, radius: f64, open: (bool, bool)) -> Result<solidcraft_geom::Mesh> {
    let (p, d) = (t.pitch, t.major_diameter);
    let h = p * 3f64.sqrt() / 2.0;
    let slope = (std::f64::consts::PI / 6.0).tan();
@@ -538,7 +538,7 @@ const QUANTUM: f64 = 1e-6;

 /// Put what a solve writes into a sketch on the [`QUANTUM`] grid: positions, radii and the
 /// measured values of driven dimensions.
-fn quantize(sk: &mut solvecraft_sketch::Sketch) {
+fn quantize(sk: &mut solidcraft_sketch::Sketch) {
    let q = |v: f64| (v / QUANTUM).round() * QUANTUM;
    for p in &mut sk.points {
        p.pos = Vec2::new(q(p.pos.x), q(p.pos.y));
@@ -572,7 +572,7 @@ fn feature_json(f: &Feature) -> String {
 /// constraints' values. Nothing else: what evaluation derives for its own copy (an offset's
 /// upgraded topology, refreshed links) stays out of the stored sketch. A `solved` that does not
 /// match `stored` entity for entity is not adopted.
-fn adopt_solution(stored: &mut solvecraft_sketch::Sketch, solved: &solvecraft_sketch::Sketch) {
+fn adopt_solution(stored: &mut solidcraft_sketch::Sketch, solved: &solidcraft_sketch::Sketch) {
    if stored.points.len() != solved.points.len()
        || stored.curves.len() != solved.curves.len()
        || stored.constraints.len() != solved.constraints.len()
@@ -771,7 +771,7 @@ impl Model {
    /// recomputed; the next [`Model::evaluate`] recomputes from the sketch on. Returns `false`,
    /// changing nothing, when the sketch has no evaluated result or a feature before it is
    /// already stale (only a full evaluation brings that up to date).
-    pub fn show_live_sketch(&mut self, feature: u64, sketch: solvecraft_sketch::Sketch, report: SolveReport) -> bool {
+    pub fn show_live_sketch(&mut self, feature: u64, sketch: solidcraft_sketch::Sketch, report: SolveReport) -> bool {
        let Some(i) = self.results.iter().position(|r| r.id == feature) else { return false };
        if self.results.iter().take(i).any(|r| r.stale) {
            return false;
@@ -1042,7 +1042,7 @@ pub fn select_profiles(ss: &SolvedSketch, sel: &ProfileSel) -> Result<Vec<Region
        // "All" means what was drawn: projected reference geometry (a face's auto-projected
        // edges) only counts when the drawn curves alone make no profile.
        ProfileSel::All => {
-            let drawn = solvecraft_sketch::find_drawn_profiles(&ss.sketch);
+            let drawn = solidcraft_sketch::find_drawn_profiles(&ss.sketch);
            if drawn.is_empty() { ps.iter().map(|p| p.region.clone()).collect() } else { drawn.into_iter().map(|p| p.region).collect() }
        }
        ProfileSel::Indices { indices } => {
@@ -1066,7 +1066,7 @@ pub fn select_profiles(ss: &SolvedSketch, sel: &ProfileSel) -> Result<Vec<Region
            let mut v = Vec::new();
            for p in points {
                // Innermost profile containing the point.
-                let found = solvecraft_sketch::profile_at_point(ps, *p).and_then(|i| ps.get(i));
+                let found = solidcraft_sketch::profile_at_point(ps, *p).and_then(|i| ps.get(i));
                v.push(found.ok_or_else(|| DocError::Unknown(format!("profile at {:?} in {}", [p.x, p.y], ss.name)))?.region.clone());
            }
            v
@@ -1079,12 +1079,12 @@ pub fn select_profiles(ss: &SolvedSketch, sel: &ProfileSel) -> Result<Vec<Region
 }

 /// The error for a profile picked by curves that no longer names exactly one profile.
-pub fn curve_pick_error(e: solvecraft_sketch::CurvePick, ids: &[String], sketch: &str) -> DocError {
+pub fn curve_pick_error(e: solidcraft_sketch::CurvePick, ids: &[String], sketch: &str) -> DocError {
    match e {
-        solvecraft_sketch::CurvePick::Missing => DocError::Invalid(format!(
+        solidcraft_sketch::CurvePick::Missing => DocError::Invalid(format!(
            "no profile of {sketch} is bounded by exactly the curves {ids:?} (a curve was deleted, or another curve now cuts the region)"
        )),
-        solvecraft_sketch::CurvePick::Ambiguous(n) => DocError::Invalid(format!(
+        solidcraft_sketch::CurvePick::Ambiguous(n) => DocError::Invalid(format!(
            "{n} profiles of {sketch} are bounded by exactly the curves {ids:?}; add a curve that tells them apart, or pick by index or point"
        )),
    }
@@ -1389,7 +1389,7 @@ fn grow_profile_for_coplanar(st: &ModelState, r: &Region2, op: Operation, target
    let delta = (size * 0.005).max(1e-3);
    let lp = r.outer.ccw();
    let lines: Option<Vec<(Vec2, Vec2)>> =
-        lp.segs.iter().map(|s| if let solvecraft_geom::Seg2::Line { a, b } = *s { Some((a, b)) } else { None }).collect();
+        lp.segs.iter().map(|s| if let solidcraft_geom::Seg2::Line { a, b } = *s { Some((a, b)) } else { None }).collect();
    let Some(lines) = lines else { return r.clone() };
    let inside_any = |p: Vec3| meshes.iter().any(|m| m.contains(p));
    let mut grow = vec![0.0; lines.len()];
@@ -1436,7 +1436,7 @@ fn grow_profile_for_coplanar(st: &ModelState, r: &Region2, op: Operation, target
        let t = (p1 - p0).cross(d1) / den;
        pts.push(p0 + d0 * t);
    }
-    Region2 { outer: solvecraft_geom::Loop2::polygon(&pts), holes: r.holes.clone() }
+    Region2 { outer: solidcraft_geom::Loop2::polygon(&pts), holes: r.holes.clone() }
 }

 /// Booleans struggle with coincident faces (a cut starting on the face it cuts, a boss
@@ -1771,7 +1771,7 @@ fn hole_tools(
    let seam = std::cell::Cell::new(0.0);
    let disc = |rad: f64| {
        seam.set(seam.get() + 0.613);
-        Region2 { outer: solvecraft_geom::Loop2::circle_from(Vec2::ZERO, rad, seam.get()), holes: vec![] }
+        Region2 { outer: solidcraft_geom::Loop2::circle_from(Vec2::ZERO, rad, seam.get()), holes: vec![] }
    };
    let cyl = |rad: f64, lo: f64, hi: f64| -> Result<Body> {
        kernel::extrude(&plane, &[disc(rad)], lo, hi)?.pop().ok_or_else(|| DocError::Invalid("hole tool".into()))
@@ -1794,7 +1794,7 @@ fn hole_tools(
                let side = up.any_perp();
                let rp = Plane::new(*position, side, up).ok_or_else(|| DocError::Invalid("hole axis".into()))?;
                let pts = [Vec2::new(0.0, top), Vec2::new(r, top), Vec2::new(r, bottom), Vec2::new(0.0, bottom - tip)];
-                let region = Region2 { outer: solvecraft_geom::Loop2::polygon(&pts), holes: vec![] };
+                let region = Region2 { outer: solidcraft_geom::Loop2::polygon(&pts), holes: vec![] };
                tools.extend(kernel::revolve(&rp, &[region], Vec2::ZERO, Vec2::Y, std::f64::consts::TAU)?);
            } else {
                tools.push(cyl(r, bottom, top)?);
@@ -1987,7 +1987,7 @@ fn feature_tools_with_constructor(
    match &f.kind {
        FeatureKind::Extrude { sketch, profiles, extent, operation, targets } => {
            let ss = st.sketch(*sketch).ok_or_else(|| DocError::Unknown(format!("sketch {sketch} (it must come earlier in the timeline)")))?.clone();
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
            // From / To Object: where the face or point lies along the normal, measured over the
            // middle of the profiles.
            let n = ss.plane.normal();
@@ -2130,7 +2130,7 @@ fn feature_tools_with_constructor(
        }
        FeatureKind::Revolve { sketch, profiles, axis, angle, angle2, symmetric, convention, to, .. } => {
            let ss = st.sketch(*sketch).ok_or_else(|| DocError::Unknown(format!("sketch {sketch} (it must come earlier in the timeline)")))?.clone();
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
            let (o, d) = revolve_axis(&ss, axis)?;
            let angles = if to.is_some() {
                (0.0, None)
@@ -2257,7 +2257,7 @@ fn feature_tools_with_constructor(
            let [a, b] = &sections[..] else { return Err(DocError::Invalid("not supported yet: a point section in a loft of more than two".into())) };
            let (prof, pt) = if a.point.is_some() { (b, a) } else { (a, b) };
            let ss = st.sketch(prof.sketch).ok_or_else(|| DocError::Unknown(format!("sketch {}", prof.sketch)))?;
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(ss, &prof.profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(ss, &prof.profiles)?);
            let [r] = &regions[..] else { return Err(DocError::Invalid("each loft section must be one profile".into())) };
            let ps = st.sketch(pt.sketch).ok_or_else(|| DocError::Unknown(format!("sketch {}", pt.sketch)))?;
            let id = pt.point.as_deref().unwrap_or_default();
@@ -2292,10 +2292,10 @@ fn feature_tools_with_constructor(
            let plane = Plane { origin: *base, x, y: k };
            let c = Vec2::new(r, 0.0);
            let outer = match section {
-                crate::CoilSection::Circular => solvecraft_geom::Loop2::circle(c, s / 2.0),
+                crate::CoilSection::Circular => solidcraft_geom::Loop2::circle(c, s / 2.0),
                crate::CoilSection::Square => {
                    let h = s / 2.0;
-                    solvecraft_geom::Loop2::polygon(&[c + Vec2::new(-h, -h), c + Vec2::new(h, -h), c + Vec2::new(h, h), c + Vec2::new(-h, h)])
+                    solidcraft_geom::Loop2::polygon(&[c + Vec2::new(-h, -h), c + Vec2::new(h, -h), c + Vec2::new(h, h), c + Vec2::new(-h, h)])
                }
            };
            let region = Region2 { outer, holes: Vec::new() };
@@ -2310,7 +2310,7 @@ fn feature_tools_with_constructor(
                let ss = st
                    .sketch(sec.sketch)
                    .ok_or_else(|| DocError::Unknown(format!("sketch {} (it must come earlier in the timeline)", sec.sketch)))?;
-                let regions = solvecraft_sketch::merge_regions(&select_profiles(ss, &sec.profiles)?);
+                let regions = solidcraft_sketch::merge_regions(&select_profiles(ss, &sec.profiles)?);
                let [r] = &regions[..] else { return Err(DocError::Invalid("each loft section must be one profile".into())) };
                secs.push((ss.plane, r.outer.clone()));
            }
@@ -2332,7 +2332,7 @@ fn feature_tools_with_constructor(
            };
            let mapped = path_in_frame(doc, ps, f.component)?;
            let ps = mapped.as_ref();
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(ss, profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(ss, profiles)?);
            let start = regions.first().map(|r| ss.plane.to_world(r.centroid())).unwrap_or_default();
            let tool = |r: &Region2, body: Body| crate::lineage::ProfileRoles::swept(Some(ss), Some(r)).tool(body, None);
            // A path through 3D sketch curves follows them as points.
@@ -2407,14 +2407,14 @@ fn pipe_region(vals: &BTreeMap<String, Value>, r: f64, wall: &Option<String>) ->
            if !(wt > 0.0 && wt < r) {
                return Err(DocError::Invalid("the wall must be thinner than the radius".into()));
            }
-            vec![solvecraft_geom::Loop2::circle(Vec2::ZERO, r - wt).reversed()]
+            vec![solidcraft_geom::Loop2::circle(Vec2::ZERO, r - wt).reversed()]
        }
        None => Vec::new(),
    };
-    Ok(Region2 { outer: solvecraft_geom::Loop2::circle(Vec2::ZERO, r), holes })
+    Ok(Region2 { outer: solidcraft_geom::Loop2::circle(Vec2::ZERO, r), holes })
 }

-fn map_wire(wire: &mut solvecraft_sketch::Wire, matrix: &Mat) {
+fn map_wire(wire: &mut solidcraft_sketch::Wire, matrix: &Mat) {
    for point in wire.pts.iter_mut().chain(&mut wire.fit) {
        *point = crate::apply_point(matrix, *point);
    }
@@ -2453,7 +2453,7 @@ fn path_in_frame<'a>(doc: &Document, sketch: &'a SolvedSketch, consumer: u64) ->
    )
    .ok_or_else(|| DocError::Invalid("path sketch frame is invalid".into()))?;
    for wire in &mut mapped.sketch.wires {
-        let matrix = if wire.space == solvecraft_sketch::WireSpace::Component { &relative } else { &inverse };
+        let matrix = if wire.space == solidcraft_sketch::WireSpace::Component { &relative } else { &inverse };
        map_wire(wire, matrix);
    }
    Ok(Cow::Owned(mapped))
@@ -2530,7 +2530,7 @@ fn path_segments(ps: &SolvedSketch, ids: &[String], start: Vec3) -> Result<Vec<k
    if let Some(pts) = path_points(ps, ids, start)? {
        return Ok(pts.windows(2).map(|w| kernel::PathSeg::Line { a: w[0], b: w[1] }).collect());
    }
-    let mut segs: Vec<solvecraft_geom::Seg2> = Vec::new();
+    let mut segs: Vec<solidcraft_geom::Seg2> = Vec::new();
    for id in ids {
        let ci = ps.sketch.curve_index(id).ok_or_else(|| DocError::Unknown(format!("path curve `{id}`")))?;
        segs.extend(ps.sketch.segs(ci));
@@ -2564,12 +2564,12 @@ fn path_segments(ps: &SolvedSketch, ids: &[String], start: Vec3) -> Result<Vec<k
    Ok(segs
        .iter()
        .flat_map(|s| match *s {
-            solvecraft_geom::Seg2::Line { a, b } => vec![kernel::PathSeg::Line { a: w(a), b: w(b) }],
-            solvecraft_geom::Seg2::Arc { center, sweep, .. } => {
+            solidcraft_geom::Seg2::Line { a, b } => vec![kernel::PathSeg::Line { a: w(a), b: w(b) }],
+            solidcraft_geom::Seg2::Arc { center, sweep, .. } => {
                vec![kernel::PathSeg::Arc { a: w(s.start()), center: w(center), axis: n * sweep.signum(), angle: sweep.abs() }]
            }
            // Free-form path curves are followed as polylines.
-            solvecraft_geom::Seg2::Cubic { .. } | solvecraft_geom::Seg2::Conic { .. } | solvecraft_geom::Seg2::Bezier { .. } => {
+            solidcraft_geom::Seg2::Cubic { .. } | solidcraft_geom::Seg2::Conic { .. } | solidcraft_geom::Seg2::Bezier { .. } => {
                s.polyline(1e-2).windows(2).map(|q| kernel::PathSeg::Line { a: w(q[0]), b: w(q[1]) }).collect()
            }
        })
@@ -3388,7 +3388,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
                (None, Some(sid)) => {
                    let ss = st.sketch(*sid).ok_or_else(|| DocError::Unknown(format!("sketch {sid}")))?;
                    // Each curve's exact segments (lines and arcs split by their own plane and cylinder).
-                    let curves: Vec<Vec<solvecraft_geom::Seg2>> = (0..ss.sketch.curves.len())
+                    let curves: Vec<Vec<solidcraft_geom::Seg2>> = (0..ss.sketch.curves.len())
                        .filter(|ci| ss.sketch.curves.get(*ci).is_some_and(|c| !c.construction))
                        .map(|ci| ss.sketch.segs(ci))
                        .filter(|segs| !segs.is_empty())
@@ -3681,7 +3681,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
        }
        FeatureKind::BoundingSolid { bodies, margin } => {
            let m = val(vals, margin, Kind::Length)?;
-            let mut bb = solvecraft_geom::Aabb3::EMPTY;
+            let mut bb = solidcraft_geom::Aabb3::EMPTY;
            for b in st.bodies.iter().filter(|b| bodies.is_empty() || bodies.contains(&b.name)) {
                bb = bb.union(&b.mesh().bounds());
            }
@@ -3812,7 +3812,7 @@ pub fn state_in_frame_at<'a>(doc: &Document, st: &'a ModelState, comp: u64, fram
        .collect();
    let sketch_m: Vec<Mat> = st.sketches.iter().map(|s| rel(comp_of_feature(s.feature), None)).collect();
    let world_wires_need_mapping = !crate::is_identity(&inv)
-        && st.sketches.iter().any(|sketch| sketch.sketch.wires.iter().any(|wire| wire.space == solvecraft_sketch::WireSpace::World));
+        && st.sketches.iter().any(|sketch| sketch.sketch.wires.iter().any(|wire| wire.space == solidcraft_sketch::WireSpace::World));
    if body_m.iter().chain(&sketch_m).all(crate::is_identity) && !world_wires_need_mapping {
        return Cow::Borrowed(st);
    }
@@ -3835,7 +3835,7 @@ pub fn state_in_frame_at<'a>(doc: &Document, st: &'a ModelState, comp: u64, fram
    }
    for (s, m) in out.sketches.iter_mut().zip(&sketch_m) {
        // Only a sketch the frame moves is copied.
-        let maps_wire = |w: &solvecraft_sketch::Wire| !crate::is_identity(if w.space == solvecraft_sketch::WireSpace::Component { m } else { &inv });
+        let maps_wire = |w: &solidcraft_sketch::Wire| !crate::is_identity(if w.space == solidcraft_sketch::WireSpace::Component { m } else { &inv });
        if crate::is_identity(m) && !s.sketch.wires.iter().any(maps_wire) {
            continue;
        }
@@ -3846,7 +3846,7 @@ pub fn state_in_frame_at<'a>(doc: &Document, st: &'a ModelState, comp: u64, fram
            s.plane = np;
        }
        for wire in &mut s.sketch.wires {
-            let matrix = if wire.space == solvecraft_sketch::WireSpace::Component { m } else { &inv };
+            let matrix = if wire.space == solidcraft_sketch::WireSpace::Component { m } else { &inv };
            map_wire(wire, matrix);
        }
    }
@@ -3919,7 +3919,7 @@ pub fn world_state(doc: &Document, st: &ModelState) -> ModelState {
                    }
                }
                for wire in &mut s2.sketch.wires {
-                    if wire.space == solvecraft_sketch::WireSpace::Component {
+                    if wire.space == solidcraft_sketch::WireSpace::Component {
                        map_wire(wire, &m);
                    }
                }
@@ -5,7 +5,7 @@ use super::*;
 use crate::EmbossFace;
 use crate::apply_point;
 use crate::sheet;
-use solvecraft_geom::{Loop2, Seg2};
+use solidcraft_geom::{Loop2, Seg2};

 pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st: &mut ModelState) -> Result<()> {
    match &f.kind {
@@ -357,7 +357,7 @@ pub(super) fn sheet_eval(
    match &f.kind {
        FeatureKind::SheetBase { sketch, profiles, rule, flip } => {
            let ss = st.sketch(*sketch).ok_or_else(|| DocError::Unknown(format!("sketch {sketch}")))?.clone();
-            let regions = solvecraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
+            let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
            let r = doc.sheet_rule(rule.as_deref());
            let rv = doc.rule_values(vals, &r)?;
            for (k, region) in regions.into_iter().enumerate() {
@@ -631,7 +631,7 @@ pub(super) fn sheet_cut(
        return Ok(Vec::new());
    }
    let Some(ss) = st.sketch(*sketch).cloned() else { return Ok(Vec::new()) };
-    let regions = solvecraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
+    let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
    let n = ss.plane.normal();
    let mut work = sheet::FlatWork::new();
    let faces = tools.iter().fold(0usize, |count, body| count.saturating_add(body.face_count()));
@@ -836,7 +836,7 @@ pub(super) fn sheet_cut(

 /// Outline loops (in `plane` coordinates) of the mesh triangles lying in the plane at distance
 /// `level` from `at` along `n`: the edges used by one of them only, chained.
-fn face_loops(mesh: &solvecraft_geom::Mesh, plane: &Plane, at: Vec3, n: Vec3, level: f64, tol: f64) -> Vec<Vec<Vec2>> {
+fn face_loops(mesh: &solidcraft_geom::Mesh, plane: &Plane, at: Vec3, n: Vec3, level: f64, tol: f64) -> Vec<Vec<Vec2>> {
    let on: Vec<[u32; 3]> = mesh
        .triangles
        .iter()
@@ -8,7 +8,7 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
            let mut made = Vec::new();
            if let Some(sk) = sketch {
                let ss = st.sketch(*sk).ok_or_else(|| DocError::Unknown(format!("sketch {sk} (it must come earlier in the timeline)")))?;
-                let regions = solvecraft_sketch::merge_regions(&select_profiles(ss, profiles)?);
+                let regions = solidcraft_sketch::merge_regions(&select_profiles(ss, profiles)?);
                for r in &regions {
                    made.push(kernel::patch_region(&ss.plane, r)?);
                }
@@ -3,7 +3,7 @@ use crate::config::ConfigFaceTarget;
 use crate::{DocError, Document, EmbossFace, FeatureKind, Model, ModelBody, ModelState, PlaneRef, Result};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use solvecraft_geom::Plane;
+use solidcraft_geom::Plane;

 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -311,7 +311,7 @@ pub fn validate_face_anchors_json(value: &Value) -> Result<()> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use solvecraft_geom::Vec3;
+    use solidcraft_geom::Vec3;
    fn fixture() -> (Document, ModelBody, usize, Plane) {
        let mut doc = Document::default();
        let kind: FeatureKind =
@@ -319,7 +319,7 @@ mod tests {
        let id = doc.add_feature(kind, Some("Base")).unwrap();
        let body = ModelBody::new(
            "Base".into(),
-            solvecraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 10.)).unwrap().with_box_certificate(id).unwrap(),
+            solidcraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 10.)).unwrap().with_box_certificate(id).unwrap(),
            id,
        );
        let index = body
@@ -327,7 +327,7 @@ mod tests {
            .face_sources()
            .unwrap()
            .iter()
-            .position(|source| matches!(source, Some(solvecraft_kernel::FaceSource::Box { axis: 2, high: true, .. })))
+            .position(|source| matches!(source, Some(solidcraft_kernel::FaceSource::Box { axis: 2, high: true, .. })))
            .unwrap();
        let canonical = body.body.face_plane(index).unwrap();
        let picked = Plane::new(canonical.origin + canonical.x * 2. + canonical.y * 3., canonical.y, -canonical.x).unwrap();
@@ -350,7 +350,7 @@ mod tests {
        assert!((initial.x - picked.x).len() < 1e-9);
        state.bodies[0] = ModelBody::new(
            "Base".into(),
-            solvecraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 20.))
+            solidcraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 20.))
                .unwrap()
                .with_box_certificate(anchor.target.origin_feature)
                .unwrap(),
@@ -361,7 +361,7 @@ mod tests {
        assert!((changed.origin.x - initial.origin.x).abs() < 1e-9);
        state.bodies[0] = ModelBody::new(
            "Control".into(),
-            solvecraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 30.))
+            solidcraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 30.))
                .unwrap()
                .with_box_certificate(anchor.target.origin_feature)
                .unwrap(),
@@ -369,7 +369,7 @@ mod tests {
        );
        assert!(doc.resolve_face_anchor(&anchor, 0, &state).is_err());
        state.bodies[0].name = "Base".into();
-        state.bodies[0].body = solvecraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 30.))
+        state.bodies[0].body = solidcraft_kernel::box_solid(Vec3::default(), Vec3::new(10., 10., 30.))
            .unwrap()
            .with_box_certificate(anchor.target.origin_feature + 1)
            .unwrap();
@@ -400,8 +400,8 @@ mod tests {
    }
    #[test]
    fn extrude_cap_profile_reordering_never_retargets_an_ordinal_body() {
-        use solvecraft_geom::Vec2;
-        let mut sketch = solvecraft_sketch::Sketch::new();
+        use solidcraft_geom::Vec2;
+        let mut sketch = solidcraft_sketch::Sketch::new();
        for offset in [0., 30.] {
            let points: Vec<_> = [(0., 0.), (10., 0.), (10., 10.), (0., 10.)]
                .iter()
@@ -432,7 +432,7 @@ mod tests {
        assert_eq!(state.bodies.len(), 2);
        let solved = state.sketch(source).unwrap();
        let regions = crate::select_profiles(solved, &crate::ProfileSel::All).unwrap();
-        let raw = solvecraft_kernel::extrude(&solved.plane, &regions, 0., 10.).unwrap();
+        let raw = solidcraft_kernel::extrude(&solved.plane, &regions, 0., 10.).unwrap();
        assert!(
            crate::config::extrude_cap_bindings(solved, &raw, 0).is_none(),
            "exhausted certification work must leave the complete producer uncertified"
@@ -449,7 +449,7 @@ mod tests {
            .face_sources()
            .unwrap()
            .iter()
-            .position(|source| matches!(source, Some(solvecraft_kernel::FaceSource::CertifiedExtrudeCap { high: true, .. })))
+            .position(|source| matches!(source, Some(solidcraft_kernel::FaceSource::CertifiedExtrudeCap { high: true, .. })))
            .unwrap();
        let picked = body.body.face_plane(index).unwrap();
        let anchor = doc.capture_face_anchor(body, index, &picked, &[], 0, &[]).unwrap();
@@ -476,7 +476,7 @@ mod tests {
                        base: Box::new(PlaneRef::Face { plane: picked, at: picked.origin, name: None, anchor: None }),
                        distance: "2".into(),
                    },
-                    sketch: solvecraft_sketch::Sketch::new(),
+                    sketch: solidcraft_sketch::Sketch::new(),
                },
                None,
            )
@@ -492,7 +492,7 @@ mod tests {
    }
    #[test]
    fn warm_root_body_offset_edit_matches_cold_attached_sketch_and_downstream_bounds() {
-        use solvecraft_geom::Vec2;
+        use solidcraft_geom::Vec2;
        let (mut doc, _, _, _) = fixture();
        let mut warm = Model::new();
        warm.evaluate(&doc);
@@ -503,12 +503,12 @@ mod tests {
            .face_sources()
            .unwrap()
            .iter()
-            .position(|source| matches!(source, Some(solvecraft_kernel::FaceSource::Box { axis: 2, high: true, .. })))
+            .position(|source| matches!(source, Some(solidcraft_kernel::FaceSource::Box { axis: 2, high: true, .. })))
            .unwrap();
        let picked = body.body.face_plane(index).unwrap();
        let anchor = doc.capture_face_anchor(body, index, &picked, &[], 0, &[]).unwrap();
        let source_name = body.name.clone();
-        let mut sketch = solvecraft_sketch::Sketch::new();
+        let mut sketch = solidcraft_sketch::Sketch::new();
        let points: Vec<_> =
            [(2., 2.), (4., 2.), (4., 4.), (2., 4.)].iter().map(|(x, y)| sketch.add_point(Vec2::new(*x, *y), None).unwrap()).collect();
        for edge in 0..4 {
@@ -1,6 +1,6 @@
 //! The design file format version and the migrations that bring older files up to date.
 //!
-//! A design file starts with `"format": "solvecraft/N"`. A file of an older format is read and
+//! A design file starts with `"format": "solidcraft/N"`. A file of an older format is read and
 //! upgraded step by step (N → N+1 → … → current): JSON-level steps first, for changes in the
 //! file's shape, then document-level steps. A file of a newer format than this build knows is
 //! refused with a message saying so, never guessed at.
@@ -55,12 +55,16 @@ use crate::{DocError, Document, Result};
 pub const FORMAT: u32 = 14;

 pub fn format_string(n: u32) -> String {
-    format!("solvecraft/{n}")
+    format!("solidcraft/{n}")
 }

-/// The version in a format string (`solvecraft/N`).
+/// The format tag of designs saved before the rename. Compatibility shim (docs/compatibility.md):
+/// read, never written.
+pub const LEGACY_FORMAT_PREFIX: &str = "solvecraft/";
+
+/// The version in a format string (`solidcraft/N`, or the legacy `solvecraft/N`).
 pub fn version_of(s: &str) -> Option<u32> {
-    s.strip_prefix("solvecraft/")?.parse().ok()
+    s.strip_prefix("solidcraft/").or_else(|| s.strip_prefix(LEGACY_FORMAT_PREFIX))?.parse().ok()
 }

 /// JSON-level upgrades: entry `i` turns format `i + 1` into `i + 2`.
@@ -300,7 +304,7 @@ pub fn read(s: &str) -> Result<Document> {
        if let Some(crate::Feature { kind: crate::FeatureKind::Sketch { sketch, .. }, .. }) = d.features.get_mut(feature_index) {
            let mut spaces = std::collections::BTreeMap::new();
            for link in &sketch.links {
-                spaces.entry(link.id.as_str()).or_insert_with(|| solvecraft_sketch::WireSpace::from_legacy_link(link));
+                spaces.entry(link.id.as_str()).or_insert_with(|| solidcraft_sketch::WireSpace::from_legacy_link(link));
            }
            for wire_index in wire_indices {
                if let Some(wire) = sketch.wires.get_mut(wire_index) {
@@ -358,9 +362,9 @@ fn validate_sketch_sizes(value: &Value) -> Result<()> {
        }
        let Some(sketch) = feature.get("sketch") else { continue };
        let len = |key: &str| sketch.get(key).and_then(Value::as_array).map_or(0, Vec::len);
-        if len("points") > solvecraft_sketch::MAX_POINTS
-            || len("curves") > solvecraft_sketch::MAX_CURVES
-            || len("constraints") > solvecraft_sketch::MAX_CONSTRAINTS
+        if len("points") > solidcraft_sketch::MAX_POINTS
+            || len("curves") > solidcraft_sketch::MAX_CURVES
+            || len("constraints") > solidcraft_sketch::MAX_CONSTRAINTS
        {
            return Err(invalid());
        }
@@ -553,7 +557,7 @@ fn validate_versioned_geometry(value: &Value) -> Result<()> {
            }
            let indices = curve.get("pts").and_then(Value::as_array).ok_or_else(invalid)?;
            work = work.saturating_add(indices.len());
-            if !(4..=solvecraft_sketch::MAX_SPLINE_POINTS).contains(&indices.len())
+            if !(4..=solidcraft_sketch::MAX_SPLINE_POINTS).contains(&indices.len())
                || work > 1_000_000
                || curve.get("control").is_some_and(|control| control.as_bool() != Some(false))
                || curve.get("degree").is_some_and(|degree| degree.as_u64() != Some(3))
@@ -630,7 +634,7 @@ fn validate_freeform_offsets(value: &Value) -> Result<()> {
            if !(1..=256).contains(&divisions)
                || !divisions.is_power_of_two()
                || !(1..=256).contains(&pieces)
-                || pieces * divisions >= solvecraft_sketch::MAX_SPLINE_POINTS as u64
+                || pieces * divisions >= solidcraft_sketch::MAX_SPLINE_POINTS as u64
                || !distance.is_finite()
                || !(1e-9..=MAX_REAL).contains(&distance.abs())
                || !tolerance.is_finite()
@@ -727,7 +731,7 @@ mod tests {
    #[test]
    fn version_thirteen_names_keep_their_meaning_under_the_legacy_mark() {
        let file = serde_json::json!({
-            "format": "solvecraft/13",
+            "format": "solidcraft/13",
            "features": [
                {"type": "fillet", "edge_names": ["F2:side:l2|F2:top#2~1", ""], "face_names": ["F2:top#1", ""]},
                {"type": "sheet_flange", "edge_names": ["base:l1:top"]},
@@ -774,7 +778,7 @@ mod tests {
    #[test]
    fn version_thirteen_marking_targets_name_fields_not_key_names() {
        let file = serde_json::json!({
-            "format": "solvecraft/13",
+            "format": "solidcraft/13",
            "features": [
                {"type": "extrude", "options": {"face": "flat", "face_name": "label", "face_names": ["a"]}},
                {"type": "fillet", "settings": {"edge_names": ["kept"]}},
@@ -794,8 +798,8 @@ mod tests {

    #[test]
    fn version_nine_wire_spaces_preserve_saved_points_and_explicit_markers() {
-        use solvecraft_geom::Vec3;
-        use solvecraft_sketch::{LinkKind, LinkSource, Sketch, WireSpace};
+        use solidcraft_geom::Vec3;
+        use solidcraft_sketch::{LinkKind, LinkSource, Sketch, WireSpace};
        let mut sketch = Sketch::new();
        sketch.add_drawn_wire(&[Vec3::new(12.0, 3.0, 4.0)]).unwrap();
        let link = sketch
@@ -810,7 +814,7 @@ mod tests {
        let mut doc = Document::new("legacy wire spaces");
        doc.add_feature(crate::FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch }, None).unwrap();
        let mut json: Value = serde_json::from_str(&doc.to_json()).unwrap();
-        json["format"] = Value::from("solvecraft/9");
+        json["format"] = Value::from("solidcraft/9");
        for wire in json["features"][0]["sketch"]["wires"].as_array_mut().unwrap() {
            wire.as_object_mut().unwrap().remove("space");
        }
@@ -891,7 +895,7 @@ mod tests {
        let mut document = Document::new("legacy named extent");
        document.set_param("offset", "2", Some("mm"), None).unwrap();
        let sketch = document
-            .add_feature(FeatureKind::Sketch { plane: PlaneRef::Origin { name: "XY".into() }, sketch: solvecraft_sketch::Sketch::new() }, None)
+            .add_feature(FeatureKind::Sketch { plane: PlaneRef::Origin { name: "XY".into() }, sketch: solidcraft_sketch::Sketch::new() }, None)
            .unwrap();
        document
            .add_feature(
@@ -905,9 +909,9 @@ mod tests {
                        start_offset: None,
                        through_all: false,
                        taper: Some("0 deg".into()),
-                        to: Some(solvecraft_geom::Vec3::new(0.0, 0.0, 10.0)),
+                        to: Some(solidcraft_geom::Vec3::new(0.0, 0.0, 10.0)),
                        to_offset: Some("offset + 1 mm".into()),
-                        from: Some(solvecraft_geom::Vec3::new(0.0, 0.0, 5.0)),
+                        from: Some(solidcraft_geom::Vec3::new(0.0, 0.0, 5.0)),
                    },
                    operation: Operation::NewBody,
                    targets: vec![],
@@ -928,7 +932,7 @@ mod tests {
            )
            .unwrap();
        let mut legacy: Value = serde_json::from_str(&document.to_json()).unwrap();
-        legacy["format"] = Value::from("solvecraft/8");
+        legacy["format"] = Value::from("solidcraft/8");
        // Version 8 exposed distance and taper, but had no model slot for To Offset.
        legacy["features"][1]["param_names"] = serde_json::json!(["d1", "d2"]);
        legacy["features"][2]["param_names"] = serde_json::json!(["d3", "d4", "d5"]);
@@ -952,8 +956,8 @@ mod tests {

    #[test]
    fn saved_offset_cannot_alias_and_overwrite_its_source_geometry() {
-        use solvecraft_geom::Vec2;
-        use solvecraft_sketch::{CurveKind, Sketch};
+        use solidcraft_geom::Vec2;
+        use solidcraft_sketch::{CurveKind, Sketch};
        let mut sketch = Sketch::new();
        let center = sketch.add_point(Vec2::ZERO, None).unwrap();
        let major = sketch.add_point(Vec2::new(10.0, 0.0), None).unwrap();
@@ -976,7 +980,7 @@ mod tests {
        let mut document = Document::new("missing offset geometry");
        document
            .add_feature(
-                crate::FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch: solvecraft_sketch::Sketch::new() },
+                crate::FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch: solidcraft_sketch::Sketch::new() },
                None,
            )
            .unwrap();
@@ -1052,7 +1056,7 @@ mod tests {
            ("degree", serde_json::json!(2)),
            ("pts", serde_json::json!([0, 1, 2])),
            ("pts", serde_json::json!([0, 1, 2, u64::MAX])),
-            ("pts", serde_json::json!(vec![0; solvecraft_sketch::MAX_SPLINE_POINTS + 1])),
+            ("pts", serde_json::json!(vec![0; solidcraft_sketch::MAX_SPLINE_POINTS + 1])),
        ] {
            let mut damaged = curve.clone();
            damaged[key] = malformed;
@@ -1091,8 +1095,8 @@ mod tests {

    #[test]
    fn periodic_file_validation_refuses_damaged_closed_geometry() {
-        use solvecraft_geom::Vec2;
-        use solvecraft_sketch::{CurveKind, Sketch};
+        use solidcraft_geom::Vec2;
+        use solidcraft_sketch::{CurveKind, Sketch};
        let mut sketch = Sketch::new();
        let mut pts = Vec::new();
        for point in [Vec2::ZERO, Vec2::new(10.0, 0.0), Vec2::new(0.0, 10.0), Vec2::ZERO] {
@@ -1199,7 +1203,7 @@ mod tests {
        ];
        d.configs.active = Some("Default".into());
        let mut legacy: Value = serde_json::from_str(&d.to_json()).unwrap();
-        legacy["format"] = Value::from("solvecraft/6");
+        legacy["format"] = Value::from("solidcraft/6");
        let original_table = legacy["configs"].clone();
        let upgraded = read(&legacy.to_string()).unwrap();
        d.features.iter_mut().for_each(|f| f.shell_piece_order = true);
@@ -1224,7 +1228,7 @@ mod tests {
        }];
        d.apply_configuration("Blue steel").unwrap();
        let mut value: Value = serde_json::from_str(&d.to_json()).unwrap();
-        value["format"] = Value::from("solvecraft/7");
+        value["format"] = Value::from("solidcraft/7");
        let original_table = value["configs"].clone();
        let roundtrip = read(&value.to_string()).unwrap();
        assert_eq!(roundtrip, d);
@@ -1241,8 +1245,8 @@ mod tests {

    #[test]
    fn version_seven_origin_sketch_keeps_geometry_dimension_ids_and_expressions() {
-        use solvecraft_geom::Vec2;
-        use solvecraft_sketch::{ConstraintKind, Sketch};
+        use solidcraft_geom::Vec2;
+        use solidcraft_sketch::{ConstraintKind, Sketch};
        let mut d = Document::new("legacy origin dimensions");
        d.set_param("reach", "25 mm", Some("mm"), None).unwrap();
        let dim = d.new_model_param("reach", "mm");
@@ -1253,7 +1257,7 @@ mod tests {
        sketch.add_constraint(ConstraintKind::Length { l: line, value: 25.0 }, Some(dim)).unwrap();
        d.add_feature(crate::FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch }, Some("Dimensioned")).unwrap();
        let mut legacy: Value = serde_json::from_str(&d.to_json()).unwrap();
-        legacy["format"] = Value::from("solvecraft/7");
+        legacy["format"] = Value::from("solidcraft/7");
        let mut features = legacy["features"].clone();
        pieces_in_shell_order(&mut features);
        let params = legacy["params"].clone();
@@ -1268,8 +1272,8 @@ mod tests {

    #[test]
    fn version_eight_persistent_angle_sweep_and_slot_dimensions_roundtrip() {
-        use solvecraft_geom::Vec2;
-        use solvecraft_sketch::{ConstraintKind, Sketch};
+        use solidcraft_geom::Vec2;
+        use solidcraft_sketch::{ConstraintKind, Sketch};
        let mut d = Document::new("persistent typed dimensions");
        let heading = d.new_model_param("45 deg", "deg");
        let sweep = d.new_model_param("180 deg", "deg");
@@ -1358,8 +1362,11 @@ mod tests {

    #[test]
    fn versions() {
-        assert_eq!(version_of("solvecraft/1"), Some(1));
-        assert_eq!(version_of("solvecraft/x"), None);
+        assert_eq!(version_of("solidcraft/1"), Some(1));
+        assert_eq!(version_of("solidcraft/x"), None);
+        // Compatibility shim: files saved before the rename carry the legacy tag.
+        assert_eq!(version_of("solvecraft/13"), Some(13));
+        assert_eq!(version_of("solvecraftx/13"), None);
        let d = Document::new("A");
        assert_eq!(d.format, format_string(FORMAT));
        let back = read(&d.to_json()).unwrap();
@@ -1378,44 +1385,44 @@ mod tests {
            )
            .unwrap();
        let mut json: Value = serde_json::from_str(&doc.to_json()).unwrap();
-        json["format"] = Value::from("solvecraft/5");
+        json["format"] = Value::from("solidcraft/5");
        let migrated = read(&json.to_string()).unwrap();
        let crate::FeatureKind::ConstructionPlane { plane } = &migrated.feature(id).unwrap().kind else { panic!("plane") };
        let (values, errors) = migrated.param_values();
        assert!(errors.is_empty());
        let p = migrated.resolve_plane(&values, plane, 0).unwrap();
-        assert_eq!(p.y, solvecraft_geom::Vec3::Z);
-        assert_eq!(p.normal(), -solvecraft_geom::Vec3::Y);
-        assert_eq!(p.origin, solvecraft_geom::Vec3::new(0.0, -7.0, 0.0));
+        assert_eq!(p.y, solidcraft_geom::Vec3::Z);
+        assert_eq!(p.normal(), -solidcraft_geom::Vec3::Y);
+        assert_eq!(p.origin, solidcraft_geom::Vec3::new(0.0, -7.0, 0.0));
        assert_eq!(read(&migrated.to_json()).unwrap(), migrated);
        let fresh = doc.resolve_plane(&values, &crate::PlaneRef::Origin { name: "XZ".into() }, 0).unwrap();
-        assert_eq!(fresh.normal(), solvecraft_geom::Vec3::Y);
+        assert_eq!(fresh.normal(), solidcraft_geom::Vec3::Y);
    }

    #[test]
    fn older_upgraded_newer_refused_others_rejected() {
        let mut v: Value = serde_json::from_str(&Document::new("A").to_json()).unwrap();
-        v["format"] = Value::from("solvecraft/1");
+        v["format"] = Value::from("solidcraft/1");
        assert_eq!(read(&v.to_string()).unwrap().format, format_string(FORMAT));
        v.as_object_mut().unwrap().remove("format");
        assert!(read(&v.to_string()).is_ok(), "a file without a format is format 1");
        v["format"] = Value::from(format_string(FORMAT + 1));
        let e = read(&v.to_string()).unwrap_err().to_string();
        assert!(e.contains("newer SolidCraft"), "{e}");
-        for bad in ["solvecraft/0", "acad/3", "solvecraft/-1", "solvecraft/99999999999999999999"] {
+        for bad in ["solidcraft/0", "acad/3", "solidcraft/-1", "solidcraft/99999999999999999999"] {
            v["format"] = Value::from(bad);
            assert!(read(&v.to_string()).is_err(), "{bad}");
        }
        assert!(read("[]").is_err());
        // Format 2 body colours become body appearances.
        let mut old: Value = serde_json::from_str(&Document::new("A").to_json()).unwrap();
-        old["format"] = Value::from("solvecraft/2");
+        old["format"] = Value::from("solidcraft/2");
        old["appearances"] = serde_json::json!({"Body1": [200, 10, 20]});
        let d = read(&old.to_string()).unwrap();
        let l = d.appearances.bodies.get("Body1").unwrap();
        // Format 3 joints (aligned unless flipped) keep their placement.
        let mut j: Value = serde_json::from_str(&Document::new("A").to_json()).unwrap();
-        j["format"] = Value::from("solvecraft/3");
+        j["format"] = Value::from("solidcraft/3");
        j["assembly"] = serde_json::json!({"joints": [{"id": 1, "name": "J", "kind": "rigid", "a": {"occurrence": 0, "snap": {"type": "point", "point": [0, 0, 0]}}, "b": {"occurrence": 0, "snap": {"type": "point", "point": [0, 0, 0]}}}]});
        let dj = read(&j.to_string()).unwrap();
        assert!(dj.assembly.joints[0].flip, "aligned before = not mated now");
@@ -1431,14 +1438,14 @@ mod tests {
    /// file too, before the arrays are deserialised.
    #[test]
    fn oversized_sketches_are_refused_before_typed_decoding() {
-        use solvecraft_sketch::{MAX_CONSTRAINTS, MAX_CURVES, MAX_POINTS, Sketch};
+        use solidcraft_sketch::{MAX_CONSTRAINTS, MAX_CURVES, MAX_POINTS, Sketch};

        // A sketch right at the point cap, chained by coincident constraints.
        let mut sketch = Sketch::new();
        let mut previous = 0;
        while sketch.points.len() < MAX_POINTS {
-            let i = sketch.add_point(solvecraft_geom::Vec2::new(0.001 * sketch.points.len() as f64, 0.0), None).unwrap();
-            sketch.add_constraint(solvecraft_sketch::ConstraintKind::Coincident { p: previous, q: i }, None).unwrap();
+            let i = sketch.add_point(solidcraft_geom::Vec2::new(0.001 * sketch.points.len() as f64, 0.0), None).unwrap();
+            sketch.add_constraint(solidcraft_sketch::ConstraintKind::Coincident { p: previous, q: i }, None).unwrap();
            previous = i;
        }
        let mut doc = Document::new("big sketch");
@@ -380,11 +380,11 @@ mod tests {

    #[test]
    fn formats_one_through_eleven_keep_legacy_offset_geometry_and_ids() {
-        let mut sketch = solvecraft_sketch::Sketch::new();
-        let center = sketch.add_point(solvecraft_geom::Vec2::new(4., 7.), Some("center")).unwrap();
-        sketch.add_circle(solvecraft_geom::Vec2::new(4., 7.), 10., Some(center), Some("source")).unwrap();
-        sketch.add_circle(solvecraft_geom::Vec2::new(4., 7.), 9., Some(center), Some("offset")).unwrap();
-        sketch.offsets.push(solvecraft_sketch::OffsetChain {
+        let mut sketch = solidcraft_sketch::Sketch::new();
+        let center = sketch.add_point(solidcraft_geom::Vec2::new(4., 7.), Some("center")).unwrap();
+        sketch.add_circle(solidcraft_geom::Vec2::new(4., 7.), 10., Some(center), Some("source")).unwrap();
+        sketch.add_circle(solidcraft_geom::Vec2::new(4., 7.), 9., Some(center), Some("offset")).unwrap();
+        sketch.offsets.push(solidcraft_sketch::OffsetChain {
            sources: vec![("source".into(), true)],
            outputs: vec!["offset".into()],
            distance: 1.,
@@ -409,15 +409,15 @@ mod tests {
            let state = model.state();
            let solved = state.sketch(sketch_id).unwrap();
            let radius = solved.sketch.curves.iter().find(|curve| curve.id == "offset").map(|curve| &curve.kind);
-            assert!(matches!(radius,Some(solvecraft_sketch::CurveKind::Circle {r,..}) if *r ==9.));
+            assert!(matches!(radius,Some(solidcraft_sketch::CurveKind::Circle {r,..}) if *r ==9.));
        }
    }

    #[test]
    fn missing_boundary_or_defining_sketch_reopens_as_a_model_error_without_retarget() {
        for missing_sketch in [false, true] {
-            let mut sketch = solvecraft_sketch::Sketch::new();
-            sketch.add_circle(solvecraft_geom::Vec2::new(0., 0.), 10., None, Some("unrelated-circle")).unwrap();
+            let mut sketch = solidcraft_sketch::Sketch::new();
+            sketch.add_circle(solidcraft_geom::Vec2::new(0., 0.), 10., None, Some("unrelated-circle")).unwrap();
            let mut document = Document::new("repairable lost boundary");
            let id = document.add_feature(FeatureKind::Sketch { plane: crate::PlaneRef::Origin { name: "XY".into() }, sketch }, None).unwrap();
            document
@@ -17,7 +17,7 @@
 use std::collections::{BTreeMap, BTreeSet};
 use std::sync::{Arc, OnceLock};

-use solvecraft_kernel::history::{FaceOrigin, FaceProv, History};
+use solidcraft_kernel::history::{FaceOrigin, FaceProv, History};

 use crate::ModelBody;
 use crate::lineage::{Lineage, Operand};
@@ -13,7 +13,7 @@
 use std::collections::{BTreeMap, BTreeSet, VecDeque};

 use serde::{Deserialize, Serialize};
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;

 use crate::{DocError, Document, IDENTITY, Mat, ModelState, Result, apply_point, apply_vector, mat_inverse, mat_mul};

@@ -273,9 +273,9 @@ pub fn resolve_origin(doc: &Document, st: &ModelState, o: &JointOrigin) -> Resul
            let comp = component_of(doc, o.occurrence)?;
            let cyl = component_bodies(doc, st, comp)
                .into_iter()
-                .filter_map(|b| solvecraft_kernel::cylinder_face_at(&b.body, *pick))
+                .filter_map(|b| solidcraft_kernel::cylinder_face_at(&b.body, *pick))
                .min_by(|a, b| {
-                    let off = |c: &solvecraft_kernel::CylinderFace| {
+                    let off = |c: &solidcraft_kernel::CylinderFace| {
                        let v = *pick - c.axis_point;
                        ((v - c.axis * v.dot(c.axis)).len() - c.radius).abs()
                    };
@@ -1,4 +1,4 @@
-//! The SolveCraft document: user and model parameters, and a parametric timeline of features
+//! The SolidCraft document: user and model parameters, and a parametric timeline of features
 //! (sketches, extrudes, revolves, fillets, primitives, combines…). Evaluating the timeline with
 //! the kernel produces the model (bodies and solved sketches). Evaluation is incremental: a
 //! feature is recomputed only when it, a parameter it uses, or an earlier feature changed.
@@ -47,8 +47,8 @@ pub use eval::{
    state_in_frame_at, through_all_distance, world_state,
 };
 pub use params::{ParamRow, ParamUser, cycles};
-pub use solvecraft_kernel as kernel;
-pub use solvecraft_sketch as sketch;
+pub use solidcraft_kernel as kernel;
+pub use solidcraft_sketch as sketch;

 #[derive(Debug, Clone, PartialEq, thiserror::Error)]
 pub enum DocError {
@@ -59,9 +59,9 @@ pub enum DocError {
    #[error("unknown {0}")]
    Unknown(String),
    #[error(transparent)]
-    Sketch(#[from] solvecraft_sketch::SketchError),
+    Sketch(#[from] solidcraft_sketch::SketchError),
    #[error(transparent)]
-    Kernel(#[from] solvecraft_kernel::KernelError),
+    Kernel(#[from] solidcraft_kernel::KernelError),
 }

 pub type Result<T> = std::result::Result<T, DocError>;
@@ -11,9 +11,9 @@

 use std::sync::{Arc, OnceLock};

-use solvecraft_geom::Region2;
-use solvecraft_kernel::Body;
-use solvecraft_kernel::history::{Change, FaceOrigin, FaceProv, History};
+use solidcraft_geom::Region2;
+use solidcraft_kernel::Body;
+use solidcraft_kernel::history::{Change, FaceOrigin, FaceProv, History};

 use crate::SolvedSketch;

@@ -183,7 +183,7 @@ impl<'a> ProfileRoles<'a> {
        if history.operands != 0 {
            return None;
        }
-        let segments: Vec<&solvecraft_geom::Seg2> =
+        let segments: Vec<&solidcraft_geom::Seg2> =
            self.region.map(|r| std::iter::once(&r.outer).chain(&r.holes).flat_map(|l| &l.segs).collect()).unwrap_or_default();
        let curves = self.sketch.map(crate::config::ExactSketchCurves::new);
        let curve = |segment: usize| -> Option<String> { curves.as_ref()?.find(segments.get(segment)?).map(|id| format!("side:{id}")) };
@@ -235,7 +235,7 @@ pub(crate) fn box_tool(body: Body) -> Traced {
        sources
            .iter()
            .map(|source| match source {
-                Some(solvecraft_kernel::FaceSource::Box { axis, high, .. }) => {
+                Some(solidcraft_kernel::FaceSource::Box { axis, high, .. }) => {
                    ["x", "y", "z"].get(usize::from(*axis)).map(|a| vec![format!("{}{a}", if *high { "+" } else { "-" })]).unwrap_or_default()
                }
                _ => Vec::new(),
@@ -3,7 +3,7 @@
 //! shown without changing the design).

 use serde::{Deserialize, Serialize};
-use solvecraft_geom::Vec3;
+use solidcraft_geom::Vec3;

 /// Occurrences whose bodies may touch but not pass through each other while joints move.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -8,7 +8,7 @@
 //! was worked out from geometry, found where the reference's point no longer lies, is reported:
 //! only geometry decided.

-use solvecraft_geom::{Mesh, Vec3};
+use solidcraft_geom::{Mesh, Vec3};

 use crate::history_names::{Match, Names};
 use crate::naming::{self, closest, edge_names, face_names, legacy_edge_names, legacy_face_names, strip_piece};
@@ -1,11 +1,11 @@
 use crate::{Document, ModelBody, ModelState};
-use solvecraft_geom::{Plane, Vec3};
-use solvecraft_sketch::{LinkKind, LinkSource, Sketch};
+use solidcraft_geom::{Plane, Vec3};
+use solidcraft_sketch::{LinkKind, LinkSource, Sketch};
 use std::collections::BTreeMap;
 use std::sync::Arc;

 fn named_box(name: &str, width: f64, height: f64) -> ModelBody {
-    let body = solvecraft_kernel::box_solid(Vec3::ZERO, Vec3::new(width, width, height)).unwrap();
+    let body = solidcraft_kernel::box_solid(Vec3::ZERO, Vec3::new(width, width, height)).unwrap();
    let mut names = vec!["unrelated".to_string(); body.faces(0.01).unwrap().len()];
    let top = body.faces(0.01).unwrap().into_iter().find(|face| face.plane_normal.is_some_and(|normal| normal.z > 0.99)).unwrap().index;
    names[top] = "shared:top".into();
@@ -17,7 +17,7 @@

 use std::sync::{Arc, OnceLock};

-use solvecraft_geom::{Mesh, Seg2, Vec2, Vec3};
+use solidcraft_geom::{Mesh, Seg2, Vec2, Vec3};

 use crate::history_names::Names;
 use crate::lineage::Lineage;
@@ -737,7 +737,7 @@ mod tests {

    #[test]
    fn merged_face_votes_collectively_for_pieces_of_one_source() {
-        let body = ModelBody::new("Input".into(), solvecraft_kernel::box_solid(Vec3::ZERO, Vec3::new(4., 1., 1.)).unwrap(), 1);
+        let body = ModelBody::new("Input".into(), solidcraft_kernel::box_solid(Vec3::ZERO, Vec3::new(4., 1., 1.)).unwrap(), 1);
        let mut mesh = Mesh::default();
        let mut points = Vec::new();
        for i in 0..3u32 {