@holoscript/plugin-civil-engineering 2.0.1 → 2.0.2

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@holoscript/plugin-civil-engineering",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "main": "src/index.ts",
   "peerDependencies": {
-    "@holoscript/core": "8.0.6"
+    "@holoscript/core": ">=8.0.0"
   },
   "license": "MIT",
   "scripts": {
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests"
   }
-}
+}

package/src/__tests__/frame2d.test.ts

@@ -18,9 +18,9 @@ import {
 } from '../frame2d';
 
 // ─── Steel W-section defaults used across tests ────────────────────────────────
-const E_GPa = 200;   // GPa (structural steel)
-const I_m4  = 1e-4;  // m⁴  (moderate W-section)
-const A_m2  = 5e-3;  // m²  (moderate W-section area)
+const E_GPa = 200; // GPa (structural steel)
+const I_m4 = 1e-4; // m⁴  (moderate W-section)
+const A_m2 = 5e-3; // m²  (moderate W-section area)
 
 // ─── Simply-supported beam ─────────────────────────────────────────────────────
 
@@ -47,15 +47,29 @@ describe('simply-supported beam under point load', () => {
       { id: 'B', x: 6, y: 0 },
     ],
     elements: [
-      { id: 'e1', fromNodeId: 'A', toNodeId: 'M', elasticModulusGPa: E_GPa, momentOfInertiaM4: I_m4, areaM2: A_m2 },
-      { id: 'e2', fromNodeId: 'M', toNodeId: 'B', elasticModulusGPa: E_GPa, momentOfInertiaM4: I_m4, areaM2: A_m2 },
+      {
+        id: 'e1',
+        fromNodeId: 'A',
+        toNodeId: 'M',
+        elasticModulusGPa: E_GPa,
+        momentOfInertiaM4: I_m4,
+        areaM2: A_m2,
+      },
+      {
+        id: 'e2',
+        fromNodeId: 'M',
+        toNodeId: 'B',
+        elasticModulusGPa: E_GPa,
+        momentOfInertiaM4: I_m4,
+        areaM2: A_m2,
+      },
     ],
     supports: [
-      { nodeId: 'A', ux: true, uy: true },  // pin
-      { nodeId: 'B', uy: true },              // roller
+      { nodeId: 'A', ux: true, uy: true }, // pin
+      { nodeId: 'B', uy: true }, // roller
     ],
     nodalLoads: [
-      { nodeId: 'M', Fy: -P },               // downward
+      { nodeId: 'M', Fy: -P }, // downward
     ],
   };
 
