@ohtaman/washi 0.0.0-stage → 0.1.1

package/dist/lib/z3-C8g-PtmP.js

@@ -0,0 +1,582 @@
+import { t as e } from "./glpk-BC32ZaPG.js";
+//#region src/modeler/boolean-expr.ts
+var t = 0, n = class {
+	and(e) {
+		return new i("and", [this, e]);
+	}
+	or(e) {
+		return new i("or", [this, e]);
+	}
+	implies(e) {
+		return new i("implies", [this, e]);
+	}
+	xor(e) {
+		return new i("xor", [this, e]);
+	}
+	not() {
+		return new i("not", [this]);
+	}
+}, r = class extends n {
+	id;
+	name;
+	value = null;
+	constructor(e) {
+		super(), this.id = ++t, this.name = e || `p_${this.id}`;
+	}
+	toString() {
+		return this.name;
+	}
+}, i = class extends n {
+	op;
+	children;
+	constructor(e, t) {
+		super(), this.op = e, this.children = t;
+	}
+	toString() {
+		return this.op === "not" ? `not(${this.children[0].toString()})` : `(${this.children.map((e) => e.toString()).join(` ${this.op} `)})`;
+	}
+};
+function a(...e) {
+	if (e.length === 0) throw Error("and() requires at least one expression");
+	return new i("and", e);
+}
+function o(...e) {
+	if (e.length === 0) throw Error("or() requires at least one expression");
+	return new i("or", e);
+}
+function s(e) {
+	return new i("not", [e]);
+}
+function c(e, t) {
+	return new i("implies", [e, t]);
+}
+function l(...e) {
+	if (e.length === 0) throw Error("xor() requires at least one expression");
+	return new i("xor", e);
+}
+//#endregion
+//#region src/modeler/constraint.ts
+var u = 0, d = class {
+	id;
+	lhs;
+	sense;
+	rhs;
+	name;
+	slack = null;
+	dual = null;
+	constructor(e, t, n, r) {
+		this.id = ++u, this.lhs = e, this.sense = t, this.rhs = n, this.name = r || `c_${this.id}`;
+	}
+	get pi() {
+		return this.dual;
+	}
+	and(e) {
+		return new i("and", [this, e]);
+	}
+	or(e) {
+		return new i("or", [this, e]);
+	}
+	implies(e) {
+		return new i("implies", [this, e]);
+	}
+	xor(e) {
+		return new i("xor", [this, e]);
+	}
+	not() {
+		return new i("not", [this]);
+	}
+	toString() {
+		let e = this.sense === "==" ? "=" : this.sense;
+		return `${this.name}: ${this.lhs.toString()} ${e} ${this.rhs}`;
+	}
+}, f = "https://cdn.jsdelivr.net/npm/highs@1.15.3/build/highs.wasm", p = null, m = null;
+function h(e) {
+	m = e, p = null;
+}
+function g() {
+	return m;
+}
+function _(e) {
+	return e.length >= 4 && e[0] === 0 && e[1] === 97 && e[2] === 115 && e[3] === 109;
+}
+async function v(e) {
+	try {
+		let t = await fetch(e, { headers: { Range: "bytes=0-3" } });
+		if (!t.ok || (t.headers.get("content-type") || "").includes("text/html")) return !1;
+		if (!t.body) return !0;
+		let n = t.body.getReader(), { value: r, done: i } = await n.read();
+		return await n.cancel(), i || !r || r.length < 4 ? !1 : _(r);
+	} catch {
+		return !1;
+	}
+}
+async function y(e) {
+	if (e) return e;
+	if (m) return m;
+	let t = typeof window < "u" ? new URL("/highs.wasm", window.location.origin).href : typeof self < "u" && self.location ? new URL("highs.wasm", self.location.href).href : "/highs.wasm";
+	return await v(t) ? t : (typeof console < "u" && console.info && console.info(`[WaSHI] Local highs.wasm not found or invalid at "${t}". Automatically falling back to official CDN: ${f}`), f);
+}
+async function b(e = {}) {
+	return p || (p = (async () => {
+		let t = await import("highs"), n = t.default || t;
+		if (typeof process < "u" && process.versions && process.versions.node && process.type !== "renderer") return await n();
+		let r = await y(e.wasmUrl);
+		return await n({ locateFile: (e) => e.endsWith(".wasm") ? r : e });
+	})(), p);
+}
+async function x(e, t = {}) {
+	let n = await b(t), r = performance.now(), i = { output_flag: t.outputFlag ?? !1 };
+	return t.timeLimit !== void 0 && (i.time_limit = t.timeLimit), t.presolve !== void 0 && (i.presolve = t.presolve), t.solver !== void 0 && (i.solver = t.solver), t.relGap !== void 0 && (i.mip_rel_gap = t.relGap), t.absGap !== void 0 && (i.mip_abs_gap = t.absGap), {
+		result: n.solve(e, i),
+		runTime: (performance.now() - r) / 1e3
+	};
+}
+//#endregion
+//#region src/highs-worker-client.ts
+var S = null, C = 0, w = /* @__PURE__ */ new Map();
+function T() {
+	if (typeof window > "u" || typeof Worker > "u") return null;
+	if (!S) try {
+		S = new Worker(new URL(
+			/* @vite-ignore */
+			"/assets/highs-worker-DeDWU6KI.js",
+			"" + import.meta.url
+		), { type: "module" }), S.onmessage = (e) => {
+			let { type: t, id: n, result: r, runTime: i, error: a } = e.data, o = w.get(n);
+			o && (w.delete(n), t === "SOLVE_SUCCESS" ? o.resolve({
+				result: r,
+				runTime: i
+			}) : o.reject(Error(a || "Worker solve failed")));
+		}, S.onerror = (e) => {
+			console.error("HiGHS Web Worker error:", e);
+		};
+	} catch (e) {
+		console.warn("Could not instantiate Web Worker, falling back to main thread:", e), S = null;
+	}
+	return S;
+}
+async function E(e, t = {}) {
+	let n = t.useWorker ?? typeof window < "u" ? T() : null;
+	if (!n) return x(e, t);
+	let r = await y(t.wasmUrl), i = {
+		...t,
+		wasmUrl: r
+	}, a = `req_${++C}`;
+	return new Promise((t, r) => {
+		w.set(a, {
+			resolve: t,
+			reject: r
+		}), n.postMessage({
+			type: "SOLVE",
+			id: a,
+			lpString: e,
+			options: i
+		});
+	});
+}
+//#endregion
+//#region src/modeler/solvers/highs.ts
+var D = class e {
+	static capabilities = {
+		supportsMIP: !0,
+		supportsQP: !0
+	};
+	name = "HiGHS";
+	version = "1.15.3";
+	capabilities = e.capabilities;
+	options;
+	constructor(e = {}) {
+		this.options = e;
+	}
+	async solve(e, t, n = {}) {
+		let r = {
+			...this.options,
+			...n
+		}, { lpString: i, nameToVar: a, nameToConstraint: o } = t, { result: s, runTime: c } = await E(i, r), l = s.Status || "Unknown", u;
+		u = l.includes("Optimal") ? "Optimal" : l.includes("Infeasible") ? "Infeasible" : l.includes("Unbounded") ? "Unbounded" : l.includes("TimeLimit") || l.includes("Time limit") ? "TimeLimit" : l.includes("IterationLimit") ? "IterationLimit" : "Optimal";
+		let d = s.ObjectiveValue, f = typeof d == "number" ? d + e.objective.constant : null, p = {}, m = {}, h = {}, g = {};
+		if (s.Columns) for (let [e, t] of Object.entries(s.Columns)) {
+			let n = a.get(e);
+			if (n) {
+				let e = Math.abs(t.Primal) < 1e-9 ? 0 : t.Primal;
+				p[n.name] = e, t.Dual !== void 0 && (h[n.name] = Math.abs(t.Dual) < 1e-9 ? 0 : t.Dual);
+			}
+		}
+		if (s.Rows) {
+			let e = Array.isArray(s.Rows) ? s.Rows : Object.values(s.Rows);
+			for (let t of e) {
+				let e = t.Name, n = o.get(e);
+				if (n && (t.Dual !== void 0 && (m[n.name] = Math.abs(t.Dual) < 1e-9 ? 0 : t.Dual), t.Primal !== void 0)) {
+					let e = n.rhs - t.Primal;
+					g[n.name] = Math.abs(e) < 1e-9 ? 0 : e;
+				}
+			}
+		}
+		return {
+			status: u,
+			objectiveValue: f,
+			values: p,
+			reducedCosts: h,
+			duals: m,
+			slacks: g,
+			runTime: c,
+			raw: s
+		};
+	}
+}, O = D, k = class {
+	name;
+	capabilities;
+	options;
+	constructor(e = {}) {
+		this.name = e.name || "MockSolver", this.capabilities = e.capabilities || {
+			supportsMIP: !0,
+			supportsQP: !0
+		}, this.options = e;
+	}
+	async solve(e, t, n = {}) {
+		let r = {
+			...this.options,
+			...n
+		};
+		return r.delayMs && r.delayMs > 0 && await new Promise((e) => setTimeout(e, r.delayMs)), {
+			status: r.status || "Optimal",
+			objectiveValue: r.objectiveValue ?? 0,
+			values: r.values || {},
+			reducedCosts: r.reducedCosts,
+			duals: r.duals,
+			slacks: r.slacks,
+			runTime: .001,
+			raw: { mock: !0 }
+		};
+	}
+}, A = /* @__PURE__ */ new Map();
+A.set("highs", (e) => new D(e)), A.set("glpk", (t) => new e(t)), A.set("mock", (e) => new k(e));
+var j = (e) => new D(e);
+function M(e, t) {
+	A.set(e.toLowerCase(), t);
+}
+function N(e) {
+	if (typeof e == "string") {
+		let t = A.get(e.toLowerCase());
+		if (!t) throw Error(`Solver '${e}' is not registered.`);
+		j = t;
+	} else j = typeof e == "function" ? e : () => e;
+}
+function P(e, t) {
+	if (!e) return j(t);
+	if (typeof e == "string") {
+		let n = A.get(e.toLowerCase());
+		if (!n) throw Error(`Solver '${e}' not found. Available solvers: ${F().join(", ")}`);
+		return n(t);
+	}
+	return e;
+}
+function F() {
+	return Array.from(A.keys());
+}
+//#endregion
+//#region src/modeler/solvers/z3.ts
+var I = null;
+async function L() {
+	return I ||= (async () => {
+		try {
+			return await (await import("z3-solver")).init();
+		} catch (e) {
+			throw Error(`Failed to load z3-solver. Ensure it is installed: npm install z3-solver. Error: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	})(), I;
+}
+var R = class {
+	name = "z3";
+	capabilities = {
+		supportsMIP: !0,
+		supportsQP: !1,
+		supportsSMT: !0,
+		supportsUnsatCore: !0
+	};
+	createContextTranslator(e) {
+		let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+		function a(n) {
+			if (!t.has(n.name)) {
+				let r = n.type === "Continuous" || n.type === "CONTINUOUS" ? e.Real.const(n.name) : e.Int.const(n.name);
+				t.set(n.name, r);
+			}
+			return t.get(n.name);
+		}
+		function o(t) {
+			if (!n.has(t.name)) {
+				let r = e.Bool.const(t.name);
+				n.set(t.name, r);
+			}
+			return n.get(t.name);
+		}
+		function s(t) {
+			let n = null;
+			if (t && t.terms) for (let [e, r] of t.terms.entries()) {
+				let t = a(e).mul(r);
+				n = n === null ? t : n.add(t);
+			}
+			let r = t && typeof t.constant == "number" ? t.constant : 0;
+			if (r !== 0 || n === null) {
+				let t = e.Real.val(r);
+				n = n === null ? t : n.add(t);
+			}
+			return n;
+		}
+		function c(t) {
+			let n = null;
+			if (t.linearTerms) for (let [e, r] of t.linearTerms.entries()) {
+				let t = a(e).mul(r);
+				n = n === null ? t : n.add(t);
+			}
+			if (t.quadTerms) for (let e of t.quadTerms.values()) {
+				let t = a(e.var1), r = a(e.var2), i = t.mul(r).mul(e.coeff);
+				n = n === null ? i : n.add(i);
+			}
+			let r = t && typeof t.constant == "number" ? t.constant : 0;
+			if (r !== 0 || n === null) {
+				let t = e.Real.val(r);
+				n = n === null ? t : n.add(t);
+			}
+			return n;
+		}
+		function l(e) {
+			let t = e.lhs instanceof Object && "quadTerms" in e.lhs ? c(e.lhs) : s(e.lhs), n = typeof e.rhs == "number" ? e.rhs : 0;
+			return e.sense === "<=" ? t.le(n) : e.sense === ">=" ? t.ge(n) : t.eq(n);
+		}
+		function u(t) {
+			if (t instanceof r) return o(t);
+			if (t instanceof d) return l(t);
+			if (t instanceof i) switch (t.op) {
+				case "and": return e.And(...t.children.map(u));
+				case "or": return e.Or(...t.children.map(u));
+				case "not": return e.Not(u(t.children[0]));
+				case "implies": return e.Implies(u(t.children[0]), u(t.children[1]));
+				case "xor": return e.Xor(u(t.children[0]), u(t.children[1]));
+				default: throw Error(`Unsupported boolean operation: ${t.op}`);
+			}
+			throw Error(`Unknown logic element: ${String(t)}`);
+		}
+		function f(e) {
+			if (!e) return 0;
+			if (typeof e.asNumber == "function") return e.asNumber();
+			let t = e.toString();
+			if (t.startsWith("(/ ")) {
+				let e = t.slice(3, -1).trim().split(/\s+/);
+				if (e.length === 2) return Number(e[0]) / Number(e[1]);
+			}
+			return Number(t);
+		}
+		return {
+			getVarAst: a,
+			getBoolVarAst: o,
+			translateLinExpr: s,
+			translateQuadExpr: c,
+			translateConstraint: l,
+			translateBoolExpr: u,
+			parseAstValue: f,
+			varAstMap: t,
+			boolVarAstMap: n
+		};
+	}
+	async check(e, t = {}) {
+		if (typeof window < "u" && window.document !== void 0) return this.fallbackCheck(e);
+		try {
+			let { Context: t } = await L(), n = new t(`check_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`), r = new n.Solver(), i = this.createContextTranslator(n), a = e.variables || e.vars || [], o = e.boolVars || [], s = e.constraints || [], c = e.logicalConstraints || [];
+			for (let e of a) {
+				let t = i.getVarAst(e);
+				e.lb !== -Infinity && r.add(t.ge(e.lb)), e.ub !== Infinity && r.add(t.le(e.ub)), (e.type === "Binary" || e.type === "BINARY") && (r.add(t.ge(0)), r.add(t.le(1)));
+			}
+			for (let e of s) {
+				let t = i.translateConstraint(e), a = n.Bool.const(e.name);
+				r.addAndTrack(t, a);
+			}
+			for (let e = 0; e < c.length; e++) {
+				let t = c[e], a = t && t.name || `lc_${e + 1}`, o = t && t.expr || t, s = i.translateBoolExpr(o), l = n.Bool.const(a);
+				r.addAndTrack(s, l);
+			}
+			let l = (await r.check()).toString();
+			if (l === "sat") {
+				let e = r.model(), t = {};
+				for (let n of a) {
+					let r = i.getVarAst(n), a = e.eval(r);
+					t[n.name] = i.parseAstValue(a);
+				}
+				for (let n of o) {
+					let r = i.getBoolVarAst(n), a = e.eval(r);
+					t[n.name] = a.toString() === "true";
+				}
+				return {
+					status: "Sat",
+					values: t
+				};
+			}
+			if (l === "unsat") {
+				let e = r.unsatCore(), t = [], n = typeof e.length == "function" ? e.length() : e.length;
+				for (let r = 0; r < n; r++) t.push(e.get(r).toString());
+				return {
+					status: "Unsat",
+					values: {},
+					unsatCore: t
+				};
+			}
+			return {
+				status: "Unknown",
+				values: {}
+			};
+		} catch {
+			return this.fallbackCheck(e);
+		}
+	}
+	fallbackCheck(e) {
+		let t = performance.now(), n = e.variables || e.vars || [], a = e.boolVars || [], o = e.constraints || [], s = e.logicalConstraints || [];
+		function c(e, t) {
+			let n = e.constant || 0;
+			if (e.terms && e.terms instanceof Map) for (let [r, i] of e.terms.entries()) {
+				let e = typeof r == "string" ? r : r.name;
+				n += i * (t.get(e) ?? 0);
+			}
+			return n;
+		}
+		function l(e, t) {
+			let n = c(e.lhs, t), r = 1e-6;
+			return e.sense === "<=" ? n <= e.rhs + r : e.sense === ">=" ? n >= e.rhs - r : e.sense === "==" && Math.abs(n - e.rhs) <= r;
+		}
+		function u(e, t, n) {
+			if (e instanceof r) return t.get(e.name) ?? !1;
+			if (e instanceof d) return l(e, n);
+			if (e instanceof i) switch (e.op) {
+				case "and": return e.children.every((e) => u(e, t, n));
+				case "or": return e.children.some((e) => u(e, t, n));
+				case "not": return !u(e.children[0], t, n);
+				case "implies": return !u(e.children[0], t, n) || u(e.children[1], t, n);
+				case "xor": return u(e.children[0], t, n) !== u(e.children[1], t, n);
+			}
+			return !1;
+		}
+		let f = /* @__PURE__ */ new Map();
+		for (let e of n) {
+			let t = /* @__PURE__ */ new Set();
+			e.lb !== -Infinity && t.add(e.lb), e.ub !== Infinity && t.add(e.ub), t.add(0);
+			for (let n of o) if (n.lhs.terms && n.lhs.terms.has(e)) {
+				let r = n.lhs.terms.get(e) || 1, i = (n.rhs - (n.lhs.constant || 0)) / r;
+				t.add(i), t.add(i - 1), t.add(i + 1);
+			}
+			for (let n of s) {
+				let r = n.expr || n, a = (n) => {
+					if (n instanceof d) {
+						if (n.lhs.terms && n.lhs.terms.has(e)) {
+							let r = n.lhs.terms.get(e) || 1, i = (n.rhs - (n.lhs.constant || 0)) / r;
+							t.add(i), t.add(i - 1), t.add(i + 1);
+						}
+					} else n instanceof i && n.children.forEach(a);
+				};
+				a(r);
+			}
+			if ((e.type === "Integer" || e.type === "INTEGER") && e.lb >= 0 && e.ub <= 25) for (let n = e.lb; n <= e.ub; n++) t.add(n);
+			f.set(e.name, Array.from(t).filter((t) => t >= (e.lb ?? -Infinity) && t <= (e.ub ?? Infinity)));
+		}
+		function p(e, t) {
+			let r = a.map((e) => e.name), i = 1 << r.length, o = n.map((e) => e.name), s = [/* @__PURE__ */ new Map()];
+			for (let e of o) {
+				let t = f.get(e) || [0], n = [];
+				for (let r of s) for (let i of t) {
+					let t = new Map(r);
+					t.set(e, i), n.push(t);
+				}
+				s = n.slice(0, 500);
+			}
+			for (let n = 0; n < i; n++) {
+				let i = /* @__PURE__ */ new Map();
+				for (let e = 0; e < r.length; e++) i.set(r[e], !!(n & 1 << e));
+				for (let n of s) if (e.every((e) => l(e, n)) && t.every((e) => u(e.expr, i, n))) return {
+					isSat: !0,
+					boolMap: i,
+					numMap: n
+				};
+			}
+			return { isSat: !1 };
+		}
+		let m = s.map((e, t) => ({
+			name: e?.name || `lc_${t + 1}`,
+			expr: e?.expr || e
+		})), h = p(o, m), g = (performance.now() - t) / 1e3;
+		if (h.isSat && h.boolMap && h.numMap) {
+			let e = {};
+			for (let [t, n] of h.numMap.entries()) e[t] = n;
+			for (let [t, n] of h.boolMap.entries()) e[t] = n;
+			return {
+				status: "Sat",
+				values: e,
+				runTime: g
+			};
+		}
+		let _ = [];
+		for (let e = 0; e < o.length; e++) p(o.filter((t, n) => n !== e), m).isSat && _.push(o[e].name);
+		for (let e = 0; e < m.length; e++) p(o, m.filter((t, n) => n !== e)).isSat && _.push(m[e].name);
+		return {
+			status: "Unsat",
+			values: {},
+			unsatCore: _.length > 0 ? _ : o.map((e) => e.name),
+			runTime: g
+		};
+	}
+	async solve(e, t, n = {}) {
+		if (!(e.objective !== null && e.objective !== void 0 && ("terms" in e.objective && e.objective.terms.size > 0 || "quadTerms" in e.objective && e.objective.quadTerms.length > 0 || e.objective.offset && e.objective.offset !== 0))) {
+			let t = await this.check(e, n), r = {};
+			for (let [e, n] of Object.entries(t.values)) r[e] = typeof n == "boolean" ? +!!n : n;
+			return {
+				status: t.status === "Sat" ? "Optimal" : t.status === "Unsat" ? "Infeasible" : "Error",
+				objectiveValue: 0,
+				values: r
+			};
+		}
+		let { Context: r } = await L(), i = new r(`opt_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`), a = new i.Optimize(), o = this.createContextTranslator(i), s = e.variables || e.vars || [], c = e.boolVars || [], l = e.constraints || [], u = e.logicalConstraints || [];
+		for (let e of s) {
+			let t = o.getVarAst(e);
+			e.lb !== -Infinity && a.add(t.ge(e.lb)), e.ub !== Infinity && a.add(t.le(e.ub)), (e.type === "Binary" || e.type === "BINARY") && (a.add(t.ge(0)), a.add(t.le(1)));
+		}
+		for (let e of l) {
+			let t = o.translateConstraint(e);
+			a.add(t);
+		}
+		for (let e of u) {
+			let t = e && e.expr || e, n = o.translateBoolExpr(t);
+			a.add(n);
+		}
+		let d = e.objective instanceof Object && "quadTerms" in e.objective ? o.translateQuadExpr(e.objective) : o.translateLinExpr(e.objective);
+		(e.sense || "MINIMIZE").toUpperCase() === "MAXIMIZE" ? a.maximize(d) : a.minimize(d);
+		let f = (await a.check()).toString();
+		if (f === "sat") {
+			let e = a.model(), t = {};
+			for (let n of s) {
+				let r = o.getVarAst(n), i = e.eval(r);
+				t[n.name] = o.parseAstValue(i);
+			}
+			for (let n of c) {
+				let r = o.getBoolVarAst(n), i = e.eval(r);
+				t[n.name] = +(i.toString() === "true");
+			}
+			return {
+				status: "Optimal",
+				objectiveValue: o.parseAstValue(e.eval(d)),
+				values: t
+			};
+		}
+		return f === "unsat" ? {
+			status: "Infeasible",
+			objectiveValue: null,
+			values: {}
+		} : {
+			status: "Error",
+			objectiveValue: null,
+			values: {}
+		};
+	}
+};
+function z() {
+	M("z3", () => new R());
+}
+z();
+//#endregion
+export { c as C, l as E, a as S, o as T, x as _, M as a, i as b, O as c, b as d, g as f, h as g, y as h, F as i, D as l, v as m, z as n, N as o, _ as p, P as r, k as s, R as t, f as u, d as v, s as w, r as x, n as y };

package/dist/types/glpk-loader.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Loader for GLPK (GNU Linear Programming Kit) WebAssembly / JS engine.
+ * Supports both Node.js (glpk.js/node) and modern browsers (glpk.js worker).
+ */
+type GlpkInstance = any;
+export declare function getGlpk(): Promise<GlpkInstance>;
+export {};
+//# sourceMappingURL=glpk-loader.d.ts.map

package/dist/types/glpk-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glpk-loader.d.ts","sourceRoot":"","sources":["../../src/glpk-loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,KAAK,YAAY,GAAG,GAAG,CAAC;AAIxB,wBAAsB,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CA0BrD"}

package/dist/types/highs-loader.d.ts

@@ -0,0 +1,55 @@
+import type { SolveOptions } from "./modeler/types.js";
+export declare const OFFICIAL_HIGHS_CDN_WASM_URL = "https://cdn.jsdelivr.net/npm/highs@1.15.3/build/highs.wasm";
+type HighsInstance = any;
+export declare function setHighsWasmUrl(url: string | null): void;
+export declare function getHighsWasmUrl(): string | null;
+/**
+ * Check if the given byte array begins with the standard WebAssembly magic header (\0asm).
+ */
+export declare function isValidWasmHeader(bytes: Uint8Array): boolean;
+/**
+ * Probe a URL to determine whether it serves a valid WebAssembly binary
+ * without downloading the entire file. Cancels the stream after checking the first chunk.
+ */
+export declare function probeWasmUrl(url: string): Promise<boolean>;
+/**
+ * Resolve the HiGHS WASM URL for browser / worker environments.
+ * - Explicit URLs (customWasmUrl or options.wasmUrl) are strictly used (no CDN fallback).
+ * - Default resolution probes the local origin; if missing or returning HTML, falls back to the official CDN.
+ */
+export declare function resolveBrowserWasmUrl(explicitUrl?: string): Promise<string>;
+/**
+ * Get or initialize the HiGHS WebAssembly solver instance.
+ * Works seamlessly in Node.js, Web Browsers, and Web Workers.
+ */
+export declare function getHighs(options?: SolveOptions): Promise<HighsInstance>;
+export interface RawHighsSolveResult {
+    Status: string;
+    ObjectiveValue: number;
+    Columns: Record<string, {
+        Index: number;
+        Lower: number;
+        Upper: number;
+        Type: string;
+        Primal: number;
+        Dual?: number;
+        Name: string;
+    }>;
+    Rows?: Record<string, {
+        Index: number;
+        Lower: number;
+        Upper: number;
+        Dual?: number;
+        Primal?: number;
+        Name: string;
+    }>;
+}
+/**
+ * Solve an LP formatted model using HiGHS WASM
+ */
+export declare function solveLpWithHighs(lpString: string, options?: SolveOptions): Promise<{
+    result: RawHighsSolveResult;
+    runTime: number;
+}>;
+export {};
+//# sourceMappingURL=highs-loader.d.ts.map

package/dist/types/highs-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highs-loader.d.ts","sourceRoot":"","sources":["../../src/highs-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,+DACsB,CAAC;AAE/D,KAAK,aAAa,GAAG,GAAG,CAAC;AAKzB,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,QAIjD;AAED,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAE/C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAQ5D;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAgChE;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BjF;AAED;;;GAGG;AACH,wBAAsB,QAAQ,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,aAAa,CAAC,CAoCjF;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;QACtB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CA6B3D"}

package/dist/types/highs-worker-client.d.ts

@@ -0,0 +1,12 @@
+import type { SolveOptions } from "./modeler/types.js";
+import { type RawHighsSolveResult } from "./highs-loader.js";
+/**
+ * Solve an LP model either in a background Web Worker or on the current thread
+ */
+export declare function solveLp(lpString: string, options?: SolveOptions & {
+    useWorker?: boolean;
+}): Promise<{
+    result: RawHighsSolveResult;
+    runTime: number;
+}>;
+//# sourceMappingURL=highs-worker-client.d.ts.map

package/dist/types/highs-worker-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highs-worker-client.d.ts","sourceRoot":"","sources":["../../src/highs-worker-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,mBAAmB,CAAC;AAgD3B;;GAEG;AACH,wBAAsB,OAAO,CAC3B,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,YAAY,GAAG;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACnD,OAAO,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAyB3D"}

package/dist/types/highs-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=highs-worker.d.ts.map

package/dist/types/highs-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highs-worker.d.ts","sourceRoot":"","sources":["../../src/highs-worker.ts"],"names":[],"mappings":""}

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * opt-ts: Modern Mathematical Optimization Modeler for TypeScript & JavaScript
+ *
+ * Elegant PuLP/python-mip style modeling with WebAssembly (HiGHS) and pluggable solvers.
+ * Supports LP (Linear Programming), MIP (Mixed-Integer Programming), and QP (Quadratic Programming).
+ */
+export { Model, type ModelOptions, Var, type VarOptions, LinExpr, sum, xsum, lpSum, QuadExpr, type QuadTerm, Constraint, BoolVar, BoolExpr, BoolOp, and, or, not, implies, xor, parseExpr, parseConstraint, expr, c, generateLpString, type LpModelData, type LpExportResult, } from "./modeler/index.js";
+export type { VarType, OptimizationSense, ComparisonSense, SolverStatus, SolveOptions, SolverSolution, } from "./modeler/types.js";
+export { LpProblem, LpVariable, LpMinimize, LpMaximize, LpContinuous, LpInteger, LpBinary, LpStatus, value, } from "./modeler/pulp-compat.js";
+export { MipModel, MINIMIZE, MAXIMIZE, CONTINUOUS, INTEGER, BINARY, maximize, minimize, } from "./modeler/mip-compat.js";
+export { type Solver, type SolverOptions, type SolverResult, type SolverCheckResult, type SolverCapabilities, HighsSolver, HiGHS, GLPKSolver, Z3Solver, registerZ3Solver, MockSolver, registerSolver, getSolver, setDefaultSolver, listAvailableSolvers, } from "./modeler/solvers/index.js";
+export { getHighs, solveLpWithHighs, setHighsWasmUrl, getHighsWasmUrl, OFFICIAL_HIGHS_CDN_WASM_URL, isValidWasmHeader, probeWasmUrl, resolveBrowserWasmUrl, } from "./highs-loader.js";
+export { getGlpk } from "./glpk-loader.js";
+//# sourceMappingURL=index.d.ts.map