@areb0s/scip.js 1.1.13 → 1.2.0

package/dist/scip-wrapper.js

@@ -1,20 +1,20 @@
 /**
  * SCIP.js - SCIP Optimization Solver for JavaScript
  * High-level wrapper around SCIP WASM
- * 
+ *
  * Supports: LP, MIP, MINLP (Mixed Integer Nonlinear Programming)
- * 
+ *
  * Usage in Worker (like OpenCV):
  *   // Set base URL before loading script
  *   self.SCIP_BASE_URL = 'https://cdn.jsdelivr.net/gh/user/scip.js@v1.0.0/dist/';
- *   
+ *
  *   // Load and execute script
  *   const response = await fetch(SCIP_BASE_URL + 'scip.min.js');
  *   new Function(await response.text())();
- *   
+ *
  *   // Wait for initialization
  *   await self.SCIP.ready;
- *   
+ *
  *   // Use
  *   const result = await self.SCIP.solve(`...`);
  */
@@ -38,31 +38,42 @@ export const ready = new Promise((resolve, reject) => {
   readyReject = reject;
 });
 
+// Read version from package.json
+const packageJson = JSON.parse(
+  readFileSync(join(rootDir, "package.json"), "utf-8")
+);
+const VERSION = packageJson.version;
+
 /**
  * Default CDN base URL for WASM files
  */