@@ -107,14 +121,19 @@ describe('cantilever beam under tip load', () => {
       { id: 'B', x: L, y: 0 },
     ],
     elements: [
-      { id: 'e1', fromNodeId: 'A', toNodeId: 'B', elasticModulusGPa: E_GPa, momentOfInertiaM4: I_m4, areaM2: A_m2 },
+      {
+        id: 'e1',
+        fromNodeId: 'A',
+        toNodeId: 'B',
+        elasticModulusGPa: E_GPa,
+        momentOfInertiaM4: I_m4,
+        areaM2: A_m2,
+      },
     ],
     supports: [
       { nodeId: 'A', ux: true, uy: true, theta: true }, // fixed
     ],
-    nodalLoads: [
-      { nodeId: 'B', Fy: -P },
-    ],
+    nodalLoads: [{ nodeId: 'B', Fy: -P }],
   };
 
   it('tip deflection matches closed-form PL³/(3EI) within 1%', () => {
@@ -158,14 +177,17 @@ describe('inclined element — coordinate transformation', () => {
       { id: 'B', x: 3, y: 4 },
     ],
     elements: [
-      { id: 'e1', fromNodeId: 'A', toNodeId: 'B', elasticModulusGPa: E_GPa, momentOfInertiaM4: I_m4, areaM2: A_m2 },
-    ],
-    supports: [
-      { nodeId: 'A', ux: true, uy: true, theta: true },
-    ],
-    nodalLoads: [
-      { nodeId: 'B', Fx: 100 },
+      {
+        id: 'e1',
+        fromNodeId: 'A',
+        toNodeId: 'B',
+        elasticModulusGPa: E_GPa,
+        momentOfInertiaM4: I_m4,
+        areaM2: A_m2,
+      },
     ],
+    supports: [{ nodeId: 'A', ux: true, uy: true, theta: true }],
+    nodalLoads: [{ nodeId: 'B', Fx: 100 }],
   };
 
   it('converges for inclined element', () => {
@@ -203,8 +225,22 @@ describe('simply-supported beam under UDL', () => {
       { id: 'B', x: 6, y: 0 },
     ],
     elements: [
-      { id: 'e1', fromNodeId: 'A', toNodeId: 'M', elasticModulusGPa: E_GPa, momentOfInertiaM4: I_m4, areaM2: A_m2 },
-      { id: 'e2', fromNodeId: 'M', toNodeId: 'B', elasticModulusGPa: E_GPa, momentOfInertiaM4: I_m4, areaM2: A_m2 },
+      {
+        id: 'e1',
+        fromNodeId: 'A',
+        toNodeId: 'M',
+        elasticModulusGPa: E_GPa,
+        momentOfInertiaM4: I_m4,
+        areaM2: A_m2,
+      },
+      {
+        id: 'e2',
+        fromNodeId: 'M',
+        toNodeId: 'B',
+        elasticModulusGPa: E_GPa,
+        momentOfInertiaM4: I_m4,
+        areaM2: A_m2,
+      },
     ],
     supports: [
       { nodeId: 'A', ux: true, uy: true },
@@ -240,8 +276,20 @@ describe('validateFrame2DModel', () => {
   it('returns valid for a well-formed model', () => {
     const model: Frame2DModel = {
       id: 'valid',
-      nodes: [{ id: 'A', x: 0, y: 0 }, { id: 'B', x: 5, y: 0 }],
-      elements: [{ id: 'e1', fromNodeId: 'A', toNodeId: 'B', elasticModulusGPa: 200, momentOfInertiaM4: 1e-4, areaM2: 5e-3 }],
+      nodes: [
+        { id: 'A', x: 0, y: 0 },
+        { id: 'B', x: 5, y: 0 },
+      ],
+      elements: [
+        {
+          id: 'e1',
+          fromNodeId: 'A',
+          toNodeId: 'B',
+          elasticModulusGPa: 200,
+          momentOfInertiaM4: 1e-4,
+          areaM2: 5e-3,
+        },
+      ],
       supports: [{ nodeId: 'A', ux: true, uy: true, theta: true }],
     };
     const v = validateFrame2DModel(model);
@@ -253,7 +301,16 @@ describe('validateFrame2DModel', () => {
     const model: Frame2DModel = {
       id: 'bad-elem',
       nodes: [{ id: 'A', x: 0, y: 0 }],
-      elements: [{ id: 'e1', fromNodeId: 'A', toNodeId: 'MISSING', elasticModulusGPa: 200, momentOfInertiaM4: 1e-4, areaM2: 5e-3 }],
+      elements: [
+        {
+          id: 'e1',
+          fromNodeId: 'A',
+          toNodeId: 'MISSING',
+          elasticModulusGPa: 200,
+          momentOfInertiaM4: 1e-4,
+          areaM2: 5e-3,
+        },
+      ],
       supports: [{ nodeId: 'A', ux: true, uy: true, theta: true }],
     };
     const v = validateFrame2DModel(model);
@@ -264,8 +321,20 @@ describe('validateFrame2DModel', () => {
   it('errors when fewer than 3 DOF are restrained', () => {
     const model: Frame2DModel = {
       id: 'unstable',
-      nodes: [{ id: 'A', x: 0, y: 0 }, { id: 'B', x: 5, y: 0 }],
-      elements: [{ id: 'e1', fromNodeId: 'A', toNodeId: 'B', elasticModulusGPa: 200, momentOfInertiaM4: 1e-4, areaM2: 5e-3 }],
+      nodes: [
+        { id: 'A', x: 0, y: 0 },
+        { id: 'B', x: 5, y: 0 },
+      ],
+      elements: [
+        {
+          id: 'e1',
+          fromNodeId: 'A',
+          toNodeId: 'B',
+          elasticModulusGPa: 200,
+          momentOfInertiaM4: 1e-4,
+          areaM2: 5e-3,
+        },
+      ],
       supports: [{ nodeId: 'A', ux: true }], // only 1 DOF
     };
     const v = validateFrame2DModel(model);
@@ -276,8 +345,20 @@ describe('validateFrame2DModel', () => {
   it('solver throws for invalid model', () => {
     const model: Frame2DModel = {
       id: 'invalid',
-      nodes: [{ id: 'A', x: 0, y: 0 }, { id: 'B', x: 5, y: 0 }],
-      elements: [{ id: 'e1', fromNodeId: 'A', toNodeId: 'B', elasticModulusGPa: 200, momentOfInertiaM4: 1e-4, areaM2: 5e-3 }],
+      nodes: [
+        { id: 'A', x: 0, y: 0 },
+        { id: 'B', x: 5, y: 0 },
+      ],
+      elements: [
+        {
+          id: 'e1',
+          fromNodeId: 'A',
+          toNodeId: 'B',
+          elasticModulusGPa: 200,
+          momentOfInertiaM4: 1e-4,
+          areaM2: 5e-3,
+        },
+      ],
       supports: [], // no supports
     };
     expect(() => solveFrame2D(model)).toThrow();
@@ -295,14 +376,17 @@ describe('buildFrame2DReceipt', () => {
     ],
     elements: [
       {
-        id: 'e1', fromNodeId: 'A', toNodeId: 'B',
-        elasticModulusGPa: E_GPa, momentOfInertiaM4: I_m4, areaM2: A_m2,
-        plasticModulusM3: 5e-4, yieldStrengthMPa: 250,
+        id: 'e1',
+        fromNodeId: 'A',
+        toNodeId: 'B',
+        elasticModulusGPa: E_GPa,
+        momentOfInertiaM4: I_m4,
+        areaM2: A_m2,
+        plasticModulusM3: 5e-4,
+        yieldStrengthMPa: 250,
       },
     ],
-    supports: [
-      { nodeId: 'A', ux: true, uy: true, theta: true },
-    ],
+    supports: [{ nodeId: 'A', ux: true, uy: true, theta: true }],
     nodalLoads: [{ nodeId: 'B', Fy: -10 }],
   };
 

package/src/__tests__/runtime-integration.test.ts

@@ -59,7 +59,14 @@ const CANTILEVER: Frame2DModel = {
     { id: 'B', x: L, y: 0 },
   ],
   elements: [
-    { id: 'e1', fromNodeId: 'A', toNodeId: 'B', elasticModulusGPa: E_GPa, momentOfInertiaM4: I_m4, areaM2: A_m2 },
+    {
+      id: 'e1',
+      fromNodeId: 'A',
+      toNodeId: 'B',
+      elasticModulusGPa: E_GPa,
+      momentOfInertiaM4: I_m4,
+      areaM2: A_m2,
+    },
   ],
   supports: [
     { nodeId: 'A', ux: true, uy: true, theta: true }, // fixed
@@ -77,7 +84,14 @@ const UNDER_CONSTRAINED: Frame2DModel = {
     { id: 'B', x: L, y: 0 },
   ],
   elements: [
-    { id: 'e1', fromNodeId: 'A', toNodeId: 'B', elasticModulusGPa: E_GPa, momentOfInertiaM4: I_m4, areaM2: A_m2 },
+    {
+      id: 'e1',
+      fromNodeId: 'A',
+      toNodeId: 'B',
+      elasticModulusGPa: E_GPa,
+      momentOfInertiaM4: I_m4,
+      areaM2: A_m2,
+    },
   ],
   supports: [{ nodeId: 'A', ux: true }], // only 1 DOF restrained
   nodalLoads: [{ nodeId: 'B', Fy: -P }],
@@ -119,7 +133,12 @@ describe('civil-engineering -> HoloScript runtime integration (dsm_frame_2d)', (
 
     // Hand-checked against global static equilibrium of the cantilever:
     //   Ry_A = +P = +50 kN ; |Mz_A| = P·L = 200 kN·m ; Rx_A = 0.
-    const reactions = summary.reactions as Array<{ nodeId: string; Rx: number; Ry: number; Mz: number }>;
+    const reactions = summary.reactions as Array<{
+      nodeId: string;
+      Rx: number;
+      Ry: number;
+      Mz: number;
+    }>;
     const rA = reactions.find((r) => r.nodeId === 'A')!;
     expect(rA.Rx).toBeCloseTo(0, 1);
     expect(rA.Ry).toBeCloseTo(EXPECTED_RY, 1); // +50 kN
@@ -165,7 +184,11 @@ describe('civil-engineering -> HoloScript runtime integration (dsm_frame_2d)', (
 
     const state = runtime.getState() as Record<string, unknown>;
     const persisted = state['dsm_frame_2d:frame'] as
-      | { converged?: boolean; nodeCount?: number; reactions?: Array<{ nodeId: string; Ry: number }> }
+      | {
+          converged?: boolean;
+          nodeCount?: number;
+          reactions?: Array<{ nodeId: string; Ry: number }>;
+        }
       | undefined;
     expect(persisted).toBeDefined();
     expect(persisted?.converged).toBe(true);

package/src/frame2d.ts

@@ -241,10 +241,12 @@ export function validateFrame2DModel(model: Frame2DModel): Frame2DValidation {
   // Minimum stability check: need enough supports to prevent rigid body motion
   const totalRestrainedDOF = model.supports.reduce(
     (sum, s) => sum + (s.ux ? 1 : 0) + (s.uy ? 1 : 0) + (s.theta ? 1 : 0),
-    0,
+    0
   );
   if (totalRestrainedDOF < 3) {
-    errors.push('insufficient supports: need at least 3 restrained DOF to prevent rigid body motion');
+    errors.push(
+      'insufficient supports: need at least 3 restrained DOF to prevent rigid body motion'
+    );
   }
 
   return { valid: errors.length === 0, errors, warnings };
@@ -264,9 +266,7 @@ function matMul(A: Matrix, B: Matrix): Matrix {
   const k = B.length;
   const C = zeros(m, n);
   for (let i = 0; i < m; i++)
-    for (let j = 0; j < n; j++)
-      for (let l = 0; l < k; l++)
-        C[i][j] += A[i][l] * B[l][j];
+    for (let j = 0; j < n; j++) for (let l = 0; l < k; l++) C[i][j] += A[i][l] * B[l][j];
   return C;
 }
 
@@ -274,9 +274,7 @@ function transpose(A: Matrix): Matrix {
   const m = A.length;
   const n = A[0].length;
   const T = zeros(n, m);
-  for (let i = 0; i < m; i++)
-    for (let j = 0; j < n; j++)
-      T[j][i] = A[i][j];
+  for (let i = 0; i < m; i++) for (let j = 0; j < n; j++) T[j][i] = A[i][j];
   return T;
 }
 
@@ -292,9 +290,13 @@ function gaussSolve(A: Matrix, b: number[]): number[] {
     let bestAbs = Math.abs(a[pivot][pivot]);
     for (let row = pivot + 1; row < n; row++) {
       const v = Math.abs(a[row][pivot]);
-      if (v > bestAbs) { bestAbs = v; bestRow = row; }
+      if (v > bestAbs) {
+        bestAbs = v;
+        bestRow = row;
+      }
     }
-    if (bestAbs < 1e-14) throw new Error('[frame2d] singular stiffness matrix — check boundary conditions');
+    if (bestAbs < 1e-14)
+      throw new Error('[frame2d] singular stiffness matrix — check boundary conditions');
     if (bestRow !== pivot) {
       [a[pivot], a[bestRow]] = [a[bestRow], a[pivot]];
       [rhs[pivot], rhs[bestRow]] = [rhs[bestRow], rhs[pivot]];
@@ -333,12 +335,12 @@ function localStiffness(E: number, I: number, A: number, L: number): Matrix {
   const L3 = L * L * L;
 
   return [
-    [ EA/L,         0,          0,    -EA/L,         0,          0    ],
-    [    0,  12*EI/L3,   6*EI/L2,        0, -12*EI/L3,   6*EI/L2   ],
-    [    0,   6*EI/L2,    4*EI/L,        0,  -6*EI/L2,    2*EI/L   ],
-    [-EA/L,         0,          0,     EA/L,         0,          0    ],
-    [    0, -12*EI/L3,  -6*EI/L2,        0,  12*EI/L3,  -6*EI/L2   ],
-    [    0,   6*EI/L2,    2*EI/L,        0,  -6*EI/L2,    4*EI/L   ],
+    [EA / L, 0, 0, -EA / L, 0, 0],
+    [0, (12 * EI) / L3, (6 * EI) / L2, 0, (-12 * EI) / L3, (6 * EI) / L2],
+    [0, (6 * EI) / L2, (4 * EI) / L, 0, (-6 * EI) / L2, (2 * EI) / L],
+    [-EA / L, 0, 0, EA / L, 0, 0],
+    [0, (-12 * EI) / L3, (-6 * EI) / L2, 0, (12 * EI) / L3, (-6 * EI) / L2],
+    [0, (6 * EI) / L2, (2 * EI) / L, 0, (-6 * EI) / L2, (4 * EI) / L],
   ];
 }
 
@@ -349,12 +351,12 @@ function localStiffness(E: number, I: number, A: number, L: number): Matrix {
  */
 function transformMatrix(c: number, s: number): Matrix {
   return [
-    [ c,  s,  0,  0,  0,  0 ],
-    [-s,  c,  0,  0,  0,  0 ],
-    [ 0,  0,  1,  0,  0,  0 ],
-    [ 0,  0,  0,  c,  s,  0 ],
-    [ 0,  0,  0, -s,  c,  0 ],
-    [ 0,  0,  0,  0,  0,  1 ],
+    [c, s, 0, 0, 0, 0],
+    [-s, c, 0, 0, 0, 0],
+    [0, 0, 1, 0, 0, 0],
+    [0, 0, 0, c, s, 0],
+    [0, 0, 0, -s, c, 0],
+    [0, 0, 0, 0, 0, 1],
   ];
 }
 
@@ -389,7 +391,7 @@ function equivalentNodalForces(
   dl: DistributedLoad,
   elem: BeamElement,
   fromNode: Node2D,
-  toNode: Node2D,
+  toNode: Node2D
 ): number[] /* 6-element global force vector */ {
   const dx = toNode.x - fromNode.x;
   const dy = toNode.y - fromNode.y;
@@ -429,14 +431,12 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
   const K = zeros(nDOF, nDOF);
   for (const elem of model.elements) {
     const fromNode = nodeById.get(elem.fromNodeId)!;
-    const toNode   = nodeById.get(elem.toNodeId)!;
+    const toNode = nodeById.get(elem.toNodeId)!;
     const Ke = globalElementStiffness(elem, fromNode, toNode);
     const i0 = nodeIndex.get(elem.fromNodeId)! * 3;
     const i1 = nodeIndex.get(elem.toNodeId)! * 3;
-    const dofs = [i0, i0+1, i0+2, i1, i1+1, i1+2];
-    for (let r = 0; r < 6; r++)
-      for (let c_ = 0; c_ < 6; c_++)
-        K[dofs[r]][dofs[c_]] += Ke[r][c_];
+    const dofs = [i0, i0 + 1, i0 + 2, i1, i1 + 1, i1 + 2];
+    for (let r = 0; r < 6; r++) for (let c_ = 0; c_ < 6; c_++) K[dofs[r]][dofs[c_]] += Ke[r][c_];
   }
 
   // Assemble global force vector
@@ -444,7 +444,7 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
 
   for (const load of model.nodalLoads ?? []) {
     const idx = nodeIndex.get(load.nodeId)! * 3;
-    F[idx]     += load.Fx ?? 0;
+    F[idx] += load.Fx ?? 0;
     F[idx + 1] += load.Fy ?? 0;
     F[idx + 2] += load.Mz ?? 0;
   }
@@ -452,11 +452,11 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
   for (const dl of model.distributedLoads ?? []) {
     const elem = elemById.get(dl.elementId)!;
     const fromNode = nodeById.get(elem.fromNodeId)!;
-    const toNode   = nodeById.get(elem.toNodeId)!;
+    const toNode = nodeById.get(elem.toNodeId)!;
     const f_global = equivalentNodalForces(dl, elem, fromNode, toNode);
     const i0 = nodeIndex.get(elem.fromNodeId)! * 3;
     const i1 = nodeIndex.get(elem.toNodeId)! * 3;
-    const dofs = [i0, i0+1, i0+2, i1, i1+1, i1+2];
+    const dofs = [i0, i0 + 1, i0 + 2, i1, i1 + 1, i1 + 2];
     for (let r = 0; r < 6; r++) F[dofs[r]] += f_global[r];
   }
 
@@ -466,9 +466,18 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
   const restraints: boolean[] = new Array<boolean>(nDOF).fill(false);
   for (const support of model.supports) {
     const idx = nodeIndex.get(support.nodeId)! * 3;
-    if (support.ux)    { K[idx][idx]         += PENALTY; restraints[idx]     = true; }
-    if (support.uy)    { K[idx+1][idx+1]     += PENALTY; restraints[idx+1]   = true; }
-    if (support.theta) { K[idx+2][idx+2]     += PENALTY; restraints[idx+2]   = true; }
+    if (support.ux) {
+      K[idx][idx] += PENALTY;
+      restraints[idx] = true;
+    }
+    if (support.uy) {
+      K[idx + 1][idx + 1] += PENALTY;
+      restraints[idx + 1] = true;
+    }
+    if (support.theta) {
+      K[idx + 2][idx + 2] += PENALTY;
+      restraints[idx + 2] = true;
+    }
   }
 
   // Solve K * u = F
@@ -479,8 +488,8 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
     const idx = nodeIndex.get(node.id)! * 3;
     return {
       nodeId: node.id,
-      ux:    u[idx],
-      uy:    u[idx + 1],
+      ux: u[idx],
+      uy: u[idx + 1],
       theta: u[idx + 2],
     };
   });
@@ -490,14 +499,13 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
   const K_clean = zeros(nDOF, nDOF);
   for (const elem of model.elements) {
     const fromNode = nodeById.get(elem.fromNodeId)!;
-    const toNode   = nodeById.get(elem.toNodeId)!;
+    const toNode = nodeById.get(elem.toNodeId)!;
     const Ke = globalElementStiffness(elem, fromNode, toNode);
     const i0 = nodeIndex.get(elem.fromNodeId)! * 3;
     const i1 = nodeIndex.get(elem.toNodeId)! * 3;
-    const dofs = [i0, i0+1, i0+2, i1, i1+1, i1+2];
+    const dofs = [i0, i0 + 1, i0 + 2, i1, i1 + 1, i1 + 2];
     for (let r = 0; r < 6; r++)
-      for (let c_ = 0; c_ < 6; c_++)
-        K_clean[dofs[r]][dofs[c_]] += Ke[r][c_];
+      for (let c_ = 0; c_ < 6; c_++) K_clean[dofs[r]][dofs[c_]] += Ke[r][c_];
   }
 
   const reactions: SupportReaction[] = model.supports.map((support) => {
@@ -505,8 +513,8 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
     const Ku_row = (row: number) => K_clean[row].reduce((s, kij, j) => s + kij * u[j], 0);
     return {
       nodeId: support.nodeId,
-      Rx: support.ux    ? Ku_row(idx)     - F[idx]     : 0,
-      Ry: support.uy    ? Ku_row(idx + 1) - F[idx + 1] : 0,
+      Rx: support.ux ? Ku_row(idx) - F[idx] : 0,
+      Ry: support.uy ? Ku_row(idx + 1) - F[idx + 1] : 0,
       Mz: support.theta ? Ku_row(idx + 2) - F[idx + 2] : 0,
     };
   });
@@ -514,7 +522,7 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
   // Recover element internal forces
   const elementForces: ElementForces[] = model.elements.map((elem) => {
     const fromNode = nodeById.get(elem.fromNodeId)!;
-    const toNode   = nodeById.get(elem.toNodeId)!;
+    const toNode = nodeById.get(elem.toNodeId)!;
     const dx = toNode.x - fromNode.x;
     const dy = toNode.y - fromNode.y;
     const L = Math.sqrt(dx * dx + dy * dy);
@@ -526,11 +534,13 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
 
     const i0 = nodeIndex.get(elem.fromNodeId)! * 3;
     const i1 = nodeIndex.get(elem.toNodeId)! * 3;
-    const u_global = [u[i0], u[i0+1], u[i0+2], u[i1], u[i1+1], u[i1+2]];
+    const u_global = [u[i0], u[i0 + 1], u[i0 + 2], u[i1], u[i1 + 1], u[i1 + 2]];
 
     // Transform to local: u_local = T * u_global
     const T = transformMatrix(c, s);
-    const u_local = u_global.map((_, i) => T[i].reduce((sum, tij, j) => sum + tij * u_global[j], 0));
+    const u_local = u_global.map((_, i) =>
+      T[i].reduce((sum, tij, j) => sum + tij * u_global[j], 0)
+    );
 
     const k_local = localStiffness(E, I, A, L);
     // f_local = k_local * u_local  (internal forces in local frame)
@@ -544,7 +554,14 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
     const dl = (model.distributedLoads ?? []).find((d) => d.elementId === elem.id);
     let f_local_adj = [...f_local];
     if (dl) {
-      const f_fef_local = [0, (dl.w * L) / 2, (dl.w * L * L) / 12, 0, (dl.w * L) / 2, -(dl.w * L * L) / 12];
+      const f_fef_local = [
+        0,
+        (dl.w * L) / 2,
+        (dl.w * L * L) / 12,
+        0,
+        (dl.w * L) / 2,
+        -(dl.w * L * L) / 12,
+      ];
       f_local_adj = f_local.map((v, i) => v + f_fef_local[i]);
     }
 
@@ -558,18 +575,18 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
 
     return {
       elementId: elem.id,
-      N_start:  -f_local_adj[0],  // sign: tension positive convention
-      V_start:  -f_local_adj[1],
-      M_start:   f_local_adj[2],
-      N_end:     f_local_adj[3],
-      V_end:     f_local_adj[4],
-      M_end:     f_local_adj[5],
+      N_start: -f_local_adj[0], // sign: tension positive convention
+      V_start: -f_local_adj[1],
+      M_start: f_local_adj[2],
+      N_end: f_local_adj[3],
+      V_end: f_local_adj[4],
+      M_end: f_local_adj[5],
       utilisationRatio,
     };
   });
 
   const maxDisplacementM = Math.max(
-    ...nodeDisplacements.map((d) => Math.sqrt(d.ux ** 2 + d.uy ** 2)),
+    ...nodeDisplacements.map((d) => Math.sqrt(d.ux ** 2 + d.uy ** 2))
   );
   const maxUtilisationRatio = Math.max(0, ...elementForces.map((ef) => ef.utilisationRatio));
 
@@ -590,7 +607,7 @@ export function solveFrame2D(model: Frame2DModel): Frame2DResult {
 export function buildFrame2DReceipt(
   model: Frame2DModel,
   result: Frame2DResult,
-  options: Frame2DReceiptOptions = {},
+  options: Frame2DReceiptOptions = {}
 ): Frame2DReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
 

package/src/index.ts

@@ -1,7 +1,20 @@
 export * from './frame2d';
-export { createStructuralAnalysisHandler, type StructuralAnalysisConfig, type StructureType, type MaterialType } from './traits/StructuralAnalysisTrait';
-export { createLoadBearingHandler, type LoadBearingConfig, type LoadCase, type LoadType } from './traits/LoadBearingTrait';
-export { createMaterialFatigueHandler, type MaterialFatigueConfig } from './traits/MaterialFatigueTrait';
+export {
+  createStructuralAnalysisHandler,
+  type StructuralAnalysisConfig,
+  type StructureType,
+  type MaterialType,
+} from './traits/StructuralAnalysisTrait';
+export {
+  createLoadBearingHandler,
+  type LoadBearingConfig,
+  type LoadCase,
+  type LoadType,
+} from './traits/LoadBearingTrait';
+export {
+  createMaterialFatigueHandler,
+  type MaterialFatigueConfig,
+} from './traits/MaterialFatigueTrait';
 export * from './traits/types';
 
 import { createStructuralAnalysisHandler } from './traits/StructuralAnalysisTrait';
@@ -10,8 +23,16 @@ import { createMaterialFatigueHandler } from './traits/MaterialFatigueTrait';
 
 export * from './frame2d';
 
-export const pluginMeta = { name: '@holoscript/plugin-civil-engineering', version: '1.0.0', traits: ['structural_analysis', 'load_bearing', 'material_fatigue', 'dsm_frame_2d'] };
-export const traitHandlers = [createStructuralAnalysisHandler(), createLoadBearingHandler(), createMaterialFatigueHandler()];
+export const pluginMeta = {
+  name: '@holoscript/plugin-civil-engineering',
+  version: '1.0.0',
+  traits: ['structural_analysis', 'load_bearing', 'material_fatigue', 'dsm_frame_2d'],
+};
+export const traitHandlers = [
+  createStructuralAnalysisHandler(),
+  createLoadBearingHandler(),
+  createMaterialFatigueHandler(),
+];
 
 // Runtime integration — behavioral trait handler + registrar that wire the
 // deterministic Direct-Stiffness-Method 2D frame solver into HoloScriptRuntime's

package/src/runtime.ts

@@ -88,7 +88,7 @@ export interface RuntimeTraitHandler {
     node: unknown,
     config: DsmFrame2dTraitConfig,
     context: TraitDispatchContext,
-    delta: number,
+    delta: number
   ) => void;
 }
 
@@ -120,7 +120,7 @@ function resolveModel(config: DsmFrame2dTraitConfig | undefined): Frame2DModel |
 function solveOntoNode(
   node: unknown,
   config: DsmFrame2dTraitConfig | undefined,
-  context: TraitDispatchContext,
+  context: TraitDispatchContext
 ): void {
   const carrier = node as DsmFrame2dNode;
   const nodeId = carrier.id ?? carrier.name ?? 'unknown';

package/src/traits/LoadBearingTrait.ts

@@ -2,24 +2,57 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type LoadType = 'dead' | 'live' | 'wind' | 'seismic' | 'snow' | 'impact' | 'thermal';
-export interface LoadCase { id: string; type: LoadType; magnitudeKN: number; direction: [number, number, number]; combinationFactor: number; }
-export interface LoadBearingConfig { capacityKN: number; loadCases: LoadCase[]; redundancyFactor: number; }
-export interface LoadBearingState { totalAppliedKN: number; remainingCapacityKN: number; criticalLoadCase: string | null; isOverloaded: boolean; }
+export interface LoadCase {
+  id: string;
+  type: LoadType;
+  magnitudeKN: number;
+  direction: [number, number, number];
+  combinationFactor: number;
+}
+export interface LoadBearingConfig {
+  capacityKN: number;
+  loadCases: LoadCase[];
+  redundancyFactor: number;
+}
+export interface LoadBearingState {
+  totalAppliedKN: number;
+  remainingCapacityKN: number;
+  criticalLoadCase: string | null;
+  isOverloaded: boolean;
+}
 
 const defaultConfig: LoadBearingConfig = { capacityKN: 100, loadCases: [], redundancyFactor: 1.0 };
 
 export function createLoadBearingHandler(): TraitHandler<LoadBearingConfig> {
-  return { name: 'load_bearing', defaultConfig,
+  return {
+    name: 'load_bearing',
+    defaultConfig,
     onAttach(n: HSPlusNode, c: LoadBearingConfig, ctx: TraitContext) {
       const total = c.loadCases.reduce((sum, lc) => sum + lc.magnitudeKN * lc.combinationFactor, 0);
-      n.__loadState = { totalAppliedKN: total, remainingCapacityKN: c.capacityKN - total, criticalLoadCase: null, isOverloaded: total > c.capacityKN };
+      n.__loadState = {
+        totalAppliedKN: total,
+        remainingCapacityKN: c.capacityKN - total,
+        criticalLoadCase: null,
+        isOverloaded: total > c.capacityKN,
+      };
       ctx.emit?.('load:assessed', { total, capacity: c.capacityKN });
     },
-    onDetach(n: HSPlusNode, _c: LoadBearingConfig, ctx: TraitContext) { delete n.__loadState; ctx.emit?.('load:removed'); },
+    onDetach(n: HSPlusNode, _c: LoadBearingConfig, ctx: TraitContext) {
+      delete n.__loadState;
+      ctx.emit?.('load:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: LoadBearingConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__loadState as LoadBearingState | undefined; if (!s) return;
-      if (e.type === 'load:add') { const kn = (e.payload?.magnitudeKN as number) ?? 0; s.totalAppliedKN += kn; s.remainingCapacityKN = c.capacityKN - s.totalAppliedKN; s.isOverloaded = s.totalAppliedKN > c.capacityKN; if (s.isOverloaded) ctx.emit?.('load:overloaded', { applied: s.totalAppliedKN, capacity: c.capacityKN }); }
+      const s = n.__loadState as LoadBearingState | undefined;
+      if (!s) return;
+      if (e.type === 'load:add') {
+        const kn = (e.payload?.magnitudeKN as number) ?? 0;
+        s.totalAppliedKN += kn;
+        s.remainingCapacityKN = c.capacityKN - s.totalAppliedKN;
+        s.isOverloaded = s.totalAppliedKN > c.capacityKN;
+        if (s.isOverloaded)
+          ctx.emit?.('load:overloaded', { applied: s.totalAppliedKN, capacity: c.capacityKN });
+      }
     },
   };
 }

package/src/traits/MaterialFatigueTrait.ts

@@ -1,27 +1,67 @@
 /** @material_fatigue Trait — Fatigue life estimation. @trait material_fatigue */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface MaterialFatigueConfig { sNcurveSlope: number; enduranceLimitMPa: number; designLifeCycles: number; stressRatio: number; surfaceFinishFactor: number; }
-export interface MaterialFatigueState { accumulatedCycles: number; damageFraction: number; remainingLifePercent: number; isFailed: boolean; }
+export interface MaterialFatigueConfig {
+  sNcurveSlope: number;
+  enduranceLimitMPa: number;
+  designLifeCycles: number;
+  stressRatio: number;
+  surfaceFinishFactor: number;
+}
+export interface MaterialFatigueState {
+  accumulatedCycles: number;
+  damageFraction: number;
+  remainingLifePercent: number;
+  isFailed: boolean;
+}
 
-const defaultConfig: MaterialFatigueConfig = { sNcurveSlope: -0.1, enduranceLimitMPa: 200, designLifeCycles: 1e6, stressRatio: -1, surfaceFinishFactor: 0.9 };
+const defaultConfig: MaterialFatigueConfig = {
+  sNcurveSlope: -0.1,
+  enduranceLimitMPa: 200,
+  designLifeCycles: 1e6,
+  stressRatio: -1,
+  surfaceFinishFactor: 0.9,
+};
 
 export function createMaterialFatigueHandler(): TraitHandler<MaterialFatigueConfig> {
-  return { name: 'material_fatigue', defaultConfig,
-    onAttach(n: HSPlusNode, _c: MaterialFatigueConfig, ctx: TraitContext) { n.__fatigueState = { accumulatedCycles: 0, damageFraction: 0, remainingLifePercent: 100, isFailed: false }; ctx.emit?.('fatigue:monitoring_started'); },
-    onDetach(n: HSPlusNode, _c: MaterialFatigueConfig, ctx: TraitContext) { delete n.__fatigueState; ctx.emit?.('fatigue:monitoring_stopped'); },
+  return {
+    name: 'material_fatigue',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: MaterialFatigueConfig, ctx: TraitContext) {
+      n.__fatigueState = {
+        accumulatedCycles: 0,
+        damageFraction: 0,
+        remainingLifePercent: 100,
+        isFailed: false,
+      };
+      ctx.emit?.('fatigue:monitoring_started');
+    },
+    onDetach(n: HSPlusNode, _c: MaterialFatigueConfig, ctx: TraitContext) {
+      delete n.__fatigueState;
+      ctx.emit?.('fatigue:monitoring_stopped');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: MaterialFatigueConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__fatigueState as MaterialFatigueState | undefined; if (!s || s.isFailed) return;
+      const s = n.__fatigueState as MaterialFatigueState | undefined;
+      if (!s || s.isFailed) return;
       if (e.type === 'fatigue:add_cycles') {
         const cycles = (e.payload?.cycles as number) ?? 0;
         const stressMPa = (e.payload?.stressAmplitudeMPa as number) ?? 0;
         s.accumulatedCycles += cycles;
-        const nf = stressMPa > c.enduranceLimitMPa ? Math.pow(stressMPa / c.enduranceLimitMPa, 1 / c.sNcurveSlope) * c.designLifeCycles : Infinity;
+        const nf =
+          stressMPa > c.enduranceLimitMPa
+            ? Math.pow(stressMPa / c.enduranceLimitMPa, 1 / c.sNcurveSlope) * c.designLifeCycles
+            : Infinity;
         s.damageFraction += cycles / nf;
         s.remainingLifePercent = Math.max(0, (1 - s.damageFraction) * 100);
-        if (s.damageFraction >= 1) { s.isFailed = true; ctx.emit?.('fatigue:failure', { cycles: s.accumulatedCycles }); }
-        else ctx.emit?.('fatigue:updated', { damage: s.damageFraction, remaining: s.remainingLifePercent });
+        if (s.damageFraction >= 1) {
+          s.isFailed = true;
+          ctx.emit?.('fatigue:failure', { cycles: s.accumulatedCycles });
+        } else
+          ctx.emit?.('fatigue:updated', {
+            damage: s.damageFraction,
+            remaining: s.remainingLifePercent,
+          });
       }
     },
   };

package/src/traits/StructuralAnalysisTrait.ts

@@ -3,25 +3,62 @@ import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types
 
 export type StructureType = 'beam' | 'column' | 'slab' | 'truss' | 'frame' | 'shell' | 'foundation';
 export type MaterialType = 'steel' | 'concrete' | 'timber' | 'masonry' | 'composite' | 'aluminum';
-export interface StructuralAnalysisConfig { structureType: StructureType; material: MaterialType; yieldStrengthMPa: number; elasticModulusGPa: number; safetyFactor: number; loadCasesCount: number; }
-export interface StructuralAnalysisState { maxStressMPa: number; maxDeflectionMm: number; utilizationRatio: number; isPasssing: boolean; }
+export interface StructuralAnalysisConfig {
+  structureType: StructureType;
+  material: MaterialType;
+  yieldStrengthMPa: number;
+  elasticModulusGPa: number;
+  safetyFactor: number;
+  loadCasesCount: number;
+}
+export interface StructuralAnalysisState {
+  maxStressMPa: number;
+  maxDeflectionMm: number;
+  utilizationRatio: number;
+  isPasssing: boolean;
+}
 
-const defaultConfig: StructuralAnalysisConfig = { structureType: 'beam', material: 'steel', yieldStrengthMPa: 250, elasticModulusGPa: 200, safetyFactor: 1.5, loadCasesCount: 1 };
+const defaultConfig: StructuralAnalysisConfig = {
+  structureType: 'beam',
+  material: 'steel',
+  yieldStrengthMPa: 250,
+  elasticModulusGPa: 200,
+  safetyFactor: 1.5,
+  loadCasesCount: 1,
+};
 
 export function createStructuralAnalysisHandler(): TraitHandler<StructuralAnalysisConfig> {
-  return { name: 'structural_analysis', defaultConfig,
-    onAttach(n: HSPlusNode, _c: StructuralAnalysisConfig, ctx: TraitContext) { n.__structState = { maxStressMPa: 0, maxDeflectionMm: 0, utilizationRatio: 0, isPasssing: true }; ctx.emit?.('structural:ready'); },
-    onDetach(n: HSPlusNode, _c: StructuralAnalysisConfig, ctx: TraitContext) { delete n.__structState; ctx.emit?.('structural:removed'); },
+  return {
+    name: 'structural_analysis',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: StructuralAnalysisConfig, ctx: TraitContext) {
+      n.__structState = {
+        maxStressMPa: 0,
+        maxDeflectionMm: 0,
+        utilizationRatio: 0,
+        isPasssing: true,
+      };
+      ctx.emit?.('structural:ready');
+    },
+    onDetach(n: HSPlusNode, _c: StructuralAnalysisConfig, ctx: TraitContext) {
+      delete n.__structState;
+      ctx.emit?.('structural:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: StructuralAnalysisConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__structState as StructuralAnalysisState | undefined; if (!s) return;
+      const s = n.__structState as StructuralAnalysisState | undefined;
+      if (!s) return;
       if (e.type === 'structural:analyze') {
         const loadKN = (e.payload?.loadKN as number) ?? 0;
         const spanM = (e.payload?.spanM as number) ?? 1;
-        s.maxStressMPa = (loadKN * 1000 * spanM) / (0.001 * c.elasticModulusGPa * 1e9) * 1e6;
+        s.maxStressMPa = ((loadKN * 1000 * spanM) / (0.001 * c.elasticModulusGPa * 1e9)) * 1e6;
         s.utilizationRatio = s.maxStressMPa / (c.yieldStrengthMPa / c.safetyFactor);
         s.isPasssing = s.utilizationRatio <= 1.0;
-        ctx.emit?.('structural:result', { stress: s.maxStressMPa, utilization: s.utilizationRatio, pass: s.isPasssing });
+        ctx.emit?.('structural:result', {
+          stress: s.maxStressMPa,
+          utilization: s.utilizationRatio,
+          pass: s.isPasssing,
+        });
       }
     },
   };

package/src/traits/types.ts

@@ -1,4 +1,22 @@
-export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitContext { emit?: (event: string, payload?: unknown) => void; [key: string]: unknown; }
-export interface TraitEvent { type: string; payload?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitHandler<T = unknown> { name: string; defaultConfig: T; onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void; onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void; onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void; onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void; }
+export interface HSPlusNode {
+  id?: string;
+  properties?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitContext {
+  emit?: (event: string, payload?: unknown) => void;
+  [key: string]: unknown;
+}
+export interface TraitEvent {
+  type: string;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitHandler<T = unknown> {
+  name: string;
+  defaultConfig: T;
+  onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void;
+  onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void;
+}

package/tsconfig.json

@@ -1 +1,5 @@
-{ "extends": "../../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true }, "include": ["src"] }
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true },
+  "include": ["src"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-2026 HoloScript Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.