@descix/egpt-math-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,985 @@
+// src/browser/wasm-loader.js
+async function probeWasmArtifact(wasmUrl) {
+  if (!wasmUrl) {
+    return { ok: false, reason: "missing-wasm-url" };
+  }
+  try {
+    if (typeof process !== "undefined" && wasmUrl.startsWith("file://")) {
+      const fs = await import("node:fs/promises");
+      const { fileURLToPath } = await import("node:url");
+      await fs.access(fileURLToPath(wasmUrl));
+      return { ok: true };
+    }
+    const response = await fetch(wasmUrl, { method: "GET" });
+    if (!response.ok) {
+      return { ok: false, reason: `artifact-unreachable:${response.status}` };
+    }
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, reason: `artifact-fetch-error:${String(error)}` };
+  }
+}
+function normalizeBrowserUrl(url) {
+  if (!url || typeof document === "undefined") return url;
+  return new URL(url, document.baseURI).href;
+}
+async function loadEgptMathWasm({ wasmUrl, wasmModuleUrl } = {}) {
+  wasmUrl = normalizeBrowserUrl(wasmUrl);
+  wasmModuleUrl = normalizeBrowserUrl(wasmModuleUrl);
+  const probe = await probeWasmArtifact(wasmUrl);
+  if (!wasmModuleUrl) {
+    return {
+      mode: probe.ok ? "wasm-skeleton" : "js-compat",
+      wasmUrl: wasmUrl ?? null,
+      wasmModuleUrl: null,
+      warnings: probe.ok ? [] : [probe.reason]
+    };
+  }
+  try {
+    const mod = await import(wasmModuleUrl);
+    let initArg = wasmUrl;
+    if (typeof process !== "undefined" && wasmUrl && wasmUrl.startsWith("file://")) {
+      const fs = await import("node:fs/promises");
+      const { fileURLToPath } = await import("node:url");
+      initArg = await fs.readFile(fileURLToPath(wasmUrl));
+    }
+    if (typeof mod.default === "function" && wasmUrl) {
+      await mod.default(initArg);
+    } else if (typeof mod.init === "function" && wasmUrl) {
+      await mod.init(initArg);
+    }
+    return {
+      mode: "wasm-bridge",
+      wasmUrl: wasmUrl ?? null,
+      wasmModuleUrl,
+      module: mod,
+      warnings: probe.ok ? [] : [probe.reason]
+    };
+  } catch (error) {
+    return {
+      mode: "js-compat",
+      wasmUrl: wasmUrl ?? null,
+      wasmModuleUrl,
+      warnings: [`module-load-failed:${String(error)}`, ...probe.ok ? [] : [probe.reason]]
+    };
+  }
+}
+
+// src/browser/wasm-math-provider.js
+var MathBackendRegistrationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MathBackendRegistrationError";
+  }
+};
+function _localEgptRealToCanonicalStr(h) {
+  const { numerator, denominator } = h._getPPFRationalParts();
+  if (denominator === 1n || denominator === -1n) {
+    return String(denominator < 0n ? -numerator : numerator);
+  }
+  return `${numerator}/${denominator}`;
+}
+function unwrap(result, opName) {
+  if (!result || !result.ok) {
+    const msg = result?.error ?? "wasm-result-unknown-error";
+    throw new Error(`WasmMathBackendProvider.${opName}: WASM call failed \u2014 ${msg}`);
+  }
+  return result.value;
+}
+function makeHandle(epoch, idx) {
+  return { p: "wasm-math", e: epoch, h: idx };
+}
+function unpackResult(u64BigInt) {
+  const n = typeof u64BigInt === "bigint" ? u64BigInt : BigInt(Math.round(Number(u64BigInt)));
+  return { e: Number(n >> 32n), h: Number(n & 0xFFFFFFFFn) };
+}
+function packHandle(epoch, idx) {
+  return BigInt(epoch) * 0x100000000n + BigInt(idx);
+}
+var _wasmFacade = null;
+function _internStr(canonStr) {
+  const r = _wasmFacade.internStr(canonStr);
+  const packed = unwrap(r, "_internStr");
+  const { e, h } = unpackResult(packed);
+  return makeHandle(e, h);
+}
+function _materializeStr(handle, opName) {
+  const packed = packHandle(handle.e, handle.h);
+  const r = _wasmFacade.materializeStr(packed);
+  return unwrap(r, opName + ".materializeStr");
+}
+function extractHandle(h, opName) {
+  if (h !== null && typeof h === "object") {
+    if (h.p === "wasm-math") {
+      return packHandle(h.e, h.h);
+    }
+    if (typeof h._getPPFRationalParts === "function") {
+      const str = _localEgptRealToCanonicalStr(h);
+      const r = _wasmFacade.internStr(str);
+      const packed = unwrap(r, opName + ".d2-intern");
+      return packed;
+    }
+  }
+  throw new TypeError(
+    `WasmMathBackendProvider.${opName}: foreign or invalid handle \u2014 expected wasm-math handle {p:'wasm-math',e,h} or EGPTReal instance; got ${typeof h}: ${h === null ? "null" : JSON.stringify(h)}`
+  );
+}
+function polyToJson(arr, opName) {
+  return JSON.stringify(arr.map((h) => String(extractHandle(h, opName))));
+}
+function jsonToHandles(json) {
+  const arr = JSON.parse(json);
+  return arr.map((s) => {
+    const n = BigInt(s);
+    const { e, h } = unpackResult(n);
+    return makeHandle(e, h);
+  });
+}
+function jsonPolyDivToObj(json) {
+  const obj = JSON.parse(json);
+  return {
+    quotient: obj.quotient.map((s) => {
+      const n = BigInt(s);
+      const { e, h } = unpackResult(n);
+      return makeHandle(e, h);
+    }),
+    remainder: obj.remainder.map((s) => {
+      const n = BigInt(s);
+      const { e, h } = unpackResult(n);
+      return makeHandle(e, h);
+    })
+  };
+}
+function _bigintGcd(a, b) {
+  a = a < 0n ? -a : a;
+  b = b < 0n ? -b : b;
+  while (b) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+}
+function buildWasmMathProvider(wasmFacade) {
+  if (!wasmFacade || typeof wasmFacade !== "object") {
+    throw new MathBackendRegistrationError(
+      "buildWasmMathProvider: wasmFacade must be a non-null object (from buildWasmFacade)."
+    );
+  }
+  const requiredArena = ["internStr", "materializeStr", "arenaAdd"];
+  const missingArena = requiredArena.filter((fn) => typeof wasmFacade[fn] !== "function");
+  if (missingArena.length > 0) {
+    throw new MathBackendRegistrationError(
+      `buildWasmMathProvider: WASM facade missing V3 arena exports: ${missingArena.join(", ")}. Rebuild the WASM bridge (npm run build:wasm-bridge in sdk/egpt-math-sdk).`
+    );
+  }
+  _wasmFacade = wasmFacade;
+  const provider = Object.freeze({
+    id: "wasm-math",
+    // ── resetScope — per-run arena lifecycle ────────────────────────────────
+    // Called by MathBackendRegistry.resetScope() (Runtime's finally block).
+    // Provider MUST NOT subscribe to Bus — Runtime calls DOWN via registry.
+    resetScope() {
+      wasmFacade.resetScope();
+    },
+    // ── Construction / conversion ──────────────────────────────────────────
+    fromBigInt(n) {
+      return _internStr(String(n));
+    },
+    fromRational(num, den) {
+      const g = _bigintGcd(num < 0n ? -num : num, den < 0n ? -den : den);
+      if (g === 0n) return _internStr("0");
+      let rn = num / g;
+      let rd = den / g;
+      if (rd < 0n) {
+        rn = -rn;
+        rd = -rd;
+      }
+      const canonical = rd === 1n ? String(rn) : `${rn}/${rd}`;
+      return _internStr(canonical);
+    },
+    fromRationalStr(str) {
+      return _internStr(str.trim());
+    },
+    toCanonicalStr(h) {
+      return _materializeStr(h, "toCanonicalStr");
+    },
+    // ── Arithmetic ─────────────────────────────────────────────────────────
+    add(a, b) {
+      const r = wasmFacade.arenaAdd(extractHandle(a, "add"), extractHandle(b, "add"));
+      const packed = unwrap(r, "add");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    subtract(a, b) {
+      const r = wasmFacade.arenaSub(extractHandle(a, "subtract"), extractHandle(b, "subtract"));
+      const packed = unwrap(r, "subtract");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    multiply(a, b) {
+      const r = wasmFacade.arenaMul(extractHandle(a, "multiply"), extractHandle(b, "multiply"));
+      const packed = unwrap(r, "multiply");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    divide(a, b) {
+      const r = wasmFacade.arenaDiv(extractHandle(a, "divide"), extractHandle(b, "divide"));
+      const packed = unwrap(r, "divide");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    normalDivide(a, b) {
+      const r = wasmFacade.arenaDiv(extractHandle(a, "normalDivide"), extractHandle(b, "normalDivide"));
+      const packed = unwrap(r, "normalDivide");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    mod(a, b) {
+      const r = wasmFacade.arenaMod(extractHandle(a, "mod"), extractHandle(b, "mod"));
+      const packed = unwrap(r, "mod");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    // ── Comparison ─────────────────────────────────────────────────────────
+    equals(a, b) {
+      const cmp = unwrap(wasmFacade.arenaCmp(extractHandle(a, "equals"), extractHandle(b, "equals")), "equals");
+      return cmp === 0;
+    },
+    compare(a, b) {
+      return unwrap(wasmFacade.arenaCmp(extractHandle(a, "compare"), extractHandle(b, "compare")), "compare");
+    },
+    // ── Exponentiation / roots ──────────────────────────────────────────────
+    pow(base, expNum, expDen) {
+      const en = Number(expNum);
+      const ed = Number(expDen);
+      const r = wasmFacade.arenaPow(extractHandle(base, "pow"), en, ed);
+      const packed = unwrap(r, "pow");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    sqrt(a) {
+      const r = wasmFacade.arenaSqrt(extractHandle(a, "sqrt"));
+      const packed = unwrap(r, "sqrt");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    // ── Rational-domain transcendentals ─────────────────────────────────────
+    exp2(exponent) {
+      const r = wasmFacade.arenaExp2(extractHandle(exponent, "exp2"));
+      const packed = unwrap(r, "exp2");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    log2(value) {
+      const r = wasmFacade.arenaLog2(extractHandle(value, "log2"));
+      const packed = unwrap(r, "log2");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    // ── PPF encode / decode ─────────────────────────────────────────────────
+    ppfEncodeInteger(n) {
+      const hN = _internStr(String(n));
+      const r = wasmFacade.arenaPpfEncode(packHandle(hN.e, hN.h));
+      const jsonStr = unwrap(r, "ppfEncodeInteger");
+      const obj = JSON.parse(jsonStr);
+      return { N: BigInt(obj.N), offset: BigInt(obj.offset) };
+    },
+    ppfDecodeInteger(ppf) {
+      const json = JSON.stringify({ N: String(ppf.N), offset: String(ppf.offset) });
+      const r = wasmFacade.arenaPpfDecode(json);
+      const packed = unwrap(r, "ppfDecodeInteger");
+      const { e, h } = unpackResult(packed);
+      const decoded = _materializeStr(makeHandle(e, h), "ppfDecodeInteger");
+      return BigInt(decoded);
+    },
+    fromPPF(ppfData) {
+      const scalar = ppfData.scalar ?? { numerator: 1n, denominator: 1n };
+      const json = JSON.stringify({
+        numerator: { N: String(ppfData.numerator.N), offset: String(ppfData.numerator.offset) },
+        denominator: { N: String(ppfData.denominator.N), offset: String(ppfData.denominator.offset) },
+        scalar: { numerator: String(scalar.numerator ?? 1n), denominator: String(scalar.denominator ?? 1n) }
+      });
+      const r = wasmFacade.arenaFromPpfJson(json);
+      const packed = unwrap(r, "fromPPF");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    // ── Bit-length ──────────────────────────────────────────────────────────
+    getIntegerBitLength(n) {
+      const r = wasmFacade.arenaGetBitLength(extractHandle(n, "getIntegerBitLength"));
+      return BigInt(unwrap(r, "getIntegerBitLength"));
+    },
+    // ── Break-symbolic exits ────────────────────────────────────────────────
+    breakSymbolicToApproximateBigInt(h) {
+      const r = wasmFacade.arenaBreakToBigint(extractHandle(h, "breakSymbolicToApproximateBigInt"));
+      return BigInt(unwrap(r, "breakSymbolicToApproximateBigInt"));
+    },
+    breakSymbolicToApproximateJSNumber(h) {
+      const r = wasmFacade.arenaBreakToJsNumber(extractHandle(h, "breakSymbolicToApproximateJSNumber"));
+      return Number(unwrap(r, "breakSymbolicToApproximateJSNumber"));
+    },
+    breakSymbolicToString(h) {
+      const r = wasmFacade.arenaBreakToString(extractHandle(h, "breakSymbolicToString"));
+      return unwrap(r, "breakSymbolicToString");
+    },
+    // ── Prime-atom boundary ─────────────────────────────────────────────────
+    toPrimeAtoms(h) {
+      const r = wasmFacade.arenaToPrimeAtoms(extractHandle(h, "toPrimeAtoms"));
+      const json = unwrap(r, "toPrimeAtoms");
+      const obj = JSON.parse(json);
+      return {
+        sign: obj.sign,
+        factors: obj.factors.map((f) => ({
+          prime: BigInt(f.prime),
+          exponent: BigInt(f.exponent)
+        }))
+      };
+    },
+    fromAtomVec(atomVec) {
+      const json = JSON.stringify({
+        sign: atomVec.sign,
+        factors: (atomVec.factors ?? []).map((f) => ({
+          prime: String(typeof f.prime === "bigint" ? f.prime : BigInt(f.prime)),
+          exponent: String(typeof f.exponent === "bigint" ? f.exponent : BigInt(f.exponent))
+        }))
+      });
+      const r = wasmFacade.arenaFromAtomVec(json);
+      const packed = unwrap(r, "fromAtomVec");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    toAtomRoot(h) {
+      const r = wasmFacade.arenaToAtomRoot(extractHandle(h, "toAtomRoot"));
+      const json = unwrap(r, "toAtomRoot");
+      const obj = JSON.parse(json);
+      return {
+        leadingCoeff: _internStr(obj.leadingCoeff),
+        roots: obj.roots.map((root) => ({
+          value: _internStr(root.value),
+          multiplicity: BigInt(root.multiplicity)
+        }))
+      };
+    },
+    fromAtomRoot(term) {
+      const lcStr = _materializeStr(term.leadingCoeff, "fromAtomRoot.leadingCoeff");
+      const rootsArr = (term.roots ?? []).map((root) => ({
+        value: _materializeStr(root.value, "fromAtomRoot.root.value"),
+        multiplicity: String(root.multiplicity)
+      }));
+      const json = JSON.stringify({ leadingCoeff: lcStr, roots: rootsArr });
+      const r = wasmFacade.arenaFromAtomRoot(json);
+      const packed = unwrap(r, "fromAtomRoot");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    // ── Integer helpers — contract takes bigint inputs ────────────────────────
+    //
+    // gcd/lcm/modPow at the contract level take bigint inputs (not handles).
+    // We intern the BigInts into the arena, compute, then return the result.
+    gcd(a, b) {
+      const ha = _internStr(String(a));
+      const hb = _internStr(String(b));
+      const r = wasmFacade.arenaGcd(packHandle(ha.e, ha.h), packHandle(hb.e, hb.h));
+      return BigInt(unwrap(r, "gcd"));
+    },
+    lcm(a, b) {
+      const ha = _internStr(String(a));
+      const hb = _internStr(String(b));
+      const r = wasmFacade.arenaLcm(packHandle(ha.e, ha.h), packHandle(hb.e, hb.h));
+      return BigInt(unwrap(r, "lcm"));
+    },
+    modPow(base, exp, mod) {
+      const hBase = _internStr(String(base));
+      const hExp = _internStr(String(exp));
+      const hMod = _internStr(String(mod));
+      const r = wasmFacade.arenaModPow(
+        packHandle(hBase.e, hBase.h),
+        packHandle(hExp.e, hExp.h),
+        packHandle(hMod.e, hMod.h)
+      );
+      const packed = unwrap(r, "modPow");
+      const { e, h } = unpackResult(packed);
+      const str = _materializeStr(makeHandle(e, h), "modPow.result");
+      return BigInt(str);
+    },
+    // ── Polynomial ops ──────────────────────────────────────────────────────
+    polyAdd(a, b) {
+      const r = wasmFacade.arenaPolyAdd(polyToJson(a, "polyAdd"), polyToJson(b, "polyAdd"));
+      return jsonToHandles(unwrap(r, "polyAdd"));
+    },
+    polyMul(a, b) {
+      const r = wasmFacade.arenaPolyMul(polyToJson(a, "polyMul"), polyToJson(b, "polyMul"));
+      return jsonToHandles(unwrap(r, "polyMul"));
+    },
+    polyDiv(dividend, divisor) {
+      const r = wasmFacade.arenaPolyDiv(polyToJson(dividend, "polyDiv"), polyToJson(divisor, "polyDiv"));
+      return jsonPolyDivToObj(unwrap(r, "polyDiv"));
+    },
+    polyForwardTransform(coeffs, n) {
+      const r = wasmFacade.arenaPolyFwd(polyToJson(coeffs, "polyForwardTransform"), n);
+      return jsonToHandles(unwrap(r, "polyForwardTransform"));
+    },
+    polyInverseTransform(samples, n) {
+      const r = wasmFacade.arenaPolyInv(polyToJson(samples, "polyInverseTransform"), n);
+      return jsonToHandles(unwrap(r, "polyInverseTransform"));
+    },
+    polyEvaluateAt(poly, x) {
+      const r = wasmFacade.arenaPolyEval(polyToJson(poly, "polyEvaluateAt"), extractHandle(x, "polyEvaluateAt"));
+      const packed = unwrap(r, "polyEvaluateAt");
+      const { e, h } = unpackResult(packed);
+      return makeHandle(e, h);
+    },
+    polyGcd(a, b) {
+      const r = wasmFacade.arenaPolyGcd(polyToJson(a, "polyGcd"), polyToJson(b, "polyGcd"));
+      return jsonToHandles(unwrap(r, "polyGcd"));
+    },
+    // ── Handle identity predicate (37th op) ──────────────────────────────────
+    // Pure structural type check of the V3 handle shape {p:'wasm-math',e,h}.
+    // Never throws. Architect ruling (b), Option-JS-only: isHandle answers a
+    // TYPE question, not a LIVENESS question — a structurally-valid but stale
+    // handle (dead epoch) still returns TRUE here, so that the FAIL-LOUD
+    // arena_get stale-throw stays at the op call site and is never masked by
+    // a false-from-this-predicate (that masking would be the FraqtlSession
+    // backend-lie class of bug). Does NOT consult arenaStats (DEBUG-ONLY) and
+    // makes NO wasm round-trip. A js-reference EGPTReal object → false (it is
+    // a HOST value the D2 seam interns, not a wasm-math handle of MY type).
+    isHandle(v) {
+      return v != null && typeof v === "object" && v.p === "wasm-math" && Number.isInteger(v.e) && Number.isInteger(v.h);
+    }
+  });
+  return provider;
+}
+
+// src/browser/wasm-facade.js
+var _provider = null;
+function _setActiveWasmProvider(provider) {
+  _provider = provider;
+}
+function _p(opName) {
+  if (!_provider) {
+    throw new Error(
+      `EGPT Math SDK (WASM-only dist): no active WASM math provider (op '${opName}'). createEgptMathSdk() must complete successfully before EGPTReal/EGPTMath/EGPTPolynomial are used \u2014 this build ships no JS math-core fallback.`
+    );
+  }
+  return _provider;
+}
+function _wrap(handle) {
+  return new EGPTReal(_CONSTRUCT_TOKEN, handle);
+}
+function _unwrap(v, opName) {
+  if (v instanceof EGPTReal) return v._handle;
+  throw new TypeError(
+    `EGPT Math SDK: ${opName} expected an EGPTReal facade instance, got ${v === null ? "null" : typeof v}`
+  );
+}
+var _CONSTRUCT_TOKEN = Symbol("egpt-real-facade-construct");
+var EGPTReal = class _EGPTReal {
+  constructor(token, handle) {
+    if (token !== _CONSTRUCT_TOKEN) {
+      throw new TypeError(
+        "EGPTReal: do not construct directly \u2014 use EGPTReal.fromBigInt / .fromRational / .fromRationalStr."
+      );
+    }
+    this._handle = handle;
+  }
+  /** @param {bigint|number|string} n @returns {EGPTReal} */
+  static fromBigInt(n) {
+    return new _EGPTReal(_CONSTRUCT_TOKEN, _p("fromBigInt").fromBigInt(BigInt(n)));
+  }
+  /** @param {bigint|number} num @param {bigint|number} den @returns {EGPTReal} */
+  static fromRational(num, den) {
+    return new _EGPTReal(_CONSTRUCT_TOKEN, _p("fromRational").fromRational(BigInt(num), BigInt(den)));
+  }
+  /** @param {string} str — "num" or "num/den" @returns {EGPTReal} */
+  static fromRationalStr(str) {
+    return new _EGPTReal(_CONSTRUCT_TOKEN, _p("fromRationalStr").fromRationalStr(String(str)));
+  }
+  static get ZERO() {
+    return _EGPTReal.fromBigInt(0n);
+  }
+  static get ONE() {
+    return _EGPTReal.fromBigInt(1n);
+  }
+  /** Exact canonical rational string ("num" or "num/den") — never decimal projection. */
+  toCanonicalStr() {
+    return _p("toCanonicalStr").toCanonicalStr(this._handle);
+  }
+  /** Alias for {@link EGPTReal#toCanonicalStr} — matches the dev-core class's narration method name. */
+  toMathString() {
+    return this.toCanonicalStr();
+  }
+  toString() {
+    return this.toCanonicalStr();
+  }
+  /** @param {EGPTReal} other @returns {EGPTReal} */
+  add(other) {
+    return _wrap(_p("add").add(this._handle, _unwrap(other, "add")));
+  }
+  /** @param {EGPTReal} other @returns {EGPTReal} */
+  subtract(other) {
+    return _wrap(_p("subtract").subtract(this._handle, _unwrap(other, "subtract")));
+  }
+  /** Shannon-space multiply. @param {EGPTReal} other @returns {EGPTReal} */
+  multiply(other) {
+    return _wrap(_p("multiply").multiply(this._handle, _unwrap(other, "multiply")));
+  }
+  /** Shannon-space divide. @param {EGPTReal} other @returns {EGPTReal} */
+  divide(other) {
+    return _wrap(_p("divide").divide(this._handle, _unwrap(other, "divide")));
+  }
+  /** Normal-space (rational) divide. @param {EGPTReal} other @returns {EGPTReal} */
+  normalDivide(other) {
+    return _wrap(_p("normalDivide").normalDivide(this._handle, _unwrap(other, "normalDivide")));
+  }
+  /** @param {EGPTReal} other @returns {EGPTReal} */
+  mod(other) {
+    return _wrap(_p("mod").mod(this._handle, _unwrap(other, "mod")));
+  }
+  /** @param {EGPTReal} other @returns {boolean} */
+  equals(other) {
+    return _p("equals").equals(this._handle, _unwrap(other, "equals"));
+  }
+  /** @param {EGPTReal} other @returns {-1|0|1} */
+  compare(other) {
+    return _p("compare").compare(this._handle, _unwrap(other, "compare"));
+  }
+  /** @param {bigint|number} expNum @param {bigint|number} [expDen=1n] @returns {EGPTReal} */
+  pow(expNum, expDen = 1n) {
+    return _wrap(_p("pow").pow(this._handle, BigInt(expNum), BigInt(expDen)));
+  }
+  /** @returns {EGPTReal} */
+  sqrt() {
+    return _wrap(_p("sqrt").sqrt(this._handle));
+  }
+  /** Rational-domain exp2. @returns {EGPTReal} */
+  exp2() {
+    return _wrap(_p("exp2").exp2(this._handle));
+  }
+  /** Rational-domain log2. @returns {EGPTReal} */
+  log2() {
+    return _wrap(_p("log2").log2(this._handle));
+  }
+  /** floor(log2(n)) + 1. @returns {bigint} */
+  getIntegerBitLength() {
+    return _p("getIntegerBitLength").getIntegerBitLength(this._handle);
+  }
+  /** @returns {bigint} */
+  breakSymbolicToApproximateBigInt() {
+    return _p("breakSymbolicToApproximateBigInt").breakSymbolicToApproximateBigInt(this._handle);
+  }
+  /** @returns {number} */
+  breakSymbolicToApproximateJSNumber() {
+    return _p("breakSymbolicToApproximateJSNumber").breakSymbolicToApproximateJSNumber(this._handle);
+  }
+  /** @returns {string} */
+  breakSymbolicToString() {
+    return _p("breakSymbolicToString").breakSymbolicToString(this._handle);
+  }
+  /** @returns {{sign:-1|0|1, factors:{prime:bigint,exponent:bigint}[]}} */
+  toPrimeAtoms() {
+    return _p("toPrimeAtoms").toPrimeAtoms(this._handle);
+  }
+  /** @returns {{leadingCoeff:EGPTReal, roots:{value:EGPTReal,multiplicity:bigint}[]}} */
+  toAtomRoot() {
+    const raw = _p("toAtomRoot").toAtomRoot(this._handle);
+    return {
+      leadingCoeff: _wrap(raw.leadingCoeff),
+      roots: raw.roots.map((r) => ({ value: _wrap(r.value), multiplicity: r.multiplicity }))
+    };
+  }
+  /** @param {{sign, factors}} atomVec @returns {EGPTReal} */
+  static fromAtomVec(atomVec) {
+    return _wrap(_p("fromAtomVec").fromAtomVec(atomVec));
+  }
+  /** @param {{leadingCoeff:EGPTReal, roots:{value:EGPTReal,multiplicity:bigint}[]}} term @returns {EGPTReal} */
+  static fromAtomRoot(term) {
+    const p = _p("fromAtomRoot");
+    return _wrap(p.fromAtomRoot({
+      leadingCoeff: _unwrap(term.leadingCoeff, "fromAtomRoot.leadingCoeff"),
+      roots: (term.roots ?? []).map((r) => ({
+        value: _unwrap(r.value, "fromAtomRoot.root.value"),
+        multiplicity: r.multiplicity
+      }))
+    }));
+  }
+  /** Integer gcd (bigint-level, not a rational op). @returns {bigint} */
+  static gcd(a, b) {
+    return _p("gcd").gcd(BigInt(a), BigInt(b));
+  }
+  /** Integer lcm (bigint-level, not a rational op). @returns {bigint} */
+  static lcm(a, b) {
+    return _p("lcm").lcm(BigInt(a), BigInt(b));
+  }
+  /** @returns {bigint} */
+  static modPow(base, exp, mod) {
+    return _p("modPow").modPow(BigInt(base), BigInt(exp), BigInt(mod));
+  }
+};
+var EGPTMath = Object.freeze({
+  add: (a, b) => a.add(b),
+  subtract: (a, b) => a.subtract(b),
+  multiply: (a, b) => a.multiply(b),
+  divide: (a, b) => a.divide(b),
+  normalDivide: (a, b) => a.normalDivide(b),
+  mod: (a, b) => a.mod(b),
+  equals: (a, b) => a.equals(b),
+  compare: (a, b) => a.compare(b),
+  pow: (base, expNum, expDen) => base.pow(expNum, expDen),
+  sqrt: (a) => a.sqrt(),
+  getIntegerBitLength: (a) => a.getIntegerBitLength()
+});
+var EGPTPolynomial = Object.freeze({
+  /** @param {EGPTReal[]} a @param {EGPTReal[]} b @returns {EGPTReal[]} */
+  add(a, b) {
+    return _p("polyAdd").polyAdd(a.map((x) => _unwrap(x, "polyAdd")), b.map((x) => _unwrap(x, "polyAdd"))).map(_wrap);
+  },
+  /** @param {EGPTReal[]} a @param {EGPTReal[]} b @returns {EGPTReal[]} */
+  multiply(a, b) {
+    return _p("polyMul").polyMul(a.map((x) => _unwrap(x, "polyMul")), b.map((x) => _unwrap(x, "polyMul"))).map(_wrap);
+  },
+  /** @param {EGPTReal[]} dividend @param {EGPTReal[]} divisor @returns {{quotient:EGPTReal[], remainder:EGPTReal[]}} */
+  divide(dividend, divisor) {
+    const r = _p("polyDiv").polyDiv(
+      dividend.map((x) => _unwrap(x, "polyDiv")),
+      divisor.map((x) => _unwrap(x, "polyDiv"))
+    );
+    return { quotient: r.quotient.map(_wrap), remainder: r.remainder.map(_wrap) };
+  },
+  /** @param {EGPTReal[]} coeffs @param {number} n @returns {EGPTReal[]} */
+  forwardTransform(coeffs, n) {
+    return _p("polyForwardTransform").polyForwardTransform(coeffs.map((x) => _unwrap(x, "polyForwardTransform")), n).map(_wrap);
+  },
+  /** @param {EGPTReal[]} samples @param {number} n @returns {EGPTReal[]} */
+  inverseTransform(samples, n) {
+    return _p("polyInverseTransform").polyInverseTransform(samples.map((x) => _unwrap(x, "polyInverseTransform")), n).map(_wrap);
+  },
+  /** @param {EGPTReal[]} poly @param {EGPTReal} x @returns {EGPTReal} */
+  evaluateAt(poly, x) {
+    return _wrap(
+      _p("polyEvaluateAt").polyEvaluateAt(poly.map((c) => _unwrap(c, "polyEvaluateAt")), _unwrap(x, "polyEvaluateAt"))
+    );
+  },
+  /** @param {EGPTReal[]} a @param {EGPTReal[]} b @returns {EGPTReal[]} */
+  gcd(a, b) {
+    return _p("polyGcd").polyGcd(a.map((x) => _unwrap(x, "polyGcd")), b.map((x) => _unwrap(x, "polyGcd"))).map(_wrap);
+  }
+});
+function _matrixZeros(rows, cols) {
+  const M = new Array(rows);
+  for (let i = 0; i < rows; i++) M[i] = new Array(cols).fill(EGPTReal.ZERO);
+  return M;
+}
+function _matrixShape(M) {
+  return { rows: M.length, cols: M.length === 0 ? 0 : M[0].length };
+}
+var EGPTMatrix = Object.freeze({
+  /** @param {number} rows @param {number} cols @returns {EGPTReal[][]} */
+  zeros: _matrixZeros,
+  /** @param {number} n @returns {EGPTReal[][]} */
+  identity(n) {
+    const M = _matrixZeros(n, n);
+    for (let i = 0; i < n; i++) M[i][i] = EGPTReal.ONE;
+    return M;
+  },
+  /**
+   * Build a matrix from a rectangular array of JS values (BigInt, integer,
+   * `[num, den]` tuple, or an existing EGPTReal facade instance).
+   * @param {Array<Array>} rows @returns {EGPTReal[][]}
+   */
+  from(rows) {
+    return rows.map((row, i) => row.map((v, j) => {
+      if (v instanceof EGPTReal) return v;
+      if (Array.isArray(v) && v.length === 2) return EGPTReal.fromRational(BigInt(v[0]), BigInt(v[1]));
+      if (typeof v === "bigint") return EGPTReal.fromBigInt(v);
+      if (typeof v === "number" && Number.isInteger(v)) return EGPTReal.fromBigInt(BigInt(v));
+      throw new Error(`EGPTMatrix.from: unsupported entry at [${i}][${j}]: ${v}`);
+    }));
+  },
+  /** @param {EGPTReal[][]} M @returns {{rows:number, cols:number}} */
+  shape: _matrixShape,
+  /** @param {EGPTReal[][]} M @returns {EGPTReal[][]} */
+  transpose(M) {
+    const { rows, cols } = _matrixShape(M);
+    const T = _matrixZeros(cols, rows);
+    for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) T[j][i] = M[i][j];
+    return T;
+  },
+  /** @param {EGPTReal[][]} A @param {EGPTReal[][]} B @returns {boolean} */
+  equals(A, B) {
+    const a = _matrixShape(A);
+    const b = _matrixShape(B);
+    if (a.rows !== b.rows || a.cols !== b.cols) return false;
+    for (let i = 0; i < a.rows; i++) for (let j = 0; j < a.cols; j++) {
+      if (!A[i][j].equals(B[i][j])) return false;
+    }
+    return true;
+  },
+  /**
+   * Dot product of two equal-length EGPTReal vectors via the polynomial-
+   * multiplication identity (the (n-1)-th coefficient of `a(x) * reverse(b)(x)`).
+   * @param {EGPTReal[]} a @param {EGPTReal[]} b @returns {EGPTReal}
+   */
+  dotViaPolynomial(a, b) {
+    if (a.length !== b.length) throw new Error(`dotViaPolynomial: length mismatch ${a.length} vs ${b.length}`);
+    const n = a.length;
+    if (n === 0) return EGPTReal.ZERO;
+    const reversed = new Array(n);
+    for (let i = 0; i < n; i++) reversed[i] = b[n - 1 - i];
+    const product = EGPTPolynomial.multiply(a, reversed);
+    return product[n - 1] !== void 0 ? product[n - 1] : EGPTReal.ZERO;
+  },
+  /** @param {EGPTReal[][]} M @param {EGPTReal[]} v @returns {EGPTReal[]} */
+  matVec(M, v) {
+    const { rows, cols } = _matrixShape(M);
+    if (v.length !== cols) throw new Error(`matVec shape mismatch: M is ${rows}x${cols}, v has length ${v.length}`);
+    return M.map((row) => EGPTMatrix.dotViaPolynomial(row, v));
+  },
+  /**
+   * GEMM: `C := alpha * (A . B) + beta * C`.
+   * @param {EGPTReal[][]} A @param {EGPTReal[][]} B
+   * @param {EGPTReal} [alpha] @param {EGPTReal} [beta] @param {EGPTReal[][]} [C]
+   * @returns {EGPTReal[][]}
+   */
+  gemm(A, B, alpha, beta, C = null) {
+    alpha = alpha ?? EGPTReal.ONE;
+    beta = beta ?? EGPTReal.ZERO;
+    const a = _matrixShape(A);
+    const b = _matrixShape(B);
+    if (a.cols !== b.rows) throw new Error(`gemm shape mismatch: A is ${a.rows}x${a.cols}, B is ${b.rows}x${b.cols}`);
+    if (C === null) {
+      C = _matrixZeros(a.rows, b.cols);
+    } else {
+      const cShape = _matrixShape(C);
+      if (cShape.rows !== a.rows || cShape.cols !== b.cols) {
+        throw new Error(`gemm: C is ${cShape.rows}x${cShape.cols}, expected ${a.rows}x${b.cols}`);
+      }
+    }
+    const cols = new Array(b.cols);
+    for (let j = 0; j < b.cols; j++) {
+      const colJ = new Array(a.cols);
+      for (let r = 0; r < a.cols; r++) colJ[r] = B[r][j];
+      cols[j] = colJ;
+    }
+    for (let i = 0; i < a.rows; i++) {
+      for (let j = 0; j < b.cols; j++) {
+        const dotProduct = EGPTMatrix.dotViaPolynomial(A[i], cols[j]);
+        const scaled = EGPTMath.multiply(alpha, dotProduct);
+        C[i][j] = beta.equals(EGPTReal.ZERO) ? scaled : EGPTMath.add(scaled, EGPTMath.multiply(beta, C[i][j]));
+      }
+    }
+    return C;
+  },
+  /** Alias for `gemm(A, B)` with default scaling. @returns {EGPTReal[][]} */
+  matMul(A, B) {
+    return EGPTMatrix.gemm(A, B);
+  },
+  // toValueReps(M) / fromValueReps(VR) are DELIBERATELY EXCLUDED from this
+  // port (unlike every other EGPTMatrix method above). The dev-core versions
+  // route through EGPTPolynomial.toValueRepresentation/fromValueRepresentation
+  // — evaluation at CANONICAL BASE nodes x = 2^0, 2^1, ..., 2^D via Horner,
+  // inverted by Newton divided differences — which is NOT the same operation
+  // as polyForwardTransform/polyInverseTransform (those sample at the uniform
+  // RATIONAL nodes k/N, the FFT-style basis EGPTFFT below uses). Neither
+  // operation is in the 37-op provider contract (lib/egpt/js/model/backend/
+  // README.md §1), and substituting the wrong one would silently produce
+  // INCORRECT round-trip values — worse than omitting the method. Per the
+  // CEO's item-2 escape valve, omission-with-a-loud-error is the correct
+  // choice here: a caller hitting this method gets a legible
+  // "EGPTMatrix.toValueReps is not a function" (FAIL LOUD), never a silently
+  // wrong number. `dotViaPolynomial`/`gemm`/`matMul`/`evaluateRowsAt` above
+  // ARE faithful (they route through the SAME polyMultiply/polyEvaluateAt ops
+  // the dev-core class uses) and are unaffected by this exclusion.
+  /** @param {EGPTReal[][]} M @param {EGPTReal} x @returns {EGPTReal[]} */
+  evaluateRowsAt(M, x) {
+    return M.map((row) => EGPTPolynomial.evaluateAt(row, x));
+  },
+  /** @param {EGPTReal[][]} M @param {string} [label] @returns {string} */
+  format(M, label) {
+    const { rows, cols } = _matrixShape(M);
+    const cells = M.map((row) => row.map((v) => v.toCanonicalStr()));
+    const widths = new Array(cols).fill(0);
+    for (let i = 0; i < rows; i++) for (let j = 0; j < cols; j++) {
+      if (cells[i][j].length > widths[j]) widths[j] = cells[i][j].length;
+    }
+    const lines = cells.map((row) => "  [ " + row.map((c, j) => c.padStart(widths[j])).join("  ") + " ]");
+    return (label ? `${label}  (${rows}x${cols})
+` : "") + lines.join("\n");
+  },
+  /** @param {EGPTReal[][]} M @param {string} [label] */
+  print(M, label) {
+    console.log(EGPTMatrix.format(M, label));
+  }
+});
+var EGPTFFT = Object.freeze({
+  /** @param {EGPTReal[]} coeffs @param {number} [N] @returns {EGPTReal[]} */
+  forward(coeffs, N) {
+    return EGPTPolynomial.forwardTransform(coeffs, N === void 0 ? coeffs.length : N);
+  },
+  /** @param {EGPTReal[]} values @param {number} [N] @returns {EGPTReal[]} */
+  inverse(values, N) {
+    return EGPTPolynomial.inverseTransform(values, N === void 0 ? values.length : N);
+  }
+});
+
+// src/examples/qft-benchmark-baseline.js
+var QFT_BENCHMARK_BASELINE = Object.freeze({
+  // --- Citation of the published supercomputer result ---
+  citation: Object.freeze({
+    authors: "Willsch, D.; Willsch, M.; Jin, F.; De Raedt, H.; Michielsen, K.",
+    title: "Large-Scale Simulation of Shor's Quantum Factoring Algorithm",
+    venue: "Mathematics (MDPI), 11, 4222",
+    year: 2023,
+    doi: "10.3390/math11194222"
+  }),
+  // --- Hardware the supercomputer result ran on ---
+  hardware: Object.freeze({
+    system: "JUWELS Booster supercomputer, J\xFClich Supercomputing Centre",
+    gpus: "2048 \xD7 NVIDIA A100 (40 GiB each)",
+    // ~80 TiB = aggregate cluster capacity (2048 × 40 GiB). The paper notes the
+    // 39/40-qubit run *requires* "slightly larger than 40 TiB" — capacity vs.
+    // requirement; see SOURCES memo nuance #3.
+    memory: "~80 TiB aggregate GPU memory"
+  }),
+  // --- Total study compute (the 594 / 49.5 figure; 496-vs-594 resolved → 594) ---
+  studyCompute: Object.freeze({
+    gpuYears: 49.5,
+    coreYears: 594
+  }),
+  // --- The single benchmark run both sides compute ---
+  benchmarkRun: Object.freeze({
+    // 39-bit semiprime — the paper's LARGEST successfully-factored case.
+    N: "549755813701",
+    factors: Object.freeze([712321, 771781]),
+    // ~200 s on 2048 A100s (the largest problem) — Willsch et al.
+    shorGpuSeconds: 200,
+    // ~210 ms on a single 1.2 GHz CPU core / 768 MB — FRAQTL white paper §4.2.
+    // (NOT "~10 s": that conflates the 256-bit run, ~39 s §4.3. See SOURCES #2.)
+    fraqtlSeconds: 0.21,
+    bits: 39
+  }),
+  // --- What was actually computed (so the comparison is apples-to-apples) ---
+  whatWasComputed: "39-bit QFT period extraction (Shor's quantum step)"
+});
+(function assertBaselineComplete(b) {
+  const missing = [];
+  const req = (path, val, ok = (v) => v !== void 0 && v !== null && v !== "") => {
+    if (!ok(val)) missing.push(path);
+  };
+  req("citation.authors", b.citation?.authors);
+  req("citation.title", b.citation?.title);
+  req("citation.venue", b.citation?.venue);
+  req("citation.year", b.citation?.year, (v) => Number.isFinite(v));
+  req("citation.doi", b.citation?.doi);
+  req("hardware.system", b.hardware?.system);
+  req("hardware.gpus", b.hardware?.gpus);
+  req("hardware.memory", b.hardware?.memory);
+  req("studyCompute.gpuYears", b.studyCompute?.gpuYears, (v) => Number.isFinite(v));
+  req("studyCompute.coreYears", b.studyCompute?.coreYears, (v) => Number.isFinite(v));
+  req("benchmarkRun.N", b.benchmarkRun?.N);
+  req(
+    "benchmarkRun.factors",
+    b.benchmarkRun?.factors,
+    (v) => Array.isArray(v) && v.length === 2 && v.every((x) => Number.isFinite(x))
+  );
+  req("benchmarkRun.shorGpuSeconds", b.benchmarkRun?.shorGpuSeconds, (v) => Number.isFinite(v));
+  req("benchmarkRun.fraqtlSeconds", b.benchmarkRun?.fraqtlSeconds, (v) => Number.isFinite(v));
+  req("benchmarkRun.bits", b.benchmarkRun?.bits, (v) => Number.isFinite(v));
+  req("whatWasComputed", b.whatWasComputed);
+  if (missing.length) {
+    throw new Error(
+      "qft-benchmark-baseline.js: incomplete baseline constant \u2014 missing/empty field(s): " + missing.join(", ") + ". A benchmark must not narrate against an absent baseline (FAIL-LOUD)."
+    );
+  }
+})(QFT_BENCHMARK_BASELINE);
+
+// src/browser/dist-entry.js
+function buildWasmFacade(wasmMetadata) {
+  const mod = wasmMetadata?.module ?? null;
+  const hasFn = (name) => !!mod && typeof mod[name] === "function";
+  const safeCall = (name, ...args) => {
+    if (!hasFn(name)) {
+      return { ok: false, error: `wasm-function-unavailable:${name}`, backend: wasmMetadata.mode };
+    }
+    try {
+      return { ok: true, value: mod[name](...args), backend: wasmMetadata.mode };
+    } catch (error) {
+      return { ok: false, error: String(error), backend: wasmMetadata.mode };
+    }
+  };
+  return {
+    internStr: (s) => safeCall("internStr", s),
+    internV2: (b) => safeCall("internV2", b),
+    materializeStr: (h) => safeCall("materializeStr", h),
+    materializeV2: (h) => safeCall("materializeV2", h),
+    releaseHandle: (h) => safeCall("releaseHandle", h),
+    resetScope: mod ? () => mod.resetScope() : null,
+    arenaStats: mod ? () => mod.arenaStats() : null,
+    arenaAdd: (a, b) => safeCall("arenaAdd", a, b),
+    arenaSub: (a, b) => safeCall("arenaSub", a, b),
+    arenaMul: (a, b) => safeCall("arenaMul", a, b),
+    arenaDiv: (a, b) => safeCall("arenaDiv", a, b),
+    arenaMod: (a, b) => safeCall("arenaMod", a, b),
+    arenaCmp: (a, b) => safeCall("arenaCmp", a, b),
+    arenaPow: (base, expNum, expDen) => safeCall("arenaPow", base, expNum, expDen),
+    arenaSqrt: (a) => safeCall("arenaSqrt", a),
+    arenaExp2: (a) => safeCall("arenaExp2", a),
+    arenaLog2: (a) => safeCall("arenaLog2", a),
+    arenaPpfEncode: (a) => safeCall("arenaPpfEncode", a),
+    arenaPpfDecode: (a) => safeCall("arenaPpfDecode", a),
+    arenaFromPpfJson: (j) => safeCall("arenaFromPpfJson", j),
+    arenaGetBitLength: (a) => safeCall("arenaGetBitLength", a),
+    arenaBreakToBigint: (a) => safeCall("arenaBreakToBigint", a),
+    arenaBreakToJsNumber: (a) => safeCall("arenaBreakToJsNumber", a),
+    arenaBreakToString: (a) => safeCall("arenaBreakToString", a),
+    arenaToPrimeAtoms: (a) => safeCall("arenaToPrimeAtoms", a),
+    arenaFromAtomVec: (j) => safeCall("arenaFromAtomVec", j),
+    arenaToAtomRoot: (a) => safeCall("arenaToAtomRoot", a),
+    arenaFromAtomRoot: (j) => safeCall("arenaFromAtomRoot", j),
+    arenaModPow: (b, e, m) => safeCall("arenaModPow", b, e, m),
+    arenaGcd: (a, b) => safeCall("arenaGcd", a, b),
+    arenaLcm: (a, b) => safeCall("arenaLcm", a, b),
+    arenaPolyAdd: (a, b) => safeCall("arenaPolyAdd", a, b),
+    arenaPolyMul: (a, b) => safeCall("arenaPolyMul", a, b),
+    arenaPolyDiv: (a, b) => safeCall("arenaPolyDiv", a, b),
+    arenaPolyFwd: (j, n) => safeCall("arenaPolyFwd", j, n),
+    arenaPolyInv: (j, n) => safeCall("arenaPolyInv", j, n),
+    arenaPolyEval: (p, x) => safeCall("arenaPolyEval", p, x),
+    arenaPolyGcd: (a, b) => safeCall("arenaPolyGcd", a, b)
+  };
+}
+async function createEgptMathSdk({ wasmUrl, wasmModuleUrl } = {}) {
+  const wasmMetadata = await loadEgptMathWasm({ wasmUrl, wasmModuleUrl });
+  if (wasmMetadata.mode !== "wasm-bridge") {
+    const warnings = (wasmMetadata.warnings || []).join("; ") || "(no diagnostic warnings captured)";
+    throw new Error(
+      `EGPT Math SDK: the WASM engine failed to load (mode='${wasmMetadata.mode}'). This build ships no JS math-core fallback (CEO 2026-07-10 standing rule: WASM-only publish surface). wasmUrl=${JSON.stringify(wasmUrl ?? null)} wasmModuleUrl=${JSON.stringify(wasmModuleUrl ?? null)}. Diagnostics: ${warnings}`
+    );
+  }
+  const wasmFacade = buildWasmFacade(wasmMetadata);
+  const wasmProvider = buildWasmMathProvider(wasmFacade);
+  _setActiveWasmProvider(wasmProvider);
+  return {
+    EGPTReal,
+    EGPTMath,
+    EGPTPolynomial,
+    EGPTMatrix,
+    EGPTFFT,
+    wasm: wasmFacade,
+    // Truth-in-labeling: derived from the provider actually built above —
+    // never a hardcoded literal. There is exactly one possible value in this
+    // dist ('wasm-math'), because createEgptMathSdk() throws above rather than
+    // returning an SDK object for any other outcome.
+    get activeMathBackend() {
+      return wasmProvider.id;
+    },
+    benchmarks: { qftBaseline: QFT_BENCHMARK_BASELINE },
+    metadata: { ...wasmMetadata }
+  };
+}
+export {
+  EGPTFFT,
+  EGPTMath,
+  EGPTMatrix,
+  EGPTPolynomial,
+  EGPTReal,
+  createEgptMathSdk
+};