feat: floorplan sketch editor

[rdmiller]

Draw a closed outline on the ground plane, set a height, extrude it into a room. Geometry could previously only arrive by import (DXF/OBJ/STL/DAE); this covers the common shoebox and polygonal cases directly, in a new Sketch panel alongside Objects/Solvers/Renderer.

Layering

The geometry logic is deliberately kept where it can be tested without mocks.

Layer	Imports	Tests
compute/geometry/	none	no mocks
objects/room-from-mesh.ts, room-mesh-editor.ts	THREE, Surface, Room	light fakes
render/floorplan-tool.ts	THREE (injected camera/element/parent)	real THREE + real DOM events
components/…/SketchPanel.tsx	shared property-row components	real tool, mocked object layer

This matters here specifically: importing Surface pulls in compute/csg, whose jscad bundle loads from an http: URL and cannot resolve under vitest — surface.spec.ts already has to stub it. Keeping the geometry core import-free means the topology, triangulation, snapping and reconciliation logic is tested directly.

Two properties that fail silently

Both would produce a room that looks right and models wrong, so they're pinned hard.

Winding. The raytracer reads intersection.face.normal (ray-core.ts:70), so orientation is physically meaningful. Every face loop is CCW seen from inside. raycast-contract.spec.ts verifies this end to end against real three.js: interior rays always meet a normal pointing back at them, and crossing parity is odd from inside / even from outside — a watertightness check that a gap or T-junction breaks. Verified on a shoebox and a concave L-shape.

Welding. An n-point outline emits exactly 2n shared vertices, so a corner is one vertex belonging to three faces. Faces stay polygonal loops over shared indices and are triangulated only at the boundary. Triangulation is ear-clipping, not a fan — room floors are routinely concave and a fan spills outside the outline.

Reconciliation, not rebuilding

Surfaces are matched to faces by stable id, so a height change updates geometry in place via Surface.init and the user's acoustic material assignments survive. One face becomes one Surface, so materials stay assignable per wall — the point of the exercise for a room-acoustics tool.

Undo/redo needed no inverse operations: both directions are "re-sync against a remembered mesh", and the reconciler handles walls added or removed as a consequence.

Persistence

Mesh and face ids ride in Room/Surface save objects, so a reloaded project stays editable and the panel re-adopts it. Both fields are optional and dropped by JSON.stringify when absent, so existing save files round-trip byte-identically. Restore validates the mesh rather than trusting it — a truncated or hand-edited save leaves the room non-editable instead of failing the whole restore.

Notes for review

• PropertyRowNumberInput gains optional name and disabled (additive, defaulted — no existing call site changes).
• A mesh edited past its floorplan is marked detached; the panel adopts it read-only rather than showing a stale outline and silently discarding those edits on the next re-extrude. Unreachable through today's UI, but it becomes reachable when direct vertex editing lands.
• flexlayout-smoke.test.tsx now mocks SketchPanel like the other panels — unmocked it reaches compute/csg.
• dist/ is intentionally not included; CI regenerates it.

Testing

2293 tests / 105 files, lint and typecheck clean. ~440 tests are new.

Verified live in project-varese against a real browser: draw → close → create, per-wall surfaces (Floor, Ceiling, Wall 1–4) in the object tree, live height edit updating in place, correct Z-up orientation, no console errors.

End-to-end solve

A sketched room (4-point outline, 36.8 m perimeter, 2.5 m height) with a source and receiver placed inside was run through the Ray Tracer on CPU:

Metric	Value
Valid rays	531 -> 2871
Convergence ratio	4.5% -> 86.3%
Est. T30, 125 Hz-8 kHz	0.62 / 0.60 / 0.30 / 0.19 / 0.32 / 0.34 / 0.29 s

Rays stayed inside the room for the whole run, which is watertightness confirmed in the solver itself rather than only in the raycast tests - a leak would let rays escape and convergence would stall instead of climbing to 86%.

Review rounds

Two rounds of automated review raised 13 issues; all were verified against the code and fixed (commits 70caeda, 3327a0d). Two were bugs my own tests had masked by asserting the right outcome via the wrong route - the adoption fixture set version by hand, and the point-edit test changed the height immediately afterwards. Those tests now fail without their fixes.

One prescription was deliberately narrowed: restore rejects duplicate faceIds rather than requiring exactly one Surface per mesh face. The strict form would make a room permanently non-editable after a user deletes a wall from the object tree - an ordinary action the reconciler already handles correctly - in exchange for guarding a state our own code cannot produce.

