@ferscloud/fers-calculation-web 0.2.22 → 0.2.26

package/README.md

@@ -1,10 +1,106 @@
 # @ferscloud/fers-calculation
 
-High-performance structural / mechanical engineering calculations compiled from Rust to WebAssembly.
-
-This package is the WebAssembly build of your Rust solver so it can be used from JavaScript and TypeScript (browser apps with a bundler, and in some Node.js setups). It is designed to take structured input (for example JSON) and return results efficiently.
+High-performance structural engineering FEM solver compiled from Rust to WebAssembly. Runs entirely in the browser — no server round-trip per calculation.
 
 ## Installation
 
 ```bash
-npm install @ferscloud/fers-calculation
+npm install @ferscloud/fers-calculation
+```
+
+## Quick start — free tier (up to 100 members)
+
+```ts
+import init, { calculate_from_json } from "@ferscloud/fers-calculation";
+
+await init(); // load the WASM module once
+
+const result = calculate_from_json(JSON.stringify(myModel));
+const data = JSON.parse(result);
+```
+
+No API key required. Works for any model with up to 100 members.
+
+## Authenticated tier — Pro (up to 10 000 members)
+
+Pro limits are unlocked by passing a short-lived signed token issued by the FERS Cloud server. The token is verified inside the WASM using an Ed25519 public key baked into the binary — it cannot be forged.
+
+### How it works
+
+```
+Your server  →  POST https://ferscloud.com/api/solver/token  →  signed 30-min token
+                (X-API-Key: <your-api-key>)
+
+Browser  →  calculate_from_json_with_token(model, token)  →  Pro limits unlocked
+```
+
+### 1. Get an API key
+
+Log in at [ferscloud.com](https://ferscloud.com), go to **Profile → API Keys**, and create a key. Store it as an environment variable on your server — never in browser code.
+
+### 2. Backend: fetch a solve token
+
+Your server fetches and caches the token. Example for a Next.js API route:
+
+```ts
+// pages/api/solve-token.ts
+const FERS_API_KEY = process.env.FERS_API_KEY!;
+
+let cached: { token: string; expiresAt: number } | null = null;
+
+export default async function handler(req, res) {
+  const now = Date.now();
+
+  // Re-use if more than 5 minutes remain
+  if (cached && cached.expiresAt - now > 5 * 60 * 1000) {
+    return res.json({ token: cached.token });
+  }
+
+  const resp = await fetch("https://ferscloud.com/api/solver/token", {
+    method: "POST",
+    headers: { "X-API-Key": FERS_API_KEY },
+  });
+
+  if (!resp.ok) return res.status(502).json({ error: "Token fetch failed" });
+
+  const { token, expiresAt } = await resp.json();
+  cached = { token, expiresAt: new Date(expiresAt).getTime() };
+  return res.json({ token });
+}
+```
+
+Same pattern works for Express, Deno, Bun, Cloudflare Workers, or any server-side runtime.
+
+### 3. Frontend: call the solver with the token
+
+```ts
+import init, { calculate_from_json_with_token } from "@ferscloud/fers-calculation";
+
+await init();
+
+const { token } = await fetch("/api/solve-token").then(r => r.json());
+
+const result = calculate_from_json_with_token(JSON.stringify(myModel), token);
+const data = JSON.parse(result);
+```
+
+If the token is missing, expired, or invalid, the solver falls back to the free 100-member limit — it never throws.
+
+## Tier comparison
+
+| Feature | Free | Pro |
+|---|---|---|
+| Max members | 100 | 10 000 |
+| WASM function | `calculate_from_json` | `calculate_from_json_with_token` |
+| Requires token | No | Yes |
+| Token TTL | — | 30 minutes |
+
+## Security note
+
+Keep your `FERS_API_KEY` server-side only. The solve token it fetches is safe to pass to the browser — it is short-lived and cryptographically signed. Only FERS Cloud can issue valid tokens; the browser WASM can only verify them.
+
+## Links
+
+- [Full documentation & getting started](https://ferscloud.com/getting-started)
+- [FERS Cloud](https://ferscloud.com)
+- [FERS_core Python package](https://pypi.org/project/fers-core/)

package/fers_calculations.d.ts

@@ -1,6 +1,17 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * Free-tier solver (100-member limit). Used when no valid solve token is present.
+ */
 export function calculate_from_json(json_data: string): string;
 
+/**
+ * Tier-aware solver. Verifies the Ed25519-signed solve token issued by the
+ * FERS Cloud server; grants Premium limits (10 000 members) when the token
+ * is valid and contains `"tier":"premium"`. Falls back to Free on any
+ * failure — expired, malformed, or wrong signature.
+ */
+export function calculate_from_json_with_token(json_data: string, solve_token: string): string;
+
 export function load_fers_from_file(path: string): string;

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, load_fers_from_file
+    calculate_from_json, calculate_from_json_with_token, load_fers_from_file
 } from "./fers_calculations_bg.js";

package/fers_calculations_bg.js

@@ -1,4 +1,5 @@
 /**
+ * Free-tier solver (100-member limit). Used when no valid solve token is present.
  * @param {string} json_data
  * @returns {string}
  */
@@ -17,6 +18,32 @@ export function calculate_from_json(json_data) {
     }
 }
 
+/**
+ * Tier-aware solver. Verifies the Ed25519-signed solve token issued by the
+ * FERS Cloud server; grants Premium limits (10 000 members) when the token
+ * is valid and contains `"tier":"premium"`. Falls back to Free on any
+ * failure — expired, malformed, or wrong signature.
+ * @param {string} json_data
+ * @param {string} solve_token
+ * @returns {string}
+ */
+export function calculate_from_json_with_token(json_data, solve_token) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json_data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(solve_token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.calculate_from_json_with_token(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * @param {string} path
  * @returns {string}
@@ -35,6 +62,13 @@ export function load_fers_from_file(path) {
         wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
+export function __wbg___wbindgen_throw_1506f2235d1bdba0(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_now_190933fa139cc119() {
+    const ret = Date.now();
+    return ret;
+}
 export function __wbindgen_init_externref_table() {
     const table = wasm.__wbindgen_externrefs;
     const offset = table.grow(4);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ferscloud/fers-calculation-web",
   "type": "module",
-  "version": "0.2.22",
+  "version": "0.2.26",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Jeroen124/FERS_calculations.git"