@ferscloud/fers-calculation-web 0.2.49 → 0.2.50

package/fers-models.d.ts

@@ -130,17 +130,22 @@ export interface components {
              * @description Controls the geometric stiffness matrix formulation for P-Delta analysis.
              *     `Consistent` (default) uses full Przemieniecki K_g; `Simplified` uses
              *     P/L-only diagonal terms matching commercial solvers.
+             *     Only affects second-order (nonlinear) analysis: linear buckling always
+             *     uses the consistent K_g.
              */
             pdelta_formulation?: components["schemas"]["PdeltaFormulation"];
             /**
              * @description High-level P-Delta strategy.  `Full` (default) amplifies all directions.
-             *     `InPlaneOnly` auto-detects the out-of-plane axis from the model's
-             *     bounding box and suppresses it, matching commercial solver behavior.
+             *     `InPlaneOnly` auto-detects the out-of-plane axis by counting unique node
+             *     coordinate layers per axis and suppresses the thin one, matching
+             *     commercial solver behavior.
              *     Overrides `pdelta_suppress_axes` when set to `InPlaneOnly`.
+             *     Only affects second-order (nonlinear) analysis.
              */
             pdelta_mode?: components["schemas"]["PdeltaMode"];
             /**
              * @description Global translational axes to exclude from P-Delta amplification.
+             *     Only affects second-order (nonlinear) analysis.
              *
              *     When a structure is near buckling in an out-of-plane direction,
              *     the consistent P-Delta amplification can produce forces that differ
@@ -152,6 +157,10 @@ export interface components {
              *     all translational directions are amplified.
              *
              *     Maps to global DOFs: "X"→0,7  "Y"→1,8  "Z"→2,9  per element.
+             *
+             *     This is a P-Delta convergence aid, not a physical property: it is
+             *     deliberately ignored by linear buckling, where suppressing an axis would
+             *     erase that axis's modes and inflate α_cr.
              */
             pdelta_suppress_axes?: string[];
             /**
@@ -291,6 +300,12 @@ export interface components {
          */
         BucklingResults: {
             modes: components["schemas"]["BucklingMode"][];
+            /**
+             * @description Advisories that qualify these results — e.g. model content the
+             *     geometric stiffness does not cover. Empty when α_cr is unqualified.
+             * @default []
+             */
+            warnings: components["schemas"]["SolverMessage"][];
         };
         /**
          * @description One line of the transparent hand-calc: a symbolic formula, the same formula
@@ -1994,6 +2009,15 @@ export interface components {
         /** @description All analysis results: per load case, per load combination, unity-check results and the optional HTML report. */
         ResultsBundle: {
             buckling?: null | components["schemas"]["BucklingResults"];
+            /**
+             * @description Version of the `fers_calculations` engine that produced these results.
+             *
+             *     The input's `schema_version` says which contract the *caller* wrote to;
+             *     this says which engine answered. Stored results therefore record the
+             *     solver that produced them, and a caller can tell a fixed engine from a
+             *     broken one without inspecting the wheel.
+             */
+            engine_version?: string;
             loadcases: {
                 [key: string]: components["schemas"]["Results"];
             };

package/fers_calculations.d.ts

@@ -28,6 +28,13 @@ export function load_fers_from_file(path: string): string;
  */
 export function render_reports_from_json(json_data: string): string;
 
+/**
+ * The engine version, queryable without solving anything. The npm package
+ * version is set from the same `Cargo.toml` at build time, but a caller
+ * holding only the module needs a way to ask the engine which features it has.
+ */
+export function version(): string;
+
 /**
  * Route panic messages to the browser console. wasm32-unknown-unknown does
  * not unwind, so `run_enveloped`'s catch_unwind never fires in the browser —

package/fers_calculations.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./fers_calculations_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    calculate_from_json, calculate_from_json_with_token, load_fers_from_file, render_reports_from_json, wasm_init
+    calculate_from_json, calculate_from_json_with_token, load_fers_from_file, render_reports_from_json, version, wasm_init
 } from "./fers_calculations_bg.js";

package/fers_calculations_bg.js

@@ -88,6 +88,25 @@ export function render_reports_from_json(json_data) {
     }
 }
 
+/**
+ * The engine version, queryable without solving anything. The npm package
+ * version is set from the same `Cargo.toml` at build time, but a caller
+ * holding only the module needs a way to ask the engine which features it has.
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Route panic messages to the browser console. wasm32-unknown-unknown does
  * not unwind, so `run_enveloped`'s catch_unwind never fires in the browser —

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ferscloud/fers-calculation-web",
   "type": "module",
-  "version": "0.2.49",
+  "version": "0.2.50",
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",