Known gaps

• A wall deleted and then restored by undo returns with the default material, not its own (the original Surface was disposed).
• Direct 3D vertex manipulation is not included. applyEdit's move-vertex op is implemented and tested to prove the topology supports it; only the gizmo is missing.

Pre-existing bugs found while testing

Both are outside this PR and filed separately:

• RayTracer.dispose() throws when a solver is deleted before it has ever run.
• TransformInput drops a leading minus sign, so negative coordinates cannot be typed.

Generated with Claude Code

[Copilot]

Pull request overview

Adds a floorplan sketch editor that extrudes editable room geometry while preserving per-surface materials and persistence.

Changes:

• Adds floorplan validation, topology, triangulation, snapping, and raycast contracts.
• Adds room reconciliation, persistence, and undo/redo support.
• Integrates a Sketch panel and drawing tool with extensive tests.

Reviewed changes

Copilot reviewed 29 out of 29 changed files in this pull request and generated 8 comments.

Show a summary per file

File	Description
src/test-utils/room-fakes.ts	Adds lightweight room test doubles.
src/render/floorplan-tool.ts	Implements canvas sketch interaction and previews.
src/render/__tests__/floorplan-tool.spec.ts	Tests tool projection, input, and lifecycle.
src/objects/surface.ts	Persists mesh face identifiers.
src/objects/room.ts	Persists editable room meshes.
src/objects/room-mesh-editor.ts	Adds mesh editing and history integration.
src/objects/room-from-mesh.ts	Converts and reconciles meshes with rooms.
src/objects/mesh-userdata.ts	Stores and validates mesh metadata.
src/objects/__tests__/surface.spec.ts	Tests face-ID persistence.
src/objects/__tests__/room-mesh-editor.spec.ts	Tests editing and history behavior.
src/objects/__tests__/room-from-mesh.spec.ts	Tests room reconciliation.
src/objects/__tests__/mesh-userdata.spec.ts	Tests metadata persistence and validation.
src/compute/geometry/triangulate.ts	Adds polygon ear-clipping triangulation.
src/compute/geometry/sync-plan.ts	Plans stable face reconciliation.
src/compute/geometry/sketch-input.ts	Implements sketch and snapping state.
src/compute/geometry/room-mesh.ts	Defines editable room topology.
src/compute/geometry/floorplan.ts	Validates and extrudes floorplans.
src/compute/geometry/__tests__/triangulate.spec.ts	Tests triangulation properties.
src/compute/geometry/__tests__/sync-plan.spec.ts	Tests reconciliation planning.
src/compute/geometry/__tests__/sketch-input.spec.ts	Tests sketch interactions.
src/compute/geometry/__tests__/room-mesh.spec.ts	Tests topology and edits.
src/compute/geometry/__tests__/raycast-contract.spec.ts	Verifies normals and watertightness.
src/compute/geometry/__tests__/floorplan.spec.ts	Tests floorplan extrusion.
src/components/workbench/WorkbenchLayout.tsx	Registers the Sketch panel.
src/components/workbench/panels/SketchPanel.tsx	Adds the sketch editor UI.
src/components/workbench/panels/__tests__/SketchPanel.spec.tsx	Tests panel workflows.
src/components/workbench/defaultLayout.ts	Adds the default Sketch tab.
src/components/workbench/__tests__/flexlayout-smoke.test.tsx	Updates layout smoke mocks.
src/components/parameter-config/property-row/PropertyRowNumberInput.tsx	Adds name and disabled support.

Suppressed comments (3)

src/components/workbench/panels/SketchPanel.tsx:165

