fix(pro): review-pass corrections on the constraint/connector fixes

Findings from the adversarial review of the fix series itself:

- ProAdvancedTab.buildInput now passes connectors — the 8th hand-built
  ModelData literal; without it every PRO advanced analysis (modal,
  buckling, P-Delta, time-history...) silently dropped connector
  stiffness while the fixed linear solve included it.
- migrateConstraint: an unmappable legacy linearMPC term DOF now drops
  the whole constraint instead of silently rewriting it onto ux
  (rewriting changes the equation's meaning; consistent with how
  rigidLink/equalDOF filter and unknown kinds drop).
- removeNode cascade is now bulkMutate-safe: the commit phase of
  bulkMutate overwrites model.constraints/model.loads with its
  pre-callback buffers, which would resurrect the pruned entries —
  the cascade prunes the buffers too (latent today: no current caller
  deletes nodes inside bulkMutate).
- Node tool: the cursor node scan is computed once and shared by the
  auto-split guard and the duplicate-coincident guard (two identical
  scans that could silently diverge if one threshold is tuned).
- Hinge-mode split gets the zero-length-element guard the extracted
  attemptSplit already had (tParam = NaN otherwise).
- linearMPC input: ';' is now the documented term separator (',' still
  accepted), and a malformed fragment ABORTS the add instead of being
  dropped — with comma separators, a decimal comma in a coefficient
  ('-0,5') split as a term boundary and committed a silently-zeroed
  equation (pre-existing; the comma-tolerant parseNum cannot fix it at
  this call site because the separator is also a comma).

Author: diegokingston

web/src/components/Viewport.svelte

