release: version 0.5.9

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UhhZMBTviDQxZvwnyP89fo

.github/ISSUE_TEMPLATE/bug.yml

@@ -41,6 +41,6 @@ body:
     id: version
     attributes:
       label: Version and platform
-      placeholder: "v0.1.0 (or commit), macOS 15 arm64"
+      placeholder: "v0.5.9 (or commit), macOS 15 arm64"
     validations:
       required: true

.github/dependabot.yml

@@ -0,0 +1,59 @@
+# Weekly dependency updates against develop, the trunk, grouped so each ecosystem opens one pull
+# request a week. Security updates are switched on in the repository settings and open their own
+# pull requests as advisories appear. CI runs the full gate on Dependabot's pull requests
+# (.github/workflows/ci.yml).
+version: 2
+updates:
+  - package-ecosystem: cargo
+    directory: /
+    target-branch: develop
+    schedule:
+      interval: weekly
+      day: monday
+      time: "05:00"
+      timezone: Etc/UTC
+    open-pull-requests-limit: 5
+    commit-message:
+      prefix: deps
+    groups:
+      # Compatible updates (Cargo.lock only) in one pull request; a breaking release of a
+      # dependency comes on its own, since it usually needs code changes.
+      cargo-compatible:
+        update-types: [minor, patch]
+    ignore:
+      # Pinned to the SolidCraft commit FieldCraft builds against, together with the truck and
+      # egui-wgpu patches from that commit ([patch.crates-io] in Cargo.toml); moved by hand.
+      - dependency-name: "solidcraft-*"
+      - dependency-name: "truck-*"
+      - dependency-name: matext4cgmath
+      - dependency-name: egui-wgpu
+      # The egui line follows SolidCraft's (its egui-wgpu fixes are patched in): patch releases
+      # come with the group, a new line (0.36 -> 0.37) moves by hand with SolidCraft.
+      - dependency-name: egui
+        update-types: ["version-update:semver-major", "version-update:semver-minor"]
+      - dependency-name: eframe
+        update-types: ["version-update:semver-major", "version-update:semver-minor"]
+      # The shared Craft components follow VectorCraft's rev.
+      - dependency-name: craft-ui
+      # The exact predicates' BigInt must be num-rational's (0.4 uses num-bigint 0.4): both move
+      # together, by hand.
+      - dependency-name: num-bigint
+        update-types: ["version-update:semver-major", "version-update:semver-minor"]
+      - dependency-name: num-rational
+        update-types: ["version-update:semver-major", "version-update:semver-minor"]
+
+  - package-ecosystem: github-actions
+    directory: /
+    target-branch: develop
+    schedule:
+      interval: weekly
+      day: monday
+      time: "05:00"
+      timezone: Etc/UTC
+    open-pull-requests-limit: 3
+    commit-message:
+      prefix: ci
+    groups:
+      # Actions are pinned by commit SHA with a version comment; Dependabot updates both.
+      actions:
+        patterns: ["*"]

.github/release-notes.md

@@ -21,6 +21,8 @@ modal problems with its own solver. AI agents can drive it over MCP (`fieldcraft
 To start with a sample model, run the app with `--sample cantilever` (macOS:
 `/Applications/FieldCraft.app/Contents/MacOS/FieldCraft --sample cantilever`).
 
+**Updates.** {update_signing}
+
 **Signing.** {macos_signing} The Linux and Windows builds are not signed; on Windows, SmartScreen
 may say "Windows protected your PC": choose **More info**, then **Run anyway**.
 

.github/workflows/arch-check.yml

@@ -0,0 +1,83 @@
+# Linux on other architectures, weekly and on demand: CI and the release build x86_64 Linux,
+# macOS and Windows only.
+# - arm64: a native runner builds the shipped binaries (release profile) and runs the CLI and
+#   engine tests.
+# - riscv64: cross-built with Ubuntu's GNU toolchain and linked; the CLI then runs under QEMU.
+#   The GUI needs no target system libraries at link time (Wayland, X11 and GL are opened at run
+#   time), so only the cross C toolchain and libc are installed.
+# The RISC-V job is adapted from SolidCraft's CI (see ATTRIBUTION.md).
+name: Linux arm64 and riscv64
+
+on:
+  schedule:
+    - cron: '17 5 * * 1'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: arch-check-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  arm64:
+    name: Linux arm64 (native)
+    runs-on: ubuntu-24.04-arm
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: arm64
+          save-if: ${{ github.ref == 'refs/heads/develop' }}
+      - name: Build fieldcraft and fieldcraft-cli (release)
+        run: cargo build --locked --release -p fieldcraft -p fieldcraft-cli
+      - name: Run the binaries
+        run: |
+          file target/release/fieldcraft target/release/fieldcraft-cli
+          target/release/fieldcraft --version
+          target/release/fieldcraft-cli --version
+          target/release/fieldcraft-cli commands >/dev/null
+      - name: CLI and engine tests
+        run: cargo test --locked --profile ci -p fieldcraft-cli -p fieldcraft-engine
+
+  riscv64:
+    name: Linux riscv64 (cross)
+    runs-on: ubuntu-24.04
+    timeout-minutes: 90
+    env:
+      TARGET: riscv64gc-unknown-linux-gnu
+      CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER: riscv64-linux-gnu-gcc
+      CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_RUNNER: qemu-riscv64 -L /usr/riscv64-linux-gnu
+      CC_riscv64gc_unknown_linux_gnu: riscv64-linux-gnu-gcc
+      CXX_riscv64gc_unknown_linux_gnu: riscv64-linux-gnu-g++
+      AR_riscv64gc_unknown_linux_gnu: riscv64-linux-gnu-ar
+      PKG_CONFIG_ALLOW_CROSS: 1
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: riscv64gc-unknown-linux-gnu
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: riscv64
+          save-if: ${{ github.ref == 'refs/heads/develop' }}
+      - name: Install the cross toolchain and QEMU
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends gcc-riscv64-linux-gnu g++-riscv64-linux-gnu \
+            libc6-dev-riscv64-cross qemu-user
+      - name: Build fieldcraft and fieldcraft-cli
+        run: cargo build --locked --profile ci --target "$TARGET" -p fieldcraft -p fieldcraft-cli
+      - name: Run the CLI under QEMU
+        run: |
+          bin="target/$TARGET/ci"
+          file "$bin/fieldcraft" "$bin/fieldcraft-cli"
+          qemu-riscv64 -L /usr/riscv64-linux-gnu "$bin/fieldcraft-cli" --version
+          qemu-riscv64 -L /usr/riscv64-linux-gnu "$bin/fieldcraft-cli" commands >/dev/null
+          qemu-riscv64 -L /usr/riscv64-linux-gnu "$bin/fieldcraft" --version

.github/workflows/ci.yml

@@ -1,9 +1,11 @@
 name: CI
 
-# CI runs once per merge, on main (AGENTS.md, "Workflow for every change"): the core team's pull
-# requests are checked locally on the crates they touch and merged; a red main is fixed forward.
+# CI runs once per merge on `develop`, the trunk (AGENTS.md, "Workflow for every change"): the core
+# team's pull requests are checked locally on the crates they touch and merged; a red trunk is
+# fixed forward. `main` holds released code only (docs/releasing.md).
 # Pull requests from forks (outside contributors) run the full gate, once the maintainer approves
-# the run, so the review sees it.
+# the run, so the review sees it; so do Dependabot's (.github/dependabot.yml), which nobody tests
+# locally. The heavy job stays off pull requests.
 on:
   pull_request:
     paths:
@@ -13,7 +15,7 @@ on:
       - 'docs/features.md'
       - 'docs/oracle.md'
   push:
-    branches: [main]
+    branches: [develop]
     # A merge that only touches prose starts no run. The generated pages are checked by the jobs
     # (features.md by `cargo xtask ci`, oracle.md by the oracle job), so they still count.
     # (Later patterns override earlier ones.)
@@ -24,8 +26,11 @@ on:
       - 'docs/features.md'
       - 'docs/oracle.md'
   schedule:
-    # Nightly: the heavy tests on main.
+    # Nightly, on the default branch (develop): the heavy tests.
     - cron: '23 3 * * *'
+    # Weekly: the oracle on macOS too, so results that differ by platform show up in CI (the
+    # fixtures are often blessed on a Mac; #115).
+    - cron: '41 4 * * 0'
   workflow_dispatch:
 
 permissions:
@@ -43,7 +48,7 @@ env:
 jobs:
   ci:
     name: cargo xtask ci
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    if: github.event.schedule != '41 4 * * 0' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository || github.event.pull_request.user.login == 'dependabot[bot]')
     runs-on: ubuntu-24.04
     timeout-minutes: 60
     steps:
@@ -54,13 +59,19 @@ jobs:
           targets: wasm32-unknown-unknown
       - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
+          save-if: ${{ github.ref == 'refs/heads/develop' }}
+      # A dependency update changes THIRD-PARTY-LICENSES.txt, which Dependabot cannot regenerate:
+      # regenerate it here so the gate checks everything else, and dependabot-licences.yml commits
+      # it to the pull request.
+      - name: Regenerate THIRD-PARTY-LICENSES.txt (Dependabot)
+        if: github.event.pull_request.user.login == 'dependabot[bot]'
+        run: cargo xtask licences
       - run: cargo xtask ci
 
   heavy:
     # The heavy verification and corpus tests (#[ignore]d) and the doc tests.
     name: cargo xtask test --heavy
-    if: github.event_name != 'pull_request'
+    if: github.event.schedule != '41 4 * * 0' && github.event_name != 'pull_request'
     runs-on: ubuntu-24.04
     timeout-minutes: 60
     steps:
@@ -68,7 +79,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
-          save-if: ${{ github.ref == 'refs/heads/main' }}
+          save-if: ${{ github.ref == 'refs/heads/develop' }}
       - run: cargo xtask test --heavy
 
   oracle:
@@ -76,7 +87,7 @@ jobs:
     # its fixture, and docs/oracle.md must be the table the cases produce. Cases marked `slow`
     # run here too while the whole set stays within a few minutes; `--quick` skips them.
     name: cargo xtask oracle
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    if: github.event.schedule != '41 4 * * 0' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository || github.event.pull_request.user.login == 'dependabot[bot]')
     runs-on: ubuntu-24.04
     timeout-minutes: 45
     steps:
@@ -85,14 +96,32 @@ jobs:
       - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
           key: oracle
-          save-if: ${{ github.ref == 'refs/heads/main' }}
+          save-if: ${{ github.ref == 'refs/heads/develop' }}
+      - run: cargo xtask oracle
+      - name: docs/oracle.md is current
+        run: git diff --exit-code docs/oracle.md
+
+  oracle-macos:
+    # The same oracle on macOS, weekly and on demand: the solvers must agree across platforms
+    # to the fixture bands, and docs/oracle.md must read the same.
+    name: cargo xtask oracle (macOS)
+    if: github.event.schedule == '41 4 * * 0' || github.event_name == 'workflow_dispatch'
+    runs-on: macos-14
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: oracle-macos
+          save-if: ${{ github.ref == 'refs/heads/develop' }}
       - run: cargo xtask oracle
       - name: docs/oracle.md is current
         run: git diff --exit-code docs/oracle.md
 
   advisories:
     name: Dependency advisories and sources
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    if: github.event.schedule != '41 4 * * 0' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository || github.event.pull_request.user.login == 'dependabot[bot]')
     runs-on: ubuntu-24.04
     timeout-minutes: 20
     steps:

.github/workflows/dependabot-licences.yml

@@ -0,0 +1,40 @@
+# Dependabot's Cargo updates change THIRD-PARTY-LICENSES.txt (`cargo xtask licences`), which
+# Dependabot cannot regenerate: this commits the regenerated file to its pull request. CI's own
+# run on the pull request regenerates it too, so its result covers everything else.
+name: Dependabot licences
+
+on:
+  pull_request:
+    branches: [develop]
+    paths: [Cargo.lock]
+
+permissions:
+  contents: write
+
+concurrency:
+  group: dependabot-licences-${{ github.head_ref }}
+  cancel-in-progress: true
+
+jobs:
+  licences:
+    if: github.event.pull_request.user.login == 'dependabot[bot]'
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: ${{ github.head_ref }}
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo xtask licences
+      - name: Commit the regenerated file
+        run: |
+          if git diff --quiet -- THIRD-PARTY-LICENSES.txt; then
+            echo "THIRD-PARTY-LICENSES.txt is up to date"
+            exit 0
+          fi
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          # [skip ci]: the pull request's CI run already regenerated this file and tested the
+          # tree with it; a bot-authored commit would otherwise wait for a maintainer's approval.
+          git commit -m "deps: regenerate THIRD-PARTY-LICENSES.txt [skip ci]" -- THIRD-PARTY-LICENSES.txt
+          git push origin "HEAD:${GITHUB_HEAD_REF}"

.github/workflows/packaging-lint.yml

@@ -0,0 +1,79 @@
+# Quick static checks for the release pipeline (seconds, no Rust build): workflow syntax, the
+# packaging shell and PowerShell scripts, the macOS property lists and the Linux desktop entry.
+# These files are otherwise exercised only by a full release run (release.yml).
+# Adapted from SolidCraft's packaging-lint.yml, itself adapted from PhotoCraft's (see ATTRIBUTION.md).
+name: Packaging lint
+
+on:
+  push:
+    branches: [develop]
+    paths: [".github/workflows/**", "packaging/**"]
+  pull_request:
+    paths: [".github/workflows/**", "packaging/**"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: packaging-lint-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    name: Packaging lint
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    env:
+      ACTIONLINT_VERSION: 1.7.12
+      ACTIONLINT_SHA256: 8aca8db96f1b94770f1b0d72b6dddcb1ebb8123cb3712530b08cc387b349a3d8
+      PSSCRIPTANALYZER_VERSION: 1.24.0
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Install tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends shellcheck desktop-file-utils libxml2-utils
+          archive="$RUNNER_TEMP/actionlint.tar.gz"
+          curl -fsSL -o "$archive" \
+            "https://github.com/rhysd/actionlint/releases/download/v${ACTIONLINT_VERSION}/actionlint_${ACTIONLINT_VERSION}_linux_amd64.tar.gz"
+          echo "$ACTIONLINT_SHA256  $archive" | sha256sum -c -
+          tar -xzf "$archive" -C "$RUNNER_TEMP" actionlint
+      - name: actionlint
+        # Also runs shellcheck on every `run:` script.
+        run: '"$RUNNER_TEMP/actionlint" -color'
+      - name: shellcheck
+        # packaging/.shellcheckrc lets the scripts' `source=../env.sh` directives resolve.
+        run: shellcheck packaging/*.sh packaging/*/*.sh packaging/linux/AppRun
+      - name: PowerShell
+        shell: pwsh
+        run: |
+          $failed = $false
+          foreach ($f in Get-ChildItem packaging/windows/*.ps1) {
+            $errors = $null
+            [System.Management.Automation.Language.Parser]::ParseFile($f.FullName, [ref]$null, [ref]$errors) | Out-Null
+            if ($errors) {
+              $errors | ForEach-Object { Write-Output "::error file=$($f.FullName),line=$($_.Extent.StartLineNumber)::$($_.Message)" }
+              $failed = $true
+            } else {
+              Write-Output "parsed $($f.Name)"
+            }
+          }
+          if ($failed) { exit 1 }
+          if (-not (Get-Module -ListAvailable PSScriptAnalyzer | Where-Object Version -eq $env:PSSCRIPTANALYZER_VERSION)) {
+            Install-Module PSScriptAnalyzer -RequiredVersion $env:PSSCRIPTANALYZER_VERSION -Scope CurrentUser -Force
+          }
+          Import-Module PSScriptAnalyzer -RequiredVersion $env:PSSCRIPTANALYZER_VERSION
+          $issues = Invoke-ScriptAnalyzer -Path packaging/windows -Recurse -Severity Error, Warning
+          $issues | ForEach-Object { Write-Output "::error file=$($_.ScriptPath),line=$($_.Line)::$($_.RuleName): $($_.Message)" }
+          if ($issues) { exit 1 }
+      - name: Property lists and desktop entry
+        run: |
+          app_id="$(sed -n 's/^APP_ID=//p' packaging/env.sh)"
+          test -n "$app_id"
+          xmllint --noout packaging/macos/*.plist*
+          desktop="packaging/linux/$app_id.desktop"
+          desktop-file-validate "$desktop"
+          # The window's X11 class / Wayland app_id is packaging's APP_ID (apps/fieldcraft/src/main.rs).
+          grep -qx "StartupWMClass=$app_id" "$desktop"
+          grep -qF "const APP_ID: &str = \"$app_id\";" apps/fieldcraft/src/main.rs

.github/workflows/pages.yml

@@ -0,0 +1,88 @@
+# The web app (apps/fieldcraft-web, docs/web.md) on GitHub Pages: https://jyviko.github.io/fieldcraft/
+# After SolidCraft's pages.yml (MIT OR Apache-2.0; see ATTRIBUTION.md).
+#
+# A push to `main` (a release; main holds released code only) builds the app with Trunk (release,
+# wasm-opt) and deploys it. A merge to `develop` that touches code builds it without deploying, so a
+# broken web build shows up before the release. A manual run builds the branch it runs on and
+# deploys only from `main`. Needs Settings › Pages › Source = GitHub Actions, and `main` allowed
+# by the github-pages environment's deployment branches.
+name: Pages
+
+on:
+  push:
+    branches: [main, develop]
+    # As ci.yml: a merge that only touches prose builds nothing.
+    paths:
+      - '**'
+      - '!**/*.md'
+      - '!docs/**'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+# One deployment at a time; a newer push waits its turn instead of cancelling a deploy part way.
+concurrency:
+  group: pages-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  CARGO_TERM_COLOR: always
+  TRUNK_VERSION: v0.21.14
+  TRUNK_SHA256: f2b4680cd239693a646a2795e4633c625328d7b2a044fbe749fa3a2fe9e7036b
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          key: web
+          save-if: ${{ github.ref == 'refs/heads/develop' }}
+      - name: Install Trunk
+        run: |
+          mkdir -p "$HOME/.local/bin"
+          curl -sSfL -o trunk.tar.gz "https://github.com/trunk-rs/trunk/releases/download/${TRUNK_VERSION}/trunk-x86_64-unknown-linux-gnu.tar.gz"
+          echo "${TRUNK_SHA256}  trunk.tar.gz" | sha256sum -c -
+          tar -xzf trunk.tar.gz -C "$HOME/.local/bin"
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+      - name: Build the web app
+        working-directory: apps/fieldcraft-web
+        env:
+          # Usage analytics only in the deployed build (main), and only with the user's consent
+          # (docs/privacy.md); develop builds get an empty key, which sends nothing.
+          FIELDCRAFT_POSTHOG_KEY: ${{ github.ref == 'refs/heads/main' && secrets.POSTHOG_KEY || '' }}
+        run: trunk build --release --public-url /fieldcraft/
+      - name: Bundle size
+        run: |
+          {
+            echo "### Web app bundle"
+            echo '| file | bytes | gzip |'
+            echo '|---|---:|---:|'
+            for f in dist/web/*.wasm dist/web/*.js; do
+              echo "| $(basename "$f") | $(stat -c %s "$f") | $(gzip -9 -c "$f" | wc -c) |"
+            done
+          } >> "$GITHUB_STEP_SUMMARY"
+      - if: github.ref == 'refs/heads/main'
+        uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
+        with:
+          path: dist/web
+
+  deploy:
+    if: github.ref == 'refs/heads/main'
+    needs: build
+    runs-on: ubuntu-24.04
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@368f82528645a54fb793d4d04e342629a3f51346 # v5.0.1

.github/workflows/release.yml

@@ -1,31 +1,33 @@
 # Release builds (docs/releasing.md), after SolidCraft's and VectorCraft's release.yml
 # (MIT OR Apache-2.0; see ATTRIBUTION.md).
 #
-# A push to `release` (fast-forwarded from main) builds every package and creates or updates the
-# DRAFT GitHub Release "FieldCraft v<version>", with SHA256SUMS.txt and generated notes. The
+# A push to `main` (fast-forwarded from a verified `develop` commit; main holds released code only)
+# builds every package and creates or updates the
+# DRAFT GitHub Release "FieldCraft v<version>", with SHA256SUMS.txt (signed with the release key
+# into SHA256SUMS.txt.minisig when the FIELDCRAFT_SIGNING_KEY secret exists) and generated notes. The
 # version is [workspace.package] version in Cargo.toml; a suffix (0.2.0-rc.1) makes a
 # pre-release. A person verifies the draft and publishes it; this workflow never publishes,
-# and pushes to main or tags never start it.
+# and pushes to develop or tags never start it.
 #
 #   macOS universal (arm64 + x86_64)   .dmg with FieldCraft.app, the CLI as a .zip   packaging/macos
-#   Linux x86_64 (glibc 2.35+)         .tar.gz and .AppImage                          packaging/linux
+#   Linux x86_64 (glibc 2.35+)         .tar.gz, .AppImage, .deb and .rpm              packaging/linux
 #   Windows x64                        .zip with fieldcraft.exe and fieldcraft-cli.exe packaging/windows
 #
 # macOS: signed with a Developer ID and notarized when the APPLE_* secrets exist, ad-hoc
 # otherwise (the release notes say which). Linux and Windows builds are not signed.
 #
 # Dry run: `gh workflow run release.yml --ref <branch>` builds everything and uploads the
-# `release-assets` artifact without creating a release. `-f draft=true` on `release` retries
+# `release-assets` artifact without creating a release. `-f draft=true` on `main` retries
 # the draft.
 name: Release
 
 on:
   push:
-    branches: [release]
+    branches: [main]
   workflow_dispatch:
     inputs:
       draft:
-        description: "Create/update the draft release (release branch only; off: build artifacts only)"
+        description: "Create/update the draft release (main only; off: build artifacts only)"
         type: boolean
         default: false
 
@@ -60,8 +62,8 @@ jobs:
             echo "::error::Cargo.toml must contain a version like 1.2.3 or 1.2.3-rc.1, not '$VERSION'"
             exit 1
           fi
-          if [ "$REQUEST_DRAFT" = true ] && [ "$GITHUB_REF" != refs/heads/release ]; then
-            echo "::error::Draft releases are built from the release branch only"
+          if [ "$REQUEST_DRAFT" = true ] && [ "$GITHUB_REF" != refs/heads/main ]; then
+            echo "::error::Draft releases are built from main only"
             exit 1
           fi
           case "$VERSION" in *-*) pre=true ;; *) pre=false ;; esac
@@ -86,7 +88,7 @@ jobs:
         with:
           key: release-macos-universal
           # Release runs are rare: only release-branch runs keep a cache, so dry runs don't evict CI's.
-          save-if: ${{ github.ref == 'refs/heads/release' }}
+          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Import the signing certificate (skipped without APPLE_CERTIFICATE)
         env:
           APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
@@ -96,6 +98,8 @@ jobs:
       - name: Build, sign, notarize and package (the dmg is mounted and checked)
         id: package
         env:
+          # The analytics project key (docs/privacy.md), built in; never printed.
+          FIELDCRAFT_POSTHOG_KEY: ${{ secrets.POSTHOG_KEY }}
           APPLE_ID: ${{ secrets.APPLE_ID }}
           APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
           APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
@@ -118,33 +122,76 @@ jobs:
     timeout-minutes: 90
     env:
       FIELDCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      # The .deb and .rpm builders (both MIT), pinned.
+      CARGO_DEB_VERSION: 3.8.0
+      CARGO_GENERATE_RPM_VERSION: 0.21.0
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Install packaging tools
         run: |
           sudo apt-get update
-          sudo apt-get install -y --no-install-recommends desktop-file-utils
+          sudo apt-get install -y --no-install-recommends desktop-file-utils lintian rpm
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
           key: release-linux-x86_64
           # Release runs are rare: only release-branch runs keep a cache, so dry runs don't evict CI's.
-          save-if: ${{ github.ref == 'refs/heads/release' }}
-      - name: Build and package (tar.gz, AppImage)
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+      - name: Install cargo-deb and cargo-generate-rpm
+        run: |
+          cargo install --locked --version "$CARGO_DEB_VERSION" cargo-deb
+          cargo install --locked --version "$CARGO_GENERATE_RPM_VERSION" cargo-generate-rpm
+      - name: Build and package (tar.gz, AppImage, deb, rpm)
+        env:
+          # The analytics project key (docs/privacy.md), built in; never printed.
+          FIELDCRAFT_POSTHOG_KEY: ${{ secrets.POSTHOG_KEY }}
         run: packaging/linux/package.sh
       - name: Check the packages
         run: |
           . packaging/env.sh
-          list="$(tar -tzf dist/release/*.tar.gz)"
+          base="fieldcraft-$VERSION-linux-x86_64"
+          deb="dist/release/fieldcraft_${VERSION}_amd64.deb"
+          rpm="dist/release/fieldcraft-$VERSION.x86_64.rpm"
+          list="$(tar -tzf "dist/release/$base.tar.gz")"
           for f in bin/fieldcraft bin/fieldcraft-cli "share/applications/$APP_ID.desktop" \
             share/doc/fieldcraft/THIRD-PARTY-LICENSES.txt; do
-            grep -Fx -- "fieldcraft-$VERSION-linux-x86_64/$f" <<<"$list"
+            grep -Fx -- "$base/$f" <<<"$list"
           done
+          # The .deb and .rpm carry the tar.gz's files under /usr (the .deb adds its copyright
+          # file); their lists live in apps/fieldcraft/Cargo.toml, so a drift fails here.
+          files() { grep -v '/$' | sed -E "s#^(\./|/|$base/)##; s#^usr/##" | grep -vx 'share/doc/fieldcraft/copyright' | sort; }
+          diff <(files <<<"$list") <(dpkg-deb --fsys-tarfile "$deb" | tar -t | files)
+          diff <(files <<<"$list") <(rpm -qpl "$rpm" | files)
+          dpkg-deb --info "$deb"
+          rpm -qpi "$rpm"
+          echo "rpm requires:"; rpm -qpR "$rpm"
+          # The release notes live on GitHub, so the package has no Debian changelog (a native
+          # package built upstream, not by a distribution).
+          lintian --info --fail-on error --suppress-tags no-changelog "$deb"
           ldd target/release/fieldcraft
           for appimage in dist/release/*.AppImage; do
             chmod +x "$appimage"
             APPIMAGE_EXTRACT_AND_RUN=1 "$appimage" --version
           done
+      - name: Install the .deb and .rpm in containers
+        run: |
+          # The oldest supported Ubuntu (the build's glibc) and a current Fedora. Recommended and
+          # weak dependencies (GPU drivers) are skipped to keep it quick; the hard ones must resolve.
+          # Both images leave out documentation when installing (dpkg path-exclude, dnf nodocs), so
+          # the licences are checked in the package's file list rather than on disk.
+          docker run --rm -v "$PWD/dist/release:/dist:ro" ubuntu:22.04 bash -euxc '
+            apt-get update -qq
+            DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends /dist/*.deb
+            fieldcraft-cli --version
+            fieldcraft --version
+            dpkg -L fieldcraft | grep -Fx /usr/share/doc/fieldcraft/THIRD-PARTY-LICENSES.txt'
+          docker run --rm -v "$PWD/dist/release:/dist:ro" fedora:44 bash -euxc '
+            dnf install -y -q --setopt=install_weak_deps=False /dist/*.rpm
+            fieldcraft-cli --version
+            fieldcraft --version
+            rpm -ql fieldcraft | grep -Fx /usr/share/doc/fieldcraft/THIRD-PARTY-LICENSES.txt
+            dnf install -y -q rpmlint
+            rpmlint /dist/*.rpm || true'
       - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: release-linux-x86_64
@@ -167,9 +214,12 @@ jobs:
         with:
           key: release-windows-x64
           # Release runs are rare: only release-branch runs keep a cache, so dry runs don't evict CI's.
-          save-if: ${{ github.ref == 'refs/heads/release' }}
+          save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Build and package (zip)
         shell: pwsh
+        env:
+          # The analytics project key (docs/privacy.md), built in; never printed.
+          FIELDCRAFT_POSTHOG_KEY: ${{ secrets.POSTHOG_KEY }}
         run: ./packaging/windows/package.ps1
       - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
@@ -196,21 +246,54 @@ jobs:
           pattern: release-*
           path: artifacts
           merge-multiple: true
-      - name: Check the set, checksums and notes
+      - name: Check the set and write the checksums
         run: |
           for f in "fieldcraft-$VERSION-macos-universal.dmg" "fieldcraft-cli-$VERSION-macos-universal.zip" \
             "fieldcraft-$VERSION-linux-x86_64.tar.gz" "fieldcraft-$VERSION-linux-x86_64.AppImage" \
+            "fieldcraft_${VERSION}_amd64.deb" "fieldcraft-$VERSION.x86_64.rpm" \
             "fieldcraft-$VERSION-windows-x64.zip"; do
             test -s "artifacts/$f" || { echo "::error::missing $f"; exit 1; }
           done
           (cd artifacts && sha256sum -- * | tee SHA256SUMS.txt)
+      - name: Sign SHA256SUMS.txt with the release key (skipped without FIELDCRAFT_SIGNING_KEY)
+        id: sign
+        env:
+          FIELDCRAFT_SIGNING_KEY: ${{ secrets.FIELDCRAFT_SIGNING_KEY }}
+          # rsign2 (MIT), a minisign-compatible signer, pinned.
+          RSIGN_VERSION: 0.6.7
+        run: |
+          if [ -z "$FIELDCRAFT_SIGNING_KEY" ]; then
+            echo "::warning::FIELDCRAFT_SIGNING_KEY is not set: SHA256SUMS.txt is not signed, so the app cannot install this release itself (docs/releasing.md)"
+            echo "signed=false" >>"$GITHUB_OUTPUT"
+            exit 0
+          fi
+          cargo install --locked --quiet --root "$RUNNER_TEMP/rsign" rsign2 --version "$RSIGN_VERSION"
+          rsign="$RUNNER_TEMP/rsign/bin/rsign"
+          key="$RUNNER_TEMP/release.key"
+          (umask 077 && printf '%s\n' "$FIELDCRAFT_SIGNING_KEY" >"$key")
+          "$rsign" sign -W -s "$key" -t "FieldCraft v$VERSION SHA256SUMS.txt" -x artifacts/SHA256SUMS.txt.minisig artifacts/SHA256SUMS.txt
+          rm -f "$key"
+          # The signature must verify with the public key the app is built with.
+          public="$(sed -n 's/^pub const PUBLIC_KEY: &str = "\(.*\)";$/\1/p' crates/update/src/lib.rs)"
+          "$rsign" verify -q -P "$public" -x artifacts/SHA256SUMS.txt.minisig artifacts/SHA256SUMS.txt
+          echo "signed=true" >>"$GITHUB_OUTPUT"
+      - name: Write the notes
+        env:
+          SIGNED: ${{ steps.sign.outputs.signed }}
+        run: |
           # The macOS paragraph says how the app was signed (packaging/macos/package.sh).
           case "$MACOS_SIGNING" in
             notarized) macos="The macOS app is signed with a Developer ID and notarized by Apple." ;;
             signed) macos="The macOS app is signed with a Developer ID but **not notarized**: the first time, right-click \`FieldCraft.app\` in Applications and choose **Open**." ;;
             *) macos="The macOS app is **ad-hoc signed and not notarized**: macOS blocks the first launch. Right-click \`FieldCraft.app\` in Applications and choose **Open** (then **Open** again), or run \`xattr -dr com.apple.quarantine /Applications/FieldCraft.app\`." ;;
           esac
-          awk -v v="$VERSION" -v m="$macos" '{ gsub(/\{version\}/, v); gsub(/\{macos_signing\}/, m); print }' \
+          # The updates paragraph says whether the app can install this release itself.
+          if [ "$SIGNED" = true ]; then
+            updates="\`SHA256SUMS.txt\` is signed with the FieldCraft release key (\`SHA256SUMS.txt.minisig\`), so FieldCraft's Help › Check for Updates can verify and install this release."
+          else
+            updates="This release's \`SHA256SUMS.txt\` is **not signed**: FieldCraft's in-app updates can't verify it and won't install it; download it from this page instead."
+          fi
+          awk -v v="$VERSION" -v m="$macos" -v u="$updates" '{ gsub(/\{version\}/, v); gsub(/\{macos_signing\}/, m); gsub(/\{update_signing\}/, u); print }' \
             .github/release-notes.md >notes.md
           cat notes.md >>"$GITHUB_STEP_SUMMARY"
       - name: Upload the dry-run artifacts

AGENTS.md

@@ -99,7 +99,7 @@ People trust FieldCraft with their models; a crash loses their work. **This outr
   1. Work in your own worktree on a branch, with your own `CARGO_TARGET_DIR`. While you work:
      `cargo check` and the tests of the crates you touch (`cargo test -p <crate>`). Commit after
      each working step (a layer that compiles with its tests passing), not one big commit per PR.
-     Every commit lands on `main` as it is, so each one must build and pass its tests and say
+     Every commit lands on `develop` as it is, so each one must build and pass its tests and say
      what it does: `git bisect` walks them one by one.
   2. When the change is done: review it once with `/simplify`, then `cargo fmt --all` and
      `cargo clippy -p <crate> --all-targets -- -D warnings` for each crate you touched, once.
@@ -108,11 +108,12 @@ People trust FieldCraft with their models; a crash loses their work. **This outr
      oracle cases or solver numerics change (`cargo xtask oracle`).
   3. Fold every fix into the commit it fixes, never a separate "fmt", "clippy", "review fixes" or
      "regenerate features.md" commit: `git commit --fixup <sha>`, then
-     `git rebase -i --autosquash origin/main` (`GIT_SEQUENCE_EDITOR=true` keeps it
+     `git rebase -i --autosquash origin/develop` (`GIT_SEQUENCE_EDITOR=true` keeps it
      non-interactive). A regenerated page goes into the commit that changed what it lists.
-  4. Rebase onto the latest `origin/main` (never merge `main` into a branch), rerun the tests of
-     the touched crates, push, open the PR and merge it with a rebase merge, which keeps `main`
-     linear and every commit bisectable. `main` is protected (CODEOWNERS review, linear history,
+  4. Branch from and rebase onto the latest `origin/develop`, the trunk (never merge `develop` into
+     a branch), rerun the tests of
+     the touched crates, push, open the PR and merge it with a rebase merge, which keeps `develop`
+     linear and every commit bisectable. `develop` and `main` are protected (CODEOWNERS review, linear history,
      rebase merges only); the core team merges as the maintainer with
      `gh pr merge <N> --rebase --admin --delete-branch`, run as its own command. Outside
      contributors' pull requests wait for the maintainer's review (CONTRIBUTING.md). Never squash.
@@ -120,20 +121,21 @@ People trust FieldCraft with their models; a crash loses their work. **This outr
   5. Never run the full gate locally: no `cargo xtask ci`, no `cargo clippy --workspace`, no
      `cargo xtask wasm` or `oracle` unless step 2 calls for it. Never watch CI. GitHub CI runs
      `cargo xtask ci` (fmt, assets, licences, layers, clippy -D warnings, tests, wasm), the
-     oracle, the heavy tests and the advisories once per merge on `main`; the coordinator
+     oracle, the heavy tests and the advisories once per merge on `develop`; the coordinator
      watches it and sends a failure back to the change that caused it, which is fixed forward
      at once.
-- **Keep the main gate fast** (under ~3 minutes on CI). A test that takes more than a few seconds
+- **Keep the trunk gate fast** (under ~3 minutes on CI). A test that takes more than a few seconds
   (convergence studies, the whole corpus, cross-checks between solvers) is
   `#[ignore = "heavy: cargo xtask test --heavy (CI heavy job)"]`, with a fast representative
-  test left in the main gate. The `heavy` CI job runs `cargo xtask test --heavy` (every ignored
-  test, benchmarks included, and the doc tests) on every merge to `main`, nightly and on
+  test left in the trunk gate. The `heavy` CI job runs `cargo xtask test --heavy` (every ignored
+  test, benchmarks included, and the doc tests) on every merge to `develop`, nightly and on
   demand (`gh workflow run CI --ref <branch>`). Hostile-input tests run commands on sessions with small
   work caps (`Session::limits`) so refusals are instant; never lower the production caps for a
   test.
 - **Publishing**: `origin` is github.com/jyviko/fieldcraft. Changes land through pull requests
   as the workflow above describes; the coordinator reads every merged diff and sends findings
-  back as fix-forward work. Never force-push `main`. Never commit `plan/`, `.agent-files/`,
+  back as fix-forward work. Never force-push `develop` or `main`; `main` holds released code and moves only by
+  fast-forward at a release (docs/releasing.md). Never commit `plan/`, `.agent-files/`,
   `worktrees/` or `target*/`; check `git ls-files` before pushing.
 
 ## Running

ATTRIBUTION.md

@@ -14,14 +14,29 @@ is committed and listed here with its exports.
 
 | File | Author | Source | Licence |
 |---|---|---|---|
+| docs/media/claude-mcp.mp4, docs/media/claude-mcp.gif | FieldCraft contributors | Original: a screen recording of Claude Code driving FieldCraft over MCP, edited with ffmpeg (title and end cards from docs/media/og.png) | MIT OR Apache-2.0 |
 | docs/media/ibeam-analysis.mp4, docs/media/ibeam-analysis.gif | FieldCraft contributors | Original: the FieldCraft window captured during an MCP session, generated by `tools/demo-video/make.py` | MIT OR Apache-2.0 |
+| docs/media/og.svg, docs/media/og.png | FieldCraft contributors | Original social-preview image (1280 × 640): the application icon's cube layer (assets/app-icon/FieldCraft.icon/Assets/02-part.svg) beside the name and tagline set in Inter (OFL, crates/ui-egui/fonts) | MIT OR Apache-2.0 |
 | docs/media/bracket-partition.png, docs/media/bracket-hex.png, docs/media/bracket-stress.png, docs/media/setup-symbols.png | FieldCraft contributors | Original: FieldCraft renders (headless MCP screenshots and a window capture) of corpus parts and the cantilever sample | MIT OR Apache-2.0 |
+| docs/media/examples/drop-test.png | FieldCraft contributors | Original: the FieldCraft window captured (`ui.capture`) with the solved drop-test sample (docs/examples.md) | MIT OR Apache-2.0 |
+| docs/media/examples/rubber-seal.png | FieldCraft contributors | Original: the FieldCraft window captured (`ui.capture`) with the solved rubber-seal sample (docs/examples.md) | MIT OR Apache-2.0 |
+| docs/media/examples/heated-bracket.png | FieldCraft contributors | Original: the FieldCraft window captured (`ui.capture`) with the solved heated-bracket sample (docs/examples.md) | MIT OR Apache-2.0 |
+| docs/media/examples/bracket-hex.png | FieldCraft contributors | Original: the FieldCraft window captured (`ui.capture`) with the solved bracket-hex sample (docs/examples.md) | MIT OR Apache-2.0 |
+| docs/media/examples/crank-arm.png | FieldCraft contributors | Original: the FieldCraft window captured (`ui.capture`) with the solved crank-arm sample (docs/examples.md) | MIT OR Apache-2.0 |
+| docs/media/examples/crank-mirror.png | FieldCraft contributors | Original: the FieldCraft window captured (`ui.capture`) with the solved crank-mirror sample (docs/examples.md) | MIT OR Apache-2.0 |
+| crates/ui-egui/thumbnails/bracket-hex.png | FieldCraft contributors | Original: the viewport of docs/media/examples/bracket-hex.png cropped to the model and scaled to 320 px wide (ImageMagick, 128-colour palette), the bracket-hex sample's thumbnail on the Start card | MIT OR Apache-2.0 |
+| crates/ui-egui/thumbnails/crank-arm.png | FieldCraft contributors | Original: the viewport of docs/media/examples/crank-arm.png cropped to the model and scaled to 320 px wide (ImageMagick, 128-colour palette), the crank-arm sample's thumbnail on the Start card | MIT OR Apache-2.0 |
+| crates/ui-egui/thumbnails/crank-mirror.png | FieldCraft contributors | Original: the viewport of docs/media/examples/crank-mirror.png cropped to the model and scaled to 320 px wide (ImageMagick, 128-colour palette), the crank-mirror sample's thumbnail on the Start card | MIT OR Apache-2.0 |
+| crates/ui-egui/thumbnails/drop-test.png | FieldCraft contributors | Original: the viewport of docs/media/examples/drop-test.png cropped to the model and scaled to 320 px wide (ImageMagick, 128-colour palette), the drop-test sample's thumbnail on the Start card | MIT OR Apache-2.0 |
+| crates/ui-egui/thumbnails/heated-bracket.png | FieldCraft contributors | Original: the viewport of docs/media/examples/heated-bracket.png cropped to the model and scaled to 320 px wide (ImageMagick, 128-colour palette), the heated-bracket sample's thumbnail on the Start card | MIT OR Apache-2.0 |
+| crates/ui-egui/thumbnails/rubber-seal.png | FieldCraft contributors | Original: the viewport of docs/media/examples/rubber-seal.png cropped to the model and scaled to 320 px wide (ImageMagick, 128-colour palette), the rubber-seal sample's thumbnail on the Start card | MIT OR Apache-2.0 |
 | crates/decks/tests/golden/nastran/*.bdf | FieldCraft contributors | Written by our Nastran writer from our own test models (crates/decks/tests/nastran.rs) | MIT OR Apache-2.0 |
 | assets/icons/assembly.instance.svg, assets/icons/assembly.instance.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/assembly.instance.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/deck.read.svg, assets/icons/deck.read.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/deck.read.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/deck.write.abaqus.svg, assets/icons/deck.write.abaqus.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/deck.write.abaqus.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/deck.write.lsdyna.svg, assets/icons/deck.write.lsdyna.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/deck.write.lsdyna.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/deck.write.nastran.svg, assets/icons/deck.write.nastran.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/deck.write.nastran.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
+| assets/icons/diagnostics.bug_report.svg, assets/icons/diagnostics.bug_report.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/diagnostics.bug_report.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/edit.redo.svg, assets/icons/edit.redo.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/edit.redo.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/edit.undo.svg, assets/icons/edit.undo.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/edit.undo.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/file.open.svg, assets/icons/file.open.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/file.open.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
@@ -30,6 +45,8 @@ is committed and listed here with its exports.
 | assets/icons/file.save.svg, assets/icons/file.save.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/file.save.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/geometry.bodies.svg, assets/icons/geometry.bodies.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/geometry.bodies.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/geometry.datum.svg, assets/icons/geometry.datum.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/geometry.datum.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
+| assets/icons/geometry.datum.axis.svg, assets/icons/geometry.datum.axis.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/geometry.datum.axis.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
+| assets/icons/geometry.datum.point.svg, assets/icons/geometry.datum.point.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/geometry.datum.point.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/geometry.import.mesh.svg, assets/icons/geometry.import.mesh.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/geometry.import.mesh.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/geometry.midsurface.svg, assets/icons/geometry.midsurface.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/geometry.midsurface.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/geometry.open.svg, assets/icons/geometry.open.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/geometry.open.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
@@ -49,11 +66,10 @@ is committed and listed here with its exports.
 | assets/icons/mesh.element.add.svg, assets/icons/mesh.element.add.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.element.add.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.hex.decompose.svg, assets/icons/mesh.hex.decompose.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.hex.decompose.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.hex.dominant.svg, assets/icons/mesh.hex.dominant.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.hex.dominant.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
-| assets/icons/mesh.hex.blocks.svg, assets/icons/mesh.hex.blocks.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.hex.blocks.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
-| assets/icons/mesh.hex.mapped.svg, assets/icons/mesh.hex.mapped.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.hex.mapped.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
+| assets/icons/mesh.cells.svg, assets/icons/mesh.cells.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.cells.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
+| assets/icons/mesh.hex.generate.svg, assets/icons/mesh.hex.generate.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.hex.generate.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.hex.octree.svg, assets/icons/mesh.hex.octree.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.hex.octree.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.hex.polycube.svg, assets/icons/mesh.hex.polycube.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.hex.polycube.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
-| assets/icons/mesh.hex.sweep.svg, assets/icons/mesh.hex.sweep.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.hex.sweep.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.import.orphan.svg, assets/icons/mesh.import.orphan.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.import.orphan.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.layers.svg, assets/icons/mesh.layers.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.layers.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.node.add.svg, assets/icons/mesh.node.add.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.node.add.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
@@ -64,7 +80,7 @@ is committed and listed here with its exports.
 | assets/icons/mesh.region.remesh.svg, assets/icons/mesh.region.remesh.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.region.remesh.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.size.adapt.svg, assets/icons/mesh.size.adapt.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.size.adapt.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.size.global.svg, assets/icons/mesh.size.global.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.size.global.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
-| assets/icons/mesh.size.seed.svg, assets/icons/mesh.size.seed.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.size.seed.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
+| assets/icons/mesh.seed.edge.svg, assets/icons/mesh.seed.edge.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.seed.edge.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.smooth.svg, assets/icons/mesh.smooth.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.smooth.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.surface.check.svg, assets/icons/mesh.surface.check.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.surface.check.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/mesh.tag.svg, assets/icons/mesh.tag.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/mesh.tag.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
@@ -134,12 +150,12 @@ is committed and listed here with its exports.
 | assets/icons/ui.sun.svg, assets/icons/ui.sun.vectorcraft | FieldCraft contributors | Original interface icon (navigation bar, title bar, browser) drawn with VectorCraft from `assets/icons/src/ui.sun.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/ui.views.svg, assets/icons/ui.views.vectorcraft | FieldCraft contributors | Original interface icon (navigation bar, title bar, browser) drawn with VectorCraft from `assets/icons/src/ui.views.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
 | assets/icons/ui.zoom.svg, assets/icons/ui.zoom.vectorcraft | FieldCraft contributors | Original interface icon (navigation bar, title bar, browser) drawn with VectorCraft from `assets/icons/src/ui.zoom.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
-| assets/app-icon/icon.vectorcraft, assets/app-icon/icon.svg, assets/app-icon/icon.png | FieldCraft contributors | Original application icon (an L bracket with a bolt hole under a structured hexahedral mesh, on a rounded-square backdrop), drawn with VectorCraft by `cargo xtask app-icon` (xtask/src/app_icon.rs); editable source, SVG and 1024 × 1024 PNG export | MIT OR Apache-2.0 |
-| assets/app-icon/icon-small.vectorcraft, assets/app-icon/icon-small.svg, assets/app-icon/icon-small.png | FieldCraft contributors | Original simplified application icon for 16–32 px (no mesh or floor grid), drawn with VectorCraft by `cargo xtask app-icon` (xtask/src/app_icon.rs) | MIT OR Apache-2.0 |
+| assets/icons/view.show_all.svg, assets/icons/view.show_all.vectorcraft | FieldCraft contributors | Original toolbar icon drawn with VectorCraft from `assets/icons/src/view.show_all.json` (`cargo xtask icons`) | MIT OR Apache-2.0 |
+| assets/app-icon/icon.vectorcraft, assets/app-icon/icon.svg, assets/app-icon/icon.png | FieldCraft contributors | Original application icon (a hexahedral-meshed cube with a banded colour fringe on its faces on a rounded-square backdrop), drawn with VectorCraft by `cargo xtask app-icon` (xtask/src/app_icon.rs); editable source, SVG and 1024 × 1024 PNG export | MIT OR Apache-2.0 |
+| assets/app-icon/icon-small.vectorcraft, assets/app-icon/icon-small.svg, assets/app-icon/icon-small.png | FieldCraft contributors | Original simplified application icon for 16–32 px (the fringe cube alone; no mesh or floor grid), drawn with VectorCraft by `cargo xtask app-icon` (xtask/src/app_icon.rs) | MIT OR Apache-2.0 |
 | assets/app-icon/layers/01-floor.vectorcraft, assets/app-icon/FieldCraft.icon/Assets/01-floor.svg | FieldCraft contributors | Original isometric floor grid with a radial fade (Default appearance), drawn with VectorCraft by `cargo xtask app-icon` (xtask/src/app_icon.rs) | MIT OR Apache-2.0 |
 | assets/app-icon/layers/01-floor-dark.vectorcraft, assets/app-icon/FieldCraft.icon/Assets/01-floor-dark.svg | FieldCraft contributors | Original isometric floor grid with a radial fade (Dark appearance), drawn with VectorCraft by `cargo xtask app-icon` (xtask/src/app_icon.rs) | MIT OR Apache-2.0 |
-| assets/app-icon/layers/02-part.vectorcraft, assets/app-icon/FieldCraft.icon/Assets/02-part.svg | FieldCraft contributors | Original bracket faces with transparent gaps at the shared edges, drawn with VectorCraft by `cargo xtask app-icon` (xtask/src/app_icon.rs) | MIT OR Apache-2.0 |
-| assets/app-icon/layers/03-mesh.vectorcraft, assets/app-icon/FieldCraft.icon/Assets/03-mesh.svg | FieldCraft contributors | Original hexahedral mesh lines (O-grid around the hole) clipped to the bracket's faces, drawn with VectorCraft by `cargo xtask app-icon` (xtask/src/app_icon.rs) | MIT OR Apache-2.0 |
+| assets/app-icon/layers/02-part.vectorcraft, assets/app-icon/FieldCraft.icon/Assets/02-part.svg | FieldCraft contributors | Original cube faces with a banded colour fringe and transparent gaps at the shared edges, and the hexahedral mesh lines clipped to them, drawn with VectorCraft by `cargo xtask app-icon` (xtask/src/app_icon.rs) | MIT OR Apache-2.0 |
 | assets/app-icon/FieldCraft.icon/icon.json | FieldCraft contributors | Icon Composer composition of the layers above (Default and Dark floor grid), written by `cargo xtask app-icon` (xtask/src/app_icon.rs) | MIT OR Apache-2.0 |
 | assets/app-icon/Assets.car | FieldCraft contributors | Apple actool compilation of assets/app-icon/FieldCraft.icon; contains original artwork only | MIT OR Apache-2.0 |
 | assets/app-icon/icon.icns | FieldCraft contributors | iconutil compilation of assets/app-icon/icon.iconset | MIT OR Apache-2.0 |
@@ -167,15 +183,24 @@ is committed and listed here with its exports.
 | crates/geometry/src/tagged_mesh.rs (package and part reading, transforms, units, caps) | SolidCraft `crates/io/src/threemf.rs` | MIT OR Apache-2.0 |
 | crates/render/src/camera.rs, crates/render/src/raster.rs | SolidCraft `crates/render/src/camera.rs`, `raster.rs` | MIT OR Apache-2.0 |
 | crates/ui-egui/src/gpu.rs, crates/ui-egui/src/theme.rs (tokens and their values), crates/ui-egui/src/control.rs, crates/ui-egui/src/lib.rs (input injection, screenshots), crates/ui-egui/src/toolbar.rs (workspace switcher, tabs, panels with drop-downs, fitting), crates/ui-egui/src/appbar.rs (application bar; the mark is drawn from assets/app-icon/icon-small.svg's coordinates), crates/ui-egui/src/titlebar.rs (caption buttons, drag and resize zones; SolidCraft took it from VectorCraft), crates/ui-egui/src/frame.rs (windows, heading bands), crates/ui-egui/src/browser.rs (row drawing), crates/ui-egui/src/palette.rs (command line and search), crates/ui-egui/src/timeline.rs (timeline strip, transport), crates/ui-egui/src/viewport.rs (navigation bar, orientation gizmo), crates/ui-egui/src/files.rs (background opening, file pickers as host services) | SolidCraft `crates/ui-egui/src/` (titlebar.rs also VectorCraft `crates/ui-egui/src/titlebar.rs`) | MIT OR Apache-2.0 |
+| crates/ui-egui/src/navigation.rs (navigation presets and bindings), crates/ui-egui/src/viewport.rs (orbit about the point under the cursor, or the drawn centre from empty space; Ctrl + left drag orbits) | SolidCraft `crates/ui-egui/src/prefs.rs` (`NavPreset`, `NavBinding`, `NAV_PRESETS`, `orbit`) | MIT OR Apache-2.0 |
+| crates/ui-egui/src/fields.rs (form rows: a label column of fixed width, then the field) | SolidCraft `crates/ui-egui/src/dialogs.rs` | MIT OR Apache-2.0 |
 | crates/io/src/fs.rs (atomic writes) | SolidCraft `crates/io/src/safe_write.rs` | MIT OR Apache-2.0 |
 | crates/io/src/recovery.rs (recovery folder, entries, locks) | SolidCraft `crates/engine/src/recovery.rs` | MIT OR Apache-2.0 |
+| crates/engine/src/crash.rs, crates/engine/src/crash_tests.rs (crash reports: panic hook, locked command journal, unclean-exit detection, report folders and limits, replay), apps/fieldcraft-cli/src/crashes.rs, docs/crash-reports.md (structure) | SolidCraft `crates/engine/src/crash.rs`, `crash_tests.rs`, `apps/solidcraft-cli/src/crashes.rs`, `docs/crash-reports.md` | MIT OR Apache-2.0 |
 | apps/fieldcraft/src/control_server.rs | SolidCraft `apps/solidcraft/src/control_server.rs` | MIT OR Apache-2.0 |
 | crates/mcp/src/ (JSON-RPC framing, MCP lifecycle, tool schema checks, the control-channel backend, base64) | SolidCraft `crates/mcp/src/` | MIT OR Apache-2.0 |
 | crates/io/src/roots.rs (the rules of read and write roots) | VectorCraft's automation roots (docs/mcp.md there) | MIT OR Apache-2.0 |
-| packaging/env.sh, packaging/macos/package.sh, packaging/macos/Info.plist.in, packaging/linux/package.sh, packaging/linux/AppRun, packaging/windows/package.ps1 | SolidCraft `packaging/` and VectorCraft `packaging/` (signing and notarization in macos/package.sh) | MIT OR Apache-2.0 |
+| packaging/env.sh, packaging/.shellcheckrc, packaging/macos/package.sh, packaging/macos/Info.plist.in, packaging/linux/package.sh, packaging/linux/AppRun, packaging/windows/package.ps1 | SolidCraft `packaging/` and VectorCraft `packaging/` (signing and notarization in macos/package.sh) | MIT OR Apache-2.0 |
+| apps/fieldcraft/Cargo.toml (the run-time dependency lists of `[package.metadata.deb]` and `[package.metadata.generate-rpm]`) | SolidCraft `packaging/linux/nfpm.yaml` | MIT OR Apache-2.0 |
 | packaging/macos/import-cert.sh | VectorCraft `packaging/macos/import-cert.sh` | MIT OR Apache-2.0 |
 | packaging/windows/check-exe.ps1 | SolidCraft `packaging/windows/check-icon.ps1` | MIT OR Apache-2.0 |
+| apps/fieldcraft-web/ (the web runner, browser file services and downloads, Trunk configuration, index.html) | VectorCraft `apps/vectorcraft-web/` and SolidCraft `apps/solidcraft-web/` | MIT OR Apache-2.0 |
+| crates/io/src/memory.rs (files kept in memory for the browser build) | SolidCraft `crates/io/src/vfs.rs` | MIT OR Apache-2.0 |
+| .github/workflows/pages.yml | SolidCraft `.github/workflows/pages.yml` | MIT OR Apache-2.0 |
 | .github/workflows/release.yml, .github/release-notes.md, docs/releasing.md | SolidCraft `.github/workflows/release.yml`, `.github/release-notes.md`, `docs/releasing.md`; VectorCraft `.github/workflows/release.yml` | MIT OR Apache-2.0 |
+| .github/workflows/packaging-lint.yml | SolidCraft `.github/workflows/packaging-lint.yml` (itself adapted from PhotoCraft, https://github.com/storytold/photocraft, Apache-2.0) | MIT OR Apache-2.0 |
+| .github/workflows/arch-check.yml (the riscv64 cross build) | SolidCraft `.github/workflows/ci.yml` (`riscv64-gates`) | MIT OR Apache-2.0 |
 
 ## Test oracles
 

CONTRIBUTING.md

@@ -1,7 +1,59 @@
-# Contributing
+# Contributing to FieldCraft
 
-Thanks for helping. Read [AGENTS.md](AGENTS.md) first: it holds the rules every change follows,
-whether a person or an agent writes it.
+FieldCraft is one open-source modeler for structures, heat and fluids, written in pure Rust: open a
+parametric SolidCraft part, mesh it (tet or all-hex), define the analysis, solve it with our own
+implicit, explicit, thermal or lattice Boltzmann solvers, and look at verified results — from the
+desktop app, the command line, or an AI agent over MCP.
+
+Help is welcome, whether that's a one-line fix, a verification benchmark, a file format or owning a
+whole solver. This page covers how to build it, the few rules that aren't negotiable, where help is
+needed most, and how to claim work. The rules every change follows, by a person or an agent, are in
+[AGENTS.md](AGENTS.md).
+
+## Get it running (about 10 minutes on a fast machine)
+
+You need stable Rust 1.95 or newer.
+
+```sh
+git clone https://github.com/jyviko/fieldcraft && cd fieldcraft
+cargo run --release -p fieldcraft -- --sample cantilever   # the desktop app on a sample model
+cargo run -p fieldcraft-cli -- commands                    # every command and its parameters
+cargo test -p fieldcraft-solver                            # the tests of one crate
+cargo xtask oracle --quick                                 # the verification cases (docs/oracle.md)
+```
+
+`develop` is the trunk and `main` holds released code. The layers and crates are in
+[docs/architecture.md](docs/architecture.md); every user-visible capability is a command in
+`crates/engine/src/cmd/` ([docs/features.md](docs/features.md) lists them).
+
+## Where help is wanted most
+
+See the [`help wanted`](https://github.com/jyviko/fieldcraft/labels/help%20wanted) and
+[`good first issue`](https://github.com/jyviko/fieldcraft/labels/good%20first%20issue) labels, and
+the `area:` labels for your field. In order of how much they would help users:
+
+1. **Reproducible meshes** ([#115](https://github.com/jyviko/fieldcraft/issues/115)). The same part
+   must give the same tet mesh on every platform and every run, as the solvers already do.
+2. **All-hex meshing of thin and curved parts** ([#85](https://github.com/jyviko/fieldcraft/issues/85)).
+   The octree mesher over-refines thin walls; concave transition templates and an up-front depth
+   are next. Hex meshing is the centre of gravity of the project.
+3. **Getting results in and out**: ParaView export ([#90](https://github.com/jyviko/fieldcraft/issues/90)),
+   Gmsh import ([#91](https://github.com/jyviko/fieldcraft/issues/91)), Abaqus deck reading
+   ([#98](https://github.com/jyviko/fieldcraft/issues/98)), CSV and STL
+   ([#92](https://github.com/jyviko/fieldcraft/issues/92), [#93](https://github.com/jyviko/fieldcraft/issues/93)).
+4. **Verification benchmarks** ([#97](https://github.com/jyviko/fieldcraft/issues/97),
+   [#106](https://github.com/jyviko/fieldcraft/issues/106)). An engineer with a published benchmark
+   can add it as an oracle case without touching solver code.
+5. **Nonlinear elements and materials**: incompatible modes at finite strain
+   ([#82](https://github.com/jyviko/fieldcraft/issues/82)), kinematic hardening
+   ([#81](https://github.com/jyviko/fieldcraft/issues/81)), and the material library
+   ([#99](https://github.com/jyviko/fieldcraft/issues/99)).
+6. **The app**: typed command forms ([#112](https://github.com/jyviko/fieldcraft/issues/112)), XY and
+   path plots ([#94](https://github.com/jyviko/fieldcraft/issues/94), [#95](https://github.com/jyviko/fieldcraft/issues/95)).
+
+Bigger areas on the [roadmap](ROADMAP.md) — contact, dynamics, composites, coupled fields, wave
+propagation, turbulence — are open to anyone who wants to own one: start a thread in
+[Discussions](https://github.com/jyviko/fieldcraft/discussions).
 
 ## Before you start: claim an issue
 
@@ -18,7 +70,8 @@ Issues labelled **in progress** are being worked on by the core team; please don
 
 ## Making the change
 
-1. Branch from `main`, keep a pull request to one topic.
+1. Branch from `develop` (the trunk; `main` holds released code only) and open the pull request
+   against `develop`. Keep it to one topic.
 2. Before pushing: `cargo fmt --all`, and `cargo clippy -p <crate> --all-targets -- -D warnings`
    and `cargo test -p <crate>` for the crates you touched. CI runs the full gate on your pull
    request once the maintainer approves the run.
@@ -30,6 +83,7 @@ Issues labelled **in progress** are being worked on by the core team; please don
 
 By contributing you agree your work is licensed under MIT OR Apache-2.0.
 
-`main` is protected: changes land only through pull requests that the maintainer has reviewed,
+`develop` and `main` are protected: changes land on `develop` only through pull requests that the
+maintainer has reviewed,
 as rebase merges (keep each commit building and passing its tests). Be kind: see the
 [code of conduct](CODE_OF_CONDUCT.md).

Cargo.lock

@@ -425,6 +425,18 @@ version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "base64"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
+
 [[package]]
 name = "bit-set"
 version = "0.10.0"
@@ -461,6 +473,15 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "block-buffer"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
+dependencies = [
+ "hybrid-array",
+]
+
 [[package]]
 name = "block2"
 version = "0.5.1"
@@ -646,6 +667,16 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common 0.1.7",
+ "inout",
+]
+
 [[package]]
 name = "clipboard-win"
 version = "5.4.1"
@@ -694,6 +725,12 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
 [[package]]
 name = "convert_case"
 version = "0.4.0"
@@ -710,6 +747,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -723,7 +770,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"
 dependencies = [
  "bitflags 1.3.2",
- "core-foundation",
+ "core-foundation 0.9.4",
  "core-graphics-types",
  "foreign-types",
  "libc",
@@ -736,7 +783,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
 dependencies = [
  "bitflags 1.3.2",
- "core-foundation",
+ "core-foundation 0.9.4",
  "libc",
 ]
 
@@ -749,6 +796,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "cpufeatures"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "craft-ui"
 version = "0.1.0"
@@ -807,6 +863,21 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "crypto-common"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "ct-codecs"
+version = "1.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd9f3db6f2cfef61c10613071955154ffdc9e515daebff26de4b54e35038fdd"
+
 [[package]]
 name = "cursor-icon"
 version = "1.2.0"
@@ -849,8 +920,20 @@ version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
- "block-buffer",
- "crypto-common",
+ "block-buffer 0.10.4",
+ "crypto-common 0.1.7",
+ "subtle",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer 0.12.1",
+ "const-oid",
+ "crypto-common 0.2.2",
 ]
 
 [[package]]
@@ -969,7 +1052,7 @@ dependencies = [
 [[package]]
 name = "egui-wgpu"
 version = "0.36.2"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "ahash",
  "bytemuck",
@@ -1187,7 +1270,7 @@ checksum = "b97b65636e5b9ef369943878ac74335ba1c55c1cb6adbf1e2c293c624248d693"
 
 [[package]]
 name = "fieldcraft"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "eframe",
  "egui",
@@ -1195,24 +1278,29 @@ dependencies = [
  "fieldcraft-engine",
  "fieldcraft-io",
  "fieldcraft-ui-egui",
+ "fieldcraft-update",
+ "getrandom 0.3.4",
  "log",
  "rfd",
+ "rustls",
  "serde_json",
+ "ureq",
 ]
 
 [[package]]
 name = "fieldcraft-cli"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-engine",
  "fieldcraft-io",
  "fieldcraft-mcp",
+ "fieldcraft-update",
  "serde_json",
 ]
 
 [[package]]
 name = "fieldcraft-decks"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-model",
  "serde_json",
@@ -1221,7 +1309,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-engine"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-decks",
  "fieldcraft-explicit",
@@ -1234,7 +1322,9 @@ dependencies = [
  "fieldcraft-parallel",
  "fieldcraft-render",
  "fieldcraft-solver",
+ "fieldcraft-update",
  "log",
+ "png",
  "serde",
  "serde_json",
  "thiserror 2.0.21",
@@ -1243,7 +1333,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-explicit"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-fem",
  "fieldcraft-model",
@@ -1254,7 +1344,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-fem"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-model",
  "thiserror 2.0.21",
@@ -1262,7 +1352,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-geometry"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-model",
  "quick-xml",
@@ -1278,20 +1368,20 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-io"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-model",
  "log",
  "serde",
  "serde_json",
- "sha2",
+ "sha2 0.11.1",
  "thiserror 2.0.21",
  "zip",
 ]
 
 [[package]]
 name = "fieldcraft-lbm"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-mesh",
  "fieldcraft-model",
@@ -1301,7 +1391,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-mcp"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-engine",
  "fieldcraft-io",
@@ -1312,7 +1402,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-mesh"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-model",
  "num-bigint",
@@ -1324,7 +1414,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-model"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "serde",
  "serde_json",
@@ -1333,14 +1423,14 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-parallel"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "rayon",
 ]
 
 [[package]]
 name = "fieldcraft-render"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-model",
  "png",
@@ -1350,7 +1440,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-solver"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-fem",
  "fieldcraft-mesh",
@@ -1362,7 +1452,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-testkit"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "fieldcraft-engine",
  "fieldcraft-geometry",
@@ -1373,7 +1463,7 @@ dependencies = [
 
 [[package]]
 name = "fieldcraft-ui-egui"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "craft-ui",
  "egui",
@@ -1384,12 +1474,60 @@ dependencies = [
  "fieldcraft-geometry",
  "fieldcraft-model",
  "fieldcraft-render",
+ "fieldcraft-update",
  "log",
+ "png",
  "resvg",
  "serde",
  "serde_json",
 ]
 
+[[package]]
+name = "fieldcraft-update"
+version = "0.5.9"
+dependencies = [
+ "flate2",
+ "log",
+ "minisign",
+ "minisign-verify",
+ "rustls",
+ "serde_json",
+ "sha2 0.11.1",
+ "tar",
+ "thiserror 2.0.21",
+ "ureq",
+ "zip",
+]
+
+[[package]]
+name = "fieldcraft-web"
+version = "0.5.9"
+dependencies = [
+ "base64 0.22.1",
+ "eframe",
+ "egui",
+ "fieldcraft-engine",
+ "fieldcraft-io",
+ "fieldcraft-ui-egui",
+ "js-sys",
+ "log",
+ "rfd",
+ "serde_json",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
+dependencies = [
+ "cfg-if",
+ "libc",
+]
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.14"
@@ -1562,8 +1700,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "r-efi 6.0.0",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -1750,6 +1890,40 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "http"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27f864f10dfb56725ce5ce5472bc52252c8f93a4ab86327122cebf62c5f59a17"
+dependencies = [
+ "typenum",
+]
+
 [[package]]
 name = "iana-time-zone"
 version = "0.1.65"
@@ -1786,6 +1960,8 @@ dependencies = [
  "num-traits",
  "png",
  "tiff",
+ "zune-core",
+ "zune-jpeg",
 ]
 
 [[package]]
@@ -1804,6 +1980,15 @@ dependencies = [
  "hashbrown 0.17.1",
 ]
 
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -2023,7 +2208,7 @@ checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
 [[package]]
 name = "matext4cgmath"
 version = "0.1.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "cgmath",
  "katexit",
@@ -2054,6 +2239,24 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "minisign"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aefd422a7a8b5efced01cd7cdf3771e62ebecbc90e3d27695002d3af6af94586"
+dependencies = [
+ "ct-codecs",
+ "getrandom 0.4.3",
+ "rpassword",
+ "scrypt",
+]
+
+[[package]]
+name = "minisign-verify"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "871285dc19d8d0ebe0eef3d0e99a205f2a71363b122632cbbfa4a6c370a960ce"
+
 [[package]]
 name = "miniz_oxide"
 version = "0.8.9"
@@ -2546,6 +2749,12 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
 [[package]]
 name = "orbclient"
 version = "0.3.55"
@@ -2604,6 +2813,16 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest 0.10.7",
+ "hmac",
+]
+
 [[package]]
 name = "peniko"
 version = "0.6.1"
@@ -3067,6 +3286,20 @@ dependencies = [
  "bytemuck",
 ]
 
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "robust"
 version = "1.2.0"
@@ -3082,6 +3315,27 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "rpassword"
+version = "7.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2da316a15f47e3d053de9cb2c439650bd8fa4aaeb9365f2e5f27f492ff73c196"
+dependencies = [
+ "libc",
+ "rtoolbox",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rtoolbox"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a1efe12a1469752d0e6ff5ebec0b6ef4924cc5c4c71046b0ec730040535819d"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
@@ -3129,12 +3383,95 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "rustls"
+version = "0.23.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf"
+dependencies = [
+ "log",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a073f5dc7469f984c52ad2752b63b0807745133b6de880b7b64c1ac4c48aec4"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1167586491e2b18b8bfbb293e8180ec17c201c4f076d7cb3070ca964e7598f98"
+dependencies = [
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki",
+ "security-framework",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eec689c0bc40ff2458a5977b6619cb718087084a18e02a131c599b62d05e1a5f"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
 
+[[package]]
+name = "salsa20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -3144,6 +3481,15 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "schannel"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "scoped-tls"
 version = "1.0.1"
@@ -3156,6 +3502,40 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "scrypt"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+dependencies = [
+ "pbkdf2",
+ "salsa20",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.13.2",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "self_cell"
 version = "1.3.0"
@@ -3238,8 +3618,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
  "cfg-if",
- "cpufeatures",
- "digest",
+ "cpufeatures 0.2.17",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha2"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d7069beb7d6ac7b9acd1039986e73443f24234f41074da099d6f994ac9ad19"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.1",
+ "digest 0.11.3",
 ]
 
 [[package]]
@@ -3400,15 +3791,16 @@ dependencies = [
 
 [[package]]
 name = "solidcraft-doc"
-version = "0.8.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+version = "0.11.0"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "log",
  "serde",
  "serde_json",
- "sha2",
+ "sha2 0.10.9",
  "solidcraft-geom",
  "solidcraft-kernel",
+ "solidcraft-render",
  "solidcraft-sketch",
  "thiserror 2.0.21",
  "web-time",
@@ -3416,8 +3808,8 @@ dependencies = [
 
 [[package]]
 name = "solidcraft-engine"
-version = "0.8.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+version = "0.11.0"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "log",
  "serde",
@@ -3433,8 +3825,8 @@ dependencies = [
 
 [[package]]
 name = "solidcraft-geom"
-version = "0.8.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+version = "0.11.0"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "serde",
  "thiserror 2.0.21",
@@ -3442,13 +3834,13 @@ dependencies = [
 
 [[package]]
 name = "solidcraft-io"
-version = "0.8.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+version = "0.11.0"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "quick-xml",
  "serde",
  "serde_json",
- "sha2",
+ "sha2 0.10.9",
  "solidcraft-doc",
  "solidcraft-geom",
  "solidcraft-kernel",
@@ -3458,13 +3850,15 @@ dependencies = [
 
 [[package]]
 name = "solidcraft-kernel"
-version = "0.8.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+version = "0.11.0"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "log",
+ "rayon",
  "serde",
  "serde_json",
  "solidcraft-geom",
+ "spade",
  "thiserror 2.0.21",
  "truck-meshalgo",
  "truck-modeling",
@@ -3475,8 +3869,8 @@ dependencies = [
 
 [[package]]
 name = "solidcraft-render"
-version = "0.8.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+version = "0.11.0"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "image",
  "serde",
@@ -3485,8 +3879,8 @@ dependencies = [
 
 [[package]]
 name = "solidcraft-sketch"
-version = "0.8.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+version = "0.11.0"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "serde",
  "solidcraft-geom",
@@ -3530,6 +3924,12 @@ dependencies = [
  "float-cmp",
 ]
 
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
 [[package]]
 name = "svgtypes"
 version = "0.16.1"
@@ -3572,6 +3972,16 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "tar"
+version = "0.4.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
+dependencies = [
+ "filetime",
+ "libc",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.27.0"
@@ -3818,7 +4228,7 @@ dependencies = [
 [[package]]
 name = "truck-meshalgo"
 version = "0.4.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "array-macro",
  "derive_more",
@@ -3868,7 +4278,7 @@ dependencies = [
 [[package]]
 name = "truck-shapeops"
 version = "0.4.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "derive_more",
  "itertools 0.13.0",
@@ -3883,7 +4293,7 @@ dependencies = [
 [[package]]
 name = "truck-stepio"
 version = "0.3.0"
-source = "git+https://github.com/bherbruck/solidcraft?rev=de1479029dd6821cffd28b70688a58e7f61f0cfd#de1479029dd6821cffd28b70688a58e7f61f0cfd"
+source = "git+https://github.com/bherbruck/solidcraft?rev=a629236650c44ee73edf36fab0dcd2385103a610#a629236650c44ee73edf36fab0dcd2385103a610"
 dependencies = [
  "chrono",
  "truck-geometry",
@@ -3964,6 +4374,40 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
 
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "ureq"
+version = "3.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a7ac20be9b7726e0bbdbf974c059676d9acb1cd414961f570a4e8231cacd7fc"
+dependencies = [
+ "base64 0.23.1",
+ "log",
+ "percent-encoding",
+ "rustls",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
+ "ureq-proto",
+ "utf8-zero",
+]
+
+[[package]]
+name = "ureq-proto"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f86fd172ccca569e458f61b6bdd6220965a9ef36e672a6852953b51a0e1583be"
+dependencies = [
+ "base64 0.23.1",
+ "http",
+ "httparse",
+ "log",
+]
+
 [[package]]
 name = "usvg"
 version = "0.48.1"
@@ -3983,6 +4427,12 @@ dependencies = [
  "tiny-skia-path",
 ]
 
+[[package]]
+name = "utf8-zero"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e"
+
 [[package]]
 name = "uuid"
 version = "1.28.0"
@@ -4283,6 +4733,15 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "weezl"
 version = "0.1.12"
@@ -4771,7 +5230,7 @@ dependencies = [
  "calloop 0.13.0",
  "cfg_aliases",
  "concurrent-queue",
- "core-foundation",
+ "core-foundation 0.9.4",
  "core-graphics",
  "cursor-icon",
  "dpi",
@@ -4897,7 +5356,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
 
 [[package]]
 name = "xtask"
-version = "0.1.0"
+version = "0.5.9"
 dependencies = [
  "serde_json",
 ]
@@ -5028,6 +5487,12 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "zeroize"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879"
+
 [[package]]
 name = "zip"
 version = "3.0.0"

Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/*", "apps/*", "xtask"]
 
 [workspace.package]
-version = "0.1.0"
+version = "0.5.9"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"
@@ -27,6 +27,7 @@ fieldcraft-testkit = { path = "crates/testkit" }
 fieldcraft-render = { path = "crates/render" }
 fieldcraft-ui-egui = { path = "crates/ui-egui" }
 fieldcraft-mcp = { path = "crates/mcp" }
+fieldcraft-update = { path = "crates/update" }
 
 # foundation
 thiserror = "2"
@@ -39,7 +40,7 @@ zip = { version = "3", default-features = false, features = ["deflate"] }
 quick-xml = "0.41"
 
 # content hashes and part checksums of .fieldcraft files (the version SolidCraft uses)
-sha2 = "0.10"
+sha2 = "0.11"
 
 # images (PNG snapshots and screenshots)
 png = "0.18"
@@ -58,13 +59,13 @@ rfd = "0.17"
 
 # Geometry: SolidCraft's B-rep kernel (MIT OR Apache-2.0), pinned. Only crates/geometry uses it
 # (plan/adr/0001-libraries.md).
-solidcraft-geom = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
-solidcraft-kernel = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
-solidcraft-doc = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
-solidcraft-io = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
+solidcraft-geom = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }
+solidcraft-kernel = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }
+solidcraft-doc = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }
+solidcraft-io = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }
 # Runs SolidCraft command scripts (the test corpus recipes); only behind fieldcraft-geometry's
 # `scripts` feature.
-solidcraft-engine = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
+solidcraft-engine = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }
 
 [workspace.lints.rust]
 unsafe_code = "forbid"
@@ -128,10 +129,10 @@ debug = "line-tables-only"
 # reach a dependent workspace, so FieldCraft applies the same ones from the same pinned commit;
 # keep this list and the rev in step with SolidCraft's [patch.crates-io].
 [patch.crates-io]
-truck-shapeops = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
-truck-stepio = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
-truck-meshalgo = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
-matext4cgmath = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
+truck-shapeops = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }
+truck-stepio = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }
+truck-meshalgo = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }
+matext4cgmath = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }
 # egui-wgpu with SolidCraft's fixes (vendor/egui-wgpu there): MSAA clamped to what the device
 # supports and 1x on OpenGL adapters, so the requested 4x never fails pipeline validation at start.
-egui-wgpu = { git = "https://github.com/bherbruck/solidcraft", rev = "de1479029dd6821cffd28b70688a58e7f61f0cfd" }
+egui-wgpu = { git = "https://github.com/bherbruck/solidcraft", rev = "a629236650c44ee73edf36fab0dcd2385103a610" }

README.md

@@ -14,6 +14,10 @@ the wider material and multiphysics library. See [ROADMAP.md](ROADMAP.md).
 [help wanted](https://github.com/jyviko/fieldcraft/labels/help%20wanted) and read
 [CONTRIBUTING.md](CONTRIBUTING.md).
 
+![Claude analyses an I-beam cantilever in FieldCraft over MCP: it opens the part, hex meshes it, sets steel, the clamp and a 1 kN tip load, solves, shows von Mises stress and the deformed shape, and checks the tip deflection against beam theory](docs/media/claude-mcp.gif)
+
+*Claude driving FieldCraft through its [MCP server](docs/mcp.md): one prompt, and it opens the part, meshes it, defines and solves the analysis, then checks the tip deflection against beam theory. Real session, waits shortened. [Full video](docs/media/claude-mcp.mp4).*
+
 ![An AI agent analyses an I-beam cantilever in FieldCraft over MCP: open, hex mesh, steel, clamp and tip load, solve, von Mises contours, the deformed shape and an orbit round it](docs/media/ibeam-analysis.gif)
 
 An AI agent drives FieldCraft over [MCP](docs/mcp.md), each stage captioned with the tool it
@@ -22,6 +26,23 @@ solves, and shows the von Mises stress and the deformed shape (tip deflection 0.
 theory with shear 0.177 mm).
 [MP4](docs/media/ibeam-analysis.mp4) · regenerated by [tools/demo-video](tools/demo-video/README.md).
 
+## Download
+
+[![Download for macOS](https://img.shields.io/badge/macOS-Download-000000?style=for-the-badge&logo=apple&logoColor=white)](https://github.com/jyviko/fieldcraft/releases/latest)
+[![Download for Windows](https://img.shields.io/badge/Windows-Download-0078D6?style=for-the-badge)](https://github.com/jyviko/fieldcraft/releases/latest)
+[![Download for Linux](https://img.shields.io/badge/Linux-Download-FCC624?style=for-the-badge&logo=linux&logoColor=black)](https://github.com/jyviko/fieldcraft/releases/latest)
+[![Try it in your browser](https://img.shields.io/badge/Browser-Try%20it-2ea44f?style=for-the-badge&logo=webassembly&logoColor=white)](https://jyviko.github.io/fieldcraft/)
+
+- **macOS:** open the `.dmg` and drag FieldCraft into Applications (Apple silicon and Intel).
+- **Windows:** unzip and run `fieldcraft.exe`.
+- **Linux:** the `.AppImage` (allow it to run as a program), or the `.tar.gz`.
+- **Browser:** [try it at jyviko.github.io/fieldcraft](https://jyviko.github.io/fieldcraft/), no install.
+- **Command line:** `fieldcraft-cli` ships in every package; AI agents connect to it over MCP
+  ([docs/mcp.md](docs/mcp.md)).
+
+Every release lists its checksums in `SHA256SUMS.txt`. Building from source is in
+[CONTRIBUTING.md](CONTRIBUTING.md#get-it-running-about-10-minutes-on-a-fast-machine).
+
 ## Hex meshing a part that does not sweep
 
 A filleted L-bracket with a hole through each leg cannot be swept in one piece. Split into 30
@@ -71,6 +92,25 @@ The same part also meshes all-hex automatically with the octree mesher (`mesh.he
 
 ![The FieldCraft window: a clamped cantilever with its supports, pressure, gravity and a coupled reference point drawn in the viewport](docs/media/setup-symbols.png)
 
+## Examples
+
+Ready-to-solve samples: open one from **File ▸ Samples** (or the start screen), or start the app
+with `fieldcraft --sample NAME`, and press **Solve**. Each opens and solves within half a minute and is checked
+against a closed form or a reference solution ([docs/examples.md](docs/examples.md)).
+
+<table>
+<tr>
+<td width="33%" valign="top"><img src="docs/media/examples/drop-test.png" alt="Drop test" width="100%"><br><b>Drop test</b> (<code>drop-test</code>): an aluminium bracket dropped 2 m onto a tilted floor; explicit dynamics, the strike's stress waves</td>
+<td width="33%" valign="top"><img src="docs/media/examples/rubber-seal.png" alt="Rubber seal" width="100%"><br><b>Rubber seal</b> (<code>rubber-seal</code>): a Mooney–Rivlin gasket ring squeezed 25 %; nonlinear static, large strain</td>
+<td width="33%" valign="top"><img src="docs/media/examples/heated-bracket.png" alt="Heated bracket" width="100%"><br><b>Heated bracket</b> (<code>heated-bracket</code>): a clamped steel bracket heated at one end; steady heat and thermal stress</td>
+</tr>
+<tr>
+<td width="33%" valign="top"><img src="docs/media/examples/bracket-hex.png" alt="Hex-meshed bracket" width="100%"><br><b>Hex-meshed bracket</b> (<code>bracket-hex</code>): the bracket split into 30 cells, meshed all-hex (hex20), von Mises</td>
+<td width="33%" valign="top"><img src="docs/media/examples/crank-arm.png" alt="Bicycle crank arm" width="100%"><br><b>Bicycle crank arm</b> (<code>crank-arm</code>): an aluminium crank meshed structured all-hex (hex20) from a partitioned half and its mirror image, a rider's weight on the pedal; root bending within 0.3 % of M/Z</td>
+<td width="33%" valign="top"><i>No picture yet: the viewport does not draw flow results (M12).</i><br><b>Flow past a bracket</b> (<code>flow-past</code>): air past an L-bracket on the floor; lattice Boltzmann flow, the drag and the force on each face</td>
+</tr>
+</table>
+
 ## Build
 
 ```sh
@@ -85,6 +125,7 @@ Rust 1.95 or later, with the `wasm32-unknown-unknown` target for `cargo xtask ci
 
 ## Documentation
 
+- [Examples](docs/examples.md): the ready-to-solve samples and their checks
 - [Architecture](docs/architecture.md): crates, layers and the meshing pipeline
 - [Element library](docs/elements.md) and [verification and validation](docs/verification.md)
 - [Capability checklist](docs/parity.md) and [roadmap](ROADMAP.md)
@@ -94,6 +135,16 @@ Rust 1.95 or later, with the `wasm32-unknown-unknown` target for `cargo xtask ci
 - [Releasing](docs/releasing.md): how a release is built, verified and published
 - [Contributing](CONTRIBUTING.md) and [agent instructions](AGENTS.md)
 
+## Privacy
+
+FieldCraft sends nothing until you agree. The first start asks once whether to share anonymous
+usage (which tools you use, nothing from your models); Help › Settings… changes it, and
+`FIELDCRAFT_TELEMETRY=0` turns it off. File names, paths, geometry, model contents, parameter
+values and messages are never sent: [docs/privacy.md](docs/privacy.md) lists every event and
+property. Crash reports and the log stay on your computer; Help › Report a Bug opens a GitHub issue
+you review and submit yourself, with your session or model attached only if you tick them
+([docs/crash-reports.md](docs/crash-reports.md)).
+
 ## License
 
 Dual-licensed under [MIT](LICENSE-MIT) or [Apache-2.0](LICENSE-APACHE), at your option. Notices

ROADMAP.md

@@ -28,20 +28,20 @@ pressure) is a degree of freedom of the existing DOF framework, not a separate s
 |---|---|---|
 | M0 Foundation | Workspace, quality gates, FE model, command engine with rollback and panic guard, CLI, geometry boundary on SolidCraft | done |
 | M1 Geometry in and surface preparation | Open `.solidcraft` designs with persistent face names, assemblies placed (done); face-tagged 3MF (done); test corpus, `cargo xtask corpus` (done); exact predicates (done); quality metrics and certified validity gate (done); weld, closed/manifold/orientation and self-intersection checks, feature edges (`fieldcraft-mesh::surface`, `mesh.surface.check`, done) | in progress |
-| M2 Tet meshing and size field | Size field (global, per face and edge seeds, curvature and proximity; the `fieldcraft_mesh::size::SizeField` trait and edge-division helpers are in); Bowyer–Watson Delaunay (exact, symbolic perturbation, verified; `fieldcraft-mesh::delaunay`, done); robust CDT boundary recovery (Diazzi et al. 2023: implicit LNC Steiner points on segments, gift-wrapping facet recovery, inside/outside labelling, B-rep face tags on boundary tet faces, flip repair of rounding (§5.1) checked by the validity gate; `fieldcraft-mesh::cdt` and `mesh.tet.generate`, done: all 20 valid corpus parts); quality stage (done: `fieldcraft-mesh::tet` — curvature-graded size field, edge-collapse coarsening, constrained Delaunay refinement with boundary points on the B-rep faces and curves, ODT smoothing, Klingner–Shewchuk improvement, tet4 and tet10 with mid-side nodes on the B-rep, quality report; one validity criterion shared by the gate and both solvers; the filleted-bracket fillet stress converges, tests/oracle); mesh verify per set | in progress |
+| M2 Tet meshing and size field | Size field (global, curvature and proximity; edge seeds done: `mesh.seed.edge` on persistent design edge names (`<face>|<face>`) with a count or size, geometric bias and an exact, min or free constraint, shown as ticks and under Mesh › Seeds, honoured by the hex sweep, extrude, revolve, mapped, blocks and cells meshers through interval assignment (conflicting exact seeds named) and by the tet mesher, which divides the edge at the seed's nodes and grades its size field from them; per-face seeds to do; the `fieldcraft_mesh::size::SizeField` trait and edge-division helpers are in); Bowyer–Watson Delaunay (exact, symbolic perturbation, verified; `fieldcraft-mesh::delaunay`, done); robust CDT boundary recovery (Diazzi et al. 2023: implicit LNC Steiner points on segments, gift-wrapping facet recovery, inside/outside labelling, B-rep face tags on boundary tet faces, flip repair of rounding (§5.1) checked by the validity gate; `fieldcraft-mesh::cdt` and `mesh.tet.generate`, done: all 20 valid corpus parts); quality stage (done: `fieldcraft-mesh::tet` — curvature-graded size field, edge-collapse coarsening, constrained Delaunay refinement with boundary points on the B-rep faces and curves, ODT smoothing, Klingner–Shewchuk improvement, tet4 and tet10 with mid-side nodes on the B-rep, quality report; one validity criterion shared by the gate and both solvers; the filleted-bracket fillet stress converges, tests/oracle); mesh verify per set | in progress |
 | M3 First deck | Sets and surfaces bound to SolidCraft face, edge, vertex and body names, resolved after meshing; materials (isotropic and orthotropic elastic, density) with a unit-system label and consistency check; sections (solid, shell, beam profiles) assigned by set; element formulation per region mapped to each solver; BCs (fixed, displacement, symmetry); loads (force and moment on reference points, pressure, gravity); reference points with kinematic and distributing coupling; steps (linear static, frequency) with explicit per-step load and BC tables and output presets; `model.check` naming every missing or bad item; `model.*` and `mesh.tag` commands (model definition: done); writers for Abaqus input (done: `deck.write`), Nastran SOL 101/103 (done: `deck.write`) and LS-DYNA implicit (done); the `.fieldcraft` file (text definition, binary mesh, geometry references reopened on load, journal; atomic saves, autosave and recovery; undo/redo on the journal: done) | in progress |
 | M4 Own solver and first results | Element library per docs/elements.md (1D and 2D first); Linear static and modal solver (tet4/10, wedge6, hex8, hex20; sparse direct, Lanczos), verified against analytic solutions (solver: done — `fieldcraft-fem` kernels, `fieldcraft-solver` with nested dissection, sparse Cholesky and block Lanczos, `solve.static`/`solve.frequency`/`solve.probe`, patch, cantilever, Lamé, Kirsch and beam-frequency tests; reference points with kinematic and distributing couplings and moments by master–slave constraint elimination, verified by rigid motion, clamping, Saint-Venant tension, bending and tube torsion; 1D elements I: rod2/rod3 trusses, point masses, rotary inertia, springs and dashpots in both solvers and all three decks, verified by the method of joints, the three-bar truss, spring–mass, two-mass chain and torsional pendulum frequencies, and damped decay; 2D elements: plane stress, plane strain and axisymmetric tri3, tri6, quad4 (incompatible modes QM6), quad8 with two degrees of freedom per node, centrifugal loads, `mesh.planar` 2D meshes of polygons and planar faces, verified by patch tests, Kirsch, Lamé (plane strain and axisymmetric), rotating discs and cylinders, and a plane stress cantilever; deck mapping to Abaqus CPS/CPE/CAX, Nastran membranes, LS-DYNA ELFORM 12/13); shells and beams (done: quad4 MITC4 and tri3 MITC3 flat shells with a Hughes–Brezzi drilling rotation, two-node Timoshenko beams with profile properties and orientations, six degrees of freedom at shell and beam nodes shared with solids and trusses, section forces and surface stresses, verified by shell patch tests, Navier's plate, cantilever and portal-frame beams, and the Scordelis–Lo and pinched-cylinder benchmarks); results display (done: `results.*` commands, deformed shape to scale, banded contours of displacement, von Mises, principal and component stresses with a legend, mode shapes with their frequencies and animation, probing a node by clicking it, reaction force and moment sums per set, stale results marked after an edit; explicit steps: field frames by slider or animation with contours per frame, energy histories plotted) | started |
-| M5 Structured hex | 2D quad meshing of faces (`fieldcraft-mesh::quad`: transfinite mapped meshes, free all-quad meshes of polygons with holes on prescribed boundary nodes, exact planar quad validity, shared `SizeField` and even edge divisions; done for planar faces); mapped hex of six-sided regions (trivariate TFI, curved faces) and sweep meshing (multi-level extrusions with imprinted cross-sections, revolutions, one-to-one sweeps through linking faces; interval assignment, hex8/hex20 on the geometry, B-rep face tags, `mesh.hex.generate`/`sweep`/`mapped`: done, 16 of 21 corpus parts all-hex); conforming interfaces between cells (done: `mesh.hex.blocks` meshes a part split with SolidCraft's Split Body into mapped blocks as one conforming mesh — composite faces for seams and tangent faces, interval assignment over all cells, shared faces meshed once, grading off holes and fillets, free-internal-face check; the filleted bracket in 30 cells, hex20 within 0.1 % of a fine tet10 tip deflection); sweepable cells in a conforming mesh and tet–hex transition; automatic decomposition into sweepable and mappable regions, proposed as SolidCraft splits | started |
+| M5 Structured hex | 2D quad meshing of faces (`fieldcraft-mesh::quad`: transfinite mapped meshes, free all-quad meshes of polygons with holes on prescribed boundary nodes, exact planar quad validity, shared `SizeField` and even edge divisions; done for planar faces); mapped hex of six-sided regions (trivariate TFI, curved faces) and sweep meshing (multi-level extrusions with imprinted cross-sections, revolutions, one-to-one sweeps through linking faces; interval assignment, hex8/hex20 on the geometry, B-rep face tags, `mesh.hex.generate`/`sweep`/`mapped`: done, 16 of 21 corpus parts all-hex); conforming interfaces between cells (done: `mesh.hex.blocks` meshes a part split with SolidCraft's Split Body into mapped blocks as one conforming mesh — composite faces for seams and tangent faces, interval assignment over all cells, shared faces meshed once, grading off holes and fillets, free-internal-face check; the filleted bracket in 30 cells, hex20 within 0.1 % of a fine tet10 tip deflection); partitions inside FieldCraft (done: datum planes and axes, `geometry.partition` cuts the open design by a datum plane, kept in the model and replayed when the design opens, the two faces of each cut paired by name); cells meshed each with its own method into one mesh (done: `mesh.cells` — hex where a method fits, else tet; matching interfaces merged node for node, others, such as hex next to tet, tied by dual mortar, verified by a tied hex–tet bar in tension to 1e-6); meshing half a symmetric part and mirroring it (done: `mesh.mirror` reflects hex8/hex20/tet4/tet10/wedge6 across a datum plane, right-handed, nodes on the plane merged, tags carried to the image half; a mirrored half bar equals the whole bar's mesh and bending deflection to 1e-12; samples `crank-arm` and `crank-mirror`: one datum, the half extruded in automatic blocks and mirrored, scaled Jacobian ≥ 0.37; or solving the half: `model.boundary_condition.symmetry` on a datum plane, a half bar with half the load bends as the whole to 1e-11); three-sided sweep regions mapped as triangle primitives (done: midpoint subdivision, dominance constraints in interval assignment); automatic blocks of extruded cross-sections (done: `hex::decompose` — holes separated, O-grids, cuts from concave corners and fillets chosen by block quality, kept only when no worse than the free mesh; nothing added to the model); pyramid transitions; automatic decomposition of 3D parts into sweepable and mappable regions | started |
 | M6 Automatic hex | Octree/grid all-hex for any part (first version: done — `fieldcraft-mesh::octree`, `mesh.hex.octree`: 3-refinement grid with conforming templates refined by curvature, thickness and narrow faces, a core cleared to a manifold boundary, feature map onto it, padding and a pillow per patch capturing every sharp curve, foldover-free fitting, certified validity, B-rep face tags; the corpus hex column and the filleted-bracket oracle case; next: transitions for concave refined regions so thin and curved parts stop over-refining); hex-dominant by tet recombination; polycube for blocky parts; layers through thin walls; mesh editing and orphan-mesh import | started |
-| M7 Assemblies, contact and friction | Needs M15. Part instances from SolidCraft occurrences; tie between non-matching meshes (mortar); implicit contact: surface-to-surface mortar and node-to-surface, penalty and augmented Lagrange, self-contact, automatic pair detection with a bounding-volume search shared with explicit contact; friction: Coulomb with stick–slip, static/kinetic, anisotropic, pressure-, rate- and temperature-dependent coefficients; contact output (pressure, slip, status); thermal contact conductance and frictional heating; wear (Archard); bolt pretension, connectors with behaviour (elastic, damped, stops, locks); amplitudes, multiple steps, restart; nonlinear steps in all three decks. Verified by Hertz (sphere and cylinder), the Cattaneo–Mindlin partial-slip problem, the sliding block, NAFEMS contact benchmarks | planned |
+| M7 Assemblies, contact and friction | Needs M15. Part instances from SolidCraft occurrences; tie between non-matching meshes (mortar: done — `interaction.tie`, dual mortar constraints in the implicit analyses, Abaqus `*TIE` and LS-DYNA tied contact, the tie patch test); implicit contact: surface-to-surface mortar and node-to-surface, penalty and augmented Lagrange, self-contact, automatic pair detection (mortar contact pairs with Coulomb friction in nonlinear static steps: done — segment-to-segment mortar with the consistent tangent by automatic differentiation of the segmentation, augmented Lagrangian with Uzawa updates to a gap tolerance, semismooth active set with a chattering cutback, small sliding without nonlinear geometry and finite sliding with it, overclosure adjusted or refused, Coulomb friction (stick/slip return map, static and kinetic coefficients, symmetrised tangent), pressure, gap, status, shear and slip output; verified by the contact patch test, Hertz cylinder and sphere, Newton's quadratic rate and sliding blocks; the linear analyses refuse contact by name); friction: Coulomb with stick–slip, static/kinetic, anisotropic, pressure-, rate- and temperature-dependent coefficients; contact output (pressure, slip, status); thermal contact conductance and frictional heating; wear (Archard); bolt pretension, connectors with behaviour (elastic, damped, stops, locks); amplitudes, multiple steps, restart; nonlinear steps in all three decks. Verified by Hertz (sphere and cylinder), the Cattaneo–Mindlin partial-slip problem, the sliding block, NAFEMS contact benchmarks | started |
 | M8 Materials, explicit, shells, composites | Plasticity, hyperelasticity, damage data per solver; explicit dynamics decks (Abaqus/Explicit, LS-DYNA); midsurface shells; composite layups and material orientations, continuum shells on swept hex; hybrid (mixed u–p) hex8/hex20/tet10 for nearly incompressible materials (done); heat transfer (solids done: steady and θ-method transient conduction with flux, convection and sources, thermal strain in static steps (solids and 2D) and explicit dynamics (with plasticity), coupled temperature–displacement, `solve.heat`; deck output, 2D/shell/beam conduction planned) | started |
 | M9 Post-processing and deck readers | Results readers for public formats (Nastran OP2, LS-DYNA d3plot, Abaqus `.fil`); XY and path plots, cuts, display groups, free-body forces; deck readers that keep unknown keywords; mesh convergence studies | planned |
-| M10 Explicit dynamics | Shared element and material kernels with the implicit solver (`fem`); central-difference solver with lumped mass, stable time step, one-point hex8 with hourglass control and nodal-pressure tet4, bulk viscosity, energy accounting (X1 core: done — `fieldcraft-explicit`, `explicit_dynamic` steps with initial velocities, prescribed motion and planar rigid walls, `solve.explicit`/`solve.history`, small-strain linear elastic; bar wave, rigid-wall impact, energy balance and cantilever-period tests); large-deformation materials (X2: done — updated Lagrangian elements, Jaumann/Hughes–Winget and Green–Naghdi/Flanagan–Taylor rates, J2 bilinear/table plasticity, Johnson–Cook strength with heating and damage, erosion; materials gain `plastic`, `damage`, `erosion` with `model.material.plasticity`/`damage`; Dienes shear, rigid rotation, J2 uniaxial and Taylor-bar tests); contact (global search, penalty with friction, rigid walls); runs on hex and tet meshes | started |
+| M10 Explicit dynamics | Shared element and material kernels with the implicit solver (`fem`); central-difference solver with lumped mass, stable time step, one-point hex8 with hourglass control and nodal-pressure tet4, bulk viscosity, energy accounting (X1 core: done — `fieldcraft-explicit`, `explicit_dynamic` steps with initial velocities, prescribed motion and planar rigid walls, `solve.explicit`/`solve.history`, small-strain linear elastic; bar wave, rigid-wall impact, energy balance and cantilever-period tests); large-deformation materials (X2: done — updated Lagrangian elements, Jaumann/Hughes–Winget and Green–Naghdi/Flanagan–Taylor rates, J2 bilinear/table plasticity, Johnson–Cook strength with heating and damage, erosion; materials gain `plastic`, `damage`, `erosion` with `model.material.plasticity`/`damage`; Dienes shear, rigid rotation, J2 uniaxial and Taylor-bar tests); contact (X3: done — `interaction.contact.pair`/`general`/`find`, segment-to-segment penalty contact both ways with polygon clipping (passes the contact patch test on non-matching meshes), pairs, general (all exterior faces) and self contact, bucket-grid search, deterministic on any thread count, a penalty from the masses and the stable increment that never shortens it, Coulomb friction with exponential decay by a return map, friction on rigid walls, contact energy and friction dissipation in the balance, initial penetrations adjusted or refused; Abaqus `*CONTACT PAIR`/`*CONTACT`/`*FRICTION` and LS-DYNA automatic contacts in the decks; verified by colliding bars, sliding blocks, the patch test and Hertz's sphere impact); hyperelastic materials (neo-Hookean, Mooney–Rivlin, Yeoh) on the shared material point with average nodal pressure tets, and opt-in mass scaling with the added mass reported: done; runs on hex and tet meshes | started |
 | M11 Equations of state and shells | Polynomial, ideal-gas, Mie–Grüneisen, JWL with programmed burn, tabulated; energy coupling; shock verification (Rankine–Hugoniot, Sod, Noh, Sedov); Belytschko–Lin–Tsay shells with self-contact on quad meshes | planned |
 | M12 CFD: lattice Boltzmann | D3Q19/D3Q27 on grids voxelised from the face-tagged surface; TRT, regularised and cumulant collision; interpolated walls, inlets and outlets; LES (Smagorinsky, WALE) with wall models; thermal LBM and conjugate heat transfer with the structure's thermal solver; non-Newtonian viscosity (power-law, Carreau–Yasuda, Cross, Herschel–Bulkley, Bingham) and temperature-dependent viscosity; porous media (Brinkman, Darcy–Forchheimer); multiphase and free surface (M13); validation by the lid-driven cavity, backward-facing step, cylinder wake (Strouhal) and turbulent channel; octree refinement shared with the hex mesher; wgpu backend (deterministic per device, checked against the CPU) (CPU core: done — `fieldcraft-lbm` with D3Q19 TRT and Guo forcing, halfway bounce-back and moving walls, slip and periodic faces, Zou–He velocity and pressure faces, exact voxelisation of obstacle bodies, momentum-exchange forces per face; fluid materials, fluid domains and fluid steps in the model; `model.fluid_domain.*`, `solve.fluid`; verified by Poiseuille channel and pipe, Couette, Taylor–Green decay, sphere-array Stokes drag and mass conservation; Schäfer–Turek 2D-1 as a benchmark) | started |
 | M13 Fluid–structure interaction | Immersed-boundary coupling of the lattice Boltzmann fluid with the explicit or implicit structure; interface force transfer; sub-cycling; Aitken then interface quasi-Newton coupling; free-surface flow | planned |
 | M14 Blast and impact fluids | EOS-driven fluids in the explicit solver: ALE multi-material or SPH, with fluid–structure contact | planned |
-| M15 Nonlinear implicit core | Newton–Raphson with line search, automatic increments and cutbacks, convergence on force, displacement and energy; geometric nonlinearity (total and updated Lagrangian, large rotations for shells and beams, follower pressure); every `fem` material behind one interface with its consistent tangent (plasticity, damage and thermal strain from the explicit solver reused implicitly); arc-length (Riks) for snap-through; linear buckling (eigen) with preload stress stiffening, and imperfections from buckling modes; nonlinear stabilisation; restart. Verified by the elastica, Lee's frame, the snap-through arch, the hinged cylindrical shell and plastic collapse loads (solids core: done — `nonlinear_static` steps with automatic increments and cutbacks, Newton–Raphson with the consistent tangent, force, displacement and energy convergence and an optional line search; a material point interface (Kirchhoff stress and spatial tangent from F, with history) with St Venant–Kirchhoff and compressible neo-Hookean; total Lagrangian tet4, tet10, wedge6, hex8, hex20 (full and reduced), hybrid hex8/hex20/tet10 by the three-field mixed form, plane strain and axisymmetric elements; follower pressure with its symmetrised load stiffness; Cauchy stress and logarithmic strain, increment history and frames, `solve.nonlinear`; Abaqus and LS-DYNA decks; verified by the patch and objectivity tests, uniaxial stretch, the elastica and tube inflation by a follower pressure (finite-strain Cook's membrane pending its transcribed reference; J2 plasticity on the interface: Simo's exponential return map at finite strain and the radial return at small strain, both with consistent tangents and the return shared with explicit dynamics, bilinear isotropic and kinematic (small strain), tabulated and Johnson–Cook (rate-independent) hardening, hybrid elements included, load paths for cyclic loading, a tangent predictor for path-dependent materials, verified by uniaxial tension to large strain, Hill's thick cylinder (plastic zone and collapse pressure), a cantilever's collapse and the Bauschinger effect, with quadratic Newton convergence; Mooney–Rivlin and Yeoh options (decoupled, hybrid elements), verified in Treloar's three modes and by a stretched tube's inflation; thermal strain by the multiplicative split at finite strain and the additive one at small strain, with temperatures from temperature loads or the step's own conduction, verified by free and constrained expansion and a heated bar held past yield. Next: incompatible modes (EAS), kinematic hardening at finite strain, shells and beams, linear buckling, arc-length with an indefinite factorization) | started |
+| M15 Nonlinear implicit core | Newton–Raphson with line search, automatic increments and cutbacks, convergence on force, displacement and energy; geometric nonlinearity (total and updated Lagrangian, large rotations for shells and beams, follower pressure); every `fem` material behind one interface with its consistent tangent (plasticity, damage and thermal strain from the explicit solver reused implicitly); arc-length (Riks) for snap-through; linear buckling (eigen) with preload stress stiffening, and imperfections from buckling modes; nonlinear stabilisation; restart. Verified by the elastica, Lee's frame, the snap-through arch, the hinged cylindrical shell and plastic collapse loads (solids core: done — `nonlinear_static` steps with automatic increments and cutbacks, Newton–Raphson with the consistent tangent, force, displacement and energy convergence and an optional line search; a material point interface (Kirchhoff stress and spatial tangent from F, with history) with St Venant–Kirchhoff and compressible neo-Hookean; total Lagrangian tet4, tet10, wedge6, hex8, hex20 (full and reduced), hybrid hex8/hex20/tet10 by the three-field mixed form, plane strain and axisymmetric elements; follower pressure with its symmetrised load stiffness; Cauchy stress and logarithmic strain, increment history and frames, `solve.nonlinear`; Abaqus and LS-DYNA decks; verified by the patch and objectivity tests, uniaxial stretch, the elastica and tube inflation by a follower pressure (finite-strain Cook's membrane pending its transcribed reference; J2 plasticity on the interface: Simo's exponential return map at finite strain and the radial return at small strain, both with consistent tangents and the return shared with explicit dynamics, bilinear isotropic and kinematic (small strain), tabulated and Johnson–Cook (rate-independent) hardening, hybrid elements included, load paths for cyclic loading, a tangent predictor for path-dependent materials, verified by uniaxial tension to large strain, Hill's thick cylinder (plastic zone and collapse pressure), a cantilever's collapse and the Bauschinger effect, with quadratic Newton convergence; Mooney–Rivlin and Yeoh options (decoupled, hybrid elements), verified in Treloar's three modes and by a stretched tube's inflation; thermal strain by the multiplicative split at finite strain and the additive one at small strain, with temperatures from temperature loads or the step's own conduction, verified by free and constrained expansion and a heated bar held past yield. a supernodal symmetric indefinite LDLᵀ factorization (bounded Bunch–Kaufman within supernodes, inertia) on which Newton continues through indefinite tangents, so nearly incompressible hybrid elements (ν = 0.4999) converge under prescribed displacement; linear buckling steps (linear preload, initial-stress stiffness of solids and 2D elements, block Lanczos in the K inner product, the shifted buckling transformation on LDLᵀ with an inertia count, `solve.buckle`, Abaqus `*BUCKLE`), verified by Euler columns and Bryan's plate; imperfections from buckling modes; arc-length (Riks–Crisfield, cylindrical or spherical) with limit and bifurcation points from the tangent's inertia, verified by the snap-through of a shallow arch. Next: Lee's frame and the hinged cylindrical shell (with shells), the follower pressure's full tangent (LU), incompatible modes (EAS), kinematic hardening at finite strain, shells and beams) | started |
 | M16 Structural dynamics | Implicit transient (Newmark, HHT-α, generalised-α); modal superposition transient; steady-state harmonic (direct and modal), with Rayleigh, modal, structural and material damping; random vibration from PSDs and response spectrum (SRSS, CQC); complex eigenvalues with damping; rotating machinery (Campbell diagrams, gyroscopic terms); substructures (Craig–Bampton) | planned |
 | M17 Constitutive library and material library | Elastic: transversely isotropic, fully anisotropic (21 constants), temperature-dependent. Elastomers: hyperelastic neo-Hookean, Mooney–Rivlin, Yeoh (these three done, in nonlinear steps), Ogden, Arruda–Boyce, Gent, Marlow, with Mullins softening and finite-strain viscoelasticity (Prony series; parallel networks after Bergström–Boyce), foams. Viscoelasticity: small- and finite-strain Prony series, time–temperature superposition (WLF, Arrhenius), storage and loss moduli for harmonic steps. Viscoplasticity and creep: Norton power law, time and strain hardening, Perzyna, Anand, Chaboche combined hardening. Plasticity: Hill anisotropic, Drucker–Prager, Mohr–Coulomb, Cam-clay, crushable foam, concrete damaged plasticity, Gurson. Fluids: Newtonian and non-Newtonian viscosity shared with M12. Material library: curated, cited data sets (steels, aluminium and titanium alloys, polymers, elastomers, composites, tissues) with units and temperature dependence; calibration from test data (uniaxial, biaxial, shear, relaxation, DMA) by least squares with Drucker stability checks; user materials as a safe Rust trait | planned |
 | M18 Composites and anisotropy | Material orientations (rectangular, cylindrical, spherical, from geometry edges and faces, per-element fields, draping of fibres over curved parts); layups on shells and continuum shells, ply stacks on swept hex; classical lamination theory checks; ply stresses and strains through the thickness; failure indices (Tsai–Wu, Tsai–Hill, Hashin, Puck, LaRC) and progressive damage; homogenisation (rule of mixtures, Mori–Tanaka, RVEs with periodic boundary conditions); delamination through M20's cohesive zones. Verified by laminate closed forms and the NAFEMS composite benchmarks | planned |
@@ -52,7 +52,7 @@ pressure) is a degree of freedom of the existing DOF framework, not a separate s
 | M23 Wave propagation and ultrasound | Elastic, acoustic and coupled waves from the explicit solver's 1D bar today to guided and ultrasonic waves, by two methods. Finite differences first, for fast 2D (then 3D) ultrasound on regular grids: staggered-grid velocity–stress FDTD (Virieux) and the elastodynamic finite integration technique for solids, the rotated staggered grid for anisotropic media, a k-space pseudospectral scheme for weakly heterogeneous tissue and water, all on grids voxelised from the face-tagged geometry by the LBM's exact voxeliser, with heterogeneous, layered and fluid–solid media, CPML boundaries, threads and the GPU backend; staircased curved boundaries scatter spuriously, so the FD grid is checked against the finite elements on curved parts. Finite elements for curved geometry and coupling with structures: spectral elements (high-order Gauss–Lobatto–Legendre hexes with diagonal mass) on the hex meshes, and a mesh check in elements per wavelength with the dispersion error it implies; absorbing boundaries (convolutional PML, absorbing layers with increasing damping) and infinite media; tone-burst sources (Hann-windowed cycles), point, line and surface excitation, and piezoelectric transducers (M19); anisotropic media (composites, crystals) and viscoelastic, power-law-in-frequency attenuation; fluid–solid interfaces and fluid-loaded plates; ultrasound in water and tissue, nonlinear acoustics (Westervelt, KZK) for focused ultrasound. Guided waves: dispersion curves by semi-analytical finite elements (SAFE) for plates, pipes, rails and layered and anisotropic laminates — Lamb, Rayleigh, Love and SH modes — with phase and group velocities and mode shapes; mode-selective excitation. Output: A-scans and B-scans at sensors, wavefield snapshots, 2D FFT (frequency–wavenumber) for mode identification, and time–frequency diagrams of any signal — short-time Fourier spectrograms, continuous wavelet transforms (Morlet), reassigned spectrograms and smoothed pseudo Wigner–Ville — with the SAFE or Rayleigh–Lamb group-velocity curves overlaid as arrival times, and group velocities extracted from the ridges. GPU paths (M12's backend) for long runs. Verified by Lamb's problem (point load on a half-space), Rayleigh-wave speed, Rayleigh–Lamb dispersion, Love waves in a layer over a half-space, reflection and transmission at interfaces, and published guided-wave measurements | planned |
 | Continuous: verification and validation | Every capability checked against theory (closed forms), experiments (published measurements) and published benchmarks (NAFEMS, vendor benchmark and verification manuals such as Abaqus's), each case our own model in `tests/oracle/` with its cited reference and tolerance; `cargo xtask oracle` runs them and writes docs/oracle.md; once a case matches, our result is frozen as a fixture so fidelity cannot regress (docs/verification.md). Runner, fixtures and CI job: done; 26 theory cases (patch tests of every solid element, cantilevers, Lamé in 3D, plane strain and axisymmetric, Kirsch in 3D and plane stress, rotating disc and cylinder, beam frequencies, couplings, explicit waves, impact and J2 plasticity, CDT invariants), 9 published benchmarks (MacNeal–Harder solid tests, Scordelis–Lo with solids, NAFEMS LE1 in 3D and 2D, LE10, FV32) and 9 pending cases with citations (shells, thermal, static plasticity, Taylor bar, CFD); `mesh.block` mapped blocks and 2D patches build their meshes | started |
 | Continuous: performance | CPU first, deterministic: results never depend on the thread count (fixed partitions, sums in a fixed order; checked by hashing results on 1, 2 and 7 threads). Supernodal left-looking Cholesky (11–15× faster than the column solver on one thread), parallel element matrices, stresses and Lanczos products, explicit element updates and LBM cell blocks on rayon threads (done — `fieldcraft-parallel`, `threads` on the solve commands, `FIELDCRAFT_THREADS`); parallel forward/back substitution and explicit tet4 assembly; GPU paths later, within a stated tolerance of the CPU | started |
-| Continuous: desktop and agents | Desktop app (viewport, model tree, commands, control channel, the open design drawn, `ui.capture` of the whole window offscreen: done; toolbar of every capability from the catalogue, ready or coming soon with its milestone, icons drawn with VectorCraft, docs/features.md: done; the Craft-family shell — title bar, workspaces and ribbon drop-downs, browser, context panel, command search, journal timeline, light and dark themes — native file pickers with background opening, drag and drop and recent files, samples and one-click Solve: done; MCP server over stdio, headless or bridged to the app, with read and write roots, docs/mcp.md: done; caps labels in Inter SemiBold; the README's analysis video recorded through MCP by `tools/demo-video`: done; support, load, reference-point and coupling symbols in the viewport and headless renders, with their browser toggles: done; selection by picking in the viewport — geometry faces, edges, vertices and bodies, mesh nodes, element faces and elements, box selection, hover, a Target row in command forms, `ui.select`/`ui.selection` and MCP `select`: done; a camera parameter for screenshots, a ribbon that follows the command being run: in progress), browser build, command schema as the public API | started |
+| Continuous: desktop and agents | Desktop app (viewport, model tree, commands, control channel, the open design drawn, `ui.capture` of the whole window offscreen: done; toolbar of every capability from the catalogue, ready or coming soon with its milestone, icons drawn with VectorCraft, docs/features.md: done; the Craft-family shell — title bar, workspaces and ribbon drop-downs, browser, context panel, command search, journal timeline, light and dark themes — native file pickers with background opening, drag and drop and recent files, samples and one-click Solve, and an examples gallery of ready-to-solve samples, each checked by a test (docs/examples.md): done; MCP server over stdio, headless or bridged to the app, with read and write roots, docs/mcp.md: done; caps labels in Inter SemiBold; the README's analysis video recorded through MCP by `tools/demo-video`: done; support, load, reference-point and coupling symbols in the viewport and headless renders, with their browser toggles: done; symbols as wireframes, one mark per constrained degree of freedom, a constant size on screen with a size setting, highlighted with their selected definition, concentrated loads drawn over the part: done; selection by picking in the viewport — geometry faces, edges, vertices and bodies, mesh nodes, element faces and elements, box selection, hover, a Target row in command forms, `ui.select`/`ui.selection` and MCP `select`: done; a camera parameter for screenshots, a ribbon that follows the command being run: in progress; the browser build — the same app in a web page with browser file pickers, downloads, drops and autosave to browser storage, deployed to GitHub Pages from each release, docs/web.md: done; in-app updates — a daily check of GitHub Releases, Help › Check for Updates and Reinstall, downloads verified against the release key's signature of SHA256SUMS.txt and swapped in after closing, `app.update.check`, `fieldcraft-cli update`, Reload to update in the browser, docs/updates.md: done), command schema as the public API | started |
 
 ## Next
 
@@ -77,7 +77,7 @@ What exists and what is missing, by area; each gap is in a milestone above.
 | Area | Today | Missing |
 |---|---|---|
 | Solution procedures | Linear static, nonlinear static (solids with geometric and material nonlinearity: hyperelasticity, J2 plasticity), frequency (Lanczos), steady and transient heat, coupled temperature–displacement, explicit dynamics, LBM flow | Nonlinear shells and beams, arc-length, buckling (M15); implicit, harmonic, random and spectrum dynamics (M16) |
-| Contact, friction, adhesion | Explicit planar rigid walls (frictionless); couplings, springs, dashpots | Implicit and explicit deformable contact, tie, friction laws, thermal contact, wear (M7); cohesive adhesion and debonding (M20) |
+| Contact, friction, adhesion | Explicit deformable contact (pairs, general, self; segment to segment, penalty) with Coulomb friction and exponential decay; rigid walls with friction; implicit mortar contact pairs (augmented Lagrangian, Coulomb friction) in nonlinear static steps; ties between non-matching meshes (dual mortar); couplings, springs, dashpots | Implicit self contact, anisotropic and pressure- or temperature-dependent friction, thermal contact, wear, eroding contact (M7, M10); cohesive adhesion and debonding (M20) |
 | Materials | Isotropic and orthotropic elasticity, density, thermal, J2 plasticity (bilinear, table, Johnson–Cook), Johnson–Cook damage and erosion, compressible neo-Hookean, Mooney–Rivlin and Yeoh hyperelasticity, Newtonian fluids | Elastomers beyond Yeoh (Ogden, Arruda–Boyce and the rest), viscoelasticity, viscoplasticity and creep, anisotropic and pressure-dependent plasticity, non-Newtonian viscosity, a cited material library and calibration (M17) |
 | Composites and anisotropy | Orthotropic constants | Orientations, layups, ply results, failure criteria, homogenisation (M18) |
 | Coupled fields | Thermal–structural (one way and coupled) | Piezoelectric, poroelastic, electro-thermal, acoustics (M19) |

apps/fieldcraft-cli/Cargo.toml

@@ -12,4 +12,8 @@ workspace = true
 fieldcraft-engine = { workspace = true }
 fieldcraft-io = { workspace = true }
 fieldcraft-mcp = { workspace = true }
+fieldcraft-update = { workspace = true }
 serde_json = { workspace = true }
+
+[dev-dependencies]
+fieldcraft-update = { workspace = true, features = ["mock"] }

apps/fieldcraft-cli/src/crashes.rs

@@ -0,0 +1,80 @@
+//! `fieldcraft-cli crashes`: the crash reports the desktop app wrote on this computer
+//! (docs/crash-reports.md): list them, show one, replay one, delete them.
+
+use std::path::Path;
+
+use fieldcraft_engine::crash;
+use serde_json::json;
+
+pub const USAGE: &str = "usage: fieldcraft-cli crashes [list [--json] | show <id> | replay <id> | dir | clear [<id>]]";
+
+pub fn run(args: &[String]) -> Result<(), String> {
+    let dir = crash::default_dir().ok_or("no crash folder on this system (set FIELDCRAFT_CRASH_DIR)")?;
+    let id = || args.get(1).map(String::as_str).ok_or_else(|| USAGE.to_string());
+    match args.first().map(String::as_str) {
+        None | Some("list") => {
+            let reports = crash::list(&dir);
+            if args.iter().any(|a| a == "--json") {
+                return print_json(&json!({ "dir": dir.to_string_lossy(), "reports": reports }));
+            }
+            println!("crash reports in {}", dir.display());
+            if reports.is_empty() {
+                println!("  (none)");
+            }
+            for r in reports {
+                let times = if r.count > 1 { format!(" ×{}", r.count) } else { String::new() };
+                let cmd = r.command.map(|c| format!(" in {c}")).unwrap_or_default();
+                let replay = if r.replayable { "  [replayable]" } else { "" };
+                println!("  {}  {}{times}{cmd}  v{}{replay}\n      {}", r.id, r.kind, r.version, r.message);
+            }
+            Ok(())
+        }
+        Some("show") => print_json(&crash::read(&dir, id()?)?),
+        Some("replay") => replay(&dir, id()?),
+        Some("dir") => {
+            println!("{}", dir.display());
+            Ok(())
+        }
+        Some("clear") => {
+            println!("deleted {} report(s)", crash::clear(&dir, args.get(1).map(String::as_str)));
+            Ok(())
+        }
+        _ => Err(USAGE.to_string()),
+    }
+}
+
+fn print_json(v: &serde_json::Value) -> Result<(), String> {
+    println!("{}", serde_json::to_string_pretty(v).map_err(|e| e.to_string())?);
+    Ok(())
+}
+
+/// Run a report's commands on its model and say whether the crash happens again. Files the
+/// commands write go to a scratch folder, never over the user's files.
+fn replay(dir: &Path, id: &str) -> Result<(), String> {
+    let report = crash::read(dir, id)?;
+    let scratch = std::env::temp_dir().join(format!("fieldcraft-replay-{}", std::process::id()));
+    std::fs::create_dir_all(&scratch).map_err(|e| format!("{}: {e}", scratch.display()))?;
+    if report["kind"] == "unclean_exit" {
+        println!("this crash ended the app without a report: if this process ends abruptly, it reproduced");
+    }
+    println!("replaying on {}", report["model_path"].as_str().unwrap_or("a new model"));
+    let r = crash::replay(&report, &scratch);
+    let _ = std::fs::remove_dir_all(&scratch);
+    let r = r?;
+    for (i, (cmd, outcome)) in r.steps.iter().enumerate() {
+        match outcome {
+            Ok(()) => println!("  {:>3}. {cmd}: ok", i + 1),
+            Err(e) => println!("  {:>3}. {cmd}: {e}", i + 1),
+        }
+    }
+    let said = |k: &str| report[k].as_str().unwrap_or_default().to_string();
+    if r.reproduced {
+        println!("reproduced: the same internal error ({}) at {}", said("message"), said("location"));
+    } else if let Some((l, m)) = r.panics.first() {
+        println!("an internal error happened, but not the reported one: {m} at {l}");
+        println!("(the report says: {} at {})", said("message"), said("location"));
+    } else {
+        println!("did not reproduce: no internal error (fixed, or it depends on something the replay does not have)");
+    }
+    Ok(())
+}

apps/fieldcraft-cli/src/main.rs

@@ -2,10 +2,15 @@
 //! fieldcraft-cli run <script.json>
 //! fieldcraft-cli features
 //! fieldcraft-cli mcp [--connect ADDR | --headless] [--automation-read-root DIR] [--automation-write-root DIR]
+//! fieldcraft-cli crashes [list [--json] | show <id> | replay <id> | dir | clear [<id>]]
+//! fieldcraft-cli update --check | --install
 //! fieldcraft-cli --version
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 #![forbid(unsafe_code)]
 
+mod crashes;
+mod update;
+
 use std::path::Path;
 use std::process::ExitCode;
 
@@ -15,6 +20,7 @@ use serde_json::json;
 const USAGE: &str = "\
 usage:
   fieldcraft-cli commands              list every command with its parameters
+  fieldcraft-cli commands --json       the same as JSON, each command's parameters as JSON Schema
   fieldcraft-cli run <script.json>     run a script (a JSON array of {\"command\", \"params\"})
                                        and print the model summary
   fieldcraft-cli features              print docs/features.md (every capability, ready or
@@ -27,6 +33,14 @@ usage:
       --automation-read-root DIR       files may be read only inside DIR
       --automation-write-root DIR      files may be written only inside DIR (with either root,
                                        the access a root left out is not granted)
+  fieldcraft-cli crashes [list|show <id>|replay <id>|dir|clear [<id>]]
+                                       the crash reports the desktop app wrote on this
+                                       computer (docs/crash-reports.md): list them (--json),
+                                       show one, replay one (does the crash happen again?),
+                                       print their folder, delete them
+  fieldcraft-cli update --check        is a newer FieldCraft published? (app.update.check; JSON)
+  fieldcraft-cli update --install      download the latest release, verify its signature and
+                                       checksum, and install it over this copy (docs/updates.md)
   fieldcraft-cli --version             print the version
 ";
 
@@ -36,6 +50,10 @@ const MAX_SCRIPT_BYTES: u64 = 256 * 1024 * 1024;
 fn main() -> ExitCode {
     let args: Vec<String> = std::env::args().skip(1).collect();
     let result = match args.first().map(String::as_str) {
+        Some("commands") if args.get(1).map(String::as_str) == Some("--json") => {
+            let all: Vec<_> = fieldcraft_engine::commands().iter().map(fieldcraft_engine::CommandSpec::listing).collect();
+            serde_json::to_string_pretty(&all).map(|text| println!("{text}")).map_err(|e| e.to_string())
+        }
         Some("commands") => {
             for c in fieldcraft_engine::commands() {
                 println!("{:<24} {:<18} {}", c.id, c.label, c.params);
@@ -47,6 +65,8 @@ fn main() -> ExitCode {
             Ok(())
         }
         Some("mcp") => mcp(args.get(1..).unwrap_or(&[])),
+        Some("crashes") => crashes::run(args.get(1..).unwrap_or(&[])),
+        Some("update") => update::run(args.get(1..).unwrap_or(&[])),
         Some("run") => args.get(1).ok_or_else(|| format!("run needs a script\n\n{USAGE}")).and_then(|p| run(p)),
         Some("-V" | "--version") => {
             println!("fieldcraft-cli {}", env!("CARGO_PKG_VERSION"));

apps/fieldcraft-cli/src/update.rs

@@ -0,0 +1,56 @@
+//! `fieldcraft-cli update --check | --install` (docs/updates.md): the same check as the app's
+//! Help › Check for Updates (`app.update.check`), and installing the latest release over this
+//! copy of the CLI's install, verified against the release key first. `FIELDCRAFT_UPDATE_HOST`
+//! points both at a local test server.
+
+use fieldcraft_engine::Session;
+use fieldcraft_update::install::{self, Finish};
+use fieldcraft_update::net::Client;
+use fieldcraft_update::stage::{self, Options};
+use serde_json::json;
+
+pub const USAGE: &str = "usage: fieldcraft-cli update --check | --install";
+
+pub fn run(args: &[String]) -> Result<(), String> {
+    match args.iter().map(String::as_str).collect::<Vec<_>>().as_slice() {
+        ["--check"] => check(),
+        ["--install"] => install(),
+        _ => Err(USAGE.into()),
+    }
+}
+
+fn check() -> Result<(), String> {
+    fieldcraft_engine::enable_update_checks(true);
+    let report = Session::default().execute("app.update.check", &json!({})).map_err(|e| e.to_string())?;
+    println!("{}", serde_json::to_string_pretty(&report).map_err(|e| e.to_string())?);
+    Ok(())
+}
+
+fn install() -> Result<(), String> {
+    let client = Client::from_env();
+    let check = client.check().map_err(|e| e.to_string())?;
+    if !check.newer() {
+        println!("FieldCraft {} is up to date (the latest release is {}).", check.current, check.latest.version);
+        return Ok(());
+    }
+    let here = install::here();
+    let downloads = fieldcraft_io::recovery::data_dir().map(|d| d.join("updates")).unwrap_or_else(|| std::env::temp_dir().join("fieldcraft-updates"));
+    eprintln!("Downloading FieldCraft {} for {}…", check.latest.version, here.describe());
+    let progress = |done: u64, total: u64| {
+        if total > 0 && done == total {
+            eprintln!("Downloaded {} MB; verifying…", total / (1024 * 1024));
+        }
+    };
+    let options = Options { key: fieldcraft_update::PUBLIC_KEY, downloads: &downloads, arch: std::env::consts::ARCH, progress: &progress };
+    let staged = stage::stage(&client, &check.latest, &here, &options).map_err(|e| e.to_string())?;
+    match install::plan(&staged, false).map_err(|e| e.to_string())? {
+        Finish::Swap(plan) => {
+            stage::apply(&plan).map_err(|e| e.to_string())?;
+            println!("Installed FieldCraft {} ({}). A running FieldCraft app uses it from its next start.", staged.version, here.describe());
+        }
+        Finish::Package { file, command } => {
+            println!("Downloaded and verified {}.\nInstall it with the system's package manager:\n  {command}", file.display());
+        }
+    }
+    Ok(())
+}

apps/fieldcraft-cli/tests/crashes.rs

@@ -0,0 +1,75 @@
+//! `fieldcraft-cli crashes` on a crash folder of its own (`FIELDCRAFT_CRASH_DIR`).
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use fieldcraft_engine::Session;
+use serde_json::{Value, json};
+
+const ID: &str = "20261014-101500-00000000deadbeef";
+
+/// A replayable report: a model with two nodes and a replay that adds a third.
+fn folder() -> PathBuf {
+    let d = std::env::temp_dir().join(format!("fieldcraft-cli-crashes-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&d);
+    let r = d.join(ID);
+    std::fs::create_dir_all(&r).unwrap();
+    let mut s = Session::default();
+    for l in 1..=2 {
+        s.execute("mesh.node.add", &json!({"label": l, "xyz": [l, 0, 0]})).unwrap();
+    }
+    std::fs::write(r.join("model.fieldcraft"), s.file_bytes(None).unwrap()).unwrap();
+    let replay = json!({"commands": [
+        {"command": "mesh.node.add", "params": {"label": 3, "xyz": [3, 0, 0]}},
+        {"command": "file.save", "params": {"path": d.join("overwritten.fieldcraft")}},
+    ]});
+    std::fs::write(r.join("replay.json"), replay.to_string()).unwrap();
+    let report = json!({
+        "format": "fieldcraft-crash/1", "id": ID, "kind": "unclean_exit", "signature": "00000000deadbeef", "count": 2,
+        "first_seen": "2026-10-14T10:15:00Z", "message": "FieldCraft ended without a clean exit while running `mesh.node.add`",
+        "location": "unclean exit in mesh.node.add", "command": {"command": "mesh.node.add", "params": {}},
+        "app": {"version": "9.9.9"}, "backtrace": [],
+    });
+    std::fs::write(r.join("report.json"), report.to_string()).unwrap();
+    d
+}
+
+fn cli(dir: &Path, args: &[&str]) -> (String, bool) {
+    let out = Command::new(env!("CARGO_BIN_EXE_fieldcraft-cli")).args(args).env("FIELDCRAFT_CRASH_DIR", dir).output().unwrap();
+    (format!("{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr)), out.status.success())
+}
+
+#[test]
+fn crashes_list_show_replay_and_clear() {
+    let d = folder();
+    let (out, ok) = cli(&d, &["crashes"]);
+    assert!(ok, "{out}");
+    assert!(out.contains(ID) && out.contains("unclean_exit ×2 in mesh.node.add") && out.contains("[replayable]"), "{out}");
+    let (out, ok) = cli(&d, &["crashes", "list", "--json"]);
+    assert!(ok);
+    let v: Value = serde_json::from_str(&out).unwrap();
+    assert_eq!(v["reports"][0]["id"], ID);
+    let (out, ok) = cli(&d, &["crashes", "show", ID]);
+    assert!(ok);
+    let v: Value = serde_json::from_str(&out).unwrap();
+    assert!(v["model_path"].as_str().unwrap().ends_with("model.fieldcraft"));
+    let (out, ok) = cli(&d, &["crashes", "replay", ID]);
+    assert!(ok, "{out}");
+    assert!(out.contains("1. mesh.node.add: ok"), "{out}");
+    // A command that writes a file is refused outside the scratch folder: the replay never
+    // writes over the user's files.
+    assert!(out.contains("2. file.save: ") && out.contains("outside the write root"), "{out}");
+    assert!(!d.join("overwritten.fieldcraft").exists());
+    assert!(out.contains("did not reproduce"), "{out}");
+    let (out, ok) = cli(&d, &["crashes", "show", "../etc"]);
+    assert!(!ok && out.contains("no crash report"), "{out}");
+    let (out, ok) = cli(&d, &["crashes", "dir"]);
+    assert!(ok && out.trim() == d.to_string_lossy(), "{out}");
+    let (out, ok) = cli(&d, &["crashes", "clear"]);
+    assert!(ok && out.contains("deleted 1 report(s)"), "{out}");
+    let (out, _) = cli(&d, &["crashes"]);
+    assert!(out.contains("(none)"), "{out}");
+    let (out, ok) = cli(&d, &["crashes", "nope"]);
+    assert!(!ok && out.contains("usage"), "{out}");
+    let _ = std::fs::remove_dir_all(&d);
+}

apps/fieldcraft-cli/tests/update.rs

@@ -0,0 +1,36 @@
+//! `fieldcraft-cli update --check` against a local release server (FIELDCRAFT_UPDATE_HOST).
+
+use std::process::Command;
+
+use fieldcraft_update::mock::Server;
+use serde_json::{Value, json};
+
+fn cli(host: &str, args: &[&str]) -> std::process::Output {
+    Command::new(env!("CARGO_BIN_EXE_fieldcraft-cli")).args(args).env("FIELDCRAFT_UPDATE_HOST", host).output().unwrap()
+}
+
+#[test]
+fn update_check_reports_the_latest_release() {
+    let server = Server::start().unwrap();
+    server.release("latest", &json!({"tag_name": "v99.0.0", "html_url": "https://github.com/jyviko/fieldcraft/releases/tag/v99.0.0", "assets": []}));
+    let out = cli(&server.url(), &["update", "--check"]);
+    assert!(out.status.success(), "{out:?}");
+    let report: Value = serde_json::from_slice(&out.stdout).unwrap();
+    assert_eq!(report["current"], env!("CARGO_PKG_VERSION"));
+    assert_eq!((report["latest"].as_str(), report["newer"].as_bool(), report["signed"].as_bool()), (Some("99.0.0"), Some(true), Some(false)));
+    // A test build is not a release package: it checks but would not install.
+    assert_eq!(report["asset"], Value::Null);
+    assert_eq!(server.requests(), 1);
+
+    // The same version: not newer, and --install has nothing to do.
+    server.release("latest", &json!({"tag_name": format!("v{}", env!("CARGO_PKG_VERSION")), "assets": []}));
+    let out = cli(&server.url(), &["update", "--check"]);
+    assert_eq!(serde_json::from_slice::<Value>(&out.stdout).unwrap()["newer"], false);
+    let out = cli(&server.url(), &["update", "--install"]);
+    assert!(out.status.success() && String::from_utf8_lossy(&out.stdout).contains("is up to date"), "{out:?}");
+
+    // Unreachable: an error, not a crash.
+    let out = cli("http://127.0.0.1:1", &["update", "--check"]);
+    assert!(!out.status.success() && String::from_utf8_lossy(&out.stderr).contains("could not reach"), "{out:?}");
+    assert!(!cli(&server.url(), &["update"]).status.success());
+}

apps/fieldcraft-web/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "fieldcraft-web"
+description = "FieldCraft in the browser (eframe web runner, WebGPU with WebGL2 fallback)"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lints]
+workspace = true
+
+[[bin]]
+name = "fieldcraft-web"
+path = "src/main.rs"
+
+[dependencies]
+fieldcraft-engine = { workspace = true }
+fieldcraft-ui-egui = { workspace = true }
+fieldcraft-io = { workspace = true }
+egui = { workspace = true }
+serde_json = { workspace = true }
+log = { workspace = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+# `wgpu` pulls egui-wgpu's defaults: WebGPU plus the WebGL2 fallback.
+eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit"] }
+# `file-handle-inner`: a picked file's size, checked before it is read.
+rfd = { workspace = true, features = ["file-handle-inner"] }
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+js-sys = "0.3"
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "Blob", "BlobPropertyBag", "Url", "Location", "DomTokenList", "CssStyleDeclaration", "Event", "EventTarget", "BeforeUnloadEvent", "Storage", "Crypto", "Headers", "Request", "RequestInit", "RequestCache", "Response"] }
+# Autosaves kept in the browser's local storage, which holds text.
+base64 = "0.22"

apps/fieldcraft-web/Trunk.toml

@@ -0,0 +1,10 @@
+# Build with: trunk build --release   (from apps/fieldcraft-web; docs/web.md)
+[build]
+target = "index.html"
+dist = "../../dist/web"
+public_url = "./"
+filehash = true
+
+[serve]
+addresses = ["127.0.0.1"]
+port = 8790

apps/fieldcraft-web/index.html

@@ -0,0 +1,68 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+  <title>FieldCraft</title>
+  <meta name="description" content="Open-source CAE modeling in Rust: mesh a part, set up the analysis and solve it, in your browser.">
+  <meta property="og:type" content="website">
+  <meta property="og:site_name" content="FieldCraft">
+  <meta property="og:title" content="FieldCraft">
+  <meta property="og:description" content="Open-source CAE built in Rust: structures, heat, fluids, and MCP for AI agents.">
+  <meta property="og:url" content="https://jyviko.github.io/fieldcraft/">
+  <meta property="og:image" content="https://jyviko.github.io/fieldcraft/og.png">
+  <meta property="og:image:width" content="1280">
+  <meta property="og:image:height" content="640">
+  <meta property="og:image:alt" content="FieldCraft: Open-source CAE built in Rust">
+  <meta name="twitter:card" content="summary_large_image">
+  <meta name="twitter:title" content="FieldCraft">
+  <meta name="twitter:description" content="Open-source CAE built in Rust: structures, heat, fluids, and MCP for AI agents.">
+  <meta name="twitter:image" content="https://jyviko.github.io/fieldcraft/og.png">
+  <link data-trunk rel="rust" data-bin="fieldcraft-web" data-wasm-opt="z" data-weak-refs />
+  <link data-trunk rel="icon" type="image/svg+xml" href="../../assets/app-icon/icon-small.svg" />
+  <link data-trunk rel="copy-file" href="../../assets/app-icon/icon.iconset/icon_128x128@2x.png" data-target-path="icons" />
+  <link data-trunk rel="copy-file" href="../../docs/media/og.png" />
+  <link rel="apple-touch-icon" href="icons/icon_128x128@2x.png">
+  <style>
+    html, body { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; background: #262c37; }
+    #fieldcraft_canvas { position: absolute; inset: 0; width: 100%; height: 100%; display: block; }
+    #fieldcraft_loading { position: absolute; inset: 0; display: flex; flex-direction: column; align-items: center; justify-content: center;
+      gap: 16px; padding: 0 16px; text-align: center; color: #c3cad6; font: 14px system-ui, sans-serif; pointer-events: none; }
+    #fieldcraft_loading img { width: 96px; height: 96px; }
+    #fieldcraft_loading p { margin: 0; max-width: 32em; }
+    #fieldcraft_loading.failed { pointer-events: auto; }
+    #fieldcraft_loading.failed img, #fieldcraft_loading.failed .spinner { display: none; }
+    .spinner { width: 24px; height: 24px; border-radius: 50%; border: 3px solid #4a5468; border-top-color: #c3cad6; animation: spin 0.9s linear infinite; }
+    @keyframes spin { to { transform: rotate(360deg); } }
+    @media (prefers-reduced-motion: reduce) { .spinner { animation: none; } }
+  </style>
+</head>
+<body>
+  <canvas id="fieldcraft_canvas"></canvas>
+  <div id="fieldcraft_loading">
+    <img src="icons/icon_128x128@2x.png" alt="">
+    <div class="spinner"></div>
+    <p>Loading FieldCraft&hellip;</p>
+    <noscript><p>FieldCraft needs JavaScript and WebAssembly.</p></noscript>
+  </div>
+  <script>
+    // The page could not load or start the app (no WebAssembly, a failed download): say so
+    // instead of loading forever. Once the app runs it removes the loading screen.
+    (function () {
+      function fail(why) {
+        var el = document.getElementById("fieldcraft_loading");
+        if (!el || el.classList.contains("failed")) return;
+        el.classList.add("failed");
+        el.textContent = "";
+        ["FieldCraft could not start: " + why, "It needs a current browser with WebAssembly and WebGPU or WebGL2."].forEach(function (t) {
+          var p = document.createElement("p");
+          p.textContent = t;
+          el.appendChild(p);
+        });
+      }
+      if (typeof WebAssembly !== "object") fail("this browser has no WebAssembly.");
+      addEventListener("unhandledrejection", function (e) { fail(String(e.reason && e.reason.message || e.reason)); });
+    })();
+  </script>
+</body>
+</html>

apps/fieldcraft-web/src/deploy.rs

@@ -0,0 +1,75 @@
+//! A new deployment of the web app: every half hour the page's own address is fetched past the browser's cache, and when it loads another build
+//! of the app than the one running (Trunk names each build's files by their content hash), the
+//! status bar offers "Reload to update" (docs/updates.md). Reloading asks first when the model
+//! has unsaved changes, as closing the page does.
+
+use std::cell::Cell;
+use std::rc::Rc;
+
+use wasm_bindgen::JsCast as _;
+
+/// How often the page looks for a new deployment (seconds).
+pub const INTERVAL: f64 = 30.0 * 60.0;
+
+/// Watches for a new deployment.
+pub struct Watch {
+    /// The build this page runs.
+    running: Option<String>,
+    /// A fetch found another build.
+    found: Rc<Cell<bool>>,
+    /// App time of the last look.
+    pub looked_at: f64,
+}
+
+impl Watch {
+    pub fn start() -> Watch {
+        let html = web_sys::window().and_then(|w| w.document()).and_then(|d| d.document_element()).map(|e| e.outer_html()).unwrap_or_default();
+        let running = crate::build_in_page(&html).map(str::to_string);
+        if running.is_none() {
+            log::info!("deploy: no hashed build in the page (a development server?); not watching");
+        }
+        Watch { running, found: Rc::default(), looked_at: 0.0 }
+    }
+
+    /// Whether a newer deployment was found.
+    pub fn found(&self) -> bool {
+        self.found.get()
+    }
+
+    /// Fetch the page again and compare its build with the running one.
+    pub fn look(&self) {
+        let (Some(running), Some(window)) = (self.running.clone(), web_sys::window()) else { return };
+        if self.found.get() {
+            return;
+        }
+        let url = window.location().pathname().unwrap_or_else(|_| "./".into());
+        let init = web_sys::RequestInit::new();
+        init.set_cache(web_sys::RequestCache::NoStore);
+        let promise = window.fetch_with_str_and_init(&url, &init);
+        let found = self.found.clone();
+        wasm_bindgen_futures::spawn_local(async move {
+            let text = async {
+                let response: web_sys::Response = wasm_bindgen_futures::JsFuture::from(promise).await.ok()?.dyn_into().ok()?;
+                if !response.ok() {
+                    return None;
+                }
+                wasm_bindgen_futures::JsFuture::from(response.text().ok()?).await.ok()?.as_string()
+            };
+            // Offline or refused: look again next time.
+            if let Some(html) = text.await
+                && let Some(deployed) = crate::build_in_page(&html)
+                && deployed != running
+            {
+                log::info!("deploy: {deployed} is deployed (running {running})");
+                found.set(true);
+            }
+        });
+    }
+}
+
+/// Reload the page (the new deployment loads).
+pub fn reload() {
+    if let Some(w) = web_sys::window() {
+        let _ = w.location().reload();
+    }
+}

apps/fieldcraft-web/src/main.rs

@@ -0,0 +1,112 @@
+//! FieldCraft in the browser.
+//!
+//! Runs the same [`fieldcraft_ui_egui::ModelApp`] 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`); docs/web.md says what works in the browser.
+//!
+//! Differences from the desktop app, all behind the UI's host services:
+//! - files live in the page ([`fieldcraft_io::fs`] keeps them in memory): File › Open and drops
+//!   read the computer's files into it; Save, Save As and Write Deck hand the written file out as
+//!   a download;
+//! - autosaves for recovery and the preferences are kept in the browser's local storage
+//!   ([`storage`], [`usage`]), and anonymous usage (when agreed) goes out with `fetch`;
+//! - no control channel (a page can't listen on a socket);
+//! - background jobs (meshing, solving) run on the page's one thread once the window has shown
+//!   that they run.
+//!
+//! Address flags: `?sample` or `?sample=cantilever` opens a sample, `?webgl` forces WebGL2.
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+#![forbid(unsafe_code)]
+
+#[cfg(target_arch = "wasm32")]
+mod deploy;
+#[cfg(target_arch = "wasm32")]
+mod storage;
+#[cfg(target_arch = "wasm32")]
+mod usage;
+#[cfg(target_arch = "wasm32")]
+mod web;
+
+#[cfg(target_arch = "wasm32")]
+fn main() {
+    web::start();
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn main() {
+    eprintln!("fieldcraft-web only runs in the browser: build it with `trunk build --release` in apps/fieldcraft-web (docs/web.md)");
+}
+
+/// The sample an address asks for (`?sample` opens the first sample, `?sample=NAME` that one).
+#[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]
+fn sample_in_query(query: &str) -> Option<String> {
+    let first = fieldcraft_engine::sample::SAMPLES.first().map_or("", |s| s.name);
+    query.trim_start_matches('?').split('&').find_map(|kv| {
+        let (key, value) = kv.split_once('=').unwrap_or((kv, ""));
+        (key == "sample").then(|| if value.is_empty() { first } else { value }.to_string())
+    })
+}
+
+/// The build of the app a page loads: the content-hashed name Trunk gives its WebAssembly
+/// (`fieldcraft-web-<hash>_bg.wasm`). A new deployment loads another one.
+#[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]
+fn build_in_page(html: &str) -> Option<&str> {
+    const HEAD: &str = "fieldcraft-web-";
+    const TAIL: &str = "_bg.wasm";
+    let mut rest = html;
+    while let Some(at) = rest.find(HEAD) {
+        let candidate = rest.get(at..)?;
+        let hash = candidate.get(HEAD.len()..)?;
+        let len = hash.bytes().take_while(u8::is_ascii_alphanumeric).count();
+        if len > 0 && hash.get(len..)?.starts_with(TAIL) {
+            return candidate.get(..HEAD.len() + len + TAIL.len());
+        }
+        rest = candidate.get(HEAD.len()..)?;
+    }
+    None
+}
+
+/// The name a file from the computer is kept under in the page: its last path part, without
+/// characters a path would read as folders.
+#[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]
+fn safe_name(name: &str) -> String {
+    let last = name.rsplit(['/', '\\']).next().unwrap_or_default();
+    let clean: String = last.chars().filter(|c| !c.is_control()).take(200).collect();
+    if clean.is_empty() || clean == "." || clean == ".." { "file".to_string() } else { clean }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn samples_from_the_address() {
+        assert_eq!(sample_in_query(""), None);
+        assert_eq!(sample_in_query("?sample").as_deref(), Some("parts"));
+        assert_eq!(sample_in_query("?webgl&sample=cantilever").as_deref(), Some("cantilever"));
+        assert_eq!(sample_in_query("?sample=").as_deref(), Some("parts"));
+        assert_eq!(sample_in_query("?samples=x"), None);
+    }
+
+    #[test]
+    fn the_running_build_is_found_in_the_page() {
+        let page = r#"<link rel="modulepreload" href="/fieldcraft/fieldcraft-web-1a2b3c.js"><link rel="preload" href="/fieldcraft/fieldcraft-web-1a2b3c_bg.wasm" as="fetch">"#;
+        assert_eq!(build_in_page(page), Some("fieldcraft-web-1a2b3c_bg.wasm"));
+        let next = page.replace("1a2b3c", "9f8e7d");
+        assert_ne!(build_in_page(page), build_in_page(&next));
+        // A development page (no hash) and other text: nothing to compare.
+        assert_eq!(build_in_page(r#"<script src="fieldcraft-web.js"></script>"#), None);
+        assert_eq!(build_in_page("fieldcraft-web-"), None);
+        assert_eq!(build_in_page(""), None);
+    }
+
+    #[test]
+    fn file_names_stay_in_their_folder() {
+        assert_eq!(safe_name("beam.fieldcraft"), "beam.fieldcraft");
+        assert_eq!(safe_name("../../etc/passwd"), "passwd");
+        assert_eq!(safe_name("C:\\work\\plate.solidcraft"), "plate.solidcraft");
+        assert_eq!(safe_name(".."), "file");
+        assert_eq!(safe_name(""), "file");
+        assert_eq!(safe_name("a\u{0}b.3mf"), "ab.3mf");
+    }
+}

apps/fieldcraft-web/src/storage.rs

@@ -0,0 +1,101 @@
+//! Autosaves kept in the browser.
+//!
+//! The engine's recovery folder is [`fieldcraft_io::recovery::BROWSER_DIR`] among the page's
+//! files, which last only as long as the page. This mirrors it to the browser's local storage
+//! (kept across visits, shared by the site's tabs): each file as base64 under
+//! [`PREFIX`]`<file name>`. At start the stored files go back into the folder, so the desktop's
+//! recovery flow (File › Recover…, `file.recovery.*`) offers what a closed or crashed page left.
+//!
+//! Local storage holds a few megabytes per site: an autosave larger than [`MAX_AUTOSAVE_BYTES`]
+//! (or one the browser refuses) is not kept, and the status bar says so.
+
+use std::collections::BTreeSet;
+use std::path::Path;
+
+use base64::Engine as _;
+use base64::engine::general_purpose::STANDARD;
+use fieldcraft_io::recovery::BROWSER_DIR;
+
+const PREFIX: &str = "fieldcraft-recovery/";
+
+/// Largest stored file taken back (local storage itself holds less).
+const MAX_STORED_CHARS: usize = 64 << 20;
+
+/// Largest autosave kept: base64 makes it a third larger, and browsers give a site about 5 MB.
+pub const MAX_AUTOSAVE_BYTES: usize = 3 << 20;
+
+fn local_storage() -> Result<web_sys::Storage, String> {
+    web_sys::window().ok_or("no window")?.local_storage().map_err(crate::web::js_err)?.ok_or_else(|| "browser storage is turned off".into())
+}
+
+/// The mirror: the stored files this page knows of (took back or wrote), by file name.
+#[derive(Default)]
+pub struct Store {
+    known: BTreeSet<String>,
+}
+
+pub fn dir() -> &'static Path {
+    Path::new(BROWSER_DIR)
+}
+
+/// A file name of the recovery folder that is safe as a key (the engine's ids and extensions).
+fn valid(name: &str) -> bool {
+    !name.is_empty() && name.len() <= 100 && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '.') && !name.starts_with('.')
+}
+
+impl Store {
+    /// Put the stored files back into the recovery folder.
+    pub fn load() -> Store {
+        let mut store = Store::default();
+        let s = match local_storage() {
+            Ok(s) => s,
+            Err(e) => {
+                log::warn!("autosaves: {e}");
+                return store;
+            }
+        };
+        let keys: Vec<String> = (0..s.length().unwrap_or(0)).filter_map(|i| s.key(i).ok().flatten()).collect();
+        for key in keys {
+            let Some(name) = key.strip_prefix(PREFIX).filter(|n| valid(n)) else { continue };
+            let Some(text) = s.get_item(&key).ok().flatten().filter(|t| t.len() <= MAX_STORED_CHARS) else { continue };
+            let Ok(bytes) = STANDARD.decode(text.as_bytes()).map_err(|e| log::warn!("autosave {name} is damaged: {e}")) else { continue };
+            match fieldcraft_io::fs::insert(&dir().join(name), bytes) {
+                Ok(()) => {
+                    store.known.insert(name.to_string());
+                }
+                Err(e) => log::warn!("autosave {name}: {e}"),
+            }
+        }
+        store
+    }
+
+    /// Keep a file the engine wrote in the recovery folder.
+    pub fn put(&mut self, path: &Path, bytes: &[u8]) -> Result<(), String> {
+        let name =
+            path.file_name().and_then(|n| n.to_str()).filter(|n| valid(n)).ok_or_else(|| format!("{}: not a recovery file", path.display()))?;
+        if bytes.len() > MAX_AUTOSAVE_BYTES {
+            return Err(format!("the model ({} MB) is too large for the browser's storage", bytes.len() >> 20));
+        }
+        self.known.insert(name.to_string());
+        local_storage()?
+            .set_item(&format!("{PREFIX}{name}"), &STANDARD.encode(bytes))
+            .map_err(|e| format!("browser storage is full or turned off ({})", crate::web::js_err(e)))
+    }
+
+    /// Drop the stored files whose entries left the recovery folder (cleared once saved,
+    /// recovered and discarded). Only files this page knows of: another tab's stay.
+    pub fn sync_removals(&mut self) {
+        let present: BTreeSet<String> =
+            fieldcraft_io::fs::list(dir()).iter().filter_map(|p| p.file_name().and_then(|n| n.to_str()).map(str::to_string)).collect();
+        let gone: Vec<String> = self.known.difference(&present).cloned().collect();
+        if gone.is_empty() {
+            return;
+        }
+        let Ok(s) = local_storage() else { return };
+        for name in gone {
+            if s.remove_item(&format!("{PREFIX}{name}")).is_ok() {
+                self.known.remove(&name);
+            }
+        }
+    }
+}

apps/fieldcraft-web/src/usage.rs

@@ -0,0 +1,86 @@
+//! Anonymous usage in the browser (docs/privacy.md): the same events and the same consent as the
+//! desktop app, the choice kept in the browser's local storage with the other preferences. Queued
+//! events are posted with `fetch` every half minute and when the page is closed or left (`keepalive`, so
+//! a closing page still sends them); a failed post is dropped silently.
+//!
+//! The project key is a build setting, `FIELDCRAFT_POSTHOG_KEY`: a build without one asks nothing
+//! and sends nothing.
+
+use fieldcraft_engine::usage;
+use fieldcraft_ui_egui::files::PrefsStore;
+use fieldcraft_ui_egui::privacy::UsageHost;
+use wasm_bindgen::JsCast as _;
+
+const KEY: Option<&str> = option_env!("FIELDCRAFT_POSTHOG_KEY");
+/// Where the preferences are kept in local storage.
+const PREFS_KEY: &str = "fieldcraft-prefs";
+/// How often queued events are sent (seconds).
+pub const INTERVAL: f64 = 30.0;
+
+fn key() -> Option<&'static str> {
+    KEY.map(str::trim).filter(|k| !k.is_empty())
+}
+
+fn local_storage() -> Option<web_sys::Storage> {
+    web_sys::window()?.local_storage().ok().flatten()
+}
+
+/// The preferences in local storage (navigation, privacy).
+pub fn prefs_store() -> PrefsStore {
+    PrefsStore {
+        load: Box::new(|| local_storage()?.get_item(PREFS_KEY).ok().flatten().map(String::into_bytes)),
+        save: Box::new(|bytes| {
+            let text = std::str::from_utf8(bytes).map_err(|e| e.to_string())?;
+            local_storage().ok_or("browser storage is turned off")?.set_item(PREFS_KEY, text).map_err(crate::web::js_err)
+        }),
+    }
+}
+
+/// What the window needs to ask and record, when the build has a key.
+pub fn host() -> Option<UsageHost> {
+    // The browser's clock for command durations (the plain wasm target has none).
+    usage::set_clock(js_sys::Date::now);
+    key().is_some().then(|| UsageHost {
+        platform: "web",
+        os: "web",
+        arch: "wasm32",
+        new_id: Box::new(|| web_sys::window()?.crypto().ok().map(|c| c.random_uuid())),
+    })
+}
+
+/// Post what is queued.
+pub fn send() {
+    let (Some(key), Some(window)) = (key(), web_sys::window()) else { return };
+    let url = format!("{}/batch/", usage::DEFAULT_HOST);
+    while let Some(batch) = usage::take_batch() {
+        let init = web_sys::RequestInit::new();
+        init.set_method("POST");
+        init.set_body(&wasm_bindgen::JsValue::from_str(&batch.body(key)));
+        // The Fetch standard's `keepalive` (a closing page still sends it); web-sys has no setter.
+        let _ = js_sys::Reflect::set(&init, &"keepalive".into(), &true.into());
+        let headers = web_sys::Headers::new().ok();
+        if let Some(h) = &headers {
+            let _ = h.set("Content-Type", "application/json");
+            init.set_headers(h);
+        }
+        let promise = window.fetch_with_str_and_init(&url, &init);
+        wasm_bindgen_futures::spawn_local(async move {
+            // Offline or refused: the batch is dropped.
+            if let Err(e) = wasm_bindgen_futures::JsFuture::from(promise).await {
+                log::debug!("usage: not sent: {}", crate::web::js_err(e));
+            }
+        });
+    }
+}
+
+/// When the page is closed or left: the session's length, then send.
+pub fn send_when_hidden(window: &web_sys::Window) {
+    let on_hide = wasm_bindgen::closure::Closure::<dyn FnMut()>::new(|| {
+        usage::closing();
+        send();
+    });
+    if let Err(e) = window.add_event_listener_with_callback("pagehide", on_hide.as_ref().unchecked_ref()) {
+        log::warn!("usage: {}", crate::web::js_err(e));
+    }
+    on_hide.forget();
+}

apps/fieldcraft-web/src/web.rs

@@ -0,0 +1,352 @@
+//! The browser shell: the web services of the UI (file pickers, downloads), dropped files, the
+//! autosave, and eframe's web runner.
+//!
+//! Structure follows VectorCraft's `apps/vectorcraft-web/src/web.rs` and SolidCraft's
+//! `apps/solidcraft-web/src/main.rs` (MIT OR Apache-2.0), see ATTRIBUTION.md.
+
+use std::cell::{Cell, RefCell};
+use std::path::Path;
+use std::rc::Rc;
+
+use fieldcraft_engine::Session;
+use fieldcraft_engine::autosave::Autosaver;
+use fieldcraft_ui_egui::files::Kind;
+use fieldcraft_ui_egui::{Filter, ModelApp, Services};
+use wasm_bindgen::JsCast as _;
+
+use crate::storage::{self, Store};
+
+const CANVAS_ID: &str = "fieldcraft_canvas";
+const LOADING_ID: &str = "fieldcraft_loading";
+const DEPTH_BITS: u8 = 24;
+
+/// The page's folder for files from the computer and the files commands write.
+const FILES_DIR: &str = "/files";
+
+/// How often unsaved changes are autosaved for recovery (seconds), as on the desktop.
+const AUTOSAVE_SECONDS: f64 = 30.0;
+
+/// Files read from the computer (picked together or dropped together), waiting for the next
+/// frame: (name, bytes or why they could not be read) each.
+type Batch = Vec<(String, Result<Vec<u8>, String>)>;
+type Inbox = Rc<RefCell<Vec<Batch>>>;
+
+/// Largest file read from the computer: what the page can hold.
+const MAX_READ_BYTES: f64 = fieldcraft_io::memory::MAX_TOTAL_BYTES as f64;
+
+/// Why a file of `size` bytes is not read, if it is too large.
+fn too_large(size: f64) -> Option<String> {
+    (size > MAX_READ_BYTES)
+        .then(|| format!("{} MB is more than this page holds ({} MB)", (size / 1048576.0).round(), fieldcraft_io::memory::MAX_TOTAL_BYTES >> 20))
+}
+
+/// Hand files read from the computer to the next frame.
+fn deliver(inbox: &Inbox, ctx: &egui::Context, batch: Batch) {
+    inbox.borrow_mut().push(batch);
+    ctx.request_repaint();
+}
+
+/// Where a file named `name` is kept in the page.
+fn page_path(name: &str) -> String {
+    format!("{FILES_DIR}/{}", crate::safe_name(name))
+}
+
+thread_local! {
+    /// The model has unsaved changes: leaving the page asks first.
+    static UNSAVED: Cell<bool> = const { Cell::new(false) };
+}
+
+pub fn js_err(e: wasm_bindgen::JsValue) -> String {
+    e.as_string().unwrap_or_else(|| format!("{e:?}"))
+}
+
+fn query() -> String {
+    web_sys::window().and_then(|w| w.location().search().ok()).unwrap_or_default()
+}
+
+fn element(id: &str) -> Option<web_sys::Element> {
+    web_sys::window()?.document()?.get_element_by_id(id)
+}
+
+pub fn start() {
+    eframe::WebLogger::init(log::LevelFilter::Info).ok();
+    // The browser's clock for the recovery entries (the plain wasm target has none).
+    fieldcraft_io::recovery::set_clock(|| js_sys::Date::now().max(0.0) as u64);
+    let Some(window) = web_sys::window() else { return };
+    ask_before_unload(&window);
+    crate::usage::send_when_hidden(&window);
+    let Some(canvas) = element(CANVAS_ID).and_then(|e| e.dyn_into::<web_sys::HtmlCanvasElement>().ok()) else {
+        log::error!("missing <canvas id=\"{CANVAS_ID}\">");
+        return;
+    };
+    wasm_bindgen_futures::spawn_local(async move {
+        let result = eframe::WebRunner::new()
+            .start(
+                canvas,
+                web_options(),
+                Box::new(|cc| {
+                    let inbox = Inbox::default();
+                    let mut app = ModelApp::new(Session::default()).with_services(services(inbox.clone(), cc.egui_ctx.clone()));
+                    // Anonymous usage: asked once, recorded only when the user agreed (docs/privacy.md).
+                    if let Some(host) = crate::usage::host() {
+                        app = app.with_usage(host);
+                    }
+                    if let Some(rs) = &cc.wgpu_render_state {
+                        let info = rs.adapter.get_info();
+                        log::info!("fieldcraft-web: graphics {:?} {}, MSAA {}x", info.backend, info.name, rs.msaa_samples);
+                        app.set_wgpu(rs, DEPTH_BITS, rs.msaa_samples, &cc.egui_ctx);
+                    }
+                    // The autosaves a closed or crashed page left, back in the recovery folder.
+                    let store = Store::load();
+                    let listed = app.session.execute("file.recovery.list", &serde_json::json!({}));
+                    let recoverable = listed.ok().and_then(|v| v.as_array().map(Vec::len)).unwrap_or(0);
+                    let autosaver = Autosaver::new(storage::dir()).map_err(|e| log::warn!("autosave unavailable: {e}")).ok();
+                    if let Some(name) = crate::sample_in_query(&query()) {
+                        app.open_sample(&name);
+                    }
+                    if recoverable > 0 {
+                        app.set_status(format!("{recoverable} autosaved model(s) can be recovered: File › Recover…"), false);
+                    }
+                    let deploy = crate::deploy::Watch::start();
+                    Ok(Box::new(Shell { app, inbox, store, autosaver, autosaved_at: 0.0, storage_error: false, sent_at: 0.0, deploy }))
+                }),
+            )
+            .await;
+        match result {
+            Ok(()) => {
+                if let Some(el) = element(LOADING_ID) {
+                    el.remove();
+                }
+            }
+            Err(e) => failed(&format!("FieldCraft could not start: {}", js_err(e))),
+        }
+    });
+}
+
+/// The runner's options: wgpu (WebGPU where available, else WebGL2; `?webgl` forces WebGL2).
+fn web_options() -> eframe::WebOptions {
+    let mut options = eframe::WebOptions { depth_buffer: DEPTH_BITS, ..Default::default() };
+    if query().split(['?', '&']).any(|kv| kv == "webgl")
+        && let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup
+    {
+        create.instance_descriptor.backends = eframe::wgpu::Backends::GL;
+    }
+    options
+}
+
+/// Replace the loading screen with why the app could not start.
+fn failed(why: &str) {
+    log::error!("{why}");
+    let Some(el) = element(LOADING_ID) else { return };
+    let Some(document) = web_sys::window().and_then(|w| w.document()) else { return };
+    el.set_text_content(None);
+    // Best effort: the console has the message too.
+    let _ = el.class_list().add_1("failed");
+    for line in
+        [why, "FieldCraft needs a browser with WebGPU or WebGL2 (a current Chrome, Edge, Firefox or Safari) and graphics acceleration turned on."]
+    {
+        if let Ok(p) = document.create_element("p") {
+            p.set_text_content(Some(line));
+            let _ = el.append_child(&p);
+        }
+    }
+}
+
+/// The browser's "leave site? changes you made may not be saved" prompt while the model has
+/// unsaved changes (a page that is closing can't show its own dialog).
+fn ask_before_unload(window: &web_sys::Window) {
+    let on_unload = wasm_bindgen::closure::Closure::<dyn FnMut(web_sys::BeforeUnloadEvent)>::new(|e: web_sys::BeforeUnloadEvent| {
+        if UNSAVED.with(Cell::get) {
+            e.prevent_default();
+            e.set_return_value("unsaved");
+        }
+    });
+    if let Err(e) = window.add_event_listener_with_callback("beforeunload", on_unload.as_ref().unchecked_ref()) {
+        log::warn!("couldn't ask before leaving: {}", js_err(e));
+    }
+    // The listener lives as long as the page.
+    on_unload.forget();
+}
+
+/// The UI's host services in the browser.
+fn services(inbox: Inbox, ctx: egui::Context) -> Services {
+    Services {
+        // The browser's file picker: the files arrive in a later frame (the picker and the reads
+        // are asynchronous), so the call itself picks nothing.
+        pick_open: Some(Box::new(move |filters: &[Filter]| {
+            let (inbox, ctx) = (inbox.clone(), ctx.clone());
+            let dialog = filters.iter().fold(rfd::AsyncFileDialog::new(), |d, f| d.add_filter(f.name, f.extensions));
+            wasm_bindgen_futures::spawn_local(async move {
+                let Some(files) = dialog.pick_files().await else { return };
+                let mut batch = Vec::with_capacity(files.len());
+                for f in files {
+                    let read = match too_large(f.inner().size()) {
+                        Some(why) => Err(why),
+                        None => Ok(f.read().await),
+                    };
+                    batch.push((f.file_name(), read));
+                }
+                deliver(&inbox, &ctx, batch);
+            });
+            None
+        })),
+        // Saving writes into the page; the shell hands each written file out as a download.
+        pick_save: Some(Box::new(|name: &str, _: &[Filter]| Some(page_path(name)))),
+        // The recent list holds the page's files, which go with the page.
+        recent_path: None,
+        // Preferences are kept in the browser's local storage.
+        prefs: Some(crate::usage::prefs_store()),
+        // egui opens links itself in the browser.
+        open_url: None,
+    }
+}
+
+/// The app with the browser's files around it.
+struct Shell {
+    app: ModelApp,
+    inbox: Inbox,
+    store: Store,
+    /// `None` when autosave could not start.
+    autosaver: Option<Autosaver>,
+    /// App time of the last autosave check.
+    autosaved_at: f64,
+    /// The last autosave did not fit in the browser's storage (said once until one fits).
+    storage_error: bool,
+    /// App time usage events were last sent.
+    sent_at: f64,
+    /// Looks for a new deployment of the app.
+    deploy: crate::deploy::Watch,
+}
+
+impl Shell {
+    /// Files read from the computer go into the page's folder, then open: a model with the
+    /// design and meshes it refers to picked or dropped with it, else each file in turn.
+    fn open_arrived(&mut self) {
+        let batches: Vec<_> = self.inbox.borrow_mut().drain(..).collect();
+        for batch in batches {
+            let mut paths = Vec::with_capacity(batch.len());
+            for (name, read) in batch {
+                let path = page_path(&name);
+                match read.and_then(|bytes| fieldcraft_io::fs::insert(Path::new(&path), bytes).map_err(|e| e.to_string())) {
+                    Ok(()) => paths.push(path),
+                    Err(e) => self.app.set_status(format!("{name}: {e}"), true),
+                }
+            }
+            let model = paths.iter().find(|p| Kind::of(p) == Some(Kind::Model)).cloned();
+            match model {
+                // Its geometry files open with it, from the same folder.
+                Some(model) => self.app.open_path(&model),
+                None => {
+                    for p in &paths {
+                        self.app.open_path(p);
+                    }
+                }
+            }
+        }
+    }
+
+    /// What commands wrote: autosaves to the browser's storage, everything else downloaded.
+    fn hand_out_writes(&mut self) {
+        for (path, bytes) in fieldcraft_io::fs::take_writes() {
+            if path.parent() == Some(storage::dir()) {
+                match self.store.put(&path, &bytes) {
+                    Ok(()) => self.storage_error = false,
+                    Err(e) if !self.storage_error => {
+                        self.storage_error = true;
+                        self.app.set_status(format!("Autosave: {e}. Save the model to keep it (File › Save downloads it)"), true);
+                    }
+                    Err(e) => log::warn!("autosave: {e}"),
+                }
+            } else if let Err(e) = download(&path, &bytes) {
+                self.app.set_status(format!("{}: the download did not start ({e})", path.display()), true);
+            }
+        }
+        self.store.sync_removals();
+    }
+
+    fn autosave(&mut self, ctx: &egui::Context) {
+        let Some(a) = &mut self.autosaver else { return };
+        if self.app.now - self.autosaved_at >= AUTOSAVE_SECONDS {
+            self.autosaved_at = self.app.now;
+            if let Err(e) = a.save(&self.app.session) {
+                log::warn!("autosave: {e}");
+            }
+        }
+        ctx.request_repaint_after(std::time::Duration::from_secs_f64(AUTOSAVE_SECONDS));
+    }
+}
+
+impl eframe::App for Shell {
+    fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        self.open_arrived();
+        self.app.logic(ctx);
+        self.autosave(ctx);
+        if self.app.now - self.sent_at >= crate::usage::INTERVAL {
+            self.sent_at = self.app.now;
+            crate::usage::send();
+        }
+        UNSAVED.with(|u| u.set(self.app.session.is_dirty() && !self.app.session.journal.is_empty()));
+        if self.app.now - self.deploy.looked_at >= crate::deploy::INTERVAL || self.app.now < self.deploy.looked_at {
+            self.deploy.looked_at = self.app.now;
+            self.deploy.look();
+        }
+        if self.deploy.found() && !self.app.reload_offered() {
+            self.app.offer_reload(Box::new(crate::deploy::reload));
+        }
+        ctx.request_repaint_after(std::time::Duration::from_secs_f64(crate::deploy::INTERVAL));
+    }
+
+    /// Dropped files are read here (browsers read them asynchronously) and arrive through the
+    /// inbox; the app never sees their names as paths.
+    fn raw_input_hook(&mut self, ctx: &egui::Context, raw: &mut egui::RawInput) {
+        let dropped = std::mem::take(&mut raw.dropped_files);
+        if !dropped.is_empty() {
+            let (inbox, ctx) = (self.inbox.clone(), ctx.clone());
+            wasm_bindgen_futures::spawn_local(async move {
+                let mut batch = Vec::with_capacity(dropped.len());
+                for f in dropped {
+                    let name = f.path().to_string_lossy().to_string();
+                    let read = match f.web_file().and_then(|w| too_large(w.size())) {
+                        Some(why) => Err(why),
+                        None => f.bytes_async().await,
+                    };
+                    batch.push((name, read));
+                }
+                deliver(&inbox, &ctx, batch);
+            });
+        }
+        self.app.raw_input_hook(raw);
+    }
+
+    fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
+        self.app.ui(ui);
+        // Once a frame, after everything that writes: autosaves, saves and decks.
+        self.hand_out_writes();
+    }
+}
+
+/// Hand `bytes` out as a download named after the last part of `path`.
+fn download(path: &Path, bytes: &[u8]) -> Result<(), String> {
+    let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("fieldcraft").to_string();
+    let window = web_sys::window().ok_or("no window")?;
+    let document = window.document().ok_or("no document")?;
+    let parts = js_sys::Array::of1(&js_sys::Uint8Array::from(bytes));
+    let options = web_sys::BlobPropertyBag::new();
+    options.set_type("application/octet-stream");
+    let blob = web_sys::Blob::new_with_u8_array_sequence_and_options(&parts, &options).map_err(js_err)?;
+    let url = web_sys::Url::create_object_url_with_blob(&blob).map_err(js_err)?;
+    let a: web_sys::HtmlAnchorElement = document.create_element("a").map_err(js_err)?.dyn_into().map_err(|_| "not a link")?;
+    a.set_href(&url);
+    a.set_download(&name);
+    a.style().set_property("display", "none").map_err(js_err)?;
+    document.body().ok_or("no body")?.append_child(&a).map_err(js_err)?;
+    a.click();
+    a.remove();
+    // Revoked once the click has been dispatched; the download keeps its own reference.
+    let revoke = wasm_bindgen::closure::Closure::once_into_js(move || {
+        let _ = web_sys::Url::revoke_object_url(&url);
+    });
+    // The download has started: a timer that can't be set leaves the URL allocated, no more.
+    let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(revoke.unchecked_ref(), 10_000);
+    Ok(())
+}

apps/fieldcraft/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fieldcraft"
-description = "FieldCraft desktop app"
+description = "Finite element modeling: meshing, model setup, solver decks and a linear solver"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
@@ -13,12 +13,98 @@ workspace = true
 fieldcraft-engine = { workspace = true }
 fieldcraft-ui-egui = { workspace = true }
 fieldcraft-io = { workspace = true }
+fieldcraft-update = { workspace = true }
 rfd = { workspace = true }
 eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "wayland", "x11"] }
 egui = { workspace = true }
 serde_json = { workspace = true }
 log = { workspace = true }
+# Usage analytics (docs/privacy.md): an HTTPS POST with rustls on ring, checked against the
+# operating system's certificates (no bundled root list), and a random install id.
+ureq = { version = "3.4", default-features = false, features = ["rustls-no-provider", "platform-verifier"] }
+rustls = { version = "0.23", default-features = false, features = ["ring", "std"] }
+getrandom = "0.3"
 
 [build-dependencies]
 # The Windows executable's icon resource (build.rs).
 embed-resource = "3.0.12"
+
+# Linux .deb and .rpm packages (cargo-deb, cargo-generate-rpm), built by packaging/linux/package.sh
+# from the release binaries it has already built and stripped; it sets the version and the file
+# names. The file list matches the tar.gz's (package.sh's staged tree; the release workflow
+# compares them).
+# The binaries link only glibc and libgcc_s. Windowing (Wayland, X11, xkbcommon), the GPU (Vulkan
+# or EGL) and the file dialogs (the XDG desktop portal) are opened at run time, so they are no ELF
+# NEEDED entries and the tools cannot find them: they are listed here.
+[package.metadata.deb]
+name = "fieldcraft"
+maintainer = "FieldCraft contributors <jyviko@users.noreply.github.com>"
+copyright = "FieldCraft contributors"
+section = "science"
+priority = "optional"
+extended-description = """\
+FieldCraft turns geometry into analysis-ready finite element models: volume \
+meshes, materials, sections, boundary conditions, loads and steps. It writes \
+Abaqus input, Nastran bulk data and LS-DYNA keyword decks, and solves linear \
+static and modal problems with its own solver. Includes fieldcraft-cli, a \
+headless command runner and MCP server."""
+depends = "$auto, libxkbcommon0, libxkbcommon-x11-0, libwayland-client0, libx11-6, libx11-xcb1, libxcb1, libxcursor1, libxi6, libvulkan1 | libegl1"
+recommends = "mesa-vulkan-drivers, libegl-mesa0, xdg-desktop-portal"
+assets = [
+    ["target/release/fieldcraft", "usr/bin/", "755"],
+    ["target/release/fieldcraft-cli", "usr/bin/", "755"],
+    ["../../packaging/linux/io.github.jyviko.fieldcraft.desktop", "usr/share/applications/", "644"],
+    ["../../assets/app-icon/icon.iconset/icon_16x16.png", "usr/share/icons/hicolor/16x16/apps/io.github.jyviko.fieldcraft.png", "644"],
+    ["../../assets/app-icon/icon.iconset/icon_32x32.png", "usr/share/icons/hicolor/32x32/apps/io.github.jyviko.fieldcraft.png", "644"],
+    ["../../assets/app-icon/icon.iconset/icon_32x32@2x.png", "usr/share/icons/hicolor/64x64/apps/io.github.jyviko.fieldcraft.png", "644"],
+    ["../../assets/app-icon/icon.iconset/icon_128x128.png", "usr/share/icons/hicolor/128x128/apps/io.github.jyviko.fieldcraft.png", "644"],
+    ["../../assets/app-icon/icon.iconset/icon_256x256.png", "usr/share/icons/hicolor/256x256/apps/io.github.jyviko.fieldcraft.png", "644"],
+    ["../../assets/app-icon/icon.iconset/icon_512x512.png", "usr/share/icons/hicolor/512x512/apps/io.github.jyviko.fieldcraft.png", "644"],
+    ["../../assets/app-icon/icon.iconset/icon_512x512@2x.png", "usr/share/icons/hicolor/1024x1024/apps/io.github.jyviko.fieldcraft.png", "644"],
+    ["../../README.md", "usr/share/doc/fieldcraft/", "644"],
+    ["../../LICENSE-MIT", "usr/share/doc/fieldcraft/", "644"],
+    ["../../LICENSE-APACHE", "usr/share/doc/fieldcraft/", "644"],
+    ["../../NOTICE", "usr/share/doc/fieldcraft/", "644"],
+    ["../../THIRD-PARTY-LICENSES.txt", "usr/share/doc/fieldcraft/", "644"],
+]
+
+[package.metadata.generate-rpm]
+name = "fieldcraft"
+license = "MIT OR Apache-2.0"
+url = "https://github.com/jyviko/fieldcraft"
+assets = [
+    { source = "target/release/fieldcraft", dest = "/usr/bin/fieldcraft", mode = "755" },
+    { source = "target/release/fieldcraft-cli", dest = "/usr/bin/fieldcraft-cli", mode = "755" },
+    { source = "../../packaging/linux/io.github.jyviko.fieldcraft.desktop", dest = "/usr/share/applications/io.github.jyviko.fieldcraft.desktop", mode = "644" },
+    { source = "../../assets/app-icon/icon.iconset/icon_16x16.png", dest = "/usr/share/icons/hicolor/16x16/apps/io.github.jyviko.fieldcraft.png", mode = "644" },
+    { source = "../../assets/app-icon/icon.iconset/icon_32x32.png", dest = "/usr/share/icons/hicolor/32x32/apps/io.github.jyviko.fieldcraft.png", mode = "644" },
+    { source = "../../assets/app-icon/icon.iconset/icon_32x32@2x.png", dest = "/usr/share/icons/hicolor/64x64/apps/io.github.jyviko.fieldcraft.png", mode = "644" },
+    { source = "../../assets/app-icon/icon.iconset/icon_128x128.png", dest = "/usr/share/icons/hicolor/128x128/apps/io.github.jyviko.fieldcraft.png", mode = "644" },
+    { source = "../../assets/app-icon/icon.iconset/icon_256x256.png", dest = "/usr/share/icons/hicolor/256x256/apps/io.github.jyviko.fieldcraft.png", mode = "644" },
+    { source = "../../assets/app-icon/icon.iconset/icon_512x512.png", dest = "/usr/share/icons/hicolor/512x512/apps/io.github.jyviko.fieldcraft.png", mode = "644" },
+    { source = "../../assets/app-icon/icon.iconset/icon_512x512@2x.png", dest = "/usr/share/icons/hicolor/1024x1024/apps/io.github.jyviko.fieldcraft.png", mode = "644" },
+    { source = "../../README.md", dest = "/usr/share/doc/fieldcraft/README.md", mode = "644", doc = true },
+    { source = "../../LICENSE-MIT", dest = "/usr/share/doc/fieldcraft/LICENSE-MIT", mode = "644", doc = true },
+    { source = "../../LICENSE-APACHE", dest = "/usr/share/doc/fieldcraft/LICENSE-APACHE", mode = "644", doc = true },
+    { source = "../../NOTICE", dest = "/usr/share/doc/fieldcraft/NOTICE", mode = "644", doc = true },
+    { source = "../../THIRD-PARTY-LICENSES.txt", dest = "/usr/share/doc/fieldcraft/THIRD-PARTY-LICENSES.txt", mode = "644", doc = true },
+]
+# The binaries' ELF dependencies (glibc, libgcc_s) are found automatically; these are opened at run
+# time. Soname provides rather than package names, so the same requirements resolve on Fedora/RHEL
+# and openSUSE.
+require-sh = false
+
+[package.metadata.generate-rpm.requires]
+"libxkbcommon.so.0()(64bit)" = "*"
+"libxkbcommon-x11.so.0()(64bit)" = "*"
+"libwayland-client.so.0()(64bit)" = "*"
+"libX11.so.6()(64bit)" = "*"
+"libX11-xcb.so.1()(64bit)" = "*"
+"libxcb.so.1()(64bit)" = "*"
+"libXcursor.so.1()(64bit)" = "*"
+"libXi.so.6()(64bit)" = "*"
+"(libvulkan.so.1()(64bit) or libEGL.so.1()(64bit))" = ""
+
+[package.metadata.generate-rpm.recommends]
+mesa-vulkan-drivers = "*"
+xdg-desktop-portal = "*"

apps/fieldcraft/src/main.rs

@@ -12,12 +12,15 @@
 #![forbid(unsafe_code)]
 
 mod control_server;
+mod update;
+mod usage;
 
-use fieldcraft_engine::Session;
 use fieldcraft_engine::autosave::{self, Autosaver};
+use fieldcraft_engine::{Session, crash, logfile};
 use fieldcraft_ui_egui::{Filter, ModelApp, Services};
 
-const USAGE: &str = "usage: fieldcraft [--sample [parts|cantilever|impact]] [--control PORT] [FILE…]  (FILE: .fieldcraft, .solidcraft or .3mf)";
+const USAGE: &str =
+    "usage: fieldcraft [--sample [NAME]] [--control PORT] [FILE…]  (NAME: a sample, docs/examples.md; FILE: .fieldcraft, .solidcraft or .3mf)";
 const DEPTH_BITS: u8 = 24;
 /// The window draws its own caption buttons where the OS ones would sit apart from the app bar.
 const CUSTOM_TITLEBAR: bool = !cfg!(target_os = "macos");
@@ -46,6 +49,10 @@ struct App {
     autosaver: Option<Autosaver>,
     /// App time of the last autosave check.
     autosaved_at: f64,
+    /// The first frame was drawn (the crash journal says the app is up).
+    running: bool,
+    /// Sends the anonymous usage events, when this run may (docs/privacy.md).
+    usage: Option<usage::Sender>,
 }
 
 impl App {
@@ -60,6 +67,10 @@ impl App {
 
 impl eframe::App for App {
     fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        if !self.running {
+            self.running = true;
+            crash::activity("running");
+        }
         self.app.logic(ctx);
         if self.app.now - self.autosaved_at >= AUTOSAVE_SECONDS {
             self.autosaved_at = self.app.now;
@@ -75,6 +86,16 @@ impl eframe::App for App {
         {
             log::warn!("autosave: {e}");
         }
+        self.app.usage_closing();
+        if let Some(u) = self.usage.take() {
+            u.finish();
+        }
+        // An update the user chose to install: swapped in now that the window has closed.
+        if let Some(staged) = self.app.take_staged_update() {
+            update::finish(&staged);
+        }
+        log::info!("FieldCraft closed");
+        crash::end_session();
     }
     fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {
         self.app.raw_input_hook(raw);
@@ -94,9 +115,57 @@ fn services() -> Services {
         })),
         // Beside the recovery folder in the per-user data folder.
         recent_path: fieldcraft_io::recovery::default_dir().and_then(|d| d.parent().map(|p| p.join("recent.json"))),
+        prefs: fieldcraft_io::recovery::default_dir()
+            .and_then(|d| d.parent().map(|p| fieldcraft_ui_egui::files::PrefsStore::file(p.join("prefs.json")))),
+        open_url: Some(Box::new(open_url)),
     }
 }
 
+/// Open a web link in the default browser, with the system's own opener: `open` (macOS),
+/// `xdg-open` (Linux and the BSDs), `explorer` (Windows). The link is one argument, never
+/// passed through a shell. Only https links are opened.
+fn open_url(url: &str) -> Result<(), String> {
+    if !url.starts_with("https://") {
+        return Err(format!("not a web link: {}", url.chars().take(80).collect::<String>()));
+    }
+    let opener = if cfg!(target_os = "macos") {
+        "open"
+    } else if cfg!(windows) {
+        "explorer"
+    } else {
+        "xdg-open"
+    };
+    let mut child = std::process::Command::new(opener).arg(url).spawn().map_err(|e| format!("{opener}: {e}"))?;
+    // Reaped off the window thread; its exit status says nothing (`explorer` exits with 1 even
+    // when it opened the link).
+    std::thread::spawn(move || {
+        let _ = child.wait();
+    });
+    Ok(())
+}
+
+/// Crash reports and the log file (docs/crash-reports.md): reports of earlier runs that crashed
+/// come back, for the window to offer. Both live in the app's data folder (a temporary one in
+/// runs driven by automation); `FIELDCRAFT_CRASH_DIR` moves the crash folder.
+fn start_reporting() -> Vec<crash::Summary> {
+    // First the crash reports: an unclean exit's report takes the dead run's lines from the log.
+    let crashed = crash::default_dir().map(|dir| crash::install(dir, crash::Build::current())).unwrap_or_default();
+    match fieldcraft_io::recovery::data_dir().map(|d| logfile::install(&d.join("logs"), log::LevelFilter::Info)) {
+        Some(Ok(path)) => eprintln!("fieldcraft: log {}", path.display()),
+        Some(Err(e)) => eprintln!("fieldcraft: no log file: {e}"),
+        None => {}
+    }
+    let b = crash::Build::current();
+    log::info!(
+        "FieldCraft {} started ({}), crash reports in {}",
+        b.version,
+        b.version_line(),
+        crash::default_dir().map(|d| d.display().to_string()).unwrap_or_default()
+    );
+    crash::activity("startup");
+    crashed
+}
+
 /// Command-line options.
 #[derive(Debug, Default, PartialEq)]
 struct Args {
@@ -148,6 +217,12 @@ fn main() -> eframe::Result {
             std::process::exit(2);
         }
     };
+    if args.control.is_some() {
+        // A run driven by automation keeps its autosaves (and recent files and preferences, which
+        // live beside them), its crash reports and its log in a temporary folder, never the user's.
+        fieldcraft_io::recovery::use_automation_dir();
+    }
+    let crashed = start_reporting();
     let options = eframe::NativeOptions {
         viewport: egui::ViewportBuilder::default()
             .with_title("FieldCraft")
@@ -170,12 +245,26 @@ fn main() -> eframe::Result {
         "FieldCraft",
         options,
         Box::new(move |cc| {
-            let mut app = ModelApp::new(Session::default()).with_services(services());
+            let mut session = Session::default();
+            // The window's model: its commands go into the crash journal.
+            session.crash_journal = crash::enabled();
+            let mut app = ModelApp::new(session).with_services(services());
+            // Anonymous usage: asked once, recorded only when the user agreed (docs/privacy.md).
+            let usage = match usage::host(args.control.is_some()) {
+                Some(host) => {
+                    app = app.with_usage(host);
+                    usage::start()
+                }
+                None => None,
+            };
+            // Updates (docs/updates.md): checked at most daily when on, installed only on a click.
+            fieldcraft_engine::enable_update_checks(true);
+            app = app.with_updates(update::host(cc.egui_ctx.clone(), args.control.is_some()));
             app.custom_titlebar = CUSTOM_TITLEBAR;
             app.integrated_titlebar = cfg!(target_os = "macos");
             if let Some(rs) = &cc.wgpu_render_state {
                 let info = rs.adapter.get_info();
-                eprintln!("fieldcraft: graphics {:?} {}, MSAA {}x (requested {MSAA}x)", info.backend, info.name, rs.msaa_samples);
+                log::info!("graphics {:?} {} ({}), MSAA {}x (requested {MSAA}x)", info.backend, info.name, info.driver, rs.msaa_samples);
                 app.set_wgpu(rs, DEPTH_BITS, rs.msaa_samples, &cc.egui_ctx);
             }
             if let Some(port) = args.control {
@@ -195,7 +284,8 @@ fn main() -> eframe::Result {
                 }
                 Autosaver::new(&dir).map_err(|e| log::warn!("autosave unavailable: {e}")).ok()
             });
-            Ok(Box::new(App { app, autosaver, autosaved_at: 0.0 }))
+            app.announce_crashes(&crashed);
+            Ok(Box::new(App { app, autosaver, autosaved_at: 0.0, running: false, usage }))
         }),
     )
 }

apps/fieldcraft/src/update.rs

@@ -0,0 +1,105 @@
+//! The desktop app's side of updates (docs/updates.md): it runs the window's update jobs
+//! ([`fieldcraft_ui_egui::updates`]) on background threads with [`fieldcraft_update`], and swaps
+//! a staged release in after the window has closed ([`finish`]).
+//!
+//! Automatic checks are off in runs driven by automation (`--control`) and under CI, so test
+//! and agent runs never reach GitHub on their own; `FIELDCRAFT_UPDATE_HOST` (a local test
+//! server) turns them back on. Help › Check for Updates works in every run.
+
+use std::cell::Cell;
+use std::path::Path;
+use std::sync::mpsc;
+
+use fieldcraft_ui_egui::updates::{Event, Job, UpdateHost};
+use fieldcraft_update::install::{self, Finish, Install};
+use fieldcraft_update::net::{Client, Which};
+use fieldcraft_update::stage::{self, Options};
+use fieldcraft_update::{Release, Staged};
+
+/// What the window needs for updates.
+pub fn host(ctx: egui::Context, automation: bool) -> UpdateHost {
+    let here = install::here();
+    log::info!("updates: {}", here.describe());
+    stage::clean_stale(&here);
+    let env = |k: &str| std::env::var_os(k).is_some_and(|v| !v.is_empty());
+    let automatic = env(fieldcraft_update::HOST_ENV) || !(automation || env("CI"));
+    let (tx, events) = mpsc::channel::<Event>();
+    let unsupported = here.unsupported();
+    let start = move |job: Job| {
+        let (tx, ctx, here) = (tx.clone(), ctx.clone(), here.clone());
+        let spawned = std::thread::Builder::new().name("fieldcraft update".into()).spawn(move || {
+            let send = |e: Event| {
+                let _ = tx.send(e);
+                ctx.request_repaint();
+            };
+            let client = Client::from_env();
+            match job {
+                Job::Check { manual } => send(Event::Checked { manual, result: client.check().map_err(|e| e.to_string()) }),
+                Job::Stage(release) => send(Event::Staged(stage_release(&client, &release, &here, &send))),
+                Job::Reinstall => {
+                    let staged = client
+                        .release(&Which::Version(fieldcraft_update::current()))
+                        .map_err(|e| e.to_string())
+                        .and_then(|r| stage_release(&client, &r, &here, &send));
+                    send(Event::Staged(staged));
+                }
+            }
+        });
+        if let Err(e) = spawned {
+            log::warn!("updates: no thread: {e}");
+        }
+    };
+    UpdateHost { unsupported, automatic, start: Box::new(start), events, now: Box::new(now), open_file: Box::new(open_file) }
+}
+
+/// Download, verify and stage `release`, reporting each whole percent.
+fn stage_release(client: &Client, release: &Release, here: &Install, send: &dyn Fn(Event)) -> Result<Staged, String> {
+    let downloads = fieldcraft_io::recovery::data_dir().map(|d| d.join("updates")).unwrap_or_else(|| std::env::temp_dir().join("fieldcraft-updates"));
+    let last = Cell::new(u64::MAX);
+    let progress = |done: u64, total: u64| {
+        let step = done.saturating_mul(100).checked_div(total).unwrap_or(done / (1024 * 1024));
+        if last.replace(step) != step {
+            send(Event::Progress(done, total));
+        }
+    };
+    let options = Options { key: fieldcraft_update::PUBLIC_KEY, downloads: &downloads, arch: std::env::consts::ARCH, progress: &progress };
+    let staged = stage::stage(client, release, here, &options).map_err(|e| e.to_string());
+    match &staged {
+        Ok(s) => log::info!("updates: FieldCraft {} verified and staged at {}", s.version, s.payload.display()),
+        Err(e) => log::warn!("updates: FieldCraft {} not staged: {e}", release.version),
+    }
+    staged
+}
+
+/// Swap `staged` in and start it: the window has closed, its autosave is closed.
+pub fn finish(staged: &Staged) {
+    match install::plan(staged, true) {
+        Ok(Finish::Swap(plan)) => match stage::apply(&plan) {
+            Ok(()) => log::info!("updates: FieldCraft {} installed ({})", staged.version, staged.install.describe()),
+            Err(e) => log::error!("updates: FieldCraft {} not installed, the previous version is kept: {e}", staged.version),
+        },
+        Ok(Finish::Package { .. }) => {}
+        Err(e) => log::error!("updates: {e}"),
+    }
+}
+
+/// Seconds since the Unix epoch.
+fn now() -> u64 {
+    std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0)
+}
+
+/// Open a downloaded package with the system's handler for it (Linux: the software installer).
+fn open_file(path: &Path) -> Result<(), String> {
+    let opener = if cfg!(target_os = "macos") {
+        "open"
+    } else if cfg!(windows) {
+        "explorer"
+    } else {
+        "xdg-open"
+    };
+    let mut child = std::process::Command::new(opener).arg(path).spawn().map_err(|e| format!("{opener}: {e}"))?;
+    std::thread::spawn(move || {
+        let _ = child.wait();
+    });
+    Ok(())
+}

apps/fieldcraft/src/usage.rs

@@ -0,0 +1,116 @@
+//! Sending the anonymous usage events (docs/privacy.md) to PostHog Cloud EU: a background
+//! thread posts the queued events ([`fieldcraft_engine::usage`]) in batches every half minute and
+//! when the window closes. A failed post (offline, a slow network) drops its batch silently;
+//! nothing waits on it but the thread.
+//!
+//! The project key is a build setting, `FIELDCRAFT_POSTHOG_KEY`, which only the release workflow
+//! sets: local, development and fork builds have none and send nothing.
+
+use std::sync::mpsc;
+use std::time::Duration;
+
+use fieldcraft_engine::usage;
+use fieldcraft_ui_egui::privacy::UsageHost;
+
+/// The PostHog project key the release build was made with.
+const KEY: Option<&str> = option_env!("FIELDCRAFT_POSTHOG_KEY");
+/// How often queued events are sent.
+const INTERVAL: Duration = Duration::from_secs(30);
+/// The longest one post may take.
+const TIMEOUT: Duration = Duration::from_secs(10);
+/// How long closing the window waits for the last batch.
+const LAST_WAIT: Duration = Duration::from_secs(2);
+
+fn key() -> Option<&'static str> {
+    KEY.map(str::trim).filter(|k| !k.is_empty())
+}
+
+/// What the window needs to ask and record, when this run may share usage: the build has a key,
+/// `FIELDCRAFT_TELEMETRY` is not `0`, and neither CI nor `--control` automation runs it (unless
+/// `FIELDCRAFT_TELEMETRY=1`).
+pub fn host(automation: bool) -> Option<UsageHost> {
+    let telemetry = std::env::var("FIELDCRAFT_TELEMETRY").ok();
+    let ci = std::env::var_os("CI").is_some_and(|v| !v.is_empty());
+    usage::allowed(key().is_some(), telemetry.as_deref(), automation, ci).then(|| UsageHost {
+        platform: "desktop",
+        os: std::env::consts::OS,
+        arch: std::env::consts::ARCH,
+        new_id: Box::new(new_id),
+    })
+}
+
+/// A random (version 4) UUID from the operating system's random source.
+fn new_id() -> Option<String> {
+    let mut b = [0u8; 16];
+    getrandom::fill(&mut b).ok()?;
+    b[6] = (b[6] & 0x0f) | 0x40;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    let hex: String = b.iter().map(|x| format!("{x:02x}")).collect();
+    Some(format!("{}-{}-{}-{}-{}", &hex[..8], &hex[8..12], &hex[12..16], &hex[16..20], &hex[20..]))
+}
+
+/// The sending thread; [`Sender::finish`] sends what is left and stops it.
+pub struct Sender {
+    stop: mpsc::Sender<()>,
+    finished: mpsc::Receiver<()>,
+}
+
+/// Start the sending thread (only when the build has a key). `FIELDCRAFT_TELEMETRY_HOST`
+/// replaces PostHog's host, for checking the payload against a local listener.
+pub fn start() -> Option<Sender> {
+    let key = key()?;
+    let host = std::env::var("FIELDCRAFT_TELEMETRY_HOST").ok().filter(|h| !h.trim().is_empty()).unwrap_or_else(|| usage::DEFAULT_HOST.into());
+    let url = format!("{}/batch/", host.trim_end_matches('/'));
+    // rustls's process-wide crypto (ring); another part of the app may have installed it first.
+    let _ = rustls::crypto::ring::default_provider().install_default();
+    let agent: ureq::Agent = ureq::Agent::config_builder()
+        .timeout_global(Some(TIMEOUT))
+        .tls_config(ureq::tls::TlsConfig::builder().root_certs(ureq::tls::RootCerts::PlatformVerifier).build())
+        .build()
+        .into();
+    let (stop, stopped) = mpsc::channel::<()>();
+    let (done, finished) = mpsc::channel::<()>();
+    let spawned = std::thread::Builder::new().name("fieldcraft usage".into()).spawn(move || {
+        loop {
+            let last = !matches!(stopped.recv_timeout(INTERVAL), Err(mpsc::RecvTimeoutError::Timeout));
+            while let Some(batch) = usage::take_batch() {
+                if let Err(e) = agent.post(&url).header("Content-Type", "application/json").send(batch.body(key)) {
+                    // Offline or refused: this batch is dropped, the rest waits for the next try.
+                    log::debug!("usage: {} event(s) not sent: {e}", batch.events.len());
+                    break;
+                }
+            }
+            if last {
+                let _ = done.send(());
+                return;
+            }
+        }
+    });
+    match spawned {
+        Ok(_) => Some(Sender { stop, finished }),
+        Err(e) => {
+            log::warn!("usage: no sending thread: {e}");
+            None
+        }
+    }
+}
+
+impl Sender {
+    /// Send what is queued (waiting briefly) and stop.
+    pub fn finish(self) {
+        let _ = self.stop.send(());
+        let _ = self.finished.recv_timeout(LAST_WAIT);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn install_ids_are_random_version_4_uuids() {
+        let (a, b) = (super::new_id().unwrap(), super::new_id().unwrap());
+        assert_ne!(a, b);
+        assert_eq!(a.len(), 36);
+        assert_eq!(a.as_bytes()[14], b'4');
+        assert!(matches!(a.as_bytes()[19], b'8' | b'9' | b'a' | b'b'), "{a}");
+    }
+}

assets/app-icon/FieldCraft.icon/Assets/01-floor-dark.svg

@@ -4,15 +4,15 @@
     <clipPath id="clip-path-1">
       <path d="M320 100 L704 100 C854 100 924 170 924 320 L924 704 C924 854 854 924 704 924 L320 924 C170 924 100 854 100 704 L100 320 C100 170 170 100 320 100 Z"/>
     </clipPath>
-    <radialGradient id="radial-gradient-1" cx="0" cy="0" r="578" gradientTransform="matrix(1 0 0 0.5 512 720)" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#4f8a82"/>
-      <stop offset="0.3" stop-color="#4f8a82" stop-opacity="0.9"/>
-      <stop offset="0.65" stop-color="#4f8a82" stop-opacity="0.35"/>
-      <stop offset="1" stop-color="#4f8a82" stop-opacity="0"/>
+    <radialGradient id="radial-gradient-1" cx="0" cy="0" r="560" gradientTransform="matrix(1 0 0 0.5 512 650)" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#4f6a86"/>
+      <stop offset="0.3" stop-color="#4f6a86" stop-opacity="0.9"/>
+      <stop offset="0.65" stop-color="#4f6a86" stop-opacity="0.35"/>
+      <stop offset="1" stop-color="#4f6a86" stop-opacity="0"/>
     </radialGradient>
   </defs>
   <title>FieldCraft icon floor grid (Dark)</title>
   <g id="Floor_grid" data-name="Floor grid" clip-path="url(#clip-path-1)">
-    <path id="floor_grid" data-name="floor grid" d="M154.62 100 L100 131.53 M869.38 100 L924 131.53 M368.82 100 L100 255.2 M655.18 100 L924 255.2 M583.01 100 L100 378.87 M440.99 100 L924 378.87 M797.21 100 L100 502.53 M226.79 100 L924 502.53 M924 150.47 L100 626.2 M100 150.47 L924 626.2 M924 274.13 L100 749.87 M100 274.13 L924 749.87 M924 397.8 L100 873.53 M100 397.8 L924 873.53 M924 521.47 L226.79 924 M100 521.47 L797.21 924 M924 645.13 L440.99 924 M100 645.13 L583.01 924 M924 768.8 L655.18 924 M100 768.8 L368.82 924 M924 892.47 L869.38 924 M100 892.47 L154.62 924" fill="none" stroke="url(#radial-gradient-1)" stroke-width="3" stroke-linejoin="round"/>
+    <path id="floor_grid" data-name="floor grid" d="M165.59 100 L100 137.87 M858.41 100 L924 137.87 M295.49 100 L100 212.87 M728.51 100 L924 212.87 M425.4 100 L100 287.87 M598.6 100 L924 287.87 M555.3 100 L100 362.87 M468.7 100 L924 362.87 M685.21 100 L100 437.87 M338.79 100 L924 437.87 M815.11 100 L100 512.87 M208.89 100 L924 512.87 M924 112.13 L100 587.87 M100 112.13 L924 587.87 M924 187.13 L100 662.87 M100 187.13 L924 662.87 M924 262.13 L100 737.87 M100 262.13 L924 737.87 M924 337.13 L100 812.87 M100 337.13 L924 812.87 M924 412.13 L100 887.87 M100 412.13 L924 887.87 M924 487.13 L167.32 924 M100 487.13 L856.68 924 M924 562.13 L297.23 924 M100 562.13 L726.77 924 M924 637.13 L427.13 924 M100 637.13 L596.87 924 M924 712.13 L557.03 924 M100 712.13 L466.97 924 M924 787.13 L686.94 924 M100 787.13 L337.06 924 M924 862.13 L816.84 924 M100 862.13 L207.16 924" fill="none" stroke="url(#radial-gradient-1)" stroke-width="3" stroke-linejoin="round"/>
   </g>
 </svg>

assets/app-icon/FieldCraft.icon/Assets/01-floor.svg

@@ -4,15 +4,15 @@
     <clipPath id="clip-path-1">
       <path d="M320 100 L704 100 C854 100 924 170 924 320 L924 704 C924 854 854 924 704 924 L320 924 C170 924 100 854 100 704 L100 320 C100 170 170 100 320 100 Z"/>
     </clipPath>
-    <radialGradient id="radial-gradient-1" cx="0" cy="0" r="578" gradientTransform="matrix(1 0 0 0.5 512 720)" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#7fa8a2"/>
-      <stop offset="0.3" stop-color="#7fa8a2" stop-opacity="0.9"/>
-      <stop offset="0.65" stop-color="#7fa8a2" stop-opacity="0.35"/>
-      <stop offset="1" stop-color="#7fa8a2" stop-opacity="0"/>
+    <radialGradient id="radial-gradient-1" cx="0" cy="0" r="560" gradientTransform="matrix(1 0 0 0.5 512 650)" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#8aa0b4"/>
+      <stop offset="0.3" stop-color="#8aa0b4" stop-opacity="0.9"/>
+      <stop offset="0.65" stop-color="#8aa0b4" stop-opacity="0.35"/>
+      <stop offset="1" stop-color="#8aa0b4" stop-opacity="0"/>
     </radialGradient>
   </defs>
   <title>FieldCraft icon floor grid</title>
   <g id="Floor_grid" data-name="Floor grid" clip-path="url(#clip-path-1)">
-    <path id="floor_grid" data-name="floor grid" d="M154.62 100 L100 131.53 M869.38 100 L924 131.53 M368.82 100 L100 255.2 M655.18 100 L924 255.2 M583.01 100 L100 378.87 M440.99 100 L924 378.87 M797.21 100 L100 502.53 M226.79 100 L924 502.53 M924 150.47 L100 626.2 M100 150.47 L924 626.2 M924 274.13 L100 749.87 M100 274.13 L924 749.87 M924 397.8 L100 873.53 M100 397.8 L924 873.53 M924 521.47 L226.79 924 M100 521.47 L797.21 924 M924 645.13 L440.99 924 M100 645.13 L583.01 924 M924 768.8 L655.18 924 M100 768.8 L368.82 924 M924 892.47 L869.38 924 M100 892.47 L154.62 924" fill="none" stroke="url(#radial-gradient-1)" stroke-width="3" stroke-linejoin="round"/>
+    <path id="floor_grid" data-name="floor grid" d="M165.59 100 L100 137.87 M858.41 100 L924 137.87 M295.49 100 L100 212.87 M728.51 100 L924 212.87 M425.4 100 L100 287.87 M598.6 100 L924 287.87 M555.3 100 L100 362.87 M468.7 100 L924 362.87 M685.21 100 L100 437.87 M338.79 100 L924 437.87 M815.11 100 L100 512.87 M208.89 100 L924 512.87 M924 112.13 L100 587.87 M100 112.13 L924 587.87 M924 187.13 L100 662.87 M100 187.13 L924 662.87 M924 262.13 L100 737.87 M100 262.13 L924 737.87 M924 337.13 L100 812.87 M100 337.13 L924 812.87 M924 412.13 L100 887.87 M100 412.13 L924 887.87 M924 487.13 L167.32 924 M100 487.13 L856.68 924 M924 562.13 L297.23 924 M100 562.13 L726.77 924 M924 637.13 L427.13 924 M100 637.13 L596.87 924 M924 712.13 L557.03 924 M100 712.13 L466.97 924 M924 787.13 L686.94 924 M100 787.13 L337.06 924 M924 862.13 L816.84 924 M100 862.13 L207.16 924" fill="none" stroke="url(#radial-gradient-1)" stroke-width="3" stroke-linejoin="round"/>
   </g>
 </svg>

assets/app-icon/FieldCraft.icon/Assets/02-part.svg

@@ -1,38 +1,51 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1024" height="1024" viewBox="0 0 1024 1024">
   <defs>
-    <linearGradient id="linear-gradient-1" x1="512" y1="141" x2="512" y2="376.622" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#86e3d3"/>
-      <stop offset="1" stop-color="#4cc4b1"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-2" x1="512" y1="457.259" x2="512" y2="755.042" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#86e3d3"/>
-      <stop offset="1" stop-color="#4cc4b1"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-3" x1="512" y1="209.598" x2="512" y2="624.284" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#20b39f"/>
-      <stop offset="1" stop-color="#118c7c"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-4" x1="512" y1="588.018" x2="512" y2="878.381" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#20b39f"/>
-      <stop offset="1" stop-color="#118c7c"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-5" x1="512" y1="335.738" x2="512" y2="878.381" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#0f786d"/>
-      <stop offset="1" stop-color="#0a544e"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-6" x1="512" y1="558.616" x2="512" y2="658.304" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#0b665e"/>
-      <stop offset="1" stop-color="#04302c"/>
-    </linearGradient>
+    <clipPath id="clip-path-1">
+      <path d="M512 200 L764.81 345.96 L512 491.92 L259.19 345.96 Z"/>
+    </clipPath>
+    <clipPath id="clip-path-2">
+      <path d="M252.19 358.08 L505 504.04 L505 795.96 L252.19 650 Z"/>
+    </clipPath>
+    <clipPath id="clip-path-3">
+      <path d="M771.81 650 L519 795.96 L519 504.04 L771.81 358.08 Z"/>
+    </clipPath>
+    <clipPath id="clip-path-4">
+      <path d="M512 200 L764.81 345.96 L512 491.92 L259.19 345.96 Z M252.19 358.08 L505 504.04 L505 795.96 L252.19 650 Z M771.81 650 L519 795.96 L519 504.04 L771.81 358.08 Z"/>
+    </clipPath>
   </defs>
-  <title>FieldCraft icon part</title>
-  <g id="Part">
-    <path id="wall_top" data-name="wall top" d="M512 141 L825.3 321.88 L730.48 376.62 L417.19 195.74 Z" fill="url(#linear-gradient-1)"/>
-    <path id="base_top" data-name="base top" d="M401.19 457.26 L714.48 638.14 L512 755.04 L198.7 574.16 Z M521.64 643.71 C555.35 624.24 555.35 592.68 521.64 573.22 C487.92 553.75 433.26 553.75 399.55 573.22 C365.83 592.68 365.83 624.24 399.55 643.71 C433.26 663.17 487.92 663.17 521.64 643.71 Z" fill="url(#linear-gradient-2)"/>
-    <path id="wall_front" data-name="wall front" d="M409.19 209.6 L722.48 390.48 L722.48 624.28 L409.19 443.4 Z" fill="url(#linear-gradient-3)"/>
-    <path id="base_front" data-name="base front" d="M190.7 588.02 L504 768.9 L504 878.38 L190.7 697.5 Z" fill="url(#linear-gradient-4)"/>
-    <path id="end" d="M833.3 697.5 L520 878.38 L520 768.9 L738.48 642.76 L738.48 390.48 L833.3 335.74 Z" fill="url(#linear-gradient-5)"/>
-    <path id="bolt_hole" data-name="bolt hole" d="M521.64 643.71 C487.92 663.17 433.26 663.17 399.55 643.71 C365.83 624.24 365.83 592.68 399.55 573.22 C433.26 553.75 487.92 553.75 521.64 573.22 C555.35 592.68 555.35 624.24 521.64 643.71 Z" fill="url(#linear-gradient-6)"/>
+  <title>FieldCraft icon cube</title>
+  <g id="Top_face" data-name="Top face" clip-path="url(#clip-path-1)">
+    <path id="top" d="M512 200 L764.81 345.96 L512 491.92 L259.19 345.96 Z" fill="#2c4fbf"/>
+    <path id="top_band_1" data-name="top band 1" d="M844.55 692 C660.89 798.04 363.11 798.04 179.45 692 C-4.22 585.96 -4.22 414.04 179.45 308 C363.11 201.96 660.89 201.96 844.55 308 C1028.22 414.04 1028.22 585.96 844.55 692 Z" fill="#2f86e0"/>
+    <path id="top_band_2" data-name="top band 2" d="M789.99 660.5 C636.46 749.14 387.54 749.14 234.01 660.5 C80.47 571.86 80.47 428.14 234.01 339.5 C387.54 250.86 636.46 250.86 789.99 339.5 C943.53 428.14 943.53 571.86 789.99 660.5 Z" fill="#22bcd8"/>
+    <path id="top_band_3" data-name="top band 3" d="M738.03 630.5 C613.2 702.57 410.8 702.57 285.97 630.5 C161.13 558.43 161.13 441.57 285.97 369.5 C410.8 297.43 613.2 297.43 738.03 369.5 C862.87 441.57 862.87 558.43 738.03 630.5 Z" fill="#3fc584"/>
+    <path id="top_band_4" data-name="top band 4" d="M686.07 600.5 C589.93 656 434.07 656 337.93 600.5 C241.79 545 241.79 455 337.93 399.5 C434.07 344 589.93 344 686.07 399.5 C782.21 455 782.21 545 686.07 600.5 Z" fill="#f0d13a"/>
+    <path id="top_band_5" data-name="top band 5" d="M634.11 570.5 C566.67 609.44 457.33 609.44 389.89 570.5 C322.45 531.56 322.45 468.44 389.89 429.5 C457.33 390.56 566.67 390.56 634.11 429.5 C701.55 468.44 701.55 531.56 634.11 570.5 Z" fill="#f28a2b"/>
+    <path id="top_band_6" data-name="top band 6" d="M582.15 540.5 C543.41 562.87 480.59 562.87 441.85 540.5 C403.11 518.13 403.11 481.87 441.85 459.5 C480.59 437.13 543.41 437.13 582.15 459.5 C620.89 481.87 620.89 518.13 582.15 540.5 Z" fill="#de3b2f"/>
+    <path id="top_shade" data-name="top shade" d="M512 200 L764.81 345.96 L512 491.92 L259.19 345.96 Z" fill="#ffffff" opacity="0.1"/>
+  </g>
+  <g id="Left_face" data-name="Left face" clip-path="url(#clip-path-2)">
+    <path id="left" d="M252.19 358.08 L505 504.04 L505 795.96 L252.19 650 Z" fill="#2c4fbf"/>
+    <path id="left_band_1" data-name="left band 1" d="M844.55 692 C844.55 479.92 695.66 222.04 512 116 C328.34 9.96 179.45 95.92 179.45 308 C179.45 520.08 328.34 777.96 512 884 C695.66 990.04 844.55 904.08 844.55 692 Z" fill="#2f86e0"/>
+    <path id="left_band_2" data-name="left band 2" d="M789.99 660.5 C789.99 483.22 665.53 267.64 512 179 C358.47 90.36 234.01 162.22 234.01 339.5 C234.01 516.78 358.47 732.36 512 821 C665.53 909.64 789.99 837.78 789.99 660.5 Z" fill="#22bcd8"/>
+    <path id="left_band_3" data-name="left band 3" d="M738.03 630.5 C738.03 486.35 636.83 311.07 512 239 C387.17 166.93 285.97 225.35 285.97 369.5 C285.97 513.65 387.17 688.93 512 761 C636.83 833.07 738.03 774.65 738.03 630.5 Z" fill="#3fc584"/>
+    <path id="left_band_4" data-name="left band 4" d="M686.07 600.5 C686.07 489.49 608.14 354.5 512 299 C415.86 243.5 337.93 288.49 337.93 399.5 C337.93 510.51 415.86 645.5 512 701 C608.14 756.5 686.07 711.51 686.07 600.5 Z" fill="#f0d13a"/>
+    <path id="left_band_5" data-name="left band 5" d="M634.11 570.5 C634.11 492.63 579.44 397.94 512 359 C444.56 320.06 389.89 351.63 389.89 429.5 C389.89 507.37 444.56 602.06 512 641 C579.44 679.94 634.11 648.37 634.11 570.5 Z" fill="#f28a2b"/>
+    <path id="left_band_6" data-name="left band 6" d="M582.15 540.5 C582.15 495.76 550.74 441.37 512 419 C473.26 396.63 441.85 414.76 441.85 459.5 C441.85 504.24 473.26 558.63 512 581 C550.74 603.37 582.15 585.24 582.15 540.5 Z" fill="#de3b2f"/>
+    <path id="left_shade" data-name="left shade" d="M252.19 358.08 L505 504.04 L505 795.96 L252.19 650 Z" fill="#000000" opacity="0.12"/>
+  </g>
+  <g id="Right_face" data-name="Right face" clip-path="url(#clip-path-3)">
+    <path id="right" d="M771.81 650 L519 795.96 L519 504.04 L771.81 358.08 Z" fill="#2c4fbf"/>
+    <path id="right_band_1" data-name="right band 1" d="M179.45 692 C179.45 479.92 328.34 222.04 512 116 C695.66 9.96 844.55 95.92 844.55 308 C844.55 520.08 695.66 777.96 512 884 C328.34 990.04 179.45 904.08 179.45 692 Z" fill="#2f86e0"/>
+    <path id="right_band_2" data-name="right band 2" d="M234.01 660.5 C234.01 483.22 358.47 267.64 512 179 C665.53 90.36 789.99 162.22 789.99 339.5 C789.99 516.78 665.53 732.36 512 821 C358.47 909.64 234.01 837.78 234.01 660.5 Z" fill="#22bcd8"/>
+    <path id="right_band_3" data-name="right band 3" d="M285.97 630.5 C285.97 486.35 387.17 311.07 512 239 C636.83 166.93 738.03 225.35 738.03 369.5 C738.03 513.65 636.83 688.93 512 761 C387.17 833.07 285.97 774.65 285.97 630.5 Z" fill="#3fc584"/>
+    <path id="right_band_4" data-name="right band 4" d="M337.93 600.5 C337.93 489.49 415.86 354.5 512 299 C608.14 243.5 686.07 288.49 686.07 399.5 C686.07 510.51 608.14 645.5 512 701 C415.86 756.5 337.93 711.51 337.93 600.5 Z" fill="#f0d13a"/>
+    <path id="right_band_5" data-name="right band 5" d="M389.89 570.5 C389.89 492.63 444.56 397.94 512 359 C579.44 320.06 634.11 351.63 634.11 429.5 C634.11 507.37 579.44 602.06 512 641 C444.56 679.94 389.89 648.37 389.89 570.5 Z" fill="#f28a2b"/>
+    <path id="right_band_6" data-name="right band 6" d="M441.85 540.5 C441.85 495.76 473.26 441.37 512 419 C550.74 396.63 582.15 414.76 582.15 459.5 C582.15 504.24 550.74 558.63 512 581 C473.26 603.37 441.85 585.24 441.85 540.5 Z" fill="#de3b2f"/>
+    <path id="right_shade" data-name="right shade" d="M771.81 650 L519 795.96 L519 504.04 L771.81 358.08 Z" fill="#000000" opacity="0.3"/>
+  </g>
+  <g id="Mesh" clip-path="url(#clip-path-4)">
+    <path id="hexahedral_mesh" data-name="hexahedral mesh" d="M576.95 237.5 L317.14 387.5 M447.05 237.5 L706.86 387.5 M317.14 687.5 L317.14 387.5 M252.19 575 L512 725 M706.86 687.5 L706.86 387.5 M771.81 575 L512 725 M641.9 275 L382.1 425 M382.1 275 L641.9 425 M382.1 725 L382.1 425 M252.19 500 L512 650 M641.9 725 L641.9 425 M771.81 500 L512 650 M706.86 312.5 L447.05 462.5 M317.14 312.5 L576.95 462.5 M447.05 762.5 L447.05 462.5 M252.19 425 L512 575 M576.95 762.5 L576.95 462.5 M771.81 425 L512 575" fill="none" stroke="#0b2236" stroke-width="3.5" stroke-linejoin="round" opacity="0.45"/>
   </g>
 </svg>

assets/app-icon/FieldCraft.icon/Assets/03-mesh.svg

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1024" height="1024" viewBox="0 0 1024 1024">
-  <defs>
-    <clipPath id="clip-path-1">
-      <path d="M512 141 L825.3 321.88 L730.48 376.62 L417.19 195.74 Z M401.19 457.26 L714.48 638.14 L512 755.04 L198.7 574.16 Z M521.64 643.71 C555.35 624.24 555.35 592.68 521.64 573.22 C487.92 553.75 433.26 553.75 399.55 573.22 C365.83 592.68 365.83 624.24 399.55 643.71 C433.26 663.17 487.92 663.17 521.64 643.71 Z M409.19 209.6 L722.48 390.48 L722.48 624.28 L409.19 443.4 Z M190.7 588.02 L504 768.9 L504 878.38 L190.7 697.5 Z M833.3 697.5 L520 878.38 L520 768.9 L738.48 642.76 L738.48 390.48 L833.3 335.74 Z"/>
-    </clipPath>
-  </defs>
-  <title>FieldCraft icon mesh</title>
-  <g id="Mesh" clip-path="url(#clip-path-1)">
-    <path id="hexahedral_mesh" data-name="hexahedral mesh" d="M460.59 482.32 L242.11 608.46 M679.07 608.46 L460.59 734.6 M354.57 484.18 L405.97 513.86 M624.45 640 L675.86 669.67 M299.95 515.71 L351.35 545.39 M569.83 671.53 L621.24 701.21 M245.32 547.25 L296.73 576.92 M515.21 703.07 L566.62 732.75 M460.59 482.32 L460.59 230.04 M563.41 170.68 L460.59 230.04 M515.21 513.86 L515.21 261.57 M618.03 202.22 L515.21 261.57 M569.83 545.39 L569.83 293.11 M672.65 233.75 L569.83 293.11 M624.45 576.93 L624.45 324.65 M727.27 265.29 L624.45 324.65 M679.07 608.46 L679.07 356.18 M781.89 296.82 L679.07 356.18 M409.19 389.57 L730.48 575.07 M409.19 326.5 L730.48 512 M409.19 263.43 L730.48 448.93 M460.59 170.68 L781.89 356.18 M242.11 727.18 L242.11 608.46 M296.73 758.72 L296.73 640 M351.35 790.25 L351.35 671.53 M405.97 821.79 L405.97 703.07 M460.59 853.32 L460.59 734.6 M190.7 638.14 L512 823.64 M781.89 727.18 L781.89 356.18 M730.48 756.86 L730.48 638.14 M675.86 788.39 L675.86 669.67 M621.24 819.93 L621.24 701.21 M566.62 851.47 L566.62 732.75 M833.3 638.14 L512 823.64 M833.3 578.78 L730.48 638.14 M833.3 515.71 L730.48 575.07 M833.3 452.64 L730.48 512 M833.3 389.57 L730.48 448.93 M460.59 558.62 L460.59 482.32 M433.29 561.17 L405.97 513.86 M399.55 573.22 L351.35 545.39 M378.69 592.7 L296.73 576.92 M374.26 608.46 L242.11 608.46 M487.89 561.17 L515.21 513.86 M378.69 624.22 L296.73 640 M521.64 573.22 L569.83 545.39 M399.55 643.71 L351.35 671.53 M542.49 592.7 L624.45 576.92 M433.29 655.75 L405.97 703.06 M546.92 608.46 L679.07 608.46 M542.49 624.22 L624.45 640 M521.64 643.71 L569.83 671.53 M487.89 655.75 L515.21 703.07 M460.59 658.3 L460.59 734.6 M545.74 657.62 L540.09 660.8 L534.3 663.92 L528.33 666.99 L522.16 670.03 L515.76 673.05 L509.11 676.08 L502.15 679.15 L494.85 682.27 L487.14 685.51 L478.94 688.9 L470.14 692.52 L460.59 696.45 L451.05 692.52 L442.25 688.9 L434.05 685.51 L426.34 682.27 L419.03 679.15 L412.08 676.08 L405.42 673.05 L399.02 670.03 L392.86 666.99 L386.89 663.92 L381.09 660.8 L375.45 657.62 L369.94 654.36 L364.54 651.01 L359.22 647.57 L353.95 644.01 L348.72 640.31 L343.47 636.47 L338.16 632.45 L332.74 628.24 L327.14 623.79 L321.26 619.05 L315 613.97 L308.19 608.46 L315 602.95 L321.26 597.87 L327.14 593.13 L332.74 588.68 L338.16 584.47 L343.47 580.45 L348.72 576.61 L353.95 572.91 L359.22 569.35 L364.54 565.91 L369.94 562.56 L375.45 559.3 L381.09 556.12 L386.89 553 L392.86 549.93 L399.02 546.89 L405.42 543.87 L412.08 540.84 L419.03 537.77 L426.34 534.65 L434.05 531.41 L442.25 528.02 L451.05 524.4 L460.59 520.47 L470.14 524.4 L478.94 528.02 L487.14 531.41 L494.85 534.65 L502.15 537.77 L509.11 540.84 L515.76 543.87 L522.16 546.89 L528.33 549.93 L534.3 553 L540.09 556.12 L545.74 559.3 L551.25 562.56 L556.65 565.91 L561.97 569.35 L567.23 572.91 L572.47 576.61 L577.72 580.45 L583.02 584.47 L588.44 588.68 L594.05 593.13 L599.92 597.87 L606.19 602.95 L613 608.46 L606.19 613.97 L599.92 619.05 L594.05 623.79 L588.44 628.24 L583.02 632.45 L577.72 636.47 L572.47 640.31 L567.23 644.01 L561.97 647.57 L556.65 651.01 L551.25 654.36 Z" fill="none" stroke="#ffffff" stroke-width="4.5" stroke-linejoin="round" opacity="0.5"/>
-  </g>
-</svg>

assets/app-icon/FieldCraft.icon/icon.json

@@ -1,37 +1,6 @@
 {
   "fill": "system-light",
   "groups": [
-    {
-      "layers": [
-        {
-          "glass-specializations": [
-            {
-              "appearance": "tinted",
-              "value": true
-            }
-          ],
-          "image-name": "03-mesh.svg",
-          "name": "03-mesh",
-          "position": {
-            "scale": 0.9,
-            "translation-in-points": [
-              0,
-              0
-            ]
-          }
-        }
-      ],
-      "name": "03 Mesh",
-      "shadow": {
-        "kind": "none",
-        "opacity": 0
-      },
-      "specular": false,
-      "translucency": {
-        "enabled": false,
-        "value": 0.3
-      }
-    },
     {
       "layers": [
         {

assets/app-icon/README.md

@@ -1,10 +1,11 @@
 # FieldCraft application icon
 
-FieldCraft's mark is an L-shaped bracket with a bolt hole, drawn in isometric view and covered
-by a structured hexahedral mesh with an O-grid around the hole. Its faces are separated by
+FieldCraft's mark is a cube in isometric view, covered by a structured hexahedral mesh, whose
+faces carry a banded colour fringe (blue to red, hottest at the front corner) as a stress or
+temperature result would. Its faces are separated by
 transparent gaps rather than painted edge lines, so the backdrop shows through them in every
 appearance. It is original artwork, attributed in `ATTRIBUTION.md`, and shares the Craft
-family's layout (rounded-square backdrop, isometric floor grid, lit top faces) in its own teal.
+family's layout (rounded-square backdrop, isometric floor grid, lit top faces).
 
 Everything here is generated by `cargo xtask app-icon` (`xtask/src/app_icon.rs`), which computes
 the geometry and draws it with VectorCraft's command-line tool (`VECTORCRAFT_CLI`, else
@@ -14,10 +15,10 @@ hand. It runs on macOS (sips, iconutil, `xcrun actool`) with ImageMagick (`magic
 | File | What it is |
 |---|---|
 | `icon.vectorcraft`, `icon.svg`, `icon.png` | The full icon on its backdrop, 1024 × 1024 |
-| `icon-small.vectorcraft`, `icon-small.svg`, `icon-small.png` | Small-size artwork used at 16–32 px: no mesh or floor grid, faces edge to edge |
+| `icon-small.vectorcraft`, `icon-small.svg`, `icon-small.png` | Small-size artwork used at 16–32 px: the fringe cube alone, no mesh or floor grid, faces edge to edge |
 | `icon.iconset/`, `icon.icns` | macOS iconset (sips) and its iconutil compilation |
 | `icon.ico` | Windows icon, 16–256 px |
-| `FieldCraft.icon/` | Icon Composer document: floor grid (Default and Dark), part and mesh layers, each scaled to 90% |
+| `FieldCraft.icon/` | Icon Composer document: floor grid (Default and Dark), and cube (faces and mesh) layers, each scaled to 90% |
 | `layers/*.vectorcraft` | Editable sources of the Icon Composer layers |
 | `Assets.car` | `actool` compilation of `FieldCraft.icon` for macOS 26 and later (needs Xcode 26 or later; the task skips it with a note otherwise) |
 

assets/app-icon/icon-small.svg

@@ -1,35 +1,20 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1024" height="1024" viewBox="0 0 1024 1024">
   <defs>
-    <filter id="filter-1" filterUnits="userSpaceOnUse" x="67" y="67" width="890" height="890" data-vc-blend="multiply" color-interpolation-filters="sRGB"><feGaussianBlur in="SourceAlpha" stdDeviation="7"/><feOffset dx="0" dy="10" result="shadow"/><feFlood flood-color="#1d3b38" flood-opacity="0.22"/><feComposite in2="shadow" operator="in" result="paint"/><feMerge><feMergeNode in="paint"/><feMergeNode in="SourceGraphic"/></feMerge></filter>
+    <filter id="filter-1" filterUnits="userSpaceOnUse" x="67" y="67" width="890" height="890" data-vc-blend="multiply" color-interpolation-filters="sRGB"><feGaussianBlur in="SourceAlpha" stdDeviation="7"/><feOffset dx="0" dy="10" result="shadow"/><feFlood flood-color="#1d2b3b" flood-opacity="0.22"/><feComposite in2="shadow" operator="in" result="paint"/><feMerge><feMergeNode in="paint"/><feMergeNode in="SourceGraphic"/></feMerge></filter>
     <linearGradient id="linear-gradient-1" x1="512" y1="100" x2="512" y2="924" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#fbfdfd"/>
-      <stop offset="1" stop-color="#dbe5e4"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-2" x1="512" y1="141" x2="512" y2="385.86" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#86e3d3"/>
-      <stop offset="1" stop-color="#4cc4b1"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-3" x1="512" y1="452.64" x2="512" y2="764.28" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#86e3d3"/>
-      <stop offset="1" stop-color="#4cc4b1"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-4" x1="512" y1="200.36" x2="512" y2="638.14" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#20b39f"/>
-      <stop offset="1" stop-color="#118c7c"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-5" x1="512" y1="578.78" x2="512" y2="883" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#20b39f"/>
-      <stop offset="1" stop-color="#118c7c"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-6" x1="512" y1="326.5" x2="512" y2="883" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#0f786d"/>
-      <stop offset="1" stop-color="#0a544e"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-7" x1="512" y1="558.616" x2="512" y2="658.304" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#0b665e"/>
-      <stop offset="1" stop-color="#04302c"/>
+      <stop offset="0" stop-color="#fbfcfe"/>
+      <stop offset="1" stop-color="#dce3ec"/>
     </linearGradient>
+    <clipPath id="clip-path-1">
+      <path d="M512 200 L771.81 350 L512 500 L252.19 350 Z"/>
+    </clipPath>
+    <clipPath id="clip-path-2">
+      <path d="M252.19 350 L512 500 L512 800 L252.19 650 Z"/>
+    </clipPath>
+    <clipPath id="clip-path-3">
+      <path d="M771.81 650 L512 800 L512 500 L771.81 350 Z"/>
+    </clipPath>
   </defs>
   <title>FieldCraft application icon, small sizes</title>
   <g id="Backdrop">
@@ -37,12 +22,34 @@
       <path id="backdrop" d="M320 100 L704 100 C854 100 924 170 924 320 L924 704 C924 854 854 924 704 924 L320 924 C170 924 100 854 100 704 L100 320 C100 170 170 100 320 100 Z" fill="url(#linear-gradient-1)"/>
     </g>
   </g>
-  <g id="Part">
-    <path id="wall_top" data-name="wall top" d="M512 141 L833.3 326.5 L730.48 385.86 L409.19 200.36 Z" fill="url(#linear-gradient-2)"/>
-    <path id="base_top" data-name="base top" d="M409.19 452.64 L730.48 638.14 L512 764.28 L190.7 578.78 Z M521.64 643.71 C555.35 624.24 555.35 592.68 521.64 573.22 C487.92 553.75 433.26 553.75 399.55 573.22 C365.83 592.68 365.83 624.24 399.55 643.71 C433.26 663.17 487.92 663.17 521.64 643.71 Z" fill="url(#linear-gradient-3)"/>
-    <path id="wall_front" data-name="wall front" d="M409.19 200.36 L730.48 385.86 L730.48 638.14 L409.19 452.64 Z" fill="url(#linear-gradient-4)"/>
-    <path id="base_front" data-name="base front" d="M190.7 578.78 L512 764.28 L512 883 L190.7 697.5 Z" fill="url(#linear-gradient-5)"/>
-    <path id="end" d="M833.3 697.5 L512 883 L512 764.28 L730.48 638.14 L730.48 385.86 L833.3 326.5 Z" fill="url(#linear-gradient-6)"/>
-    <path id="bolt_hole" data-name="bolt hole" d="M521.64 643.71 C487.92 663.17 433.26 663.17 399.55 643.71 C365.83 624.24 365.83 592.68 399.55 573.22 C433.26 553.75 487.92 553.75 521.64 573.22 C555.35 592.68 555.35 624.24 521.64 643.71 Z" fill="url(#linear-gradient-7)"/>
+  <g id="Top_face" data-name="Top face" clip-path="url(#clip-path-1)">
+    <path id="top" d="M512 200 L771.81 350 L512 500 L252.19 350 Z" fill="#2c4fbf"/>
+    <path id="top_band_1" data-name="top band 1" d="M844.55 692 C660.89 798.04 363.11 798.04 179.45 692 C-4.22 585.96 -4.22 414.04 179.45 308 C363.11 201.96 660.89 201.96 844.55 308 C1028.22 414.04 1028.22 585.96 844.55 692 Z" fill="#2f86e0"/>
+    <path id="top_band_2" data-name="top band 2" d="M789.99 660.5 C636.46 749.14 387.54 749.14 234.01 660.5 C80.47 571.86 80.47 428.14 234.01 339.5 C387.54 250.86 636.46 250.86 789.99 339.5 C943.53 428.14 943.53 571.86 789.99 660.5 Z" fill="#22bcd8"/>
+    <path id="top_band_3" data-name="top band 3" d="M738.03 630.5 C613.2 702.57 410.8 702.57 285.97 630.5 C161.13 558.43 161.13 441.57 285.97 369.5 C410.8 297.43 613.2 297.43 738.03 369.5 C862.87 441.57 862.87 558.43 738.03 630.5 Z" fill="#3fc584"/>
+    <path id="top_band_4" data-name="top band 4" d="M686.07 600.5 C589.93 656 434.07 656 337.93 600.5 C241.79 545 241.79 455 337.93 399.5 C434.07 344 589.93 344 686.07 399.5 C782.21 455 782.21 545 686.07 600.5 Z" fill="#f0d13a"/>
+    <path id="top_band_5" data-name="top band 5" d="M634.11 570.5 C566.67 609.44 457.33 609.44 389.89 570.5 C322.45 531.56 322.45 468.44 389.89 429.5 C457.33 390.56 566.67 390.56 634.11 429.5 C701.55 468.44 701.55 531.56 634.11 570.5 Z" fill="#f28a2b"/>
+    <path id="top_band_6" data-name="top band 6" d="M582.15 540.5 C543.41 562.87 480.59 562.87 441.85 540.5 C403.11 518.13 403.11 481.87 441.85 459.5 C480.59 437.13 543.41 437.13 582.15 459.5 C620.89 481.87 620.89 518.13 582.15 540.5 Z" fill="#de3b2f"/>
+    <path id="top_shade" data-name="top shade" d="M512 200 L771.81 350 L512 500 L252.19 350 Z" fill="#ffffff" opacity="0.1"/>
+  </g>
+  <g id="Left_face" data-name="Left face" clip-path="url(#clip-path-2)">
+    <path id="left" d="M252.19 350 L512 500 L512 800 L252.19 650 Z" fill="#2c4fbf"/>
+    <path id="left_band_1" data-name="left band 1" d="M844.55 692 C844.55 479.92 695.66 222.04 512 116 C328.34 9.96 179.45 95.92 179.45 308 C179.45 520.08 328.34 777.96 512 884 C695.66 990.04 844.55 904.08 844.55 692 Z" fill="#2f86e0"/>
+    <path id="left_band_2" data-name="left band 2" d="M789.99 660.5 C789.99 483.22 665.53 267.64 512 179 C358.47 90.36 234.01 162.22 234.01 339.5 C234.01 516.78 358.47 732.36 512 821 C665.53 909.64 789.99 837.78 789.99 660.5 Z" fill="#22bcd8"/>
+    <path id="left_band_3" data-name="left band 3" d="M738.03 630.5 C738.03 486.35 636.83 311.07 512 239 C387.17 166.93 285.97 225.35 285.97 369.5 C285.97 513.65 387.17 688.93 512 761 C636.83 833.07 738.03 774.65 738.03 630.5 Z" fill="#3fc584"/>
+    <path id="left_band_4" data-name="left band 4" d="M686.07 600.5 C686.07 489.49 608.14 354.5 512 299 C415.86 243.5 337.93 288.49 337.93 399.5 C337.93 510.51 415.86 645.5 512 701 C608.14 756.5 686.07 711.51 686.07 600.5 Z" fill="#f0d13a"/>
+    <path id="left_band_5" data-name="left band 5" d="M634.11 570.5 C634.11 492.63 579.44 397.94 512 359 C444.56 320.06 389.89 351.63 389.89 429.5 C389.89 507.37 444.56 602.06 512 641 C579.44 679.94 634.11 648.37 634.11 570.5 Z" fill="#f28a2b"/>
+    <path id="left_band_6" data-name="left band 6" d="M582.15 540.5 C582.15 495.76 550.74 441.37 512 419 C473.26 396.63 441.85 414.76 441.85 459.5 C441.85 504.24 473.26 558.63 512 581 C550.74 603.37 582.15 585.24 582.15 540.5 Z" fill="#de3b2f"/>
+    <path id="left_shade" data-name="left shade" d="M252.19 350 L512 500 L512 800 L252.19 650 Z" fill="#000000" opacity="0.12"/>
+  </g>
+  <g id="Right_face" data-name="Right face" clip-path="url(#clip-path-3)">
+    <path id="right" d="M771.81 650 L512 800 L512 500 L771.81 350 Z" fill="#2c4fbf"/>
+    <path id="right_band_1" data-name="right band 1" d="M179.45 692 C179.45 479.92 328.34 222.04 512 116 C695.66 9.96 844.55 95.92 844.55 308 C844.55 520.08 695.66 777.96 512 884 C328.34 990.04 179.45 904.08 179.45 692 Z" fill="#2f86e0"/>
+    <path id="right_band_2" data-name="right band 2" d="M234.01 660.5 C234.01 483.22 358.47 267.64 512 179 C665.53 90.36 789.99 162.22 789.99 339.5 C789.99 516.78 665.53 732.36 512 821 C358.47 909.64 234.01 837.78 234.01 660.5 Z" fill="#22bcd8"/>
+    <path id="right_band_3" data-name="right band 3" d="M285.97 630.5 C285.97 486.35 387.17 311.07 512 239 C636.83 166.93 738.03 225.35 738.03 369.5 C738.03 513.65 636.83 688.93 512 761 C387.17 833.07 285.97 774.65 285.97 630.5 Z" fill="#3fc584"/>
+    <path id="right_band_4" data-name="right band 4" d="M337.93 600.5 C337.93 489.49 415.86 354.5 512 299 C608.14 243.5 686.07 288.49 686.07 399.5 C686.07 510.51 608.14 645.5 512 701 C415.86 756.5 337.93 711.51 337.93 600.5 Z" fill="#f0d13a"/>
+    <path id="right_band_5" data-name="right band 5" d="M389.89 570.5 C389.89 492.63 444.56 397.94 512 359 C579.44 320.06 634.11 351.63 634.11 429.5 C634.11 507.37 579.44 602.06 512 641 C444.56 679.94 389.89 648.37 389.89 570.5 Z" fill="#f28a2b"/>
+    <path id="right_band_6" data-name="right band 6" d="M441.85 540.5 C441.85 495.76 473.26 441.37 512 419 C550.74 396.63 582.15 414.76 582.15 459.5 C582.15 504.24 550.74 558.63 512 581 C473.26 603.37 441.85 585.24 441.85 540.5 Z" fill="#de3b2f"/>
+    <path id="right_shade" data-name="right shade" d="M771.81 650 L512 800 L512 500 L771.81 350 Z" fill="#000000" opacity="0.3"/>
   </g>
 </svg>

assets/app-icon/icon.svg

@@ -1,46 +1,31 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1024" height="1024" viewBox="0 0 1024 1024">
   <defs>
-    <filter id="filter-1" filterUnits="userSpaceOnUse" x="67" y="67" width="890" height="890" data-vc-blend="multiply" color-interpolation-filters="sRGB"><feGaussianBlur in="SourceAlpha" stdDeviation="7"/><feOffset dx="0" dy="10" result="shadow"/><feFlood flood-color="#1d3b38" flood-opacity="0.22"/><feComposite in2="shadow" operator="in" result="paint"/><feMerge><feMergeNode in="paint"/><feMergeNode in="SourceGraphic"/></feMerge></filter>
+    <filter id="filter-1" filterUnits="userSpaceOnUse" x="67" y="67" width="890" height="890" data-vc-blend="multiply" color-interpolation-filters="sRGB"><feGaussianBlur in="SourceAlpha" stdDeviation="7"/><feOffset dx="0" dy="10" result="shadow"/><feFlood flood-color="#1d2b3b" flood-opacity="0.22"/><feComposite in2="shadow" operator="in" result="paint"/><feMerge><feMergeNode in="paint"/><feMergeNode in="SourceGraphic"/></feMerge></filter>
     <linearGradient id="linear-gradient-1" x1="512" y1="100" x2="512" y2="924" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#fbfdfd"/>
-      <stop offset="1" stop-color="#dbe5e4"/>
+      <stop offset="0" stop-color="#fbfcfe"/>
+      <stop offset="1" stop-color="#dce3ec"/>
     </linearGradient>
     <clipPath id="clip-path-1">
       <path d="M320 100 L704 100 C854 100 924 170 924 320 L924 704 C924 854 854 924 704 924 L320 924 C170 924 100 854 100 704 L100 320 C100 170 170 100 320 100 Z"/>
     </clipPath>
-    <radialGradient id="radial-gradient-1" cx="0" cy="0" r="578" gradientTransform="matrix(1 0 0 0.5 512 720)" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#7fa8a2"/>
-      <stop offset="0.3" stop-color="#7fa8a2" stop-opacity="0.9"/>
-      <stop offset="0.65" stop-color="#7fa8a2" stop-opacity="0.35"/>
-      <stop offset="1" stop-color="#7fa8a2" stop-opacity="0"/>
+    <radialGradient id="radial-gradient-1" cx="0" cy="0" r="560" gradientTransform="matrix(1 0 0 0.5 512 650)" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#8aa0b4"/>
+      <stop offset="0.3" stop-color="#8aa0b4" stop-opacity="0.9"/>
+      <stop offset="0.65" stop-color="#8aa0b4" stop-opacity="0.35"/>
+      <stop offset="1" stop-color="#8aa0b4" stop-opacity="0"/>
     </radialGradient>
-    <linearGradient id="linear-gradient-2" x1="512" y1="141" x2="512" y2="376.622" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#86e3d3"/>
-      <stop offset="1" stop-color="#4cc4b1"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-3" x1="512" y1="457.259" x2="512" y2="755.042" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#86e3d3"/>
-      <stop offset="1" stop-color="#4cc4b1"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-4" x1="512" y1="209.598" x2="512" y2="624.284" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#20b39f"/>
-      <stop offset="1" stop-color="#118c7c"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-5" x1="512" y1="588.018" x2="512" y2="878.381" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#20b39f"/>
-      <stop offset="1" stop-color="#118c7c"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-6" x1="512" y1="335.738" x2="512" y2="878.381" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#0f786d"/>
-      <stop offset="1" stop-color="#0a544e"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-7" x1="512" y1="558.616" x2="512" y2="658.304" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#0b665e"/>
-      <stop offset="1" stop-color="#04302c"/>
-    </linearGradient>
     <clipPath id="clip-path-2">
-      <path d="M512 141 L825.3 321.88 L730.48 376.62 L417.19 195.74 Z M401.19 457.26 L714.48 638.14 L512 755.04 L198.7 574.16 Z M521.64 643.71 C555.35 624.24 555.35 592.68 521.64 573.22 C487.92 553.75 433.26 553.75 399.55 573.22 C365.83 592.68 365.83 624.24 399.55 643.71 C433.26 663.17 487.92 663.17 521.64 643.71 Z M409.19 209.6 L722.48 390.48 L722.48 624.28 L409.19 443.4 Z M190.7 588.02 L504 768.9 L504 878.38 L190.7 697.5 Z M833.3 697.5 L520 878.38 L520 768.9 L738.48 642.76 L738.48 390.48 L833.3 335.74 Z"/>
+      <path d="M512 200 L764.81 345.96 L512 491.92 L259.19 345.96 Z"/>
+    </clipPath>
+    <clipPath id="clip-path-3">
+      <path d="M252.19 358.08 L505 504.04 L505 795.96 L252.19 650 Z"/>
+    </clipPath>
+    <clipPath id="clip-path-4">
+      <path d="M771.81 650 L519 795.96 L519 504.04 L771.81 358.08 Z"/>
+    </clipPath>
+    <clipPath id="clip-path-5">
+      <path d="M512 200 L764.81 345.96 L512 491.92 L259.19 345.96 Z M252.19 358.08 L505 504.04 L505 795.96 L252.19 650 Z M771.81 650 L519 795.96 L519 504.04 L771.81 358.08 Z"/>
     </clipPath>
   </defs>
   <title>FieldCraft application icon</title>
@@ -50,17 +35,39 @@
     </g>
   </g>
   <g id="Floor_grid" data-name="Floor grid" clip-path="url(#clip-path-1)">
-    <path id="floor_grid" data-name="floor grid" d="M154.62 100 L100 131.53 M869.38 100 L924 131.53 M368.82 100 L100 255.2 M655.18 100 L924 255.2 M583.01 100 L100 378.87 M440.99 100 L924 378.87 M797.21 100 L100 502.53 M226.79 100 L924 502.53 M924 150.47 L100 626.2 M100 150.47 L924 626.2 M924 274.13 L100 749.87 M100 274.13 L924 749.87 M924 397.8 L100 873.53 M100 397.8 L924 873.53 M924 521.47 L226.79 924 M100 521.47 L797.21 924 M924 645.13 L440.99 924 M100 645.13 L583.01 924 M924 768.8 L655.18 924 M100 768.8 L368.82 924 M924 892.47 L869.38 924 M100 892.47 L154.62 924" fill="none" stroke="url(#radial-gradient-1)" stroke-width="3" stroke-linejoin="round"/>
+    <path id="floor_grid" data-name="floor grid" d="M165.59 100 L100 137.87 M858.41 100 L924 137.87 M295.49 100 L100 212.87 M728.51 100 L924 212.87 M425.4 100 L100 287.87 M598.6 100 L924 287.87 M555.3 100 L100 362.87 M468.7 100 L924 362.87 M685.21 100 L100 437.87 M338.79 100 L924 437.87 M815.11 100 L100 512.87 M208.89 100 L924 512.87 M924 112.13 L100 587.87 M100 112.13 L924 587.87 M924 187.13 L100 662.87 M100 187.13 L924 662.87 M924 262.13 L100 737.87 M100 262.13 L924 737.87 M924 337.13 L100 812.87 M100 337.13 L924 812.87 M924 412.13 L100 887.87 M100 412.13 L924 887.87 M924 487.13 L167.32 924 M100 487.13 L856.68 924 M924 562.13 L297.23 924 M100 562.13 L726.77 924 M924 637.13 L427.13 924 M100 637.13 L596.87 924 M924 712.13 L557.03 924 M100 712.13 L466.97 924 M924 787.13 L686.94 924 M100 787.13 L337.06 924 M924 862.13 L816.84 924 M100 862.13 L207.16 924" fill="none" stroke="url(#radial-gradient-1)" stroke-width="3" stroke-linejoin="round"/>
   </g>
-  <g id="Part">
-    <path id="wall_top" data-name="wall top" d="M512 141 L825.3 321.88 L730.48 376.62 L417.19 195.74 Z" fill="url(#linear-gradient-2)"/>
-    <path id="base_top" data-name="base top" d="M401.19 457.26 L714.48 638.14 L512 755.04 L198.7 574.16 Z M521.64 643.71 C555.35 624.24 555.35 592.68 521.64 573.22 C487.92 553.75 433.26 553.75 399.55 573.22 C365.83 592.68 365.83 624.24 399.55 643.71 C433.26 663.17 487.92 663.17 521.64 643.71 Z" fill="url(#linear-gradient-3)"/>
-    <path id="wall_front" data-name="wall front" d="M409.19 209.6 L722.48 390.48 L722.48 624.28 L409.19 443.4 Z" fill="url(#linear-gradient-4)"/>
-    <path id="base_front" data-name="base front" d="M190.7 588.02 L504 768.9 L504 878.38 L190.7 697.5 Z" fill="url(#linear-gradient-5)"/>
-    <path id="end" d="M833.3 697.5 L520 878.38 L520 768.9 L738.48 642.76 L738.48 390.48 L833.3 335.74 Z" fill="url(#linear-gradient-6)"/>
-    <path id="bolt_hole" data-name="bolt hole" d="M521.64 643.71 C487.92 663.17 433.26 663.17 399.55 643.71 C365.83 624.24 365.83 592.68 399.55 573.22 C433.26 553.75 487.92 553.75 521.64 573.22 C555.35 592.68 555.35 624.24 521.64 643.71 Z" fill="url(#linear-gradient-7)"/>
+  <g id="Top_face" data-name="Top face" clip-path="url(#clip-path-2)">
+    <path id="top" d="M512 200 L764.81 345.96 L512 491.92 L259.19 345.96 Z" fill="#2c4fbf"/>
+    <path id="top_band_1" data-name="top band 1" d="M844.55 692 C660.89 798.04 363.11 798.04 179.45 692 C-4.22 585.96 -4.22 414.04 179.45 308 C363.11 201.96 660.89 201.96 844.55 308 C1028.22 414.04 1028.22 585.96 844.55 692 Z" fill="#2f86e0"/>
+    <path id="top_band_2" data-name="top band 2" d="M789.99 660.5 C636.46 749.14 387.54 749.14 234.01 660.5 C80.47 571.86 80.47 428.14 234.01 339.5 C387.54 250.86 636.46 250.86 789.99 339.5 C943.53 428.14 943.53 571.86 789.99 660.5 Z" fill="#22bcd8"/>
+    <path id="top_band_3" data-name="top band 3" d="M738.03 630.5 C613.2 702.57 410.8 702.57 285.97 630.5 C161.13 558.43 161.13 441.57 285.97 369.5 C410.8 297.43 613.2 297.43 738.03 369.5 C862.87 441.57 862.87 558.43 738.03 630.5 Z" fill="#3fc584"/>
+    <path id="top_band_4" data-name="top band 4" d="M686.07 600.5 C589.93 656 434.07 656 337.93 600.5 C241.79 545 241.79 455 337.93 399.5 C434.07 344 589.93 344 686.07 399.5 C782.21 455 782.21 545 686.07 600.5 Z" fill="#f0d13a"/>
+    <path id="top_band_5" data-name="top band 5" d="M634.11 570.5 C566.67 609.44 457.33 609.44 389.89 570.5 C322.45 531.56 322.45 468.44 389.89 429.5 C457.33 390.56 566.67 390.56 634.11 429.5 C701.55 468.44 701.55 531.56 634.11 570.5 Z" fill="#f28a2b"/>
+    <path id="top_band_6" data-name="top band 6" d="M582.15 540.5 C543.41 562.87 480.59 562.87 441.85 540.5 C403.11 518.13 403.11 481.87 441.85 459.5 C480.59 437.13 543.41 437.13 582.15 459.5 C620.89 481.87 620.89 518.13 582.15 540.5 Z" fill="#de3b2f"/>
+    <path id="top_shade" data-name="top shade" d="M512 200 L764.81 345.96 L512 491.92 L259.19 345.96 Z" fill="#ffffff" opacity="0.1"/>
   </g>
-  <g id="Mesh" clip-path="url(#clip-path-2)">
-    <path id="hexahedral_mesh" data-name="hexahedral mesh" d="M460.59 482.32 L242.11 608.46 M679.07 608.46 L460.59 734.6 M354.57 484.18 L405.97 513.86 M624.45 640 L675.86 669.67 M299.95 515.71 L351.35 545.39 M569.83 671.53 L621.24 701.21 M245.32 547.25 L296.73 576.92 M515.21 703.07 L566.62 732.75 M460.59 482.32 L460.59 230.04 M563.41 170.68 L460.59 230.04 M515.21 513.86 L515.21 261.57 M618.03 202.22 L515.21 261.57 M569.83 545.39 L569.83 293.11 M672.65 233.75 L569.83 293.11 M624.45 576.93 L624.45 324.65 M727.27 265.29 L624.45 324.65 M679.07 608.46 L679.07 356.18 M781.89 296.82 L679.07 356.18 M409.19 389.57 L730.48 575.07 M409.19 326.5 L730.48 512 M409.19 263.43 L730.48 448.93 M460.59 170.68 L781.89 356.18 M242.11 727.18 L242.11 608.46 M296.73 758.72 L296.73 640 M351.35 790.25 L351.35 671.53 M405.97 821.79 L405.97 703.07 M460.59 853.32 L460.59 734.6 M190.7 638.14 L512 823.64 M781.89 727.18 L781.89 356.18 M730.48 756.86 L730.48 638.14 M675.86 788.39 L675.86 669.67 M621.24 819.93 L621.24 701.21 M566.62 851.47 L566.62 732.75 M833.3 638.14 L512 823.64 M833.3 578.78 L730.48 638.14 M833.3 515.71 L730.48 575.07 M833.3 452.64 L730.48 512 M833.3 389.57 L730.48 448.93 M460.59 558.62 L460.59 482.32 M433.29 561.17 L405.97 513.86 M399.55 573.22 L351.35 545.39 M378.69 592.7 L296.73 576.92 M374.26 608.46 L242.11 608.46 M487.89 561.17 L515.21 513.86 M378.69 624.22 L296.73 640 M521.64 573.22 L569.83 545.39 M399.55 643.71 L351.35 671.53 M542.49 592.7 L624.45 576.92 M433.29 655.75 L405.97 703.06 M546.92 608.46 L679.07 608.46 M542.49 624.22 L624.45 640 M521.64 643.71 L569.83 671.53 M487.89 655.75 L515.21 703.07 M460.59 658.3 L460.59 734.6 M545.74 657.62 L540.09 660.8 L534.3 663.92 L528.33 666.99 L522.16 670.03 L515.76 673.05 L509.11 676.08 L502.15 679.15 L494.85 682.27 L487.14 685.51 L478.94 688.9 L470.14 692.52 L460.59 696.45 L451.05 692.52 L442.25 688.9 L434.05 685.51 L426.34 682.27 L419.03 679.15 L412.08 676.08 L405.42 673.05 L399.02 670.03 L392.86 666.99 L386.89 663.92 L381.09 660.8 L375.45 657.62 L369.94 654.36 L364.54 651.01 L359.22 647.57 L353.95 644.01 L348.72 640.31 L343.47 636.47 L338.16 632.45 L332.74 628.24 L327.14 623.79 L321.26 619.05 L315 613.97 L308.19 608.46 L315 602.95 L321.26 597.87 L327.14 593.13 L332.74 588.68 L338.16 584.47 L343.47 580.45 L348.72 576.61 L353.95 572.91 L359.22 569.35 L364.54 565.91 L369.94 562.56 L375.45 559.3 L381.09 556.12 L386.89 553 L392.86 549.93 L399.02 546.89 L405.42 543.87 L412.08 540.84 L419.03 537.77 L426.34 534.65 L434.05 531.41 L442.25 528.02 L451.05 524.4 L460.59 520.47 L470.14 524.4 L478.94 528.02 L487.14 531.41 L494.85 534.65 L502.15 537.77 L509.11 540.84 L515.76 543.87 L522.16 546.89 L528.33 549.93 L534.3 553 L540.09 556.12 L545.74 559.3 L551.25 562.56 L556.65 565.91 L561.97 569.35 L567.23 572.91 L572.47 576.61 L577.72 580.45 L583.02 584.47 L588.44 588.68 L594.05 593.13 L599.92 597.87 L606.19 602.95 L613 608.46 L606.19 613.97 L599.92 619.05 L594.05 623.79 L588.44 628.24 L583.02 632.45 L577.72 636.47 L572.47 640.31 L567.23 644.01 L561.97 647.57 L556.65 651.01 L551.25 654.36 Z" fill="none" stroke="#ffffff" stroke-width="4.5" stroke-linejoin="round" opacity="0.5"/>
+  <g id="Left_face" data-name="Left face" clip-path="url(#clip-path-3)">
+    <path id="left" d="M252.19 358.08 L505 504.04 L505 795.96 L252.19 650 Z" fill="#2c4fbf"/>
+    <path id="left_band_1" data-name="left band 1" d="M844.55 692 C844.55 479.92 695.66 222.04 512 116 C328.34 9.96 179.45 95.92 179.45 308 C179.45 520.08 328.34 777.96 512 884 C695.66 990.04 844.55 904.08 844.55 692 Z" fill="#2f86e0"/>
+    <path id="left_band_2" data-name="left band 2" d="M789.99 660.5 C789.99 483.22 665.53 267.64 512 179 C358.47 90.36 234.01 162.22 234.01 339.5 C234.01 516.78 358.47 732.36 512 821 C665.53 909.64 789.99 837.78 789.99 660.5 Z" fill="#22bcd8"/>
+    <path id="left_band_3" data-name="left band 3" d="M738.03 630.5 C738.03 486.35 636.83 311.07 512 239 C387.17 166.93 285.97 225.35 285.97 369.5 C285.97 513.65 387.17 688.93 512 761 C636.83 833.07 738.03 774.65 738.03 630.5 Z" fill="#3fc584"/>
+    <path id="left_band_4" data-name="left band 4" d="M686.07 600.5 C686.07 489.49 608.14 354.5 512 299 C415.86 243.5 337.93 288.49 337.93 399.5 C337.93 510.51 415.86 645.5 512 701 C608.14 756.5 686.07 711.51 686.07 600.5 Z" fill="#f0d13a"/>
+    <path id="left_band_5" data-name="left band 5" d="M634.11 570.5 C634.11 492.63 579.44 397.94 512 359 C444.56 320.06 389.89 351.63 389.89 429.5 C389.89 507.37 444.56 602.06 512 641 C579.44 679.94 634.11 648.37 634.11 570.5 Z" fill="#f28a2b"/>
+    <path id="left_band_6" data-name="left band 6" d="M582.15 540.5 C582.15 495.76 550.74 441.37 512 419 C473.26 396.63 441.85 414.76 441.85 459.5 C441.85 504.24 473.26 558.63 512 581 C550.74 603.37 582.15 585.24 582.15 540.5 Z" fill="#de3b2f"/>
+    <path id="left_shade" data-name="left shade" d="M252.19 358.08 L505 504.04 L505 795.96 L252.19 650 Z" fill="#000000" opacity="0.12"/>
+  </g>
+  <g id="Right_face" data-name="Right face" clip-path="url(#clip-path-4)">
+    <path id="right" d="M771.81 650 L519 795.96 L519 504.04 L771.81 358.08 Z" fill="#2c4fbf"/>
+    <path id="right_band_1" data-name="right band 1" d="M179.45 692 C179.45 479.92 328.34 222.04 512 116 C695.66 9.96 844.55 95.92 844.55 308 C844.55 520.08 695.66 777.96 512 884 C328.34 990.04 179.45 904.08 179.45 692 Z" fill="#2f86e0"/>
+    <path id="right_band_2" data-name="right band 2" d="M234.01 660.5 C234.01 483.22 358.47 267.64 512 179 C665.53 90.36 789.99 162.22 789.99 339.5 C789.99 516.78 665.53 732.36 512 821 C358.47 909.64 234.01 837.78 234.01 660.5 Z" fill="#22bcd8"/>
+    <path id="right_band_3" data-name="right band 3" d="M285.97 630.5 C285.97 486.35 387.17 311.07 512 239 C636.83 166.93 738.03 225.35 738.03 369.5 C738.03 513.65 636.83 688.93 512 761 C387.17 833.07 285.97 774.65 285.97 630.5 Z" fill="#3fc584"/>
+    <path id="right_band_4" data-name="right band 4" d="M337.93 600.5 C337.93 489.49 415.86 354.5 512 299 C608.14 243.5 686.07 288.49 686.07 399.5 C686.07 510.51 608.14 645.5 512 701 C415.86 756.5 337.93 711.51 337.93 600.5 Z" fill="#f0d13a"/>
+    <path id="right_band_5" data-name="right band 5" d="M389.89 570.5 C389.89 492.63 444.56 397.94 512 359 C579.44 320.06 634.11 351.63 634.11 429.5 C634.11 507.37 579.44 602.06 512 641 C444.56 679.94 389.89 648.37 389.89 570.5 Z" fill="#f28a2b"/>
+    <path id="right_band_6" data-name="right band 6" d="M441.85 540.5 C441.85 495.76 473.26 441.37 512 419 C550.74 396.63 582.15 414.76 582.15 459.5 C582.15 504.24 550.74 558.63 512 581 C473.26 603.37 441.85 585.24 441.85 540.5 Z" fill="#de3b2f"/>
+    <path id="right_shade" data-name="right shade" d="M771.81 650 L519 795.96 L519 504.04 L771.81 358.08 Z" fill="#000000" opacity="0.3"/>
+  </g>
+  <g id="Mesh" clip-path="url(#clip-path-5)">
+    <path id="hexahedral_mesh" data-name="hexahedral mesh" d="M576.95 237.5 L317.14 387.5 M447.05 237.5 L706.86 387.5 M317.14 687.5 L317.14 387.5 M252.19 575 L512 725 M706.86 687.5 L706.86 387.5 M771.81 575 L512 725 M641.9 275 L382.1 425 M382.1 275 L641.9 425 M382.1 725 L382.1 425 M252.19 500 L512 650 M641.9 725 L641.9 425 M771.81 500 L512 650 M706.86 312.5 L447.05 462.5 M317.14 312.5 L576.95 462.5 M447.05 762.5 L447.05 462.5 M252.19 425 L512 575 M576.95 762.5 L576.95 462.5 M771.81 425 L512 575" fill="none" stroke="#0b2236" stroke-width="3.5" stroke-linejoin="round" opacity="0.45"/>
   </g>
 </svg>

assets/icons/diagnostics.bug_report.svg

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24">
+  <title>diagnostics.bug_report</title>
+  <g id="Layer_1" data-name="Layer 1">
+    <path d="M12 8.5 L12 8.5 C14.209 8.5 16 10.291 16 12.5 L16 15.5 C16 17.709 14.209 19.5 12 19.5 L12 19.5 C9.791 19.5 8 17.709 8 15.5 L8 12.5 C8 10.291 9.791 8.5 12 8.5 Z" fill="none" stroke="#dde2ea" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M9.9 5.8 C9.9 4.64 10.84 3.7 12 3.7 C13.16 3.7 14.1 4.64 14.1 5.8 C14.1 6.96 13.16 7.9 12 7.9 C10.84 7.9 9.9 6.96 9.9 5.8 Z" fill="none" stroke="#dde2ea" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M12 10.5 L12 18" fill="none" stroke="#4f9ce8" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M8 11.5 L4.8 9.8" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M8 14.5 L4.4 14.5" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M8.3 17.4 L5 19.4" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M16 11.5 L19.2 9.8" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M16 14.5 L19.6 14.5" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M15.7 17.4 L19 19.4" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+  </g>
+</svg>

assets/icons/geometry.datum.axis.svg

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24">
+  <title>geometry.datum.axis</title>
+  <g id="Layer_1" data-name="Layer 1">
+    <path d="M7 17 L19 5" fill="none" stroke="#4f9ce8" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M20 4 L15 5.2 M20 4 L18.8 9" fill="none" stroke="#4f9ce8" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M5.5 18.5 L2.5 21.5" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.5 2"/>
+    <path d="M8.8 12 C8.8 10.233 10.233 8.8 12 8.8 C13.767 8.8 15.2 10.233 15.2 12 C15.2 13.767 13.767 15.2 12 15.2 C10.233 15.2 8.8 13.767 8.8 12 Z" fill="#2d4e70" stroke="#dde2ea" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M10.6 12 C10.6 11.227 11.227 10.6 12 10.6 C12.773 10.6 13.4 11.227 13.4 12 C13.4 12.773 12.773 13.4 12 13.4 C11.227 13.4 10.6 12.773 10.6 12 Z" fill="#f0b44a"/>
+  </g>
+</svg>

assets/icons/geometry.datum.point.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24">
+  <title>geometry.datum.point</title>
+  <g id="Layer_1" data-name="Layer 1">
+    <path d="M3 16 L9 10 L21 10 L15 16 Z" fill="#2d4e70" stroke="#dde2ea" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M12 3 L12 11 M8 7 L16 7" fill="none" stroke="#4f9ce8" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M10.2 7 C10.2 6.006 11.006 5.2 12 5.2 C12.994 5.2 13.8 6.006 13.8 7 C13.8 7.994 12.994 8.8 12 8.8 C11.006 8.8 10.2 7.994 10.2 7 Z" fill="#f0b44a"/>
+    <path d="M12 12.5 L12 20" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.5 2"/>
+  </g>
+</svg>

assets/icons/mesh.cells.svg

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24">
-  <title>mesh.hex.blocks</title>
+  <title>mesh.cells</title>
   <g id="Layer_1" data-name="Layer 1">
     <path d="M12 3 L20 7 L20 16 L12 20 L4 16 L4 7 Z" fill="#2d4e70" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
     <path d="M4 7 L12 11 L20 7 M12 11 L12 20" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>

assets/icons/mesh.hex.generate.svg

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24">
-  <title>mesh.hex.mapped</title>
+  <title>mesh.hex.generate</title>
   <g id="Layer_1" data-name="Layer 1">
     <path d="M12 3 L20 7 L20 16 L12 20 L4 16 L4 7 Z" fill="#2d4e70" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
     <path d="M4 7 L12 11 L20 7 M12 11 L12 20" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>

assets/icons/mesh.hex.sweep.svg

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24">
-  <title>mesh.hex.sweep</title>
-  <g id="Layer_1" data-name="Layer 1">
-    <path d="M3 8 L12 8 L12 17 L3 17 Z" fill="#2d4e70" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-    <path d="M7.5 8 L7.5 17 M3 12.5 L12 12.5" fill="none" stroke="#dde2ea" stroke-linecap="round" stroke-linejoin="round"/>
-    <path d="M3 8 L8 4 L21 4 L21 13 L12 17 M12 8 L21 4" fill="none" stroke="#dde2ea" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
-    <path d="M14 13 L20 10 M18.17 12.63 L20 10 L16.8 9.88" fill="none" stroke="#4f9ce8" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-  </g>
-</svg>

assets/icons/mesh.seed.edge.svg

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24">
-  <title>mesh.size.seed</title>
+  <title>mesh.seed.edge</title>
   <g id="Layer_1" data-name="Layer 1">
     <path d="M3 19 C7 5 17 5 21 19" fill="none" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
     <path d="M1.7 19 C1.7 18.282 2.282 17.7 3 17.7 C3.718 17.7 4.3 18.282 4.3 19 C4.3 19.718 3.718 20.3 3 20.3 C2.282 20.3 1.7 19.718 1.7 19 Z" fill="#4f9ce8"/>

assets/icons/src/diagnostics.bug_report.json

@@ -0,0 +1 @@
+{"shapes": [{"rect": [8, 8.5, 8, 11], "radius": 4, "stroke": "line", "width": 1.6}, {"circle": [12, 5.8, 2.1], "stroke": "line", "width": 1.6}, {"line": [12, 10.5, 12, 18], "stroke": "accent", "width": 1.5}, {"line": [8, 11.5, 4.8, 9.8], "stroke": "line"}, {"line": [8, 14.5, 4.4, 14.5], "stroke": "line"}, {"line": [8.3, 17.4, 5, 19.4], "stroke": "line"}, {"line": [16, 11.5, 19.2, 9.8], "stroke": "line"}, {"line": [16, 14.5, 19.6, 14.5], "stroke": "line"}, {"line": [15.7, 17.4, 19, 19.4], "stroke": "line"}]}

assets/icons/src/geometry.datum.axis.json

@@ -0,0 +1 @@
+{"shapes": [{"d": "M7 17 L19 5", "stroke": "accent", "width": 2}, {"d": "M20 4 L15 5.2 M20 4 L18.8 9", "stroke": "accent", "width": 2}, {"d": "M5.5 18.5 L2.5 21.5", "stroke": "line", "dash": [1.5, 2]}, {"circle": [12, 12, 3.2], "fill": "soft", "stroke": "line", "width": 1.25}, {"circle": [12, 12, 1.4], "fill": "warm", "stroke": null}]}

assets/icons/src/geometry.datum.point.json

@@ -0,0 +1 @@
+{"shapes": [{"d": "M3 16 L9 10 L21 10 L15 16 Z", "fill": "soft", "stroke": "line", "width": 1.25}, {"d": "M12 3 L12 11 M8 7 L16 7", "stroke": "accent", "width": 2}, {"circle": [12, 7, 1.8], "fill": "warm", "stroke": null}, {"d": "M12 12.5 L12 20", "stroke": "line", "dash": [1.5, 2]}]}

assets/icons/src/mesh.hex.sweep.json

@@ -1 +0,0 @@
-{"shapes": [{"rect": [3, 8, 9, 9], "fill": "soft", "stroke": "line"}, {"d": "M7.5 8 L7.5 17 M3 12.5 L12 12.5", "stroke": "line", "width": 1}, {"d": "M3 8 L8 4 L21 4 L21 13 L12 17 M12 8 L21 4", "stroke": "line", "width": 1.25}, {"d": "M14 13 L20 10 M18.17 12.63 L20 10 L16.8 9.88", "stroke": "accent", "width": 1.5}]}

assets/icons/src/view.show_all.json

@@ -0,0 +1 @@
+{"shapes": [{"d": "M2.5 13 C5.5 7.5 18.5 7.5 21.5 13 C18.5 18.5 5.5 18.5 2.5 13 Z", "fill": "soft", "stroke": "line"}, {"circle": [12, 13, 2.6], "fill": "accent", "stroke": "accent", "width": 1}, {"d": "M12 2.5 L12 5 M5.5 4.5 L7 6.5 M18.5 4.5 L17 6.5", "stroke": "warm", "width": 1.5}]}

assets/icons/view.show_all.svg

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24">
+  <title>view.show_all</title>
+  <g id="Layer_1" data-name="Layer 1">
+    <path d="M2.5 13 C5.5 7.5 18.5 7.5 21.5 13 C18.5 18.5 5.5 18.5 2.5 13 Z" fill="#2d4e70" stroke="#dde2ea" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M9.4 13 C9.4 11.564 10.564 10.4 12 10.4 C13.436 10.4 14.6 11.564 14.6 13 C14.6 14.436 13.436 15.6 12 15.6 C10.564 15.6 9.4 14.436 9.4 13 Z" fill="#4f9ce8" stroke="#4f9ce8" stroke-linecap="round" stroke-linejoin="round"/>
+    <path d="M12 2.5 L12 5 M5.5 4.5 L7 6.5 M18.5 4.5 L17 6.5" fill="none" stroke="#f0b44a" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+  </g>
+</svg>

crates/decks/src/abaqus.rs

@@ -13,8 +13,25 @@
 //!
 //! In order: heading, nodes (mesh nodes, then reference points), elements grouped by element type,
 //! sets (a node set, an element set and an element-face surface per model set, each written when
-//! the set resolves to some), materials, sections, couplings, the initial state's boundary
-//! conditions, then the steps.
+//! the set resolves to some), materials, sections, couplings, contact, the initial state's
+//! boundary conditions, then the steps.
+//!
+//! # Contact
+//!
+//! Each contact is a `*SURFACE INTERACTION` with its friction (`*FRICTION`, or
+//! `*FRICTION, EXPONENTIAL DECAY` with the static and kinetic coefficients and the decay
+//! coefficient, the same law). A pair is `*CONTACT PAIR, TYPE=SURFACE TO SURFACE` with the
+//! secondary surface first, and `ADJUST=0.0` when initially overclosed nodes are adjusted. General
+//! contact is the model's one `*CONTACT` definition: `*CONTACT INCLUSIONS, ALL EXTERIOR` for every
+//! exterior face, a surface with a blank partner for self contact, and a
+//! `*CONTACT PROPERTY ASSIGNMENT` line per contact. FieldCraft's penalty scale and its refusal of
+//! initial overclosure have no Abaqus counterpart and are noted in comments (Abaqus chooses its
+//! own penalty and resolves overclosure in the first increment).
+//!
+//! # Ties
+//!
+//! Each tie is `*TIE, NAME=…, ADJUST=NO` with the secondary surface first and its position
+//! tolerance when it has one: FieldCraft ties the nodes where they are (no adjustment).
 //!
 //! # Steps and the activity table
 //!
@@ -130,8 +147,8 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::fmt::Write as _;
 
 use fieldcraft_model::{
-    BeamProfile, BoundaryCondition, CouplingKind, Elastic, Element, ElementKind, Hardening, Hyperelastic, Integration, Load, Model, OutputVariable,
-    Plastic, Procedure, Resolved, Section, SectionKind, Step, Symmetry, Target,
+    BeamProfile, BoundaryCondition, ContactSurfaces, CouplingKind, Elastic, Element, ElementKind, Hardening, Hyperelastic, InitialPenetration,
+    Integration, Load, Model, OutputVariable, Plastic, Procedure, Resolved, Section, SectionKind, Step, Symmetry, Target,
 };
 
 use crate::{Error, Result, unsupported};
@@ -174,6 +191,8 @@ pub fn write_resolved(model: &Model, r: &Resolved) -> Result<String> {
     d.sections(model)?;
     d.discrete_properties(&discrete)?;
     d.couplings(model, r);
+    d.contacts(model, r)?;
+    d.ties(model)?;
     d.steps(model, r)?;
     Ok(d.out)
 }
@@ -957,6 +976,92 @@ impl Deck {
         }
     }
 
+    /// One surface interaction (the friction) per contact, then its pair, and every general
+    /// contact in the model's one `*CONTACT` definition.
+    fn contacts(&mut self, model: &Model, r: &Resolved) -> Result<()> {
+        if model.contacts().is_empty() {
+            return Ok(());
+        }
+        let mut taken: BTreeSet<String> = model.sets().keys().map(|n| n.to_ascii_uppercase()).collect();
+        taken.extend(coupling_surfaces(model, r).into_values().map(|n| n.to_ascii_uppercase()));
+        self.comment("Contact: a surface interaction (Coulomb friction) per contact, contact pairs, general contact");
+        let mut general = Vec::new();
+        for (name, c) in model.contacts() {
+            let interaction = crate::unique_name(&format!("{name}-interaction"), &mut taken);
+            self.line(&format!("*SURFACE INTERACTION, NAME={interaction}"));
+            let f = c.friction;
+            if f.decay > 0.0 {
+                self.line("*FRICTION, EXPONENTIAL DECAY");
+                self.numbers_line("", &[f.static_coefficient, f.kinetic_coefficient(), f.decay])?;
+            } else {
+                self.line("*FRICTION");
+                self.numbers_line("", &[f.static_coefficient])?;
+            }
+            if c.penalty_scale != 1.0 {
+                self.comment(&format!(
+                    "contact `{name}`: penalty scale {} of FieldCraft's explicit penalty stiffness; Abaqus chooses its own",
+                    c.penalty_scale
+                ));
+            }
+            match &c.surfaces {
+                ContactSurfaces::Pair { main, secondary } => {
+                    // ADJUST=0.0 moves the secondary nodes that start inside the main surface
+                    // onto it, strain-free; Abaqus has no refusal of initial overclosure.
+                    let adjust = match c.initial_penetration {
+                        InitialPenetration::Adjust => ", ADJUST=0.0",
+                        InitialPenetration::Refuse => {
+                            self.comment(&format!(
+                                "contact `{name}`: FieldCraft refuses initially overclosed nodes; Abaqus resolves them in the first increment"
+                            ));
+                            ""
+                        }
+                    };
+                    self.line(&format!("*CONTACT PAIR, INTERACTION={interaction}, TYPE=SURFACE TO SURFACE{adjust}"));
+                    self.line(&format!("{secondary}, {main}"));
+                }
+                ContactSurfaces::General { surface } => general.push((surface.clone(), interaction)),
+            }
+        }
+        if general.is_empty() {
+            return Ok(());
+        }
+        // General contact: every surface against itself (a blank second surface), or every
+        // exterior face; each with its interaction.
+        self.line("*CONTACT");
+        if general.iter().any(|(s, _)| s.is_none()) {
+            self.line("*CONTACT INCLUSIONS, ALL EXTERIOR");
+        }
+        let named: Vec<&str> = general.iter().filter_map(|(s, _)| s.as_deref()).collect();
+        if !named.is_empty() {
+            self.line("*CONTACT INCLUSIONS");
+            for s in &named {
+                self.line(&format!("{s},"));
+            }
+        }
+        self.line("*CONTACT PROPERTY ASSIGNMENT");
+        for (surface, interaction) in &general {
+            match surface {
+                Some(s) => self.line(&format!("{s}, {s}, {interaction}")),
+                None => self.line(&format!(", , {interaction}")),
+            }
+        }
+        Ok(())
+    }
+
+    /// Ties: `*TIE` per tie, secondary surface first.
+    fn ties(&mut self, model: &Model) -> Result<()> {
+        if model.ties().is_empty() {
+            return Ok(());
+        }
+        self.comment("Ties: each secondary surface bonded to its main surface");
+        for (name, t) in model.ties() {
+            let tolerance = t.position_tolerance.map_or(String::new(), |v| format!(", POSITION TOLERANCE={v:?}"));
+            self.line(&format!("*TIE, NAME={name}, ADJUST=NO{tolerance}"));
+            self.line(&format!("{}, {}", t.secondary, t.main));
+        }
+        Ok(())
+    }
+
     fn boundary_lines<'n>(&mut self, model: &Model, r: &Resolved, names: impl IntoIterator<Item = &'n String>) -> Result<()> {
         for name in names {
             let Some(bc) = model.boundary_condition(name) else { continue };
@@ -1106,10 +1211,38 @@ impl Deck {
                 Procedure::Fluid { .. } => return Err(crate::fluid_step(FORMAT, &step.name)),
                 Procedure::Static {} | Procedure::NonlinearStatic(_) => {
                     if let Procedure::NonlinearStatic(n) = &step.procedure {
+                        if n.imperfection.is_some() {
+                            return Err(Error::Unsupported {
+                                format: FORMAT,
+                                what: format!(
+                                    "step `{}`: an imperfection from a buckling mode (FieldCraft computes the mode when it solves)",
+                                    step.name
+                                ),
+                            });
+                        }
                         let nlgeom = if n.nonlinear_geometry { "YES" } else { "NO" };
                         self.line(&format!("*STEP, NAME={}, NLGEOM={nlgeom}, INC={}", step.name, n.max_increments));
-                        self.line("*STATIC");
-                        self.numbers_line("", &[n.initial_increment, 1.0, n.min_increment, n.max_increment])?;
+                        if let Some(arc) = &n.arc_length {
+                            // Riks: initial arc, period, minimum and maximum arcs, the load
+                            // proportionality factor and the displacement that end the step.
+                            if arc.constraint != fieldcraft_model::ArcConstraint::Cylindrical {
+                                return Err(Error::Unsupported {
+                                    format: FORMAT,
+                                    what: format!("step `{}`: a spherical arc-length constraint", step.name),
+                                });
+                            }
+                            self.line("*STATIC, RIKS");
+                            self.numbers_line("", &[n.initial_increment, 1.0, n.min_increment, n.max_increment, arc.max_load_factor])?;
+                            if let Some(l) = &arc.displacement_limit {
+                                self.out.pop();
+                                let _ = write!(self.out, ", {}, {}, ", l.node, l.direction);
+                                push_number(&mut self.out, l.displacement)?;
+                                self.out.push('\n');
+                            }
+                        } else {
+                            self.line("*STATIC");
+                            self.numbers_line("", &[n.initial_increment, 1.0, n.min_increment, n.max_increment])?;
+                        }
                         if n.line_search {
                             self.line("*CONTROLS, PARAMETERS=LINE SEARCH");
                             self.line("5,");
@@ -1131,6 +1264,34 @@ impl Deck {
                     base_bcs.clone_from(&step.boundary_conditions);
                     base_loads.clone_from(&step.loads);
                 }
+                Procedure::Buckle { modes, shift } => {
+                    // Abaqus's buckling base state is the end of the previous general step;
+                    // FieldCraft's steps all start from the undeformed, unloaded model.
+                    if !base_loads.is_empty()
+                        || steps
+                            .iter()
+                            .take_while(|s| !std::ptr::eq(*s, step))
+                            .any(|s| !matches!(s.procedure, Procedure::Frequency { .. } | Procedure::Buckle { .. }))
+                    {
+                        return Err(Error::Unsupported {
+                            format: FORMAT,
+                            what: format!(
+                                "step `{}`: a buckling step after a general step (Abaqus would buckle from that step's loaded state)",
+                                step.name
+                            ),
+                        });
+                    }
+                    if shift.is_some() {
+                        return Err(Error::Unsupported { format: FORMAT, what: format!("step `{}`: a buckling shift", step.name) });
+                    }
+                    self.line(&format!("*STEP, NAME={}", step.name));
+                    self.line("*BUCKLE, EIGENSOLVER=LANCZOS");
+                    self.line(&format!("{modes}"));
+                    self.step_boundaries(model, r, &base_bcs, &step.boundary_conditions)?;
+                    let loads = StepLoads::new(model, r, step, &everything);
+                    self.step_loads(&loads, written)?;
+                    written = loads.written();
+                }
                 Procedure::Frequency { modes, min_hz, max_hz } => {
                     self.line(&format!("*STEP, NAME={}", step.name));
                     self.line("*FREQUENCY, EIGENSOLVER=LANCZOS");

crates/decks/src/lsdyna/mod.rs

@@ -22,6 +22,13 @@
 //! - couplings: kinematic as `*CONSTRAINED_NODAL_RIGID_BODY` (the reference point first in its
 //!   node set), distributing as `*CONSTRAINED_INTERPOLATION` (the reference point dependent on
 //!   the set's translations, equal weights);
+//! - contact: a pair as `*CONTACT_AUTOMATIC_SURFACE_TO_SURFACE` between segment sets (the
+//!   secondary surface first; a tie as `*CONTACT_TIED_SURFACE_TO_SURFACE` likewise), general
+//!   contact as `*CONTACT_AUTOMATIC_SINGLE_SURFACE` on a segment
+//!   set or on every part (`surfatyp` 5); the static and kinetic coefficients and the decay
+//!   coefficient (`fs`, `fd`, `dc`: the same exponential decay law) and the penalty scale on both
+//!   sides (`sfsa`, `sfsb`, a factor on LS-DYNA's own default stiffness). LS-DYNA moves nodes
+//!   that start inside the other surface out, as `adjust` does; a refusal is noted in a comment;
 //! - per step: `*CONTROL_IMPLICIT_GENERAL`, `*CONTROL_IMPLICIT_SOLUTION` (linear) or
 //!   `*CONTROL_IMPLICIT_EIGENVALUE`, `*CONTROL_TERMINATION` (a static step is one implicit step
 //!   from time 0 to 1 with every load ramped by one curve, `*DEFINE_CURVE`); a nonlinear static
@@ -69,8 +76,8 @@ mod elements;
 use std::collections::{BTreeMap, BTreeSet};
 
 use fieldcraft_model::{
-    BoundaryCondition, CouplingKind, Diagnostic, Dofs, Elastic, Element, ElementKind, Hardening, Load, Material, Model, OutputVariable, Plastic,
-    Procedure, Resolved, ResolvedDirection, Section, SectionKind, Step, Target,
+    BoundaryCondition, ContactSurfaces, CouplingKind, Diagnostic, Dofs, Elastic, Element, ElementKind, Hardening, InitialPenetration, Load, Material,
+    Model, OutputVariable, Plastic, Procedure, Resolved, ResolvedDirection, Section, SectionKind, Step, Target,
 };
 
 use crate::{Error, Result};
@@ -177,6 +184,7 @@ fn write_with(model: &Model, r: &Resolved) -> Result<Written> {
     element_cards(&mut d, &plan)?;
     sets(&mut d, model, r, &plan)?;
     couplings(&mut d, model, r, &plan)?;
+    contacts(&mut d, model, &plan)?;
     discrete(&mut d, model, r, &plan)?;
     if let Some(parts) = &plan.gravity_parts {
         d.line("*SET_PART_LIST");
@@ -269,6 +277,13 @@ fn plan<'a>(model: &'a Model, r: &Resolved) -> Result<Plan<'a>> {
             node_sets.insert(c.set.as_str());
         }
     }
+    // Contact surfaces are segment sets.
+    for c in model.contacts().values() {
+        segment_sets.extend(c.surfaces.sets());
+    }
+    for t in model.ties().values() {
+        segment_sets.extend([t.main.as_str(), t.secondary.as_str()]);
+    }
     let mut gravity_sets: BTreeSet<Option<&str>> = BTreeSet::new();
     for step in model.steps() {
         if matches!(step.procedure, Procedure::ExplicitDynamic(_)) {
@@ -689,6 +704,57 @@ fn couplings(d: &mut Deck, model: &Model, r: &Resolved, plan: &Plan) -> Result<(
     Ok(())
 }
 
+/// Contacts (see the module docs): a pair as an automatic surface-to-surface contact between the
+/// segment sets, general contact as an automatic single-surface contact.
+fn contacts(d: &mut Deck, model: &Model, plan: &Plan) -> Result<()> {
+    for (name, c) in model.contacts() {
+        let sid = |set: &str| plan.sets.get(set).copied().ok_or_else(|| broken(format!("contact `{name}`: set `{set}`")));
+        d.comment(&format!("contact `{name}`"));
+        if c.initial_penetration == InitialPenetration::Refuse {
+            d.comment("FieldCraft refuses nodes that start inside the other surface; LS-DYNA moves them out (as `adjust` does)");
+        }
+        match &c.surfaces {
+            ContactSurfaces::Pair { main, secondary } => {
+                d.line("*CONTACT_AUTOMATIC_SURFACE_TO_SURFACE");
+                d.header(&["surfa", "surfb", "surfatyp", "surfbtyp"]);
+                d.card([Field::from(sid(secondary)?), Field::from(sid(main)?), Field::from(0), Field::from(0)]);
+            }
+            ContactSurfaces::General { surface: Some(s) } => {
+                d.line("*CONTACT_AUTOMATIC_SINGLE_SURFACE");
+                d.header(&["surfa", "surfb", "surfatyp"]);
+                d.card([Field::from(sid(s)?), Field::Blank, Field::from(0)]);
+            }
+            ContactSurfaces::General { surface: None } => {
+                // SURFATYP 5: every part.
+                d.line("*CONTACT_AUTOMATIC_SINGLE_SURFACE");
+                d.header(&["surfa", "surfb", "surfatyp"]);
+                d.card([Field::from(0), Field::Blank, Field::from(5)]);
+            }
+        }
+        let f = c.friction;
+        d.header(&["fs", "fd", "dc"]);
+        d.card([Field::from(f.static_coefficient), Field::from(f.kinetic_coefficient()), Field::from(f.decay)]);
+        d.header(&["sfsa", "sfsb"]);
+        d.card([Field::from(c.penalty_scale), Field::from(c.penalty_scale)]);
+    }
+    // Ties: a tied surface-to-surface contact between the segment sets, secondary first.
+    for (name, t) in model.ties() {
+        let sid = |set: &str| plan.sets.get(set).copied().ok_or_else(|| broken(format!("tie `{name}`: set `{set}`")));
+        d.comment(&format!("tie `{name}`"));
+        if t.position_tolerance.is_some() {
+            d.comment("FieldCraft's position tolerance: LS-DYNA ties the nodes within its own search distance");
+        }
+        d.line("*CONTACT_TIED_SURFACE_TO_SURFACE");
+        d.header(&["surfa", "surfb", "surfatyp", "surfbtyp"]);
+        d.card([Field::from(sid(&t.secondary)?), Field::from(sid(&t.main)?), Field::from(0), Field::from(0)]);
+        d.header(&["fs", "fd", "dc"]);
+        d.card([Field::from(0.0), Field::from(0.0), Field::from(0.0)]);
+        d.header(&["sfsa", "sfsb"]);
+        d.card([Field::from(1.0), Field::from(1.0)]);
+    }
+    Ok(())
+}
+
 /// Point masses, springs and dashpots (see the module docs).
 fn discrete(d: &mut Deck, model: &Model, r: &Resolved, plan: &Plan) -> Result<()> {
     if r.masses.is_empty() && r.springs.is_empty() {
@@ -827,6 +893,15 @@ fn write_step(d: &mut Deck, model: &Model, r: &Resolved, plan: &Plan, step: &Ste
             d.card([Field::from(1)]);
         }
         Procedure::NonlinearStatic(n) => {
+            if n.arc_length.is_some() {
+                return Err(Error::Unsupported { format: FORMAT, what: format!("step `{}`: arc-length control", step.name) });
+            }
+            if n.imperfection.is_some() {
+                return Err(Error::Unsupported {
+                    format: FORMAT,
+                    what: format!("step `{}`: an imperfection from a buckling mode (FieldCraft computes the mode when it solves)", step.name),
+                });
+            }
             // Nonlinear with a stiffness reformation every iteration (full Newton), at most
             // `max_iterations` per increment; LS-DYNA's own convergence norms and line search.
             d.line("*CONTROL_IMPLICIT_SOLUTION");
@@ -852,7 +927,7 @@ fn write_step(d: &mut Deck, model: &Model, r: &Resolved, plan: &Plan, step: &Ste
                 d.card([Field::Blank, Field::Blank, Field::Blank, Field::Blank, Field::from(1)]);
             }
         }
-        Procedure::ExplicitDynamic(_) | Procedure::HeatTransfer { .. } | Procedure::CoupledTemperatureDisplacement {} => {
+        Procedure::ExplicitDynamic(_) | Procedure::HeatTransfer { .. } | Procedure::CoupledTemperatureDisplacement {} | Procedure::Buckle { .. } => {
             return Err(Error::Unsupported { format: FORMAT, what: format!("step `{}`: {} steps", step.name, step.procedure.name()) });
         }
     }

crates/decks/src/nastran/mod.rs

@@ -280,6 +280,9 @@ fn solution(steps: &[&Step]) -> std::result::Result<u32, String> {
     if let Some(s) = steps.iter().find(|s| matches!(s.procedure, Procedure::ExplicitDynamic(_))) {
         return Err(format!("step `{}`: explicit dynamic steps (Nastran's linear solutions have none)", s.name));
     }
+    if let Some(s) = steps.iter().find(|s| matches!(s.procedure, Procedure::Buckle { .. })) {
+        return Err(format!("step `{}`: buckling steps (Nastran's SOL 105; this writer writes SOL 101 and 103 so far)", s.name));
+    }
     if let Some(s) = steps.iter().find(|s| matches!(s.procedure, Procedure::NonlinearStatic(_))) {
         return Err(format!("step `{}`: nonlinear static steps (Nastran's SOL 400; this writer writes SOL 101 and 103 so far)", s.name));
     }
@@ -331,6 +334,12 @@ impl<'m> Deck<'m> {
         self.plan_constraints()?;
         self.plan_loads()?;
         self.problems.extend(crate::thermal_items(self.model));
+        for name in self.model.contacts().keys() {
+            self.problems.insert(format!("contact `{name}` (Nastran's linear solutions SOL 101 and 103 have no contact)"));
+        }
+        for name in self.model.ties().keys() {
+            self.problems.insert(format!("tie `{name}` (this writer does not write glued contact yet)"));
+        }
         for sub in &mut self.subcases {
             if matches!(sub.step.procedure, Procedure::Frequency { .. }) {
                 sub.method = Some(next_id(&mut self.next_sid)?);

crates/decks/tests/abaqus.rs

@@ -828,3 +828,42 @@ fn nonlinear_plastic_steps_and_what_is_refused() {
     m.add_step(step("Again", Procedure::NonlinearStatic(NonlinearStatic::default()), &["clamp"], &["end"]), None).unwrap();
     assert!(unsupported(&m).contains("plastic material `Steel` in a deck of 2 general steps"));
 }
+
+/// A buckling step is `*BUCKLE` with its loads as the perturbation loads; after a general step
+/// (Abaqus's base state would be that step's) and with a shift it is refused by name.
+#[test]
+fn buckling_steps() {
+    let mut m = cantilever_mesh();
+    m.add_load("end", Load::Force { target: Target::Set("tip".into()), vector: [-100.0, 0.0, 0.0], distribution: Distribution::Total }).unwrap();
+    m.add_step(step("Buckle", Procedure::Buckle { modes: 4, shift: None }, &["clamp"], &["end"]), None).unwrap();
+    let deck = abaqus::write(&m).unwrap();
+    assert!(deck.contains("*BUCKLE, EIGENSOLVER=LANCZOS\n4\n") && deck.contains("*CLOAD"), "{deck}");
+    let mut shifted = m.clone();
+    shifted.replace_step(step("Buckle", Procedure::Buckle { modes: 4, shift: Some(2.0) }, &["clamp"], &["end"])).unwrap();
+    assert!(abaqus::write(&shifted).unwrap_err().to_string().contains("shift"));
+    m.add_step(step("Bend", Procedure::Static {}, &["clamp"], &["end"]), Some("Buckle")).unwrap();
+    assert!(abaqus::write(&m).unwrap_err().to_string().contains("after a general step"));
+    assert!(fieldcraft_decks::lsdyna::write(&m).is_err() && fieldcraft_decks::nastran::write(&m).is_err());
+}
+
+/// An arc-length step is `*STATIC, RIKS` with the arcs, the maximum load factor and the
+/// displacement that end it; a spherical constraint is refused, and LS-DYNA refuses the step.
+#[test]
+fn arc_length_steps() {
+    use fieldcraft_model::{ArcConstraint, ArcLength, DisplacementLimit, NonlinearStatic};
+    let mut m = cantilever_mesh();
+    m.add_load("end", Load::Force { target: Target::Set("tip".into()), vector: [0.0, 0.0, -100.0], distribution: Distribution::Total }).unwrap();
+    let arc = ArcLength {
+        max_load_factor: 3.0,
+        displacement_limit: Some(DisplacementLimit { node: 2, direction: 3, displacement: -5.0 }),
+        ..ArcLength::default()
+    };
+    let settings = NonlinearStatic { arc_length: Some(arc.clone()), ..NonlinearStatic::default() };
+    m.add_step(step("Snap", Procedure::NonlinearStatic(settings), &["clamp"], &["end"]), None).unwrap();
+    let deck = abaqus::write(&m).unwrap();
+    assert!(deck.contains("*STATIC, RIKS\n0.1, 1.0, 1.0E-5, 1.0, 3.0, 2, 3, -5.0\n"), "{deck}");
+    assert!(fieldcraft_decks::lsdyna::write(&m).is_err());
+    let spherical = NonlinearStatic { arc_length: Some(ArcLength { constraint: ArcConstraint::Spherical, ..arc }), ..NonlinearStatic::default() };
+    m.replace_step(step("Snap", Procedure::NonlinearStatic(spherical), &["clamp"], &["end"])).unwrap();
+    assert!(abaqus::write(&m).is_err());
+}

crates/decks/tests/contact.rs

@@ -0,0 +1,102 @@
+//! Contact definitions in every deck format: Abaqus surface interactions, contact pairs and
+//! general contact; LS-DYNA automatic contacts; Nastran refuses them by name.
+
+use fieldcraft_decks::{Error, abaqus, lsdyna, nastran};
+use fieldcraft_model::{
+    BoundaryCondition, Contact, ContactSurfaces, Elastic, ElementFace, ElementKind, Friction, InitialPenetration, Material, Model, Procedure,
+    Section, SectionKind, Set, Step, Target, Tie, UnitSystem,
+};
+
+/// Two unit hex8 cubes, the second on top of the first (separate nodes), with face sets for the
+/// touching faces and a static step.
+fn model() -> Model {
+    let mut m = Model::default();
+    m.set_units(UnitSystem::MmTonneS);
+    let corners = [[0., 0., 0.], [1., 0., 0.], [1., 1., 0.], [0., 1., 0.], [0., 0., 1.], [1., 0., 1.], [1., 1., 1.], [0., 1., 1.]];
+    for cube in 0..2u32 {
+        for (i, c) in corners.iter().enumerate() {
+            m.set_node(8 * cube + i as u32 + 1, [c[0], c[1], c[2] + cube as f64]).unwrap();
+        }
+        m.set_element(cube + 1, ElementKind::Hex8, (8 * cube + 1..=8 * cube + 8).collect()).unwrap();
+    }
+    m.add_set("all", Set { elements: vec![1, 2], ..Set::default() }).unwrap();
+    m.add_set("lower", Set { faces: vec![ElementFace { element: 1, face: 2 }], ..Set::default() }).unwrap();
+    m.add_set("upper", Set { faces: vec![ElementFace { element: 2, face: 1 }], ..Set::default() }).unwrap();
+    m.add_set("base", Set { nodes: vec![1, 2, 3, 4], ..Set::default() }).unwrap();
+    m.add_material(
+        "Steel",
+        Material { elastic: Some(Elastic::Isotropic { young: 210_000.0, poisson: 0.3 }), density: Some(7.85e-9), ..Material::default() },
+    )
+    .unwrap();
+    m.add_section("all", Section { set: "all".into(), material: "Steel".into(), kind: SectionKind::Solid {}, formulation: Default::default() })
+        .unwrap();
+    m.add_boundary_condition("fix", BoundaryCondition::Fixed { target: Target::Set("base".into()) }).unwrap();
+    let mut step = Step::new("Load", Procedure::Static {});
+    step.boundary_conditions.insert("fix".into());
+    m.add_step(step, None).unwrap();
+    let pair = Contact {
+        friction: Friction { static_coefficient: 0.3, kinetic: Some(0.2), decay: 5.0 },
+        initial_penetration: InitialPenetration::Adjust,
+        ..Contact::new(ContactSurfaces::Pair { main: "lower".into(), secondary: "upper".into() })
+    };
+    m.add_contact("stack", pair).unwrap();
+    m.add_contact("everything", Contact { friction: Friction::coulomb(0.1), ..Contact::new(ContactSurfaces::General { surface: None }) }).unwrap();
+    m.add_contact("fold", Contact { penalty_scale: 0.5, ..Contact::new(ContactSurfaces::General { surface: Some("upper".into()) }) }).unwrap();
+    m.add_tie("glue", Tie { position_tolerance: Some(0.05), ..Tie::new("lower", "upper") }).unwrap();
+    m
+}
+
+#[test]
+fn abaqus_writes_interactions_pairs_and_general_contact() {
+    let deck = abaqus::write(&model()).unwrap();
+    for expected in [
+        "*SURFACE, TYPE=ELEMENT, NAME=lower\n1, S2\n",
+        "*SURFACE INTERACTION, NAME=stack-interaction\n*FRICTION, EXPONENTIAL DECAY\n0.3, 0.2, 5.0\n",
+        "*CONTACT PAIR, INTERACTION=stack-interaction, TYPE=SURFACE TO SURFACE, ADJUST=0.0\nupper, lower\n",
+        "*SURFACE INTERACTION, NAME=everything-interaction\n*FRICTION\n0.1\n",
+        "*SURFACE INTERACTION, NAME=fold-interaction\n*FRICTION\n0.0\n",
+        "*CONTACT\n*CONTACT INCLUSIONS, ALL EXTERIOR\n*CONTACT INCLUSIONS\nupper,\n*CONTACT PROPERTY ASSIGNMENT\n, , everything-interaction\nupper, upper, fold-interaction\n",
+        "** contact `fold`: penalty scale 0.5",
+        "*TIE, NAME=glue, ADJUST=NO, POSITION TOLERANCE=0.05\nupper, lower\n",
+    ] {
+        assert!(deck.contains(expected), "{expected}\n{deck}");
+    }
+    // Model data: before the first step.
+    assert!(deck.find("*CONTACT PAIR") < deck.find("*STEP"));
+}
+
+#[test]
+fn lsdyna_writes_automatic_contacts_on_segment_sets() {
+    let deck = lsdyna::write(&model()).unwrap().text;
+    let after = |keyword: &str| -> Vec<String> {
+        let at = deck.find(keyword).unwrap_or_else(|| panic!("{keyword}\n{deck}"));
+        deck[at..].lines().skip(1).filter(|l| !l.starts_with('$')).take(3).map(|l| l.split_whitespace().collect::<Vec<_>>().join(" ")).collect()
+    };
+    // Sets are numbered in name order: all 1, base 2, lower 3, upper 4.
+    assert_eq!(after("*CONTACT_AUTOMATIC_SURFACE_TO_SURFACE"), ["4 3 0 0", "0.3 0.2 5.0", "1.0 1.0"], "{deck}");
+    let single: Vec<&str> = deck.match_indices("*CONTACT_AUTOMATIC_SINGLE_SURFACE").map(|(i, _)| &deck[i..]).collect();
+    assert_eq!(single.len(), 2, "{deck}");
+    let cards = |text: &str| -> Vec<String> {
+        text.lines().skip(1).filter(|l| !l.starts_with('$')).take(3).map(|l| l.split_whitespace().collect::<Vec<_>>().join(" ")).collect()
+    };
+    // `everything` (every part), then `fold` (the upper face's segment set).
+    assert_eq!(cards(single[0]), ["0 5", "0.1 0.1 0.0", "1.0 1.0"], "{deck}");
+    assert_eq!(cards(single[1]), ["4 0", "0.0 0.0 0.0", "0.5 0.5"], "{deck}");
+    for set in ["lower", "upper"] {
+        assert!(deck.contains(&format!("*SET_SEGMENT_TITLE\n{set}\n")), "{set}\n{deck}");
+    }
+    assert_eq!(after("*CONTACT_TIED_SURFACE_TO_SURFACE"), ["4 3 0 0", "0.0 0.0 0.0", "1.0 1.0"], "{deck}");
+}
+
+#[test]
+fn nastran_refuses_contact_by_name() {
+    match nastran::write(&model()) {
+        Err(Error::Unsupported { what, .. }) => {
+            for name in ["everything", "fold", "stack"] {
+                assert!(what.contains(&format!("contact `{name}`")), "{what}");
+            }
+            assert!(what.contains("tie `glue`"), "{what}");
+        }
+        other => panic!("{other:?}"),
+    }
+}

crates/engine/Cargo.toml

@@ -10,7 +10,8 @@ workspace = true
 
 [dependencies]
 fieldcraft-model = { workspace = true }
-fieldcraft-geometry = { workspace = true }
+# Samples build their geometry from SolidCraft scripts (sample.rs).
+fieldcraft-geometry = { workspace = true, features = ["scripts"] }
 fieldcraft-mesh = { workspace = true }
 fieldcraft-io = { workspace = true }
 fieldcraft-decks = { workspace = true }
@@ -24,8 +25,9 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 log = { workspace = true }
+# app.update.check (docs/updates.md); the browser build has no update check.
+fieldcraft-update = { workspace = true }
 
 [dev-dependencies]
+png = { workspace = true }
 zip = { workspace = true }
-# Multi-body designs from SolidCraft scripts in tests.
-fieldcraft-geometry = { workspace = true, features = ["scripts"] }

crates/engine/samples/crank-arm.json

@@ -0,0 +1,27 @@
+{"commands": [
+  {"command": "parameters.change", "params": {"name": "arm_thickness", "expression": "16 mm"}},
+  {"command": "sketch.create", "params": {"plane": "XY", "name": "ArmProfile"}},
+  {"command": "sketch.line", "params": {"points": [[15.471735240951828, -18.362928548901984], [160.67227699330076, -12.384082712040556]], "ids": ["lo"]}},
+  {"command": "sketch.arc.center_point", "params": {"center": [160.91912663845798, -18.3790026658586], "start": [161.58293237729853, -12.415835559271503], "end": [160.67227699330076, -12.384082712040556]}},
+  {"command": "sketch.arc.center_point", "params": {"center": [170.0, 0], "start": [161.58293237729853, -12.415835559271503], "end": [161.58293237729853, 12.415835559271503]}},
+  {"command": "sketch.arc.center_point", "params": {"center": [160.91912663845798, 18.3790026658586], "start": [160.67227699330076, 12.384082712040556], "end": [161.58293237729853, 12.415835559271503]}},
+  {"command": "sketch.line", "params": {"points": [[160.67227699330076, 12.384082712040556], [15.471735240951828, 18.362928548901984]], "ids": ["hi"]}},
+  {"command": "sketch.arc.center_point", "params": {"center": [15.883151316213851, 28.354461805265395], "start": [13.455063072993756, 18.65372021077189], "end": [15.471735240951828, 18.362928548901984]}},
+  {"command": "sketch.arc.center_point", "params": {"center": [0, 0], "start": [13.455063072993756, 18.65372021077189], "end": [13.455063072993756, -18.65372021077189]}},
+  {"command": "sketch.arc.center_point", "params": {"center": [15.883151316213851, -28.354461805265395], "start": [15.471735240951828, -18.362928548901984], "end": [13.455063072993756, -18.65372021077189]}},
+  {"command": "sketch.finish", "params": {}},
+  {"command": "solid.extrude", "params": {"distance": "arm_thickness", "body_name": "CrankArm", "name": "Arm"}},
+  {"command": "solid.cylinder", "params": {"diameter": 46.0, "height": 22, "base": [0, 0, 0], "operation": "join", "targets": ["CrankArm"], "name": "SpindleBoss"}},
+  {"command": "solid.cylinder", "params": {"diameter": 30.0, "height": 20, "base": [170.0, 0, 0], "operation": "join", "targets": ["CrankArm"], "name": "PedalBoss"}},
+  {"command": "sketch.create", "params": {"plane": "XY", "name": "BackPocket"}},
+  {"command": "sketch.rectangle.two_point", "params": {"p0": [48, -7], "p1": [130, 7]}},
+  {"command": "sketch.finish", "params": {}},
+  {"command": "solid.extrude", "params": {"distance": 8, "operation": "cut", "targets": ["CrankArm"], "name": "Pocket"}},
+  {"command": "sketch.create", "params": {"plane": "XY", "name": "SpindleSquare"}},
+  {"command": "sketch.rectangle.center", "params": {"center": [0, 0], "corner": [6.35, 6.35]}},
+  {"command": "sketch.finish", "params": {}},
+  {"command": "solid.extrude", "params": {"through_all": true, "operation": "cut", "targets": ["CrankArm"], "name": "SpindleTaper"}},
+  {"command": "solid.fillet", "params": {"edges": [[6.35, 6.35, 10], [-6.35, 6.35, 10], [-6.35, -6.35, 10], [6.35, -6.35, 10]], "radius": 1.5, "name": "SquareCornerFillet"}},
+  {"command": "solid.hole", "params": {"position": [170.0, 0, 20], "diameter": 14, "name": "PedalHole"}},
+  {"command": "solid.fillet", "params": {"edges": [[48, -7, 4], [48, 7, 4], [130, -7, 4], [130, 7, 4]], "radius": 5, "name": "PocketCornerFillet"}}
+]}

crates/engine/src/autosave.rs

@@ -47,6 +47,7 @@ impl Autosaver {
         let bytes = s.file_bytes(None)?;
         self.slot.write(&bytes, s.path.as_deref(), s.model.nodes().len(), s.model.elements().len())?;
         self.saved = Some(s.revision());
+        crate::crash::autosaved(s, &self.slot.file());
         Ok(true)
     }
 
@@ -84,6 +85,7 @@ mod tests {
         let listed = s.execute("file.recovery.list", &json!({"dir": dir})).unwrap();
         assert_eq!(listed[0]["id"], id);
         assert_eq!(listed[0]["nodes"], 1);
+        assert!(listed[0]["age"].as_u64().is_some_and(|a| a < 60), "{listed}");
         let mut next = Session::default();
         let r = next.execute("file.recover", &json!({"id": id, "dir": dir})).unwrap();
         assert_eq!(r["nodes"], 1);

crates/engine/src/bug_report.rs

@@ -0,0 +1,393 @@
+//! Bug report drafts (Help › Report a Bug, and Report it after a crash): a GitHub new-issue link
+//! that fills in the bug form (`.github/ISSUE_TEMPLATE/bug.yml`), and the files to attach.
+//!
+//! Nothing here sends anything. The user reviews the draft, then their browser opens the issue
+//! form, which they submit or not.
+//!
+//! What a draft holds by default: the version, the OS, what went wrong (the user's words, the
+//! last error or the crash's message) and, for a crash, where it happened. The user's home
+//! folder is shown as `~`. Only with **Share my session** does it also carry the commands that
+//! built the model (the replayable journal, which can name the user's files), and only with
+//! **Include the model** as well the model file. A session too long for the link (GitHub
+//! refuses long new-issue links) goes out as a file to attach and on the clipboard instead; the
+//! model file is always one to attach.
+
+use serde_json::{Value, json};
+
+use crate::crash::without_home;
+
+/// The issue form.
+pub const ISSUE_URL: &str = "https://github.com/jyviko/fieldcraft/issues/new";
+/// The longest link a draft opens: GitHub refuses new-issue links much past 8 KB.
+pub const MAX_URL: usize = 7000;
+/// The session file a draft attaches.
+pub const SESSION_FILE: &str = "fieldcraft-session.json";
+/// The model file a draft attaches.
+pub const MODEL_FILE: &str = "model.fieldcraft";
+/// Backtrace frames a crash's draft quotes.
+const FRAMES: usize = 12;
+/// A field's text is cut at this many bytes.
+const MAX_FIELD: usize = 3000;
+
+/// What to put in a draft.
+#[derive(Clone, Debug, Default)]
+pub struct Input {
+    pub title: String,
+    /// What happened: the user's words, or the last error.
+    pub observed: String,
+    /// A crash report (`crash::read`), when reporting one.
+    pub crash: Option<Value>,
+    /// Attach the replayable commands.
+    pub share_session: bool,
+    /// The commands (each `{command, params}`) that rebuild the model from `model` (or from an
+    /// empty model when there is none).
+    pub commands: Vec<Value>,
+    /// Attach the model file too (only with `share_session`).
+    pub include_model: bool,
+    pub model: Option<Vec<u8>>,
+}
+
+/// A file the user attaches to the issue.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Attachment {
+    pub name: String,
+    pub bytes: Vec<u8>,
+    /// What it is, for the review.
+    pub what: String,
+}
+
+/// A draft ready for review.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Draft {
+    pub title: String,
+    /// The bug form's fields by id (`observed`, `reproduction`, `evidence`, `version`), as the
+    /// link fills them.
+    pub fields: Vec<(&'static str, String)>,
+    /// The link that opens the filled form.
+    pub url: String,
+    /// Files to attach (the session when too long for the link, the model).
+    pub attachments: Vec<Attachment>,
+    /// Text to put on the clipboard (the session, when it is an attachment).
+    pub clipboard: Option<String>,
+}
+
+impl Draft {
+    /// The draft as JSON (attachments by name, size and what they are).
+    pub fn to_json(&self) -> Value {
+        json!({
+            "title": self.title,
+            "fields": self.fields.iter().map(|(k, v)| (k.to_string(), json!(v))).collect::<serde_json::Map<String, Value>>(),
+            "url": self.url,
+            "attachments": self.attachments.iter().map(|a| json!({"name": a.name, "bytes": a.bytes.len(), "what": a.what})).collect::<Vec<_>>(),
+            "clipboard": self.clipboard.as_ref().map(String::len),
+        })
+    }
+}
+
+/// `v0.5.8 (abc1234), macos aarch64`.
+pub fn version_line(version: &str, commit: &str) -> String {
+    let commit = if commit.is_empty() { String::new() } else { format!(" ({commit})") };
+    format!("v{version}{commit}, {} {}", std::env::consts::OS, std::env::consts::ARCH)
+}
+
+/// Percent-encode `s` for a query value (RFC 3986 unreserved characters stay).
+pub fn encode(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    for b in s.bytes() {
+        if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~') {
+            out.push(char::from(b));
+        } else {
+            out.push_str(&format!("%{b:02X}"));
+        }
+    }
+    out
+}
+
+fn cut(s: &str, n: usize) -> String {
+    if s.len() <= n {
+        return s.to_string();
+    }
+    let mut end = n;
+    while !s.is_char_boundary(end) {
+        end -= 1;
+    }
+    format!("{}\n[cut: {} bytes in all]", s.get(..end).unwrap_or_default(), s.len())
+}
+
+fn link(title: &str, fields: &[(&'static str, String)]) -> String {
+    let mut url = format!("{ISSUE_URL}?template=bug.yml&title={}", encode(title));
+    for (k, v) in fields {
+        if !v.is_empty() {
+            url.push_str(&format!("&{k}={}", encode(v)));
+        }
+    }
+    url
+}
+
+/// What a crash report says, for the evidence field: its kind, message, place, command (its id;
+/// its parameters only with the session) and the top of its backtrace.
+fn crash_evidence(report: &Value, share: bool) -> String {
+    let s = |k: &str| report.get(k).and_then(Value::as_str).unwrap_or("?");
+    let mut out =
+        format!("Crash report `{}` ({}), seen {} time(s)\n\n", s("id"), s("kind"), report.get("count").and_then(Value::as_u64).unwrap_or(1));
+    out.push_str(&format!("Message: {}\nAt: {}\n", without_home(s("message")), without_home(s("location"))));
+    if let Some(c) = report.get("command").filter(|c| !c.is_null()) {
+        let id = c.get("command").and_then(Value::as_str).unwrap_or("?");
+        match c.get("params").filter(|_| share) {
+            Some(p) => out.push_str(&format!("Command: `{id}` {}\n", without_home(&p.to_string()))),
+            None => out.push_str(&format!("Command: `{id}`\n")),
+        }
+    }
+    if let Some(a) = report.get("last_activity").and_then(Value::as_str) {
+        out.push_str(&format!("Last activity: {a}\n"));
+    }
+    let frames: Vec<&str> = report.get("backtrace").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_str).take(FRAMES).collect();
+    if !frames.is_empty() {
+        out.push_str("\nBacktrace (top):\n```\n");
+        for f in frames {
+            out.push_str(&without_home(f));
+            out.push('\n');
+        }
+        out.push_str("```\n");
+    }
+    out
+}
+
+/// The draft for `input`, by the [`version_line`] `version`.
+pub fn draft(input: &Input, version: &str) -> Draft {
+    let crash = input.crash.as_ref();
+    let mut title = input.title.trim().to_string();
+    if title.is_empty() {
+        title = match crash.and_then(|c| c.get("kind")).and_then(Value::as_str) {
+            Some("unclean_exit") => "FieldCraft closed unexpectedly".to_string(),
+            Some(_) => "Internal error".to_string(),
+            None => match input.observed.trim().lines().next().filter(|l| !l.is_empty()) {
+                Some(line) => format!("Bug: {}", line.chars().take(100).collect::<String>()),
+                None => "Bug report".to_string(),
+            },
+        };
+        if let Some(c) = crash.and_then(|c| c.get("command")).and_then(|c| c.get("command")).and_then(Value::as_str) {
+            title.push_str(&format!(" in {c}"));
+        }
+    }
+    let title = cut(&without_home(&title), 200);
+    let mut observed = without_home(input.observed.trim());
+    if observed.is_empty()
+        && let Some(m) = crash.and_then(|c| c.get("message")).and_then(Value::as_str)
+    {
+        observed = without_home(m);
+    }
+    let observed = cut(&observed, MAX_FIELD);
+    let share = input.share_session;
+    let mut evidence = crash.map(|c| crash_evidence(c, share)).unwrap_or_default();
+    let mut attachments = Vec::new();
+    let mut clipboard = None;
+    let mut reproduction = String::new();
+    // The session: the replayable script, from the attached model when there is one.
+    let model = input.model.as_ref().filter(|_| share && input.include_model);
+    let script = share.then(|| {
+        let mut steps = Vec::new();
+        if model.is_some() {
+            steps.push(json!({"command": "file.open", "params": {"path": MODEL_FILE}}));
+        }
+        steps.extend(input.commands.iter().cloned());
+        Value::Array(steps)
+    });
+    if let Some(m) = model {
+        attachments.push(Attachment { name: MODEL_FILE.into(), bytes: m.clone(), what: format!("the model ({} KB)", m.len().div_ceil(1024)) });
+    }
+    if let Some(script) = &script {
+        let n = script.as_array().map_or(0, Vec::len);
+        reproduction = format!("Replay the attached session ({n} command(s)): `fieldcraft-cli run {SESSION_FILE}`");
+        if model.is_some() {
+            reproduction.push_str(&format!(" in a folder holding `{MODEL_FILE}` too"));
+        } else if crash.is_some_and(|c| c.get("files").and_then(|f| f.get("model")).is_some()) {
+            reproduction.push_str(" (the crash replays from the model, which is not attached)");
+        }
+        reproduction.push('.');
+    }
+    let inline = |evidence: &str, script: &Value| {
+        let text = serde_json::to_string_pretty(script).unwrap_or_default();
+        format!("{evidence}\nSession ({SESSION_FILE}):\n```json\n{text}\n```\n")
+    };
+    let fields = |evidence: String| {
+        vec![("observed", observed.clone()), ("reproduction", reproduction.clone()), ("evidence", evidence), ("version", version.to_string())]
+    };
+    // The session in the link when it fits, else a file to attach (also on the clipboard).
+    let mut url = String::new();
+    if let Some(script) = &script {
+        let candidate = fields(inline(&evidence, script));
+        let u = link(&title, &candidate);
+        if u.len() <= MAX_URL {
+            evidence = inline(&evidence, script);
+            url = u;
+        } else {
+            let text = serde_json::to_string_pretty(script).unwrap_or_default();
+            evidence.push_str(&format!(
+                "\nThe session is too long for this form: FieldCraft saved it as `{SESSION_FILE}` and copied it to the clipboard. Attach the file here (drag it in) or paste it.\n"
+            ));
+            attachments.insert(0, Attachment { name: SESSION_FILE.into(), bytes: text.clone().into_bytes(), what: "the session's commands".into() });
+            clipboard = Some(text);
+        }
+    }
+    if model.is_some() {
+        evidence.push_str(&format!("\nThe model is attached as `{MODEL_FILE}` (drag it in from the folder FieldCraft saved it to).\n"));
+    }
+    if url.is_empty() || model.is_some() {
+        let mut f = fields(evidence.clone());
+        url = link(&title, &f);
+        // Still too long (a very long message): cut the longest field until it fits.
+        while url.len() > MAX_URL {
+            let Some((i, len)) = f.iter().enumerate().map(|(i, (_, v))| (i, v.len())).max_by_key(|(_, l)| *l) else { break };
+            if len < 200 {
+                break;
+            }
+            if let Some((_, v)) = f.get_mut(i) {
+                *v = cut(v, len.saturating_sub(url.len() - MAX_URL + 64).min(len / 2 + 1));
+            }
+            url = link(&title, &f);
+        }
+        evidence = f.get(2).map(|(_, v)| v.clone()).unwrap_or_default();
+    }
+    let fields = fields(evidence);
+    // The fields as the link carries them (a cut field included).
+    let fields = if url == link(&title, &fields) { fields } else { decode_fields(&url) };
+    Draft { title, fields, url, attachments, clipboard }
+}
+
+/// Write a draft's attachments to `bug-reports/<time>/` in the app's data folder (the user
+/// attaches them from there); returns the folder.
+pub fn save_attachments(draft: &Draft) -> Result<std::path::PathBuf, String> {
+    let root = fieldcraft_io::recovery::data_dir().ok_or("no data folder on this system")?;
+    let dir = root.join("bug-reports").join(crate::crash::stamp_now());
+    fieldcraft_io::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
+    for a in &draft.attachments {
+        fieldcraft_io::fs::write_atomic(&dir.join(&a.name), &a.bytes, false).map_err(|e| e.to_string())?;
+    }
+    Ok(dir)
+}
+
+/// The fields a link carries (for the review, when a field had to be cut).
+fn decode_fields(url: &str) -> Vec<(&'static str, String)> {
+    let query = url.split_once('?').map_or("", |(_, q)| q);
+    ["observed", "reproduction", "evidence", "version"]
+        .into_iter()
+        .map(|k| {
+            let v = query.split('&').find_map(|kv| kv.strip_prefix(k).and_then(|r| r.strip_prefix('='))).unwrap_or_default();
+            (k, decode(v))
+        })
+        .collect()
+}
+
+fn decode(s: &str) -> String {
+    let b = s.as_bytes();
+    let mut out = Vec::with_capacity(b.len());
+    let mut i = 0;
+    while let Some(&c) = b.get(i) {
+        let hex = b.get(i + 1..i + 3).and_then(|h| std::str::from_utf8(h).ok()).and_then(|h| u8::from_str_radix(h, 16).ok());
+        match (c, hex) {
+            (b'%', Some(v)) => {
+                out.push(v);
+                i += 3;
+            }
+            _ => {
+                out.push(c);
+                i += 1;
+            }
+        }
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn home() -> String {
+        std::env::var("HOME").or_else(|_| std::env::var("USERPROFILE")).unwrap_or_else(|_| "/home/someone".into())
+    }
+
+    fn crash() -> Value {
+        json!({
+            "id": "20261014-101500-00000000deadbeef", "kind": "command_panic", "count": 2,
+            "message": format!("index out of bounds in {}/model.fieldcraft", home()),
+            "location": "crates/mesh/src/tet.rs:42",
+            "command": {"command": "mesh.tet.generate", "params": {"body": "Plate", "path": format!("{}/secret/plate.step", home())}},
+            "backtrace": ["fieldcraft_mesh::tet::insert (crates/mesh/src/tet.rs:42)"],
+            "files": {"model": "model.fieldcraft", "replay": "replay.json"},
+        })
+    }
+
+    #[test]
+    fn without_sharing_a_draft_names_no_paths_commands_or_model() {
+        let input = Input {
+            observed: format!("cannot open {}/parts/bracket.solidcraft", home()),
+            crash: Some(crash()),
+            commands: vec![json!({"command": "geometry.open", "params": {"path": format!("{}/parts/bracket.solidcraft", home())}})],
+            model: Some(b"model bytes".to_vec()),
+            include_model: true,
+            ..Default::default()
+        };
+        let d = draft(&input, "v1.2.3, testos x");
+        assert!(d.url.starts_with("https://github.com/jyviko/fieldcraft/issues/new?template=bug.yml&title="), "{}", d.url);
+        assert!(d.attachments.is_empty() && d.clipboard.is_none(), "nothing attached without Share my session");
+        let all = format!("{} {:?} {}", d.title, d.fields, decode(&d.url));
+        assert!(!all.contains(&home()), "no home folder: {all}");
+        assert!(!all.contains("secret") && !all.contains("geometry.open"), "no parameters or commands: {all}");
+        assert!(all.contains("~/parts/bracket.solidcraft"), "the error, its home shown as ~: {all}");
+        assert!(all.contains("mesh.tet.generate") && all.contains("tet.rs:42") && all.contains("v1.2.3, testos x"), "{all}");
+        assert_eq!(d.title, "Internal error in mesh.tet.generate");
+        assert_eq!(decode_fields(&d.url), d.fields, "the review shows what the link carries");
+    }
+
+    #[test]
+    fn a_short_session_goes_in_the_link() {
+        let input = Input {
+            title: "Solve fails".into(),
+            share_session: true,
+            commands: vec![json!({"command": "file.sample", "params": {"name": "cantilever"}}), json!({"command": "solve.run", "params": {}})],
+            ..Default::default()
+        };
+        let d = draft(&input, "v1");
+        assert!(d.attachments.is_empty() && d.clipboard.is_none());
+        let evidence = &d.fields.iter().find(|(k, _)| *k == "evidence").unwrap().1;
+        assert!(evidence.contains("\"command\": \"solve.run\""), "{evidence}");
+        assert!(d.url.len() <= MAX_URL);
+        assert!(decode(&d.url).contains("file.sample"));
+    }
+
+    #[test]
+    fn a_long_session_and_the_model_are_attachments() {
+        let commands: Vec<Value> = (0..400).map(|i| json!({"command": "mesh.node.add", "params": {"label": i + 1, "xyz": [i, 0, 0]}})).collect();
+        let input =
+            Input { share_session: true, include_model: true, commands, model: Some(vec![7; 3000]), crash: Some(crash()), ..Default::default() };
+        let d = draft(&input, "v1");
+        assert!(d.url.len() <= MAX_URL, "{}", d.url.len());
+        let names: Vec<&str> = d.attachments.iter().map(|a| a.name.as_str()).collect();
+        assert_eq!(names, [SESSION_FILE, MODEL_FILE]);
+        let session: Value = serde_json::from_slice(&d.attachments[0].bytes).unwrap();
+        assert_eq!(session[0], json!({"command": "file.open", "params": {"path": MODEL_FILE}}), "the replay opens the attached model");
+        assert_eq!(session.as_array().unwrap().len(), 401);
+        assert_eq!(d.clipboard.as_deref().map(str::as_bytes), Some(d.attachments[0].bytes.as_slice()));
+        let text = decode(&d.url);
+        assert!(text.contains("too long for this form") && text.contains(MODEL_FILE) && !text.contains("\"label\": 399"), "{text}");
+        // With the session shared, the crash's command parameters are shown (home as ~).
+        assert!(text.contains("~/secret/plate.step"), "{text}");
+    }
+
+    #[test]
+    fn a_huge_message_is_cut_to_fit_the_link() {
+        let input = Input { observed: "é".repeat(20_000), ..Default::default() };
+        let d = draft(&input, "v1");
+        assert!(d.url.len() <= MAX_URL, "{}", d.url.len());
+        assert!(d.fields[0].1.contains("[cut:"));
+        assert_eq!(decode_fields(&d.url), d.fields);
+    }
+
+    #[test]
+    fn encoding_round_trips() {
+        let s = "a b&c=d/é\n```json";
+        assert_eq!(decode(&encode(s)), s);
+        assert_eq!(encode("a b&"), "a%20b%26");
+    }
+}

crates/engine/src/catalogue.rs

@@ -155,6 +155,10 @@ pub struct Capability {
     pub status: Status,
     /// Related commands in the entry's drop-down (edit, delete…).
     pub more: &'static [&'static str],
+    /// Commands the entry's own form covers (an option of it does the same), or that act on what
+    /// it makes from the browser's item menu (edit, delete): claimed by the entry for the command
+    /// search and the ribbon's stage, but not listed in the ribbon.
+    pub covers: &'static [&'static str],
 }
 
 impl Capability {
@@ -194,7 +198,7 @@ impl Capability {
 }
 
 const fn ready(id: &'static str, label: &'static str, tab: Tab, panel: &'static str, tip: &'static str) -> Capability {
-    Capability { id, label, tab, panel, tip, status: Status::Ready, more: &[] }
+    Capability { id, label, tab, panel, tip, status: Status::Ready, more: &[], covers: &[] }
 }
 
 const fn ready_more(
@@ -208,12 +212,23 @@ const fn ready_more(
     Capability { more, ..ready(id, label, tab, panel, tip) }
 }
 
+const fn covering(
+    id: &'static str,
+    label: &'static str,
+    tab: Tab,
+    panel: &'static str,
+    tip: &'static str,
+    covers: &'static [&'static str],
+) -> Capability {
+    Capability { covers, ..ready(id, label, tab, panel, tip) }
+}
+
 const fn soon(id: &'static str, label: &'static str, tab: Tab, panel: &'static str, milestone: &'static str, tip: &'static str) -> Capability {
-    Capability { id, label, tab, panel, tip, status: Status::Planned { milestone }, more: &[] }
+    Capability { id, label, tab, panel, tip, status: Status::Planned { milestone }, more: &[], covers: &[] }
 }
 
 const fn deck(id: &'static str, label: &'static str, format: &'static str, tip: &'static str) -> Capability {
-    Capability { id, label, tab: Tab::Solve, panel: "Decks", tip, status: Status::Deck { format, milestone: "M3" }, more: &[] }
+    Capability { id, label, tab: Tab::Solve, panel: "Decks", tip, status: Status::Deck { format, milestone: "M3" }, more: &[], covers: &[] }
 }
 
 use Tab::*;
@@ -232,12 +247,50 @@ pub static CATALOGUE: &[Capability] = &[
         "Inspect",
         "Weld, closed, manifold, orientation and self-intersection checks; feature edges",
     ),
-    soon("geometry.partition", "Partition", Geometry, "Prepare", "M5", "Split bodies and faces as SolidCraft features"),
-    soon("geometry.datum", "Datum Plane", Geometry, "Prepare", "M5", "Construction planes for partitions"),
+    // Edit and delete of datums and partitions are on the browser's item menu, not the ribbon.
+    covering(
+        "geometry.datum",
+        "Datum Plane",
+        Geometry,
+        "Prepare",
+        "A datum plane: principal plane and offset, three points or datum points, point and normal, normal to an axis",
+        &["geometry.datum.edit", "geometry.datum.delete"],
+    ),
+    covering(
+        "geometry.datum.axis",
+        "Datum Axis",
+        Geometry,
+        "Prepare",
+        "A datum axis: principal axis, two points or datum points, point and direction",
+        &["geometry.datum.axis.edit"],
+    ),
+    covering(
+        "geometry.datum.point",
+        "Datum Point",
+        Geometry,
+        "Prepare",
+        "A datum point: coordinates, a mesh vertex, along an edge, a face's centre, an axis through a plane",
+        &["geometry.datum.point.edit"],
+    ),
+    covering(
+        "geometry.partition",
+        "Partition",
+        Geometry,
+        "Prepare",
+        "Cut bodies into cells by a datum plane; the two faces of each cut are paired by name",
+        &["geometry.partition.delete"],
+    ),
     soon("geometry.midsurface", "Midsurface", Geometry, "Prepare", "M8", "Extract midsurfaces of thin parts for shell meshes"),
     // ---- Mesh ----
     soon("mesh.size.global", "Global Size", Mesh, "Size", "M2", "One element size for the whole part"),
-    soon("mesh.size.seed", "Seed Edges", Mesh, "Size", "M2", "Element counts, sizes and bias per edge and face"),
+    ready_more(
+        "mesh.seed.edge",
+        "Seed Edges",
+        Mesh,
+        "Size",
+        "Element counts or sizes per design edge, with bias and an exact, minimum or free constraint; the meshers honour them",
+        &["mesh.seed.clear", "mesh.seed.list"],
+    ),
     soon("mesh.size.adapt", "Curvature", Mesh, "Size", "M2", "Refine by curvature and proximity"),
     ready(
         "mesh.tet.generate",
@@ -256,30 +309,30 @@ pub static CATALOGUE: &[Capability] = &[
         "Quad or triangle mesh of a planar face or polygon in the XY plane for plane stress, plane strain and axisymmetric models; edges tagged",
     ),
     soon("mesh.quad.faces", "Quad Faces", Mesh, "Structured Hex", "M5", "All-quad meshes of faces on shared edge nodes"),
-    ready_more(
-        "mesh.hex.mapped",
-        "Mapped Hex",
+    covering(
+        "mesh.hex.generate",
+        "Hex Mesh",
         Mesh,
         "Structured Hex",
-        "Mapped hex mesh of a six-sided block (curved faces allowed)",
-        &["mesh.hex.generate"],
+        "Structured hex mesh of a body: automatic, or extruded, swept, revolved or mapped (the Method drop-down)",
+        &["mesh.hex.sweep", "mesh.hex.mapped"],
     ),
-    ready_more(
-        "mesh.hex.sweep",
-        "Sweep Hex",
+    covering(
+        "mesh.cells",
+        "Partitioned Mesh",
         Mesh,
         "Structured Hex",
-        "Hex mesh swept along extrusions (several levels), around revolutions, or from a source face to a target",
-        &["mesh.hex.generate"],
+        "One mesh of a partitioned part, a method per cell (hex, tet, or all hex as conforming blocks); cells joined across partitions",
+        &["mesh.hex.blocks"],
     ),
-    ready(
-        "mesh.hex.blocks",
-        "Block Hex",
+    soon(
+        "mesh.hex.decompose",
+        "Decompose",
         Mesh,
         "Structured Hex",
-        "One conforming hex mesh of a part split into six-sided blocks: shared faces meshed once",
+        "M5",
+        "Find sweepable and mappable regions of 3D parts (extruded cross-sections are already cut into blocks by Hex Mesh)",
     ),
-    soon("mesh.hex.decompose", "Decompose", Mesh, "Structured Hex", "M5", "Find sweepable and mappable regions and propose the splits"),
     soon("mesh.transition", "Transition", Mesh, "Structured Hex", "M5", "Conforming tet–hex interfaces with pyramids"),
     ready(
         "mesh.hex.octree",
@@ -300,7 +353,7 @@ pub static CATALOGUE: &[Capability] = &[
         Mesh,
         "Edit",
         "Add an element on existing nodes, or a mapped block of them",
-        &["mesh.element.remove", "mesh.block"],
+        &["mesh.element.remove", "mesh.block", "mesh.mirror"],
     ),
     soon("mesh.node.merge", "Merge Nodes", Mesh, "Edit", "M6", "Merge coincident nodes"),
     soon("mesh.region.remesh", "Remesh Region", Mesh, "Edit", "M6", "Remesh a region in place; split and collapse elements"),
@@ -372,7 +425,7 @@ pub static CATALOGUE: &[Capability] = &[
         Loads,
         "Boundary Conditions",
         "Fixed, displacement or symmetry condition on a set or reference point",
-        &["model.boundary_condition.edit", "model.boundary_condition.delete"],
+        &["model.boundary_condition.edit", "model.boundary_condition.delete", "model.boundary_condition.symmetry"],
     ),
     ready_more(
         "model.load.create",
@@ -414,10 +467,37 @@ pub static CATALOGUE: &[Capability] = &[
         "Kinematic or distributing coupling of a set to a reference point",
         &["model.coupling.edit", "model.coupling.delete"],
     ),
-    soon("interaction.tie", "Tie", Interactions, "Constraints", "M7", "Tie non-matching meshes together"),
-    soon("interaction.contact.general", "General Contact", Interactions, "Contact", "M7", "Contact between everything that touches, with friction"),
-    soon("interaction.contact.pair", "Contact Pair", Interactions, "Contact", "M7", "Contact between two surfaces"),
-    soon("interaction.contact.find", "Find Contacts", Interactions, "Contact", "M7", "Detect contact pairs automatically"),
+    ready_more(
+        "interaction.tie",
+        "Tie",
+        Interactions,
+        "Constraints",
+        "Tie non-matching meshes together (dual mortar constraints)",
+        &["interaction.tie.edit", "interaction.tie.delete"],
+    ),
+    ready_more(
+        "interaction.contact.general",
+        "General Contact",
+        Interactions,
+        "Contact",
+        "Contact between everything that may touch, or self contact of a surface, with friction (explicit dynamics and nonlinear static steps)",
+        &["interaction.contact.edit", "interaction.contact.delete"],
+    ),
+    // Its edit and delete rows are General Contact's: they act on contacts of either kind.
+    ready(
+        "interaction.contact.pair",
+        "Contact Pair",
+        Interactions,
+        "Contact",
+        "Contact between two surfaces: with friction in explicit dynamics, mortar contact with friction in nonlinear static steps",
+    ),
+    ready(
+        "interaction.contact.find",
+        "Find Contacts",
+        Interactions,
+        "Contact",
+        "Find the parts of the mesh that touch, and make contact pairs of them",
+    ),
     soon("interaction.rigid_wall", "Rigid Wall", Interactions, "Contact", "M10", "Rigid walls for explicit dynamics"),
     soon("interaction.bolt", "Bolt Load", Interactions, "Connectors", "M7", "Bolt pretension"),
     ready_more(
@@ -450,8 +530,8 @@ pub static CATALOGUE: &[Capability] = &[
         "Static",
         Solve,
         "Implicit",
-        "Linear static (or coupled temperature–displacement) solve of a step with FieldCraft's own solver; nonlinear static and heat transfer in the drop-down",
-        &["solve.nonlinear", "solve.heat"],
+        "Linear static (or coupled temperature–displacement) solve of a step with FieldCraft's own solver; nonlinear static, buckling and heat transfer in the drop-down",
+        &["solve.nonlinear", "solve.buckle", "solve.heat"],
     ),
     ready("solve.frequency", "Frequency", Solve, "Implicit", "Natural frequencies and mode shapes of a frequency step"),
     ready(
@@ -507,8 +587,25 @@ pub static CATALOGUE: &[Capability] = &[
         "Open a model autosaved by an app that crashed or closed with unsaved changes",
         &["file.recovery.list", "file.recovery.discard"],
     ),
+    // Hide, show and isolate act on the browser's items, from their eyes and item menus.
+    covering(
+        "view.show_all",
+        "Show All",
+        Tools,
+        "View",
+        "Show every item hidden in the viewport (hide, show and isolate items from the browser)",
+        &["view.hide", "view.show", "view.isolate"],
+    ),
     ready("edit.undo", "Undo", Tools, "History", "Undo the last command that changed the model"),
     ready("edit.redo", "Redo", Tools, "History", "Redo the command undone last"),
+    ready_more(
+        "diagnostics.bug_report",
+        "Report a Bug",
+        Tools,
+        "Help",
+        "Draft a GitHub bug report with the version, the OS and the last error; you review it, and nothing is sent until you submit it",
+        &["diagnostics.crash_reports", "diagnostics.crash_report", "diagnostics.crash_test", "app.update.check"],
+    ),
 ];
 
 /// The catalogue entry with this id.
@@ -517,9 +614,12 @@ pub fn find(id: &str) -> Option<&'static Capability> {
 }
 
 /// The entry that claims a command: the one running it, else the one listing it among its
-/// related commands. Every registered command has one (a test checks it).
+/// related commands or covering it. Every registered command has one (a test checks it).
 pub fn entry_of(command: &str) -> Option<&'static Capability> {
-    CATALOGUE.iter().find(|c| c.command() == Some(command)).or_else(|| CATALOGUE.iter().find(|c| c.more.contains(&command)))
+    CATALOGUE
+        .iter()
+        .find(|c| c.command() == Some(command))
+        .or_else(|| CATALOGUE.iter().find(|c| c.more.contains(&command) || c.covers.contains(&command)))
 }
 
 /// The tab the ribbon follows to when `command` has run from anywhere but the ribbon (a script,
@@ -562,7 +662,8 @@ pub fn features_page() -> String {
             let preset = c.preset();
             let main =
                 c.command().map(|id| if preset.as_object().is_some_and(|o| !o.is_empty()) { format!("`{id} {preset}`") } else { format!("`{id}`") });
-            let commands: Vec<String> = main.into_iter().chain(c.more.iter().map(|id| format!("`{id}`"))).collect();
+            let commands: Vec<String> =
+                main.into_iter().chain(c.more.iter().map(|id| format!("`{id}`"))).chain(c.covers.iter().map(|id| format!("(`{id}`)"))).collect();
             let _ = writeln!(md, "| {} | {} — {} | {status} | {} |", c.panel, c.label, c.tip, commands.join(", "));
         }
     }
@@ -592,6 +693,25 @@ mod tests {
         }
     }
 
+    /// Each command has one place in the ribbon: no two menu rows (an entry or a drop-down row)
+    /// run the same command with the same preset, and a command an entry's form covers is no row.
+    #[test]
+    fn no_command_appears_twice_across_ribbon_menus() {
+        let mut rows: Vec<String> = Vec::new();
+        for c in CATALOGUE {
+            let entry = c.command().map(|id| format!("{id} {}", c.preset()));
+            for row in entry.into_iter().chain(c.more.iter().map(|id| format!("{id} {{}}"))) {
+                assert!(!rows.contains(&row), "{}: `{row}` is in the ribbon twice", c.id);
+                rows.push(row);
+            }
+        }
+        for c in CATALOGUE {
+            for m in c.covers {
+                assert!(!rows.iter().any(|r| r.split(' ').next() == Some(m)), "{}: `{m}` is covered by its form and also a ribbon row", c.id);
+            }
+        }
+    }
+
     #[test]
     fn the_ribbon_follows_each_command_to_its_stage() {
         assert_eq!(stage_tab("mesh.hex.sweep"), Some(Tab::Mesh));
@@ -606,7 +726,7 @@ mod tests {
         assert_eq!(stage_tab("no.such"), None);
         // A ribbon click (an entry's command, or one of its drop-down's) stays on the tab shown.
         for c in CATALOGUE {
-            for command in c.command().into_iter().chain(c.more.iter().copied()) {
+            for command in c.command().into_iter().chain(c.more.iter().copied()).chain(c.covers.iter().copied()) {
                 assert!(stage_tab(command).is_none_or(|t| t == c.tab), "{}: `{command}` would move the ribbon from {:?}", c.id, c.tab);
             }
         }
@@ -620,9 +740,9 @@ mod tests {
                 assert!(find_command(command).is_some(), "{}: `{command}` is not a registered command", c.id);
                 claimed.push(command);
             } else {
-                assert!(c.more.is_empty(), "{}: a planned entry has no commands", c.id);
+                assert!(c.more.is_empty() && c.covers.is_empty(), "{}: a planned entry has no commands", c.id);
             }
-            for m in c.more {
+            for m in c.more.iter().chain(c.covers) {
                 assert!(find_command(m).is_some(), "{}: `{m}` is not a registered command", c.id);
                 claimed.push(m);
             }

crates/engine/src/cmd/block.rs

@@ -18,7 +18,9 @@ pub const BLOCK: CommandSpec = CommandSpec {
     id: "mesh.block",
     label: "Mesh Block",
     params: r#"{"body": "Plate", "kind": "hex8|hex20|tet4|tet10|wedge6", "corners": [[x, y, z] × 8] (hex8 order: 1-2-3-4 counter-clockwise seen from 5-6-7-8), "divisions": [n12, n14, n15] (elements along 1→2, 1→4, 1→5), "bias": [1, 1, 1] (optional: last over first element size along each direction), "edges": [{"corners": [1, 2], "arc": {"center": [x, y, z]}} | {"corners": [2, 3], "ellipse": {"center": [x, y, z], "axes": [[a], [b]] (perpendicular)}} | {"corners": [5, 6], "name": "tip_edge"}] (optional: curved edges, the shorter arc between the corners, and edge names), "faces": {"1": "bottom", "4": "tip"} (optional: names of block faces, numbered as hex8 faces: 1 = 1-2-3-4, 2 = 5-6-7-8, 3 = 1-2-6-5, 4 = 2-3-7-6, 5 = 3-4-8-7, 6 = 4-1-5-8), "vertices": {"1": "A"} (optional: names of corners), "merge": distance (optional, default 1e-6 of the block's diagonal; 0 never joins)} — adds a mapped mesh of the block (transfinite interpolation of its edges; quadratic nodes on the curves), uses existing nodes within `merge` of new ones so blocks that share a face join (the shared face must have the same elements on both sides, or nothing changes), and tags the elements with the body and element faces, edges and nodes with the named faces, edges and vertices. 2D: "kind": "quad4|quad8|tri3|tri6", four "corners" at z = 0 (counter-clockwise from +z), "divisions": [n12, n14], "bias": [r, r], "face": "area" (the face of the body the elements fill, default `area`), edges and vertices numbered among the four corners; for plane stress, plane strain and axisymmetric sections"#,
+    form: Some(super::forms::BLOCK),
     kind: CommandKind::Model,
+    requires: &[],
     run: block_mesh,
 };
 
@@ -107,7 +109,7 @@ fn block_mesh(s: &mut Session, p: &Value) -> Result<Value> {
     let region = match (planar, &p.face) {
         (true, face) => GeometryRef::face(p.body.clone(), face.clone().unwrap_or_else(|| "area".into()))?,
         (false, None) => GeometryRef::body(p.body.clone())?,
-        (false, Some(_)) => return Err(EngineError::Params("`face` names the region of 2D elements; a solid block fills its body".into())),
+        (false, Some(_)) => return Err(EngineError::invalid("face", "names the region of 2D elements; a solid block fills its body")),
     };
     if planar && !p.faces.is_empty() {
         return Err(EngineError::Params("a 2D patch has no faces to name: name its edges".into()));

crates/engine/src/cmd/cells.rs

@@ -0,0 +1,494 @@
+//! Meshing a partitioned part cell by cell (`mesh.cells`): each cell (a body of the open design,
+//! typically made by `geometry.partition`) with its own method, all into one mesh, and the cells
+//! joined across the partitions that divide them.
+//!
+//! **Joining.** Two cells on either side of a partition `P` meet on faces named
+//! `partition:P:a` and `partition:P:b`. Where the element faces of the two sides match node for
+//! node (the same divisions and kind on both sides, e.g. a mesh and its mirror image) the
+//! coincident nodes are merged and the mesh is conforming there. Elsewhere — a hex cell next to a
+//! tet cell, or two cells meshed with different divisions — the two surfaces are tied: a set on
+//! each side's partition faces and a tie between them (`interaction.tie`; dual mortar
+//! constraints in the implicit analyses, so a constant stress crosses the interface exactly).
+//! The tie is the transition between hex and tet cells; pyramid elements are not used, because
+//! they need their own element formulation in every solver and deck, while the tie works for any
+//! pair of meshes and keeps each cell's mesh as its method made it. The reply lists every
+//! interface and how it was joined.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use fieldcraft_mesh::cdt::CdtOptions;
+use fieldcraft_mesh::hex::{HexMesh, HexMethod};
+use fieldcraft_model::geometry::Entity;
+use fieldcraft_model::{ElementFace, GeometryRef, Model, Set, Tie};
+use serde_json::{Value, json};
+
+use super::hex::{Input, add_hex, hex_body};
+use super::mesh::{BodyTets, add_tets, mesh_body, quality_options};
+use crate::requirement::Requirement;
+use crate::{CommandKind, CommandSpec, EngineError, Result, Session};
+
+pub const CELLS: CommandSpec = CommandSpec {
+    id: "mesh.cells",
+    label: "Partitioned Mesh",
+    params: r#"{"methods": {"Body1/a": "tet", "Body1/b": "swept"} (per cell; default `default`), "default": "auto", "bodies": ["Body1/a", "Body1/b"] (default: every body of the open design), "size": 2.0 (element size, mm; default 1/25 of the bounding-box diagonal of all of them), "order": 1 | 2 (hex8 and tet4, or hex20 and tet10), "tolerance": 0.05 (chordal tolerance, mm)} — replaces the cells' meshes (as mesh.tet.generate; other bodies keep theirs) with one mesh of the cells, each with its method: "auto" (structured hex where a method fits, else tet), "hex" (any structured hex method), "swept", "extrude", "sweep", "revolve", "mapped" or "tet"; or "default": "blocks" (with no `methods`): every cell a mapped block, division counts assigned over all cells together, exactly mesh.hex.blocks with the same parameters. Cells on either side of a partition (faces `partition:<name>:a` and `:b`) are joined: where their element faces match node for node the nodes are merged (conforming); otherwise, as between a hex and a tet cell, a set on each side and a tie between them are made (`tie_<partition>_<k>`, sets `<tie>_main` and `<tie>_secondary`: the side with fewer nodes is the main surface), replacing ties of those names from an earlier run. Reports each cell's method (and why auto fell back to tet), and each interface: `merged` with the nodes merged, or `tied`"#,
+    form: Some(super::forms::CELLS),
+    kind: CommandKind::Model,
+    requires: &[Requirement::Design],
+    run: cells,
+};
+
+/// Distance (relative to the cells' bounding-box diagonal) within which interface nodes coincide.
+const COINCIDENT: f64 = 1e-7;
+
+/// A cell's method.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Method {
+    Auto,
+    Hex(HexMethod),
+    Tet,
+}
+
+impl Method {
+    fn parse(v: &Value) -> Result<Method> {
+        let name = v.as_str().unwrap_or_default();
+        Ok(match name {
+            "auto" => Method::Auto,
+            "hex" => Method::Hex(HexMethod::Auto),
+            "tet" => Method::Tet,
+            _ => match HexMethod::from_name(name).filter(|m| *m != HexMethod::Auto) {
+                Some(m) => Method::Hex(m),
+                None => {
+                    return Err(EngineError::Params(format!(
+                        "method `{}` is not one of auto, hex, swept, extrude, sweep, revolve, mapped, tet",
+                        name.chars().take(40).collect::<String>()
+                    )));
+                }
+            },
+        })
+    }
+}
+
+/// A meshed cell.
+enum Meshed<'a> {
+    Hex(Input<'a>, HexMesh),
+    Tet(BodyTets),
+}
+
+fn cells(s: &mut Session, p: &Value) -> Result<Value> {
+    if p.get("default").and_then(Value::as_str) == Some("blocks") {
+        if p.get("methods").is_some_and(|m| m.as_object().is_none_or(|o| !o.is_empty())) {
+            return Err(EngineError::param(
+                "methods",
+                crate::schema::ProblemKind::Invalid("must be empty with \"default\": \"blocks\" (every cell a block)".into()),
+            ));
+        }
+        return super::hex::hex_blocks(s, p);
+    }
+    let size = super::hex::number(p, "size")?;
+    let quadratic = match p.get("order") {
+        None => false,
+        Some(v) => match v.as_u64() {
+            Some(1) => false,
+            Some(2) => true,
+            _ => return Err(EngineError::invalid("order", "must be 1 or 2")),
+        },
+    };
+    let default = p.get("default").map(Method::parse).transpose()?.unwrap_or(Method::Auto);
+    let methods: BTreeMap<String, Method> = match p.get("methods") {
+        None => BTreeMap::new(),
+        Some(Value::Object(m)) => m.iter().map(|(k, v)| Ok((k.clone(), Method::parse(v)?))).collect::<Result<_>>()?,
+        Some(_) => return Err(EngineError::invalid("methods", "must map cell names to methods")),
+    };
+    let design = s.design.clone().ok_or_else(|| EngineError::Params("open a design first".into()))?;
+    let names: Vec<String> = match p.get("bodies") {
+        None => design.bodies.iter().map(|b| b.name.clone()).collect(),
+        Some(_) => super::req(p, "bodies")?,
+    };
+    if names.is_empty() || names.len() > fieldcraft_mesh::hex::MAX_CELLS {
+        return Err(EngineError::Params(format!("{} cells; mesh.cells meshes 1 to {}", names.len(), fieldcraft_mesh::hex::MAX_CELLS)));
+    }
+    for n in methods.keys() {
+        if !names.contains(n) {
+            return Err(EngineError::Params(format!("`methods` names `{n}`, which is not a cell being meshed")));
+        }
+    }
+    // One size and tolerance from the cells' joint extent, as mesh.hex.blocks does.
+    let (mut lo, mut hi) = ([f64::INFINITY; 3], [f64::NEG_INFINITY; 3]);
+    let mut shapes = Vec::with_capacity(names.len());
+    for (i, n) in names.iter().enumerate() {
+        if names.get(..i).is_some_and(|b| b.contains(n)) {
+            return Err(EngineError::Params(format!("cell `{n}` is listed twice")));
+        }
+        let shape = design.body(n).ok_or_else(|| EngineError::Params(format!("no body `{n}`")))?;
+        let m = shape.measure()?;
+        for k in 0..3 {
+            lo[k] = lo[k].min(m.bbox_min[k]);
+            hi[k] = hi[k].max(m.bbox_max[k]);
+        }
+        shapes.push(shape);
+    }
+    let diagonal = (0..3).map(|k| (hi[k] - lo[k]).powi(2)).sum::<f64>().sqrt();
+    if !(diagonal > 0.0 && diagonal.is_finite()) {
+        return Err(EngineError::Params("the cells have no extent".into()));
+    }
+    let size = Some(size.unwrap_or(diagonal / 25.0));
+    let tolerance = super::hex::number(p, "tolerance")?.unwrap_or(1e-3 * diagonal);
+    // The tet mesher's parameters: the same size and tolerance, its own order names.
+    let mut tet_params = json!({"size": size, "tolerance": tolerance, "order": if quadratic { "quadratic" } else { "linear" }});
+    for key in ["weld", "weld_distance", "feature_angle"] {
+        if let (Some(v), Some(o)) = (p.get(key), tet_params.as_object_mut()) {
+            o.insert(key.into(), v.clone());
+        }
+    }
+    let mut hex_params = tet_params.clone();
+    if let Some(o) = hex_params.as_object_mut() {
+        o.remove("order");
+    }
+    let (tet_options, quality) = quality_options(&tet_params, s.limits.max_tets as u64)?;
+    let cdt = CdtOptions { max_steiner: s.limits.max_steiner, max_tets: tet_options.max_tets };
+
+    let seeds = super::seeds::edge_seeds(s)?;
+    let mut meshed: Vec<(Meshed, Value)> = Vec::with_capacity(shapes.len());
+    for shape in shapes {
+        let method = methods.get(&shape.name).copied().unwrap_or(default);
+        let input = || Ok::<_, EngineError>(Input { seeds: seeds.clone(), ..super::hex::shape_input(shape, Some(tolerance))? });
+        let hex = |m: HexMethod| -> Result<(Input<'static>, HexMesh)> {
+            let b = input()?;
+            let mesh = hex_body(&hex_params, &b, m, quadratic, size)?;
+            Ok((b, mesh))
+        };
+        let tet = |s: &Session| mesh_body(s, &tet_params, input()?, &cdt, &tet_options, quality, true);
+        let (cell, mut info) = match method {
+            Method::Hex(m) => {
+                let (b, mesh) = hex(m)?;
+                let info = json!({"method": mesh.report.method.name()});
+                (Meshed::Hex(b, mesh), info)
+            }
+            Method::Tet => (Meshed::Tet(tet(s)?), json!({"method": "tet"})),
+            Method::Auto => match hex(HexMethod::Auto) {
+                Ok((b, mesh)) => {
+                    let info = json!({"method": mesh.report.method.name()});
+                    (Meshed::Hex(b, mesh), info)
+                }
+                Err(e) => (Meshed::Tet(tet(s)?), json!({"method": "tet", "why": e.to_string()})),
+            },
+        };
+        if let Some(o) = info.as_object_mut() {
+            o.insert("body".into(), json!(shape.name));
+        }
+        meshed.push((cell, info));
+    }
+
+    // Replace the cells' meshes (replace.rs), each after the labels before it; other bodies
+    // and the definitions stay.
+    let model = &mut s.model;
+    let cleared = super::replace::clear(model, names.iter().map(String::as_str));
+    let mut report = Vec::with_capacity(meshed.len());
+    for (cell, mut info) in meshed {
+        let (kind, elements, nodes) = match &cell {
+            Meshed::Hex(b, m) => {
+                add_hex(model, b, m)?;
+                (m.kind, m.element_count(), m.nodes.len())
+            }
+            Meshed::Tet(t) => {
+                add_tets(model, &t.name, &t.face_names, &t.mesh)?;
+                (t.mesh.kind, t.mesh.elements.len(), t.mesh.points.len())
+            }
+        };
+        if let Some(o) = info.as_object_mut() {
+            o.insert("kind".into(), json!(kind.name()));
+            o.insert("elements".into(), json!(elements));
+            o.insert("nodes".into(), json!(nodes));
+        }
+        report.push(info);
+    }
+    let interfaces = join(model, &names, COINCIDENT * diagonal)?;
+    let (nodes, elements) = (model.nodes().len(), model.elements().len());
+    Ok(cleared.report(s, json!({"cells": report, "interfaces": interfaces, "nodes": nodes, "elements": elements, "size": size})))
+}
+
+/// One side of an interface: a cell's element faces on one side of a partition.
+struct Side {
+    body: String,
+    /// The face name (`partition:P:a`), which selects its pieces too.
+    face: String,
+    faces: Vec<ElementFace>,
+    nodes: BTreeSet<u32>,
+    lo: [f64; 3],
+    hi: [f64; 3],
+}
+
+/// The element faces of each cell tagged with a partition's cut faces, by partition and side.
+fn sides(model: &Model, cells: &[String]) -> BTreeMap<String, [Vec<Side>; 2]> {
+    let c = model.classification();
+    // Tag → (partition, side), for cut faces of the meshed cells.
+    let mut cut: BTreeMap<u32, (String, usize, String)> = BTreeMap::new();
+    for (t, r) in c.entities().iter().enumerate() {
+        let Entity::Face(name) = &r.entity else { continue };
+        if !cells.contains(&r.body) {
+            continue;
+        }
+        let base = name.split_once('#').map_or(name.as_str(), |(b, _)| b);
+        let Some(rest) = base.strip_prefix("partition:") else { continue };
+        let Some((partition, side)) = rest.rsplit_once(':') else { continue };
+        let side = match side {
+            "a" => 0,
+            "b" => 1,
+            _ => continue,
+        };
+        if let Ok(t) = u32::try_from(t) {
+            cut.insert(t, (partition.to_string(), side, r.body.clone()));
+        }
+    }
+    let mut grouped: BTreeMap<(String, usize, String), Vec<ElementFace>> = BTreeMap::new();
+    for (&element, tags) in c.elements() {
+        for (&face, t) in &tags.faces {
+            if let Some(key) = cut.get(t) {
+                grouped.entry(key.clone()).or_default().push(ElementFace { element, face });
+            }
+        }
+    }
+    let mut out: BTreeMap<String, [Vec<Side>; 2]> = BTreeMap::new();
+    for ((partition, side, body), faces) in grouped {
+        let nodes: BTreeSet<u32> = faces.iter().filter_map(|f| model.face_nodes(*f)).flatten().collect();
+        let (mut lo, mut hi) = ([f64::INFINITY; 3], [f64::NEG_INFINITY; 3]);
+        for n in nodes.iter().filter_map(|&n| model.node(n)) {
+            for k in 0..3 {
+                lo[k] = lo[k].min(n.xyz[k]);
+                hi[k] = hi[k].max(n.xyz[k]);
+            }
+        }
+        let face = format!("partition:{partition}:{}", if side == 0 { "a" } else { "b" });
+        if let Some(slot) = out.entry(partition).or_insert_with(|| [Vec::new(), Vec::new()]).get_mut(side) {
+            slot.push(Side { body, face, faces, nodes, lo, hi });
+        }
+    }
+    out
+}
+
+/// Join the cells across every partition: merge where the two sides match node for node, tie
+/// where they do not. Returns the interfaces.
+fn join(model: &mut Model, cells: &[String], tol: f64) -> Result<Vec<Value>> {
+    let mut out = Vec::new();
+    for (partition, [a_sides, b_sides]) in sides(model, cells) {
+        let mut k = 0;
+        for a in &a_sides {
+            for b in &b_sides {
+                let overlap = (0..3).all(|i| a.lo[i] <= b.hi[i] + tol && b.lo[i] <= a.hi[i] + tol);
+                if !overlap {
+                    continue;
+                }
+                k += 1;
+                let matched = matching(model, a, b, tol);
+                if let Some(map) = matched {
+                    let count = map.len();
+                    model.merge_nodes(&map)?;
+                    out.push(json!({"partition": partition, "cells": [a.body, b.body], "joined": "merged", "nodes": count}));
+                } else {
+                    let name = format!("tie_{partition}_{k}");
+                    let (main, secondary) = if a.nodes.len() <= b.nodes.len() { (a, b) } else { (b, a) };
+                    let set = |side: &Side| -> Result<Set> { Ok(Set::of_geometry(vec![GeometryRef::face(side.body.as_str(), side.face.as_str())?])) };
+                    let (main_set, secondary_set) = (format!("{name}_main"), format!("{name}_secondary"));
+                    for (n, side) in [(&main_set, main), (&secondary_set, secondary)] {
+                        if model.set(n).is_some() {
+                            model.replace_set(n, set(side)?)?;
+                        } else {
+                            model.add_set(n, set(side)?)?;
+                        }
+                    }
+                    if model.tie(&name).is_some() {
+                        model.remove_tie(&name)?;
+                    }
+                    model.add_tie(&name, Tie::new(&main_set, &secondary_set))?;
+                    out.push(json!({
+                        "partition": partition,
+                        "cells": [a.body, b.body],
+                        "joined": "tied",
+                        "tie": name,
+                        "main": main.body,
+                        "secondary": secondary.body,
+                        "faces": [a.faces.len(), b.faces.len()],
+                    }));
+                }
+            }
+        }
+    }
+    Ok(out)
+}
+
+/// When the two sides' nodes coincide one to one (within `tol`) and their faces are the same
+/// in number, the merge: each node of side `b` to the node of side `a` at its place (or the other
+/// way round, so the lower label survives).
+fn matching(model: &Model, a: &Side, b: &Side, tol: f64) -> Option<BTreeMap<u32, u32>> {
+    if a.nodes.len() != b.nodes.len() || a.faces.len() != b.faces.len() {
+        return None;
+    }
+    let both: BTreeSet<u32> = a.nodes.union(&b.nodes).copied().collect();
+    let map = fieldcraft_mesh::join::coincident_nodes(model, Some(&both), tol).ok()?;
+    // Every pair joins one node of each side, and every node of either side is in a pair.
+    let one_to_one = map.len() == a.nodes.len()
+        && map.iter().all(|(from, to)| (a.nodes.contains(from) && b.nodes.contains(to)) || (b.nodes.contains(from) && a.nodes.contains(to)));
+    one_to_one.then_some(map)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The sample plate (40 × 30 × 10, a Ø10 hole at (15, 15)) open and cut at x = 30, right of
+    /// the hole: `Body1/a` holds the hole, `Body1/b` is a 10 × 30 × 10 block.
+    fn cut_plate() -> (crate::tests::TempDir, Session) {
+        let (dir, path) = crate::tests::sample_design_file(&fieldcraft_geometry::sample::Plate::default());
+        let mut s = Session::default();
+        s.execute("geometry.open", &json!({"path": path})).unwrap();
+        s.execute("geometry.datum", &json!({"name": "X30", "by": {"type": "offset", "plane": "yz", "offset": 30}})).unwrap();
+        s.execute("geometry.partition", &json!({"name": "P", "datum": "X30"})).unwrap();
+        (dir, s)
+    }
+
+    #[test]
+    fn hex_and_tet_cells_are_tied_and_matching_hex_cells_merged() {
+        let (_dir, mut s) = cut_plate();
+        // A tet cell next to a hex cell: tied, main the coarser side.
+        let r = s.execute("mesh.cells", &json!({"methods": {"Body1/a": "tet", "Body1/b": "mapped"}, "size": 2.5})).unwrap();
+        assert_eq!(r["cells"][0]["kind"], "tet4", "{r}");
+        assert_eq!(r["cells"][1]["kind"], "hex8", "{r}");
+        let i = &r["interfaces"][0];
+        assert_eq!(i["joined"], "tied", "{r}");
+        assert_eq!(s.model.ties().len(), 1);
+        for set in ["tie_P_1_main", "tie_P_1_secondary"] {
+            assert!(s.model.resolve_set(set).unwrap().faces.len() > 4, "{set}");
+        }
+        // Both cells hex at one size: the plane faces match node for node and merge.
+        let r = s.execute("mesh.cells", &json!({"default": "hex", "size": 2.5})).unwrap();
+        assert_eq!(r["interfaces"].as_array().map(Vec::len), Some(1), "{r}");
+        let i = &r["interfaces"][0];
+        assert_eq!(i["joined"], "merged", "{r}");
+        let separate = r["cells"].as_array().unwrap().iter().map(|c| c["nodes"].as_u64().unwrap()).sum::<u64>();
+        assert_eq!(r["nodes"].as_u64().unwrap() + i["nodes"].as_u64().unwrap(), separate, "{r}");
+        // Rerunning replaces the tie it made rather than adding another.
+        s.execute("mesh.cells", &json!({"methods": {"Body1/a": "tet"}, "size": 2.5})).unwrap();
+        assert_eq!(s.model.ties().len(), 1);
+    }
+
+    /// The half crank arm (cut on its symmetry plane only) has no cell that maps or sweeps as
+    /// the design gives it; the extrusion decomposes its cross-section into blocks itself, alike
+    /// through mesh.hex.generate (auto) and mesh.cells, with no seeds.
+    #[test]
+    fn the_half_crank_extrudes_in_blocks_without_partitions() {
+        let bytes = fieldcraft_geometry::script_design(crate::sample::CRANK_ARM).unwrap();
+        let (_dir, path) = crate::tests::design_file(&bytes);
+        let mut s = Session::default();
+        s.execute("geometry.open", &json!({"path": path})).unwrap();
+        s.execute("geometry.datum", &json!({"name": "Sym", "by": {"type": "offset", "plane": "zx", "offset": 0}})).unwrap();
+        s.execute("geometry.partition", &json!({"name": "Half", "datum": "Sym"})).unwrap();
+        let r = s.execute("mesh.hex.generate", &json!({"body": "CrankArm/a", "size": 3})).unwrap();
+        let body = &r["bodies"][0];
+        assert_eq!(body["method"], "extrude", "{r}");
+        assert!(body["description"].as_str().unwrap().contains(" 0 free)"), "{r}");
+        assert!(body["quality"]["min_scaled_jacobian"].as_f64().unwrap() >= 0.37, "{r}");
+        let r = s.execute("mesh.cells", &json!({"bodies": ["CrankArm/a"], "default": "extrude", "size": 3})).unwrap();
+        assert_eq!(r["cells"][0]["method"], "extrude", "{r}");
+        assert_eq!(r["elements"], body["elements"], "{r}");
+    }
+
+    #[test]
+    fn auto_falls_back_to_tet_and_says_why() {
+        let (_dir, mut s) = cut_plate();
+        let r = s.execute("mesh.cells", &json!({"default": "mapped", "methods": {"Body1/a": "auto"}, "size": 3})).unwrap();
+        // The holed cell is not a mapped block, but auto sweeps it.
+        assert!(r["cells"][0]["method"].as_str().is_some(), "{r}");
+        assert_eq!(r["cells"][1]["method"], "mapped", "{r}");
+    }
+
+    #[test]
+    fn hostile_params_change_nothing() {
+        let (_dir, mut s) = cut_plate();
+        let journal = s.journal.len();
+        for p in [
+            json!({"default": "pyramid"}),
+            json!({"methods": {"Nope": "tet"}}),
+            json!({"methods": ["tet"]}),
+            json!({"bodies": []}),
+            json!({"bodies": ["Body1/a", "Body1/a"]}),
+            json!({"bodies": ["Nope"]}),
+            json!({"order": 3}),
+            json!({"size": -1}),
+            json!({"default": "mapped", "bodies": ["Body1/a"]}),
+        ] {
+            assert!(s.execute("mesh.cells", &p).is_err(), "{p}");
+        }
+        assert_eq!(s.journal.len(), journal);
+        assert!(s.model.elements().is_empty());
+    }
+
+    /// A 40 × 10 × 10 bar in uniaxial tension, cut in the middle: one half hex, the other tet,
+    /// tied. With ν = 0, symmetry conditions on three faces and the end load spread by consistent
+    /// weights, the stress is uniform, which both elements and the dual mortar tie carry exactly:
+    /// the end moves F L / (E A).
+    #[test]
+    fn a_tied_hex_tet_bar_in_tension_stretches_as_the_formula_says() {
+        let commands = json!({"commands": [
+            {"command": "solid.box", "params": {"length": 40, "width": 10, "height": 10, "body_name": "Bar"}},
+        ]});
+        let bytes = fieldcraft_geometry::script_design(&commands.to_string()).unwrap();
+        let (_dir, path) = crate::tests::design_file(&bytes);
+        let mut s = Session::default();
+        s.execute("geometry.open", &json!({"path": path})).unwrap();
+        let bbox = s.execute("geometry.bodies", &json!({})).unwrap()[0]["bbox"].clone();
+        let lo: Vec<f64> = bbox[0].as_array().unwrap().iter().map(|v| v.as_f64().unwrap()).collect();
+        let hi: Vec<f64> = bbox[1].as_array().unwrap().iter().map(|v| v.as_f64().unwrap()).collect();
+        let (axis, length) = (0..3).map(|k| (k, hi[k] - lo[k])).max_by(|a, b| a.1.total_cmp(&b.1)).unwrap();
+        assert!((length - 40.0).abs() < 1e-9);
+        let mid = (lo[axis] + hi[axis]) / 2.0;
+        let mut normal = [0.0; 3];
+        normal[axis] = 1.0;
+        let mut point = [0.0; 3];
+        point[axis] = mid;
+        s.execute("geometry.datum", &json!({"name": "Mid", "by": {"type": "point_normal", "point": point, "normal": normal}})).unwrap();
+        s.execute("geometry.partition", &json!({"name": "Cut", "datum": "Mid"})).unwrap();
+        let r = s.execute("mesh.cells", &json!({"methods": {"Bar/a": "mapped", "Bar/b": "tet"}, "size": 2.5})).unwrap();
+        assert_eq!(r["interfaces"][0]["joined"], "tied", "{r}");
+
+        let m = &s.model;
+        let on = |k: usize, v: f64| -> Vec<u32> { m.nodes().iter().filter(|(_, n)| (n.xyz[k] - v).abs() < 1e-9).map(|(l, _)| *l).collect() };
+        let others: Vec<usize> = (0..3).filter(|k| *k != axis).collect();
+        let end: Vec<Value> = m
+            .elements()
+            .iter()
+            .flat_map(|(&e, el)| (1..=el.kind.faces().len() as u8).map(move |f| (e, f)))
+            .filter(|&(e, f)| {
+                m.face_nodes(ElementFace { element: e, face: f })
+                    .is_some_and(|ns| ns.iter().all(|n| (m.node(*n).unwrap().xyz[axis] - hi[axis]).abs() < 1e-9))
+            })
+            .map(|(e, f)| json!({"element": e, "face": f}))
+            .collect();
+        let plane = |k: usize| ["x", "y", "z"][k];
+        let (young, area, force) = (70_000.0, 100.0, 1000.0);
+        let script = json!([
+            {"command": "model.set.create", "params": {"name": "all", "elements": m.elements().keys().collect::<Vec<_>>()}},
+            {"command": "model.set.create", "params": {"name": "root", "nodes": on(axis, lo[axis])}},
+            {"command": "model.set.create", "params": {"name": "side1", "nodes": on(others[0], lo[others[0]])}},
+            {"command": "model.set.create", "params": {"name": "side2", "nodes": on(others[1], lo[others[1]])}},
+            {"command": "model.set.create", "params": {"name": "end", "faces": end}},
+            {"command": "model.material.create", "params": {"name": "Al", "elastic": {"type": "isotropic", "young": young, "poisson": 0}}},
+            {"command": "model.section.create", "params": {"name": "Bar", "set": "all", "material": "Al", "kind": {"type": "solid"}}},
+            {"command": "model.boundary_condition.create", "params": {"name": "s0", "type": "symmetry", "target": {"set": "root"}, "plane": plane(axis)}},
+            {"command": "model.boundary_condition.create", "params": {"name": "s1", "type": "symmetry", "target": {"set": "side1"}, "plane": plane(others[0])}},
+            {"command": "model.boundary_condition.create", "params": {"name": "s2", "type": "symmetry", "target": {"set": "side2"}, "plane": plane(others[1])}},
+            {"command": "model.load.create", "params": {"name": "Pull", "type": "force", "target": {"set": "end"}, "vector": normal.map(|n| n * force)}},
+            {"command": "model.step.create", "params": {"name": "Load", "procedure": {"type": "static"}, "boundary_conditions": ["s0", "s1", "s2"], "loads": ["Pull"]}},
+        ]);
+        let tip = on(axis, hi[axis]);
+        s.run_script(&script).unwrap();
+        s.execute("solve.static", &json!({})).unwrap();
+        let probe = s.execute("solve.probe", &json!({"step": "Load", "nodes": tip})).unwrap();
+        let expected = force * length / (young * area);
+        let probed = probe["nodes"].as_array().unwrap();
+        assert!(probed.len() > 4, "{probe}");
+        for n in probed {
+            let u = n["displacement"][axis].as_f64().unwrap();
+            assert!((u - expected).abs() < 1e-6 * expected, "{u} vs {expected}: {n}");
+        }
+    }
+}