strictjs-runtime 2.0.6 → 2.0.10

package/index.js

@@ -1,67 +1,238 @@
 import initWASM, {
-  StrictNumber,
-  StrictString,
-  get_memory,
-  HeapType,
-  StrictArray,
-  StrictForLoop,
-  StrictFunction,
-  StrictObject,
-  Schema
+  StrictNumber, StrictString, get_memory, HeapType, StrictArray, StrictForLoop, StrictFunction, StrictObject, Schema,
+  // Additional exports from your wasm file
+  StrictBoolean, StrictBigInt, StrictPromise, StrictTimeout, StrictWhileLoop, StrictAsync,
+  ThreadManager, ThreadPool, ThreadTask, GPUMemoryManager, JsGPUType, JsSIMDType, JsHeapType,
+  JsTypeCapabilities, OptimizationMode, StringEncoding, TaskPriority, ThreadPriority, ThreadState,
+  getIterator, createTensor, createVector, createMatrix, createZeros, createOnes, createRange,
+  strict_fetch, init_thread_manager, create_simd_f32x4, create_simd_i32x4, create_simd_u8x16,
+  createGPUType, getAvailableGPUTypes, createSIMDType, getAvailableSIMDTypes, getSIMDTypeForUseCase
 } from "./pkg/strictjs_runtime.js";
 
 let nodeInitWASM = null;
+let isInitialized = false;
 
