Rename the project to FieldCraft

Crates fieldcraft-*, binaries fieldcraft and fieldcraft-cli, the .fieldcraft file (format tag
fieldcraft/1, manifest fieldcraft.json), FIELDCRAFT_* environment variables, the MCP server
name, egui widget ids (fc_*), the app icon document FieldCraft.icon and its generated family,
docs and licences. No compatibility shim: no files of the earlier name exist.

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

crates/lbm/src/flow.rs

@@ -36,9 +36,9 @@
 //! only its own populations; the wall forces are summed in link order. There are no parallel
 //! reductions, so the result is the same bit for bit on any number of threads and platform.
 
-use modelcraft_model::{BoxFace, FaceCondition, Profile};
+use fieldcraft_model::{BoxFace, FaceCondition, Profile};
 
-use modelcraft_parallel as parallel;
+use fieldcraft_parallel as parallel;
 
 use crate::lattice::{C, Q, W, c, equilibrium, moving_wall, opposite};
 use crate::setup::{MAX_LATTICE_SPEED, Obstacle, Setup};

crates/lbm/src/lib.rs

@@ -1,6 +1,6 @@
-//! ModelCraft's lattice Boltzmann flow solver (CPU).
+//! FieldCraft's lattice Boltzmann flow solver (CPU).
 //!
-//! It solves a fluid step of the model ([`modelcraft_model::Procedure::Fluid`]) in its fluid
+//! It solves a fluid step of the model ([`fieldcraft_model::Procedure::Fluid`]) in its fluid
 //! domain: weakly compressible, isothermal, Newtonian flow on a uniform grid of cubic cells that
 //! fills the domain's box, less the cells inside the obstacle bodies.
 //!
@@ -33,14 +33,14 @@
 //! - P. Lallemand, L.-S. Luo, *Theory of the lattice Boltzmann method: dispersion, dissipation,
 //!   isotropy, Galilean invariance, and stability*, PRE 61:6546, 2000 (stability limits).
 //! - H. Edelsbrunner, E. P. Mücke, *Simulation of Simplicity*, ACM TOG 9(1):66–104, 1990;
-//!   J. R. Shewchuk 1997 (exact predicates, through `modelcraft_mesh::predicates`).
+//!   J. R. Shewchuk 1997 (exact predicates, through `fieldcraft_mesh::predicates`).
 //!
 //! No code of any lattice Boltzmann package was read; everything is written from these papers and
 //! the book.
 //!
 //! # Determinism
 //! Double precision and fixed loop orders. Collision and streaming run on threads by fixed blocks
-//! of cells ([`modelcraft_parallel`]), each cell's update independent of the others; the wall
+//! of cells ([`fieldcraft_parallel`]), each cell's update independent of the others; the wall
 //! forces and every other sum run in a fixed order on one thread. The same model gives the same
 //! result bit for bit on any number of threads and on every platform, wasm included.
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
@@ -71,9 +71,9 @@ pub enum Error {
     #[error("unstable: {0}")]
     Unstable(String),
     #[error(transparent)]
-    Model(#[from] modelcraft_model::Error),
+    Model(#[from] fieldcraft_model::Error),
     #[error(transparent)]
-    Mesh(#[from] modelcraft_mesh::Error),
+    Mesh(#[from] fieldcraft_mesh::Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;

crates/lbm/src/setup.rs

@@ -25,8 +25,8 @@
 //! While running, a lattice speed above [`MAX_LATTICE_SPEED`] or a non-finite or non-positive
 //! density stops the run with [`crate::Error::Unstable`].
 
-use modelcraft_mesh::surface::BoundarySurface;
-use modelcraft_model::{BoxFace, FaceCondition, FluidDomain, Model, Procedure, SurfaceCondition};
+use fieldcraft_mesh::surface::BoundarySurface;
+use fieldcraft_model::{BoxFace, FaceCondition, FluidDomain, Model, Procedure, SurfaceCondition};
 
 use crate::voxel::Grid;
 use crate::{Error, Limits, Result};
@@ -101,7 +101,7 @@ fn norm(v: [f64; 3]) -> f64 {
 }
 
 /// The fluid step named `step` (or the only fluid step when `step` is `None`) and its domain.
-pub fn fluid_step<'m>(model: &'m Model, step: Option<&str>) -> Result<(&'m modelcraft_model::Step, &'m FluidDomain)> {
+pub fn fluid_step<'m>(model: &'m Model, step: Option<&str>) -> Result<(&'m fieldcraft_model::Step, &'m FluidDomain)> {
     let s = model.select_step(step, |p| p.fluid_domain().is_some(), "fluid")?;
     let name = s.procedure.fluid_domain().unwrap_or_default();
     let domain = model.fluid_domain(name).ok_or_else(|| Error::NotFound(format!("fluid domain `{name}`")))?;
@@ -258,7 +258,7 @@ impl Setup {
             for sb in domain.surfaces.iter().filter(|sb| &sb.face.body == body) {
                 let mut hit = false;
                 for (tag, name) in names.iter().enumerate() {
-                    if sb.face.selects(&modelcraft_model::GeometryRef::face(body.as_str(), name.as_str())?) {
+                    if sb.face.selects(&fieldcraft_model::GeometryRef::face(body.as_str(), name.as_str())?) {
                         hit = true;
                         if let (Some(slot), SurfaceCondition::MovingWall { velocity }) = (velocities.get_mut(tag), sb.condition) {
                             *slot = velocity.map(|c| c * dt / h);

crates/lbm/src/solve.rs

@@ -1,6 +1,6 @@
 //! Running a fluid step: the time loop, output frames and force histories, in model units.
 
-use modelcraft_model::Model;
+use fieldcraft_model::Model;
 
 use crate::flow::Flow;
 use crate::setup::{Obstacle, Setup};

crates/lbm/src/voxel.rs

@@ -30,8 +30,8 @@
 //! lower triangle index, so the assignment is deterministic. This is a classification for
 //! reporting, not a meshing decision, so floating-point distances are adequate.
 
-use modelcraft_mesh::predicates::{Point2, Point3, Sign, orient2d, orient3d, snap_to_domain};
-use modelcraft_mesh::surface::BoundarySurface;
+use fieldcraft_mesh::predicates::{Point2, Point3, Sign, orient2d, orient3d, snap_to_domain};
+use fieldcraft_mesh::surface::BoundarySurface;
 
 use crate::{Error, Result};
 
@@ -373,7 +373,7 @@ impl TriangleTree {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use modelcraft_mesh::surface::SurfaceOptions;
+    use fieldcraft_mesh::surface::SurfaceOptions;
 
     /// The surface of the box [lo, hi], outward, two triangles per side, side k tagged k.
     pub(crate) fn cube(lo: [f64; 3], hi: [f64; 3]) -> BoundarySurface {