• Once a room has been adopted, this guard prevents reconciliation on later store replacements. Opening another project or deleting the room leaves room pointing at a disposed object, so subsequent height edits mutate the old room instead of the current project. On each container change, first verify the selected room still exists and adopt/clear it as needed.

  useEffect(() => {
    if (room || adoptionDismissed) return;

src/objects/room-from-mesh.ts:148

• Reconciliation changes room.allSurfaces and geometry but never refreshes Room's derived state. After adding a wall, room.surfaceMap lacks its UUID, so response-by-intensity.ts:25 dereferences undefined when a ray hits it; boundingBox and cached volume also remain stale. Rebuild these fields after all add/update/remove operations.

  // Keep the Room's record current, so the next diff is against what is
  // actually on screen. This is also what lets undo/redo be a plain re-sync.
  setRoomMesh(room, mesh);

src/objects/room-mesh-editor.ts:65

• Undo/redo only mutates the Room object. It does not request a render, increment observable store state, or update SketchPanel's separate height/draft state, so undoing a height/point edit leaves both the viewport and controls showing the post-edit value until another action occurs. The recall path must publish the restored mesh and request rendering.

    recallFunction: (direction?: keyof Directions) => {
      syncRoomFromMesh(room, direction === 'UNDO' ? before : after, options);
    },

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[Copilot]

Pull request overview

Copilot reviewed 30 out of 30 changed files in this pull request and generated 5 comments.

Suppressed comments (6)

src/objects/room-from-mesh.ts:143

• Surface.dispose() only detaches the object; it does not dispose the mesh, edge, or vertex-normal GPU resources. Therefore every topology edit that removes a face leaks all buffers (and the helper material) for that wall, and undo/redo can repeat the leak. Add resource cleanup to the Surface disposal path before emitting removal.

  for (const id of plan.removed) {
    const surface = byFaceId.get(id)!;
    surface.dispose();
    emit('REMOVE_SURFACE', surface.uuid);

src/compute/geometry/floorplan.ts:164

• The preceding loop records a missing/null point as non-finite, but execution continues here and dereferences a.x/b.x before the early return at line 176. Thus malformed runtime input throws instead of returning the collected validation issue. Skip this geometric check whenever either endpoint is not a finite point.

  for (let i = 0; i < points.length; i++) {
    const a = points[i];
    const b = points[(i + 1) % points.length];
    if (Math.abs(a.x - b.x) < EPS && Math.abs(a.y - b.y) < EPS) {

src/components/workbench/panels/SketchPanel.tsx:170

• This early return prevents the panel from reacting when the current project replaces or removes the adopted room. After Open/New, room still points at the old disposed object, so subsequent height edits call setFloorplan on an object no longer in the store; adoptionDismissed likewise suppresses adoption in later projects. On each containers change, first verify the selected room UUID is still present, then clear/re-adopt when the project contents change.

  useEffect(() => {
    if (room || adoptionDismissed) return;

src/compute/geometry/floorplan.ts:249

• Wall IDs are array positions rather than stable edge identities. Inserting/appending a point changes the physical edge represented by an existing ID (for example, the former closing wall-3 becomes the edge from the old last point to the new point), so reconciliation preserves that wall's material on the wrong wall. Use persistent vertex/edge IDs, or explicitly remap unchanged geometric edges, before claiming material-preserving topology edits.

  for (let i = 0; i < n; i++) {
    const j = (i + 1) % n;
    faces.push({
      id: `wall-${i}`,
      name: `Wall ${i + 1}`,
      // floor i -> ceiling i -> ceiling j -> floor j, which for a CCW outline
      // puts the normal at (-dy, dx): the interior side of the wall.
      loop: [i, n + i, n + j, j],

src/objects/surface.ts:275

• The claim that all materials are module singletons does not hold for VertexNormalsHelper: each helper constructs its own material. Re-init disposes the helper geometry but abandons that material, so every live edit still leaks one material per surface. Dispose the old helper's material (or invoke a helper disposal method that releases both geometry and material) while retaining the shared mesh/wire materials.

      // Release the GPU buffers behind the objects just detached. Removing them
      // from the group does not free anything, so every re-init — a restore, or
      // a live geometry edit — otherwise leaks a set of buffers per surface.
      // A Set dedupes mesh and wire, which deliberately share one geometry.
      // Materials are module-level singletons and must not be disposed here.
      // Anything handed back in as the new geometry is left alone.
      const stale = new Set<THREE.BufferGeometry>();
      for (const object of [this.mesh, this.wire, this.edges, this.vertexNormals]) {
        const geometry = object?.geometry as THREE.BufferGeometry | undefined;
        // Helpers such as VertexNormalsHelper are supplied by three/examples,
        // so do not assume every attached geometry is disposable.
        if (geometry && geometry !== props.geometry && typeof geometry.dispose === 'function') {
          stale.add(geometry);
        }
      }
      stale.forEach((geometry) => geometry.dispose());

src/objects/room-from-mesh.ts:129

• Surface.init rebuilds every omitted option from defaults, so a geometry edit silently resets the surface's scattering coefficient to 0.1. This coefficient is solver input and can be configured per surface, so changing only the room height changes the acoustic model. Pass the current coefficient back into init along with the material.

    surface.init({
      geometry: geometryForFace(mesh, face),
      acousticMaterial: surface.acousticMaterial,
    });