@@ -1176,7 +1176,8 @@
           if (nearElem) {
             const ni = modelStore.getNode(nearElem.nodeI);
             const nj = modelStore.getNode(nearElem.nodeJ);
-            if (ni && nj) {
+            if (ni && nj && ((nj.x - ni.x) ** 2 + (nj.y - ni.y) ** 2) > 1e-10) {
+              // (zero-length guard: a degenerate element would make t NaN)
               const edx = nj.x - ni.x;
               const edy = nj.y - ni.y;
               const lenSq = edx * edx + edy * edy;
@@ -1228,13 +1229,17 @@
           resultsStore.clear();
           return true;
         };
+        // One shared scan: both the auto-split guard and the
+        // duplicate-coincident-node guard below answer the same question
+        // ('is the cursor on an existing node?') with the same threshold —
+        // two separate calls would silently diverge if one threshold is tuned.
+        const nodeAtCursor = findNearestNode(world.x, world.y, 0.5);
         if (uiStore.autoSplitOnNodePlace) {
           // Only auto-split when the cursor isn't already targeting an
           // existing node. snapWithMidpoint returns node coords if a node is
           // within nodeThreshold of the raw cursor; we re-check explicitly
           // to keep the guard tight (also handles the same threshold).
-          const nearNode = findNearestNode(world.x, world.y, 0.5);
-          if (!nearNode) {
+          if (!nodeAtCursor) {
             // 1st attempt — cursor-based: use the RAW cursor to find which
             // element the user is pointing at (grid-snap can warp the cursor
             // off the element line), but project the GRID-SNAPPED cursor so
@@ -1266,7 +1271,7 @@
           // placement point `ms`: with grid snap on, `ms` can land exactly
           // on an existing grid-aligned node that is >0.5m from the cursor —
           // creating an exact coincident duplicate.
-          const onExisting = findNearestNode(world.x, world.y, 0.5)
+          const onExisting = nodeAtCursor
             ?? findNearestNode(ms.x, ms.y, 0.01);
           if (onExisting) {
             if (!uiStore.selectedNodes.has(onExisting.id)) {

web/src/components/pro/ProAdvancedTab.svelte

@@ -74,7 +74,8 @@
     const input = buildSolverInput3D(
       { nodes: modelStore.nodes, elements: modelStore.elements, supports: modelStore.supports,
         loads: modelStore.loads, materials: modelStore.materials, sections: modelStore.sections,
-        quads: modelStore.quads, plates: modelStore.plates, constraints: modelStore.constraints },
+        quads: modelStore.quads, plates: modelStore.plates, constraints: modelStore.constraints,
+        connectors: modelStore.connectors },
       uiStore.includeSelfWeight,
     );
     if (!input) throw new Error(t('advanced.emptyModel'));

web/src/components/pro/ProConstraintsTab.svelte

@@ -136,20 +136,29 @@
   }
 
   function addLinearMpc() {
-    // Parse terms: "nodeId:dof:coefficient, ..." e.g. "1:ux:1.0, 2:ux:-1.0".
+    // Parse terms: "nodeId:dof:coefficient; ..." e.g. "1:ux:1.0; 2:ux:-1.0".
     // Convert to the shape Rust expects: type discriminator `linearMPC`,
     // each term { nodeId, dof: usize-index, coefficient: f64 }. The constraint
     // sums to 0 by definition — no `rhs` field exists in LinearMPCConstraint.
-    const parsed = mpcTerms.split(',').map(s => {
+    //
+    // Separator: ';' when present, ',' otherwise (legacy). With comma
+    // separators a decimal comma in a coefficient ('-0,5') would be split as
+    // a term boundary and the coefficient silently read as '-0' — so when
+    // commas separate terms, a malformed fragment must ABORT the add (not be
+    // dropped) to avoid committing a corrupted equation.
+    const separator = mpcTerms.includes(';') ? ';' : ',';
+    const fragments = mpcTerms.split(separator).filter(s => s.trim().length > 0);
+    const parsed: Array<{ nodeId: number; dof: number; coefficient: number }> = [];
+    for (const s of fragments) {
       const parts = s.trim().split(':');
-      if (parts.length !== 3) return null;
+      if (parts.length !== 3) return; // malformed fragment → reject the whole input
       const nodeId = parseInt(parts[0]);
       const dofName = parts[1].trim();
       const coefficient = parseNum(parts[2]);
       const dofIdx = dofLabels.indexOf(dofName as typeof dofLabels[number]);
-      if (isNaN(nodeId) || isNaN(coefficient) || dofIdx < 0) return null;
-      return { nodeId, dof: dofIdx, coefficient };
-    }).filter(Boolean) as Array<{ nodeId: number; dof: number; coefficient: number }>;
+      if (isNaN(nodeId) || isNaN(coefficient) || dofIdx < 0) return;
+      parsed.push({ nodeId, dof: dofIdx, coefficient });
+    }
     if (parsed.length === 0) return;
     modelStore.addConstraint({
       type: 'linearMPC',
@@ -403,7 +412,7 @@
 
     {:else if selectedKind === 'linearMPC'}
       <div class="pro-cst-row">
-        <label class="pro-label-wide">{t('pro.terms')}: <input type="text" bind:value={mpcTerms} placeholder="nodo:dof:coeff, ..." class="pro-input-wide" /></label>
+        <label class="pro-label-wide">{t('pro.terms')}: <input type="text" bind:value={mpcTerms} placeholder="nodo:dof:coef; ... (ej: 1:ux:1; 2:ux:-1)" class="pro-input-wide" /></label>
       </div>
       <div class="pro-cst-hint">{t('pro.formatHint')}</div>
     {/if}

web/src/lib/store/model.svelte.ts

@@ -511,14 +511,18 @@ function createModelStore() {
         return { ...raw, type, dofs: mapDofs(raw.dofs) };
       case 'equalDOF':
         return { ...raw, type, dofs: mapDofs(raw.dofs) ?? [] };
-      case 'linearMPC':
-        return {
-          ...raw, type,
-          terms: (raw.terms ?? []).map((t: any) => ({
-            ...t,
-            dof: typeof t.dof === 'string' ? (LEGACY_DOF_NAME_TO_INDEX[t.dof] ?? 0) : t.dof,
-          })),
-        };
+      case 'linearMPC': {
+        const terms = (raw.terms ?? []).map((t: any) => ({
+          ...t,
+          dof: typeof t.dof === 'string' ? LEGACY_DOF_NAME_TO_INDEX[t.dof] : t.dof,
+        }));
+        // An unmappable term DOF must drop the whole constraint — silently
+        // rewriting it (e.g. to ux) would change the equation's meaning.
+        if (terms.length === 0 || terms.some((t: any) => !Number.isInteger(t.dof) || t.dof < 0 || t.dof > 5)) {
+          return null;
+        }
+        return { ...raw, type, terms };
+      }
       case 'diaphragm':
       case 'eccentricConnection':
         return { ...raw, type };
@@ -1069,9 +1073,10 @@ function createModelStore() {
         }
       }
       model.supports = new Map(model.supports);
-      model.loads = model.loads.filter(l =>
-        !((l.type === 'nodal' || l.type === 'nodal3d') && l.data.nodeId === id)
-      );
+      const keepLoad = (l: Load) =>
+        !((l.type === 'nodal' || l.type === 'nodal3d') && l.data.nodeId === id);
+      model.loads = model.loads.filter(keepLoad);
+      if (_bulkLoadBuffer) _bulkLoadBuffer = _bulkLoadBuffer.filter(keepLoad);
       // Cascade to connectors/constraints: a dangling node reference is worse
       // than a missing entity — the engine silently skips it (zero stiffness)
       // while the connectivity preflight keeps crediting it as an edge.
@@ -1083,7 +1088,7 @@ function createModelStore() {
         }
       }
       if (connectorsChanged) model.connectors = new Map(model.connectors);
-      model.constraints = model.constraints
+      const pruneConstraints = (arr: Constraint3D[]) => arr
         .map((c): Constraint3D | null => {
           if (c.type === 'diaphragm') {
             if (c.masterNode === id) return null;
@@ -1099,6 +1104,10 @@ function createModelStore() {
           return (c.masterNode === id || c.slaveNode === id) ? null : c;
         })
         .filter((c): c is Constraint3D => c !== null);
+      model.constraints = pruneConstraints(model.constraints);
+      // Inside bulkMutate the commit phase overwrites model.constraints with
+      // the buffer — prune the buffer too or dangling constraints resurrect.
+      if (_bulkConstraintBuffer) _bulkConstraintBuffer = pruneConstraints(_bulkConstraintBuffer);
     },
 
     removeElement(id: number): void {