-// Only import `fs` and `path` in Node environment
-if (typeof window === "undefined") {
-  const fs = await import("fs");
-  const path = await import("path");
-  const { fileURLToPath } = await import("url");
-
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path.dirname(__filename);
+/**
+ * This function dynamically loads WASM in Node.js
+ */
+async function setupNodeLoader() {
+  try {
+    const fs = await import("fs");
+    const path = await import("path");
+    const { fileURLToPath } = await import("url");
+    
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    
+    return async () => {
+      try {
+        const wasmPath = path.resolve(__dirname, "pkg/strictjs_runtime_bg.wasm");
+        
+        // Check if file exists before reading
+        if (!fs.existsSync(wasmPath)) {
+          // Try alternative path
+          const altWasmPath = path.resolve(__dirname, "strictjs_runtime_bg.wasm");
+          if (!fs.existsSync(altWasmPath)) {
+            throw new Error(`WASM file not found at ${wasmPath} or ${altWasmPath}`);
+          }
+          const wasmBuffer = fs.readFileSync(altWasmPath);
+          await initWASM(wasmBuffer);
+        } else {
+          const wasmBuffer = fs.readFileSync(wasmPath);
+          await initWASM(wasmBuffer);
+        }
+        
+        isInitialized = true;
+      } catch (error) {
+        throw new Error(`Failed to load WASM in Node.js: ${error.message}`);
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to setup Node.js loader: ${error.message}`);
+  }
+}
 
-  nodeInitWASM = async () => {
-    const wasmPath = path.resolve(__dirname, "pkg/strictjs_runtime_bg.wasm");
-    const wasmBuffer = fs.readFileSync(wasmPath);
-    await initWASM(wasmBuffer);
-  };
+// Lazy initialize Node loader if in Node.js environment
+if (typeof window === "undefined" && typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
+  nodeInitWASM = await setupNodeLoader();
 }
 
 /**
  * Initializes StrictJS Runtime
  * - Node: Loads WASM from filesystem
  * - Browser: WASM auto-fetch
+ * 
+ * @param {Object} options - Initialization options
+ * @param {string} [options.wasmPath] - Custom path to WASM file (browser only)
+ * @param {boolean} [options.sync=false] - Use synchronous initialization (Node.js only)
+ * @returns {Promise<Object>} Runtime exports
+ * @throws {Error} If initialization fails
  */
-export default async function strictInit() {
-  if (typeof window === "undefined") {
-    // Node.js environment
-    await nodeInitWASM();
-  } else {
-    // Browser environment
-    await initWASM();
+export default async function strictInit(options = {}) {
+  // Prevent multiple initializations
+  if (isInitialized) {
+    return getExports();
   }
+  
+  try {
+    if (typeof window === "undefined") {
+      // Node.js environment
+      if (!nodeInitWASM) {
+        throw new Error("Node.js loader not initialized");
+      }
+      await nodeInitWASM();
+    } else {
+      // Browser environment
+      if (options.wasmPath) {
+        // Custom WASM path
+        const response = await fetch(options.wasmPath);
+        if (!response.ok) {
+          throw new Error(`Failed to fetch WASM: ${response.statusText}`);
+        }
+        const buffer = await response.arrayBuffer();
+        await initWASM(buffer);
+      } else {
+        // Default - let the wasm bindings fetch it
+        await initWASM();
+      }
+    }
+    
+    isInitialized = true;
+    return getExports();
+  } catch (error) {
+    throw new Error(`StrictJS initialization failed: ${error.message}`);
+  }
+}
 
+/**
+ * Get runtime exports
+ * @private
+ */
+function getExports() {
   return {
+    // Core types
     StrictNumber,
     StrictString,
-    get_memory,
-    HeapType,
     StrictArray,
-    StrictForLoop,
-    StrictFunction,
+    StrictBoolean,
+    StrictBigInt,
     StrictObject,
-    Schema
+    StrictFunction,
+    StrictPromise,
+    
+    // Loops and async
+    StrictForLoop,
+    StrictWhileLoop,
+    StrictTimeout,
+    StrictAsync,
+    
+    // Threading
+    ThreadManager,
+    ThreadPool,
+    ThreadTask,
+    
+    // GPU and SIMD
+    GPUMemoryManager,
+    JsGPUType,
+    JsSIMDType,
+    JsHeapType,
+    JsTypeCapabilities,
+    
+    // Schema
+    Schema,
+    
+    // Memory
+    get_memory,
+    
+    // Enums
+    HeapType,
+    OptimizationMode,
+    StringEncoding,
+    TaskPriority,
+    ThreadPriority,
+    ThreadState,
+    
+    // Factory functions
+    getIterator,
+    createTensor,
+    createVector,
+    createMatrix,
+    createZeros,
+    createOnes,
+    createRange,
+    strict_fetch,
+    init_thread_manager,
+    create_simd_f32x4,
+    create_simd_i32x4,
+    create_simd_u8x16,
+    createGPUType,
+    getAvailableGPUTypes,
+    createSIMDType,
+    getAvailableSIMDTypes,
+    getSIMDTypeForUseCase
   };
 }
 
-// Named exports
+// Named exports for core functionality
 export {
-  get_memory,
-  HeapType,
+  // Core types
+  StrictNumber,
+  StrictString,
   StrictArray,
-  StrictForLoop,
-  StrictFunction,
+  StrictBoolean,
+  StrictBigInt,
   StrictObject,
-  Schema
-};
+  StrictFunction,
+  StrictPromise,
+  
+  // Loops and async
+  StrictForLoop,
+  StrictWhileLoop,
+  StrictTimeout,
+  StrictAsync,
+  
+  // Threading
+  ThreadManager,
+  ThreadPool,
+  ThreadTask,
+  
+  // GPU and SIMD
+  GPUMemoryManager,
+  JsGPUType,
+  JsSIMDType,
+  JsHeapType,
+  JsTypeCapabilities,
+  
+  // Schema
+  Schema,
+  
+  // Memory
+  get_memory,
+  
+  // Enums
+  HeapType,
+  OptimizationMode,
+  StringEncoding,
+  TaskPriority,
+  ThreadPriority,
+  ThreadState,
+  
+  // Factory functions
+  getIterator,
+  createTensor,
+  createVector,
+  createMatrix,
+  createZeros,
+  createOnes,
+  createRange,
+  strict_fetch,
+  init_thread_manager,
+  create_simd_f32x4,
+  create_simd_i32x4,
+  create_simd_u8x16,
+  createGPUType,
+  getAvailableGPUTypes,
+  createSIMDType,
+  getAvailableSIMDTypes,
+  getSIMDTypeForUseCase
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strictjs-runtime",
-  "version": "2.0.6",
+  "version": "2.0.10",
   "description": "A lightweight low-level runtime for StrictJS with WebAssembly support.",
   "main": "index.js",
   "module": "index.js",

package/pkg/README.md

@@ -1,20 +0,0 @@
-
-# StrictJS Runtime
-
-Type-safe JavaScript runtime with WebAssembly - Bringing Rust's safety guarantees to JavaScript.
-
-## Features
-
-- 🔒 **Type-safe numbers** with automatic clamping
-- 📏 **Bounded strings** with character limits
-- 🧮 **Safe arrays** with bounds checking
-- 🏗️ **Schema-based objects** with type guarantees
-- ⚡ **WebAssembly performance** with JavaScript convenience
-
-## Installation
-
-### CDN (Browser)
-```html
-<script type="module">
-  import { StrictNumber, HeapType, StrictString, StrictArray, StrictObject } from 'https://cdn.jsdelivr.net/npm/strictjs-runtime@latest/pkg/strictjs_runtime.js';
-</script>

package/pkg/package.json

@@ -1,24 +0,0 @@
-{
-  "name": "strictjs-runtime",
-  "type": "module",
-  "collaborators": [
-    "Your Name kennethmburu21@gmail.com"
-  ],
-  "description": "Type-safe JavaScript runtime with WebAssembly - Bringing Rust's safety guarantees to JavaScript",
-  "version": "0.1.0",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/yourusername/strictjs-runtime"
-  },
-  "files": [
-    "strictjs_runtime_bg.wasm",
-    "strictjs_runtime.js",
-    "strictjs_runtime.d.ts"
-  ],
-  "main": "strictjs_runtime.js",
-  "types": "strictjs_runtime.d.ts",
-  "sideEffects": [
-    "./snippets/*"
-  ]
-}