-const DEFAULT_CDN_BASE = 'https://cdn.jsdelivr.net/npm/@areb0s/scip.js@1.1.6/dist/';
+const DEFAULT_CDN_BASE = `https://cdn.jsdelivr.net/npm/@areb0s/scip.js@${VERSION}/dist/`;
 
 /**
  * Get base URL from global SCIP_BASE_URL or default CDN
  */
 function getBaseUrl() {
   // Safe check for global scope (works in browser, worker, and SSR)
-  const globalScope = (typeof globalThis !== 'undefined' && globalThis) ||
-                      (typeof self !== 'undefined' && self) ||
-                      (typeof window !== 'undefined' && window) ||
-                      {};
-  
+  const globalScope =
+    (typeof globalThis !== "undefined" && globalThis) ||
+    (typeof self !== "undefined" && self) ||
+    (typeof window !== "undefined" && window) ||
+    {};
+
   // Check for explicit SCIP_BASE_URL
   if (globalScope.SCIP_BASE_URL) {
     return globalScope.SCIP_BASE_URL;
   }
-  
+
   // Check for __importMetaUrl (set by bundler)
-  if (typeof __importMetaUrl !== 'undefined' && __importMetaUrl && !__importMetaUrl.startsWith('blob:')) {
-    return __importMetaUrl.substring(0, __importMetaUrl.lastIndexOf('/') + 1);
+  if (
+    typeof __importMetaUrl !== "undefined" &&
+    __importMetaUrl &&
+    !__importMetaUrl.startsWith("blob:")
+  ) {
+    return __importMetaUrl.substring(0, __importMetaUrl.lastIndexOf("/") + 1);
   }
-  
+
   // Default to CDN
   return DEFAULT_CDN_BASE;
 }
@@ -71,22 +82,22 @@ function getBaseUrl() {
  * Solution status enum
  */
 export const Status = {
-  OPTIMAL: 'optimal',
-  INFEASIBLE: 'infeasible',
-  UNBOUNDED: 'unbounded',
-  TIME_LIMIT: 'timelimit',
-  UNKNOWN: 'unknown',
-  ERROR: 'error'
+  OPTIMAL: "optimal",
+  INFEASIBLE: "infeasible",
+  UNBOUNDED: "unbounded",
+  TIME_LIMIT: "timelimit",
+  UNKNOWN: "unknown",
+  ERROR: "error",
 };
 
 /**
  * Parse SCIP status from output
  */
 function parseStatus(output) {
-  if (output.includes('optimal solution found')) return Status.OPTIMAL;
-  if (output.includes('problem is infeasible')) return Status.INFEASIBLE;
-  if (output.includes('problem is unbounded')) return Status.UNBOUNDED;
-  if (output.includes('time limit reached')) return Status.TIME_LIMIT;
+  if (output.includes("optimal solution found")) return Status.OPTIMAL;
+  if (output.includes("problem is infeasible")) return Status.INFEASIBLE;
+  if (output.includes("problem is unbounded")) return Status.UNBOUNDED;
+  if (output.includes("time limit reached")) return Status.TIME_LIMIT;
   return Status.UNKNOWN;
 }
 
@@ -98,30 +109,30 @@ function parseStatus(output) {
 function parseSolution(output, rawSolution = null) {
   const variables = {};
   const objective = { value: null, sense: null };
-  
+
   // Use rawSolution if available (more reliable)
   const solText = rawSolution || output;
-  
+
   // Parse objective value
   const objMatch = solText.match(/objective value:\s*([\d.e+-]+)/i);
   if (objMatch) {
     objective.value = parseFloat(objMatch[1]);
   }
-  
+
   // Parse variable values from solution display
   // Match ZIMPL-style variable names: x$sun#0, effSum$star#1, b_sun_10, etc.
   // Format: variableName    value    (obj:coef)
   const varRegex = /^([\w$#]+)\s+([\d.e+-]+)/gm;
   let match;
-  
+
   while ((match = varRegex.exec(solText)) !== null) {
     const name = match[1];
     const value = parseFloat(match[2]);
-    if (!isNaN(value) && name !== 'objective' && name !== 'solution') {
+    if (!isNaN(value) && name !== "objective" && name !== "solution") {
       variables[name] = value;
     }
   }
-  
+
   return { variables, objective };
 }
 
@@ -133,21 +144,21 @@ function parseStatistics(output) {
     solvingTime: null,
     nodes: null,
     iterations: null,
-    gap: null
+    gap: null,
   };
-  
+
   const timeMatch = output.match(/Solving Time \(sec\)\s*:\s*([\d.]+)/);
   if (timeMatch) stats.solvingTime = parseFloat(timeMatch[1]);
-  
+
   const nodesMatch = output.match(/Nodes\s*:\s*(\d+)/);
   if (nodesMatch) stats.nodes = parseInt(nodesMatch[1]);
-  
+
   const iterMatch = output.match(/LP Iterations\s*:\s*(\d+)/);
   if (iterMatch) stats.iterations = parseInt(iterMatch[1]);
-  
+
   const gapMatch = output.match(/Gap\s*:\s*([\d.]+)\s*%/);
   if (gapMatch) stats.gap = parseFloat(gapMatch[1]);
-  
+
   return stats;
 }
 
@@ -164,19 +175,19 @@ export async function init(options = {}) {
   if (initPromise) {
     return initPromise;
   }
-  
+
   initPromise = (async () => {
     try {
       // Auto-detect wasmPath from SCIP_BASE_URL or script location
       const baseUrl = getBaseUrl();
-      const wasmPath = options.wasmPath || (baseUrl + 'scip.wasm');
-      
+      const wasmPath = options.wasmPath || baseUrl + "scip.wasm";
+
       // Dynamic import of the Emscripten-generated module
-      const createSCIP = (await import('./scip-core.js')).default;
-      
+      const createSCIP = (await import("./scip-core.js")).default;
+
       scipModule = await createSCIP({
         locateFile: (path) => {
-          if (path.endsWith('.wasm')) {
+          if (path.endsWith(".wasm")) {
             return wasmPath;
           }
           return path;
@@ -195,25 +206,37 @@ export async function init(options = {}) {
         // Capture abort/exit reasons for better error messages
         onAbort: (reason) => {
           lastAbortReason = reason;
-          console.error('[SCIP WASM Abort]', reason);
+          console.error("[SCIP WASM Abort]", reason);
         },
         onExit: (code) => {
           lastExitCode = code;
           if (code !== 0) {
-            console.error('[SCIP WASM Exit]', code);
+            console.error("[SCIP WASM Exit]", code);
           }
-        }
+        },
       });
-      
+
       // Create directories for problems, solutions, settings
       if (scipModule.FS) {
-        try { scipModule.FS.mkdir('/problems'); } catch (e) { /* exists */ }
-        try { scipModule.FS.mkdir('/solutions'); } catch (e) { /* exists */ }
-        try { scipModule.FS.mkdir('/settings'); } catch (e) { /* exists */ }
+        try {
+          scipModule.FS.mkdir("/problems");
+        } catch (e) {
+          /* exists */
+        }
+        try {
+          scipModule.FS.mkdir("/solutions");
+        } catch (e) {
+          /* exists */
+        }
+        try {
+          scipModule.FS.mkdir("/settings");
+        } catch (e) {
+          /* exists */
+        }
       }
-      
+
       isInitialized = true;
-      
+
       // Resolve ready promise
       if (readyResolve) {
         readyResolve();
@@ -225,7 +248,7 @@ export async function init(options = {}) {
       throw error;
     }
   })();
-  
+
   return initPromise;
 }
 
@@ -239,9 +262,9 @@ export function isReady() {
 
 /**
  * Solve an optimization problem
- * 
+ *
  * Supports LP, MIP, and MINLP (Mixed Integer Nonlinear Programming) problems.
- * 
+ *
  * @param {string} problem - Problem definition in one of the supported formats
  * @param {Object} options - Solver options
  * @param {string} options.format - Input format: 'lp', 'mps', 'zpl', 'cip' (default: 'lp')
@@ -254,7 +277,7 @@ export function isReady() {
  * @param {boolean} options.verbose - Enable verbose output
  * @param {Object} options.parameters - Additional SCIP parameters
  * @returns {Promise<Object>} Solution object
- * 
+ *
  * @example
  * // LP format (linear)
  * const result = await solve(`
@@ -266,7 +289,7 @@ export function isReady() {
  *     0 <= y <= 10
  *   End
  * `);
- * 
+ *
  * @example
  * // ZIMPL format (MINLP with nonlinear)
  * const result = await solve(`
@@ -275,7 +298,7 @@ export function isReady() {
  *   minimize cost: x^2 + y^2;
  *   subto c1: x + y >= 1;
  * `, { format: 'zpl' });
- * 
+ *
  * console.log(result.status);      // 'optimal'
  * console.log(result.objective);   // 1.0
  * console.log(result.variables);   // { x: 1, y: 0 }
@@ -284,82 +307,82 @@ export async function solve(problem, options = {}) {
   if (!isInitialized) {
     await init(options);
   }
-  
+
   const {
-    format = 'lp',
+    format = "lp",
     timeLimit = 3600,
     gap = null,
     verbose = false,
-    parameters = {}
+    parameters = {},
   } = options;
-  
+
   // Capture output
-  let stdout = '';
-  let stderr = '';
-  
+  let stdout = "";
+  let stderr = "";
+
   scipModule.onStdout = (text) => {
-    stdout += text + '\n';
-    if (verbose) console.log('[SCIP]', text);
+    stdout += text + "\n";
+    if (verbose) console.log("[SCIP]", text);
   };
-  
+
   scipModule.onStderr = (text) => {
-    stderr += text + '\n';
-    if (verbose) console.error('[SCIP Error]', text);
+    stderr += text + "\n";
+    if (verbose) console.error("[SCIP Error]", text);
   };
-  
+
   try {
     // Determine file extension based on format
-    const formatExtMap = { mps: 'mps', zpl: 'zpl', cip: 'cip', lp: 'lp' };
-    const ext = formatExtMap[format] || 'lp';
+    const formatExtMap = { mps: "mps", zpl: "zpl", cip: "cip", lp: "lp" };
+    const ext = formatExtMap[format] || "lp";
     const problemFile = `/problems/problem.${ext}`;
-    const solutionFile = '/solutions/solution.sol';
-    
+    const solutionFile = "/solutions/solution.sol";
+
     // Write problem to virtual filesystem
     scipModule.FS.writeFile(problemFile, problem);
-    
+
     // Build SCIP command
     const commands = [];
-    
+
     // Set parameters
     commands.push(`set limits time ${timeLimit}`);
-    
+
     if (gap !== null) {
       commands.push(`set limits gap ${gap}`);
     }
-    
+
     // Custom parameters
     for (const [key, value] of Object.entries(parameters)) {
       commands.push(`set ${key} ${value}`);
     }
-    
+
     // Read and solve
     commands.push(`read ${problemFile}`);
-    commands.push('optimize');
-    commands.push('display solution');
+    commands.push("optimize");
+    commands.push("display solution");
     commands.push(`write solution ${solutionFile}`);
-    commands.push('display statistics');
-    commands.push('quit');
-    
+    commands.push("display statistics");
+    commands.push("quit");
+
     // Write settings file
-    const settingsContent = commands.join('\n');
-    scipModule.FS.writeFile('/settings/commands.txt', settingsContent);
-    
+    const settingsContent = commands.join("\n");
+    scipModule.FS.writeFile("/settings/commands.txt", settingsContent);
+
     // Run SCIP with batch mode
-    const exitCode = scipModule.callMain(['-b', '/settings/commands.txt']);
-    
+    const exitCode = scipModule.callMain(["-b", "/settings/commands.txt"]);
+
     // Try to read solution file first (more reliable for parsing)
     let rawSolution = null;
     try {
-      rawSolution = scipModule.FS.readFile(solutionFile, { encoding: 'utf8' });
+      rawSolution = scipModule.FS.readFile(solutionFile, { encoding: "utf8" });
     } catch (e) {
       // Solution file may not exist if infeasible
     }
-    
+
     // Parse results
     const status = parseStatus(stdout);
     const { variables, objective } = parseSolution(stdout, rawSolution);
     const statistics = parseStatistics(stdout);
-    
+
     return {
       status,
       objective: objective.value,
@@ -367,26 +390,26 @@ export async function solve(problem, options = {}) {
       statistics,
       exitCode,
       output: verbose ? stdout : undefined,
-      rawSolution
+      rawSolution,
     };
-    
   } catch (error) {
     // Attempt to extract detailed exception message from WASM
     let errorMessage = error.message || String(error);
     let exceptionInfo = null;
-    
+
     // Check if this is a WASM exception (pointer address)
-    if (typeof error === 'number' || /^\d+$/.test(String(error))) {
-      const ptr = typeof error === 'number' ? error : parseInt(String(error), 10);
-      
+    if (typeof error === "number" || /^\d+$/.test(String(error))) {
+      const ptr =
+        typeof error === "number" ? error : parseInt(String(error), 10);
+
       // Try to get exception message using Emscripten's exception handling
       if (scipModule) {
         try {
           // Modern Emscripten exception handling
-          if (typeof scipModule.getExceptionMessage === 'function') {
+          if (typeof scipModule.getExceptionMessage === "function") {
             exceptionInfo = scipModule.getExceptionMessage(ptr);
             errorMessage = `WASM Exception: ${exceptionInfo}`;
-          } else if (typeof scipModule.UTF8ToString === 'function') {
+          } else if (typeof scipModule.UTF8ToString === "function") {
             // Fallback: try to read as string from memory
             try {
               const str = scipModule.UTF8ToString(ptr);
@@ -394,18 +417,20 @@ export async function solve(problem, options = {}) {
                 exceptionInfo = str;
                 errorMessage = `WASM Exception: ${str}`;
               }
-            } catch (e) { /* not a valid string pointer */ }
+            } catch (e) {
+              /* not a valid string pointer */
+            }
           }
         } catch (e) {
-          console.error('[SCIP] Failed to get exception message:', e);
+          console.error("[SCIP] Failed to get exception message:", e);
         }
       }
-      
+
       if (!exceptionInfo) {
         errorMessage = `WASM Exception (ptr: ${ptr}). Enable exception handling in build for details.`;
       }
     }
-    
+
     return {
       status: Status.ERROR,
       error: errorMessage,
@@ -416,9 +441,9 @@ export async function solve(problem, options = {}) {
         exitCode: lastExitCode,
         type: typeof error,
         stdout: stdout,
-        stderr: stderr
+        stderr: stderr,
       },
-      output: stdout + stderr
+      output: stdout + stderr,
     };
   } finally {
     // Reset exception tracking
@@ -426,15 +451,17 @@ export async function solve(problem, options = {}) {
     lastExitCode = null;
     // Cleanup all possible problem files
     const cleanupFiles = [
-      '/problems/problem.lp',
-      '/problems/problem.mps',
-      '/problems/problem.zpl',
-      '/problems/problem.cip',
-      '/solutions/solution.sol',
-      '/settings/commands.txt'
+      "/problems/problem.lp",
+      "/problems/problem.mps",
+      "/problems/problem.zpl",
+      "/problems/problem.cip",
+      "/solutions/solution.sol",
+      "/settings/commands.txt",
     ];
     for (const file of cleanupFiles) {
-      try { scipModule.FS.unlink(file); } catch (e) {}
+      try {
+        scipModule.FS.unlink(file);
+      } catch (e) {}
     }
   }
 }
@@ -445,8 +472,8 @@ export async function solve(problem, options = {}) {
  */
 export async function minimize(problem, options = {}) {
   // LP format uses "Minimize" keyword, ensure it's present
-  if (!problem.toLowerCase().includes('minimize')) {
-    problem = 'Minimize\n' + problem;
+  if (!problem.toLowerCase().includes("minimize")) {
+    problem = "Minimize\n" + problem;
   }
   return solve(problem, options);
 }
@@ -457,8 +484,8 @@ export async function minimize(problem, options = {}) {
  */
 export async function maximize(problem, options = {}) {
   // LP format uses "Maximize" keyword
-  if (!problem.toLowerCase().includes('maximize')) {
-    problem = 'Maximize\n' + problem;
+  if (!problem.toLowerCase().includes("maximize")) {
+    problem = "Maximize\n" + problem;
   }
   return solve(problem, options);
 }
@@ -470,12 +497,14 @@ export async function version() {
   if (!isInitialized) {
     await init();
   }
-  
-  let output = '';
-  scipModule.onStdout = (text) => { output += text + '\n'; };
-  
-  scipModule.callMain(['--version']);
-  
+
+  let output = "";
+  scipModule.onStdout = (text) => {
+    output += text + "\n";
+  };
+
+  scipModule.callMain(["--version"]);
+
   return output.trim();
 }
 
@@ -486,13 +515,15 @@ export async function getParameters() {
   if (!isInitialized) {
     await init();
   }
-  
-  let output = '';
-  scipModule.onStdout = (text) => { output += text + '\n'; };
-  
-  scipModule.FS.writeFile('/settings/params.txt', 'set\nquit\n');
-  scipModule.callMain(['-b', '/settings/params.txt']);
-  
+
+  let output = "";
+  scipModule.onStdout = (text) => {
+    output += text + "\n";
+  };
+
+  scipModule.FS.writeFile("/settings/params.txt", "set\nquit\n");
+  scipModule.callMain(["-b", "/settings/params.txt"]);
+
   return output;
 }
 
@@ -506,5 +537,5 @@ export default {
   maximize,
   version,
   getParameters,
-  Status
+  Status,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@areb0s/scip.js",
-  "version": "1.1.13",
+  "version": "1.2.0",
   "description": "SCIP Optimization Solver compiled to WebAssembly - LP, MIP, and MINLP support",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",