opendi-js 0.1.0

package/README.md

@@ -0,0 +1,278 @@
+# opendi-js
+
+WebAssembly bindings for the OpenDI math and machine learning library. Compiles the pure C99 engine to WASM via Emscripten and wraps it with an idiomatic JavaScript API.
+
+Works in Node.js, Deno, Bun, and browsers.
+
+## Features
+
+- **Primitive Operations** - add, subtract, multiply, divide, abs, min, max, round, pow
+- **Calculus** - Forward/backward/central difference, second derivative, nth derivative, Romberg integration
+- **Linear Algebra** - Vectors (add, dot, cross, norm, scale) and matrices (multiply, add, scale, transpose)
+- **Activations** - relu, sigmoid, softmax
+- **Loss Functions** - MSE, cross-entropy
+- **Backward Functions** - Gradient computation for activations and matrix operations
+- **Optimizers** - SGD weight updates
+- **Random** - Seeded uniform and normal distributions
+- **Statistics** - Z-score normalization
+- **Pipeline** - Batch activations, dense layers, loss gradients, weight initialization
+- **Session API** - Pointer-level arena control for training loops
+- **Zero Copy Overhead** - WASM heap operations, no serialization
+
+## Two-Tier API
+
+### Tier 1: Simple Functions
+
+Pass JavaScript arrays, get results back. Memory is managed automatically.
+
+```js
+import { init } from 'opendi-js'
+
+const o = await init()
+
+o.add(1, 2, 3)                    // 6
+o.softmax([1, 2, 3])              // Float64Array [0.09, 0.24, 0.66]
+o.matmul([1,2,3,4], [5,6,7,8], 2, 2, 2)  // Float64Array [19,22,43,50]
+o.forwarddiff(x => x * x, 3, 0.001)      // ~6.0
+```
+
+### Tier 2: Session API
+
+For training loops where performance matters. Work with WASM pointers directly, control arena memory manually.
+
+```js
+const session = o.createSession(65536)
+
+const inputPtr = session.writeArray([0.1, 0.3, 0.7, 0.9])
+const targetPtr = session.writeArray([0, 0, 1, 1])
+
+const fwd = session.denseForward(inputPtr, weights._ptr, 4, 1, 1, 'sigmoid')
+const loss = session.mseLoss(fwd.outputPtr, targetPtr, 4)
+
+session.clear()    // reuse arena memory between epochs
+session.destroy()  // free arena when done
+```
+
+## Quick Start
+
+### Install
+
+```bash
+npm install opendi-js
+```
+
+### ESM
+
+```js
+import { init } from 'opendi-js'
+const o = await init()
+```
+
+### CommonJS
+
+```js
+const { init } = require('opendi-js')
+const o = await init()
+```
+
+## API Reference
+
+### Primitives
+
+```js
+o.add(1, 2, 3)          // 6 (variadic)
+o.subtract(10, 3)       // 7 (variadic)
+o.multiply(2, 3, 4)     // 24 (variadic)
+o.divide(100, 5, 2)     // 10 (variadic)
+o.abs(-5)               // 5
+o.min(3, 1, 2)          // 1 (variadic)
+o.max(3, 1, 2)          // 3 (variadic)
+o.round('floor', 3.7)   // 3 ('floor', 'ceil', 'round')
+o.pow(2, 10)            // 1024
+```
+
+### Activations
+
+```js
+o.relu(5)               // 5
+o.relu(-5)              // 0
+o.sigmoid(0)            // 0.5
+o.softmax([1, 2, 3])    // Float64Array (sums to 1.0)
+```
+
+### Vectors
+
+```js
+o.vecadd([1,2,3], [4,5,6])    // Float64Array [5,7,9]
+o.vecscale([1,2,3], 2)        // Float64Array [2,4,6]
+o.veccross([1,0,0], [0,1,0])  // Float64Array [0,0,1]
+o.vecdot([1,2,3], [4,5,6])    // 32
+o.vecnorm([3, 4])             // 5
+```
+
+### Matrices
+
+All matrices are flat arrays in row-major order.
+
+```js
+o.matmul([1,2,3,4], [5,6,7,8], 2, 2, 2)    // Float64Array [19,22,43,50]
+o.matadd([1,2,3,4], [10,20,30,40], 2, 2)    // Float64Array [11,22,33,44]
+o.matscale([1,2,3,4], 3, 2, 2)              // Float64Array [3,6,9,12]
+o.mattranspose([1,2,3,4,5,6], 2, 3)         // Float64Array [1,4,2,5,3,6]
+```
+
+### Loss Functions
+
+```js
+o.mseLoss([1,2,3], [1,2,3])    // 0 (perfect prediction)
+o.crossEntropy(pred, targets)   // cross-entropy loss
+```
+
+### Backward (Gradients)
+
+```js
+o.reluBackward(dout, input)                   // Float64Array
+o.sigmoidBackward(dout, output)               // Float64Array
+o.softmaxBackward(dout, output)               // Float64Array
+o.matmulBackwardA(dout, b, m, n, p)           // Float64Array (gradient w.r.t. A)
+o.matmulBackwardB(a, dout, m, n, p)           // Float64Array (gradient w.r.t. B)
+```
+
+### Optimizer
+
+```js
+o.sgdUpdate([1,2,3], [0.1,0.2,0.3], 1.0)    // Float64Array [0.9, 1.8, 2.7]
+```
+
+### Random
+
+```js
+o.randomSeed(42)
+o.randomUniform(0, 1, 5)      // Float64Array of 5 values in [0, 1]
+o.randomNormal(0, 1, 5)       // Float64Array of 5 values ~ N(0, 1)
+```
+
+### Statistics
+
+```js
+o.normalize([2,4,4,4,5,5,7,9])    // Float64Array (mean ~0, std ~1)
+```
+
+### Calculus
+
+Pass regular JavaScript functions. They are compiled to WASM function pointers internally.
+
+```js
+o.forwarddiff(x => x*x, 3, 0.001)         // ~6.0
+o.backwarddiff(x => x*x, 3, 0.001)        // ~6.0
+o.centralDifference(x => x*x, 3, 0.001)   // ~6.0
+o.secondDerivative(x => x*x, 3, 0.001)    // ~2.0
+o.centralNth(x => x*x, 3, 0.001, 2)       // ~2.0 (nth derivative)
+o.rombergIntegrate(x => x*x, 0, 1, 1e-8, 10)  // ~0.333
+```
+
+### Pipeline
+
+```js
+o.batchRelu([-1, 2, -3, 4])           // Float64Array [0,2,0,4]
+o.batchSigmoid([0, 0])                // Float64Array [0.5, 0.5]
+o.batchSoftmax(input, rows, cols)     // Float64Array (per-row softmax)
+o.batchNormalize(features, n, nFeat)  // Float64Array (z-score normalized)
+o.mseBackward(pred, targets)          // Float64Array (MSE gradient)
+o.crossEntropyBackward(pred, targets, nSamples, nClasses)  // Float64Array
+o.accuracy(pred, labels, nSamples, nClasses)               // number
+```
+
+### Weights
+
+```js
+o.randomSeed(42)
+const w = o.initWeights(10, 0.0, 0.1)
+w.data      // Float64Array of 10 values
+w._ptr      // WASM pointer (for session API)
+w.length    // 10
+w.free()    // free the malloc'd memory
+```
+
+### Session API
+
+```js
+const session = o.createSession(65536)
+
+session.writeArray([1, 2, 3])          // returns WASM pointer
+session.writeI32Array([0, 1, 2])       // returns WASM pointer (int32)
+session.readArray(ptr, 3)              // Float64Array from pointer
+session.copyToPtr(destPtr, srcArray)   // write JS array to existing pointer
+
+// All math functions available with pointer args:
+session.vecadd(aPtr, bPtr, n)
+session.matmul(aPtr, bPtr, m, n, p)
+session.denseForward(inputPtr, weightsPtr, m, n, p, 'sigmoid')
+session.denseBackward(doutPtr, inputPtr, weightsPtr, cachePtr, m, n, p, 'sigmoid')
+session.sgdUpdate(weightsPtr, gradsPtr, lr, n)
+session.mseLoss(predPtr, targetsPtr, n)
+
+session.clear()      // arena_clear() - reuse memory
+session.destroy()    // arena_destroy() - free arena
+```
+
+## Training Loop Example
+
+```js
+import { init } from 'opendi-js'
+
+const o = await init()
+o.randomSeed(42)
+
+const features = [0.1, 0.3, 0.7, 0.9]
+const targets = [0, 0, 1, 1]
+const nSamples = 4, nFeatures = 1
+
+const weights = o.initWeights(nFeatures, 0.0, 0.1)
+const session = o.createSession(65536)
+
+for (let epoch = 0; epoch < 200; epoch++) {
+	const featPtr = session.writeArray(features)
+	const targPtr = session.writeArray(targets)
+
+	const fwd = session.denseForward(featPtr, weights._ptr, nSamples, nFeatures, 1, 'sigmoid')
+	const loss = session.mseLoss(fwd.outputPtr, targPtr, nSamples)
+
+	const dLoss = session.mseBackward(fwd.outputPtr, targPtr, nSamples)
+	const grad = session.denseBackward(dLoss, featPtr, weights._ptr, fwd.cachePtr, nSamples, nFeatures, 1, 'sigmoid')
+
+	const newWPtr = session.sgdUpdate(weights._ptr, grad.dWeightsPtr, 1.0, nFeatures)
+	session.copyToPtr(weights._ptr, session.readArray(newWPtr, nFeatures))
+
+	session.clear()
+}
+
+session.destroy()
+weights.free()
+```
+
+## Building from Source
+
+Requires [Emscripten](https://emscripten.org/).
+
+```bash
+cd opendi-js
+bash scripts/build.sh
+```
+
+Produces `build/opendi.js` and `build/opendi.wasm`.
+
+## Testing
+
+```bash
+node test/test.mjs
+```
+
+## Documentation
+
+API documentation is in `docs/`. Each function group has its own documentation file organized by module.
+
+## See Also
+
+- [OpenDI C Library](../README.md) - The underlying C99 engine
+- [API Documentation](docs/) - Detailed function reference

package/build/opendi.js

@@ -0,0 +1,2 @@
+async function createOpenDI(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("module");var require=createRequire(import.meta.url)}var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");if(_scriptName.startsWith("file:")){scriptDirectory=require("path").dirname(require("url").fileURLToPath(_scriptName))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var isFileURI=filename=>filename.startsWith("file://");var readyPromiseResolve,readyPromiseReject;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["__wasm_call_ctors"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("opendi.wasm")}return new URL("opendi.wasm",import.meta.url).href}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={env:wasmImports,wasi_snapshot_preview1:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);function getValue(ptr,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":return HEAP8[ptr];case"i8":return HEAP8[ptr];case"i16":return HEAP16[ptr>>1];case"i32":return HEAP32[ptr>>2];case"i64":return HEAP64[ptr>>3];case"float":return HEAPF32[ptr>>2];case"double":return HEAPF64[ptr>>3];case"*":return HEAPU32[ptr>>2];default:abort(`invalid type for getValue: ${type}`)}}var noExitRuntime=true;function setValue(ptr,value,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":HEAP8[ptr]=value;break;case"i8":HEAP8[ptr]=value;break;case"i16":HEAP16[ptr>>1]=value;break;case"i32":HEAP32[ptr>>2]=value;break;case"i64":HEAP64[ptr>>3]=BigInt(value);break;case"float":HEAPF32[ptr>>2]=value;break;case"double":HEAPF64[ptr>>3]=value;break;case"*":HEAPU32[ptr>>2]=value;break;default:abort(`invalid type for setValue: ${type}`)}}var stackRestore=val=>__emscripten_stack_restore(val);var stackSave=()=>_emscripten_stack_get_current();var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func(...cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};var wasmTableMirror=[];var getWasmTableEntry=funcPtr=>{var func=wasmTableMirror[funcPtr];if(!func){wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func};var updateTableMap=(offset,count)=>{if(functionsInTableMap){for(var i=offset;i<offset+count;i++){var item=getWasmTableEntry(i);if(item){functionsInTableMap.set(item,i)}}}};var functionsInTableMap;var getFunctionAddress=func=>{if(!functionsInTableMap){functionsInTableMap=new WeakMap;updateTableMap(0,wasmTable.length)}return functionsInTableMap.get(func)||0};var freeTableIndexes=[];var getEmptyTableSlot=()=>{if(freeTableIndexes.length){return freeTableIndexes.pop()}return wasmTable["grow"](1)};var setWasmTableEntry=(idx,func)=>{wasmTable.set(idx,func);wasmTableMirror[idx]=wasmTable.get(idx)};var uleb128EncodeWithLen=arr=>{const n=arr.length;return[n%128|128,n>>7,...arr]};var wasmTypeCodes={i:127,p:127,j:126,f:125,d:124,e:111};var generateTypePack=types=>uleb128EncodeWithLen(Array.from(types,type=>{var code=wasmTypeCodes[type];return code}));var convertJsFunctionToWasm=(func,sig)=>{var bytes=Uint8Array.of(0,97,115,109,1,0,0,0,1,...uleb128EncodeWithLen([1,96,...generateTypePack(sig.slice(1)),...generateTypePack(sig[0]==="v"?"":sig[0])]),2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var module=new WebAssembly.Module(bytes);var instance=new WebAssembly.Instance(module,{e:{f:func}});var wrappedFunc=instance.exports["f"];return wrappedFunc};var addFunction=(func,sig)=>{var rtn=getFunctionAddress(func);if(rtn){return rtn}var ret=getEmptyTableSlot();try{setWasmTableEntry(ret,func)}catch(err){if(!(err instanceof TypeError)){throw err}var wrapped=convertJsFunctionToWasm(func,sig);setWasmTableEntry(ret,wrapped)}functionsInTableMap.set(func,ret);return ret};var removeFunction=index=>{functionsInTableMap.delete(getWasmTableEntry(index));setWasmTableEntry(index,null);freeTableIndexes.push(index)};{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["ccall"]=ccall;Module["cwrap"]=cwrap;Module["addFunction"]=addFunction;Module["removeFunction"]=removeFunction;Module["setValue"]=setValue;Module["getValue"]=getValue;Module["UTF8ToString"]=UTF8ToString;Module["stringToUTF8"]=stringToUTF8;Module["lengthBytesUTF8"]=lengthBytesUTF8;var _exponents,_roundval,_absolute,_random_normal,_random_seed,_random_uniform,_cross_entropy,_mse_loss,_centralnth,_forwarddiff,_central_difference,_secondderivative,_backwarddiff,_romberg_integrate,_free,_matmul_backward_a,_mattranspose,_matmul,_matmul_backward_b,_softmax_backward,_sigmoid_backward,_relu_backward,_normalize,_batch_sigmoid,_sigmoid,_batch_normalize,_init_weights,_malloc,_batch_softmax,_dense_forward,_relu,_dense_backward,_accuracy,_cross_entropy_backward,_batch_relu,_mse_backward,_matadd,_matscale,_vecdot,_vecscale,_vecnorm,_veccross,_vecadd,_sgd_update,_softmax,_glue_arena_create,_glue_arena_push,_glue_arena_clear,_glue_arena_destroy,_glue_add,_glue_subtract,_glue_multiply,_glue_divide,_glue_min,_glue_max,_glue_dense_forward,_glue_get_cache_ptr,_glue_dense_backward,_glue_get_dw_ptr,_glue_get_di_ptr,_glue_free,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,memory,__indirect_function_table,wasmMemory,wasmTable;function assignWasmExports(wasmExports){_exponents=Module["_exponents"]=wasmExports["exponents"];_roundval=Module["_roundval"]=wasmExports["roundval"];_absolute=Module["_absolute"]=wasmExports["absolute"];_random_normal=Module["_random_normal"]=wasmExports["random_normal"];_random_seed=Module["_random_seed"]=wasmExports["random_seed"];_random_uniform=Module["_random_uniform"]=wasmExports["random_uniform"];_cross_entropy=Module["_cross_entropy"]=wasmExports["cross_entropy"];_mse_loss=Module["_mse_loss"]=wasmExports["mse_loss"];_centralnth=Module["_centralnth"]=wasmExports["centralnth"];_forwarddiff=Module["_forwarddiff"]=wasmExports["forwarddiff"];_central_difference=Module["_central_difference"]=wasmExports["central_difference"];_secondderivative=Module["_secondderivative"]=wasmExports["secondderivative"];_backwarddiff=Module["_backwarddiff"]=wasmExports["backwarddiff"];_romberg_integrate=Module["_romberg_integrate"]=wasmExports["romberg_integrate"];_free=Module["_free"]=wasmExports["free"];_matmul_backward_a=Module["_matmul_backward_a"]=wasmExports["matmul_backward_a"];_mattranspose=Module["_mattranspose"]=wasmExports["mattranspose"];_matmul=Module["_matmul"]=wasmExports["matmul"];_matmul_backward_b=Module["_matmul_backward_b"]=wasmExports["matmul_backward_b"];_softmax_backward=Module["_softmax_backward"]=wasmExports["softmax_backward"];_sigmoid_backward=Module["_sigmoid_backward"]=wasmExports["sigmoid_backward"];_relu_backward=Module["_relu_backward"]=wasmExports["relu_backward"];_normalize=Module["_normalize"]=wasmExports["normalize"];_batch_sigmoid=Module["_batch_sigmoid"]=wasmExports["batch_sigmoid"];_sigmoid=Module["_sigmoid"]=wasmExports["sigmoid"];_batch_normalize=Module["_batch_normalize"]=wasmExports["batch_normalize"];_init_weights=Module["_init_weights"]=wasmExports["init_weights"];_malloc=Module["_malloc"]=wasmExports["malloc"];_batch_softmax=Module["_batch_softmax"]=wasmExports["batch_softmax"];_dense_forward=Module["_dense_forward"]=wasmExports["dense_forward"];_relu=Module["_relu"]=wasmExports["relu"];_dense_backward=Module["_dense_backward"]=wasmExports["dense_backward"];_accuracy=Module["_accuracy"]=wasmExports["accuracy"];_cross_entropy_backward=Module["_cross_entropy_backward"]=wasmExports["cross_entropy_backward"];_batch_relu=Module["_batch_relu"]=wasmExports["batch_relu"];_mse_backward=Module["_mse_backward"]=wasmExports["mse_backward"];_matadd=Module["_matadd"]=wasmExports["matadd"];_matscale=Module["_matscale"]=wasmExports["matscale"];_vecdot=Module["_vecdot"]=wasmExports["vecdot"];_vecscale=Module["_vecscale"]=wasmExports["vecscale"];_vecnorm=Module["_vecnorm"]=wasmExports["vecnorm"];_veccross=Module["_veccross"]=wasmExports["veccross"];_vecadd=Module["_vecadd"]=wasmExports["vecadd"];_sgd_update=Module["_sgd_update"]=wasmExports["sgd_update"];_softmax=Module["_softmax"]=wasmExports["softmax"];_glue_arena_create=Module["_glue_arena_create"]=wasmExports["glue_arena_create"];_glue_arena_push=Module["_glue_arena_push"]=wasmExports["glue_arena_push"];_glue_arena_clear=Module["_glue_arena_clear"]=wasmExports["glue_arena_clear"];_glue_arena_destroy=Module["_glue_arena_destroy"]=wasmExports["glue_arena_destroy"];_glue_add=Module["_glue_add"]=wasmExports["glue_add"];_glue_subtract=Module["_glue_subtract"]=wasmExports["glue_subtract"];_glue_multiply=Module["_glue_multiply"]=wasmExports["glue_multiply"];_glue_divide=Module["_glue_divide"]=wasmExports["glue_divide"];_glue_min=Module["_glue_min"]=wasmExports["glue_min"];_glue_max=Module["_glue_max"]=wasmExports["glue_max"];_glue_dense_forward=Module["_glue_dense_forward"]=wasmExports["glue_dense_forward"];_glue_get_cache_ptr=Module["_glue_get_cache_ptr"]=wasmExports["glue_get_cache_ptr"];_glue_dense_backward=Module["_glue_dense_backward"]=wasmExports["glue_dense_backward"];_glue_get_dw_ptr=Module["_glue_get_dw_ptr"]=wasmExports["glue_get_dw_ptr"];_glue_get_di_ptr=Module["_glue_get_di_ptr"]=wasmExports["glue_get_di_ptr"];_glue_free=Module["_glue_free"]=wasmExports["glue_free"];__emscripten_stack_restore=wasmExports["_emscripten_stack_restore"];__emscripten_stack_alloc=wasmExports["_emscripten_stack_alloc"];_emscripten_stack_get_current=wasmExports["emscripten_stack_get_current"];memory=wasmMemory=Module["wasmMemory"]=wasmExports["memory"];__indirect_function_table=wasmTable=wasmExports["__indirect_function_table"]}var wasmImports={emscripten_resize_heap:_emscripten_resize_heap};function run(){preRun();function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})}
+;return moduleRtn}export default createOpenDI;

package/opendi.d.ts

@@ -0,0 +1,157 @@
+export interface Weights {
+	/** Raw WASM pointer — use with Session API */
+	_ptr: number
+	/** Copy of the weight data as Float64Array */
+	data: Float64Array
+	/** Number of weights */
+	length: number
+	/** Free the underlying malloc'd memory */
+	free(): void
+}
+
+export interface ForwardResult {
+	/** WASM pointer to output array */
+	outputPtr: number
+	/** WASM pointer to cache (for backward pass), or 0 if softmax/none */
+	cachePtr: number
+}
+
+export interface BackwardResult {
+	/** WASM pointer to weight gradients (n × p) */
+	dWeightsPtr: number
+	/** WASM pointer to input gradients (m × n) */
+	dInputPtr: number
+}
+
+export type Activation = 'none' | 'relu' | 'sigmoid' | 'softmax' | number
+
+export interface Session {
+	writeArray(arr: ArrayLike<number>): number
+	writeI32Array(arr: ArrayLike<number>): number
+	readArray(ptr: number, n: number): Float64Array
+	/** Copy a JS array into a WASM pointer (e.g. malloc'd weights) */
+	copyToPtr(destPtr: number, srcArray: ArrayLike<number>): void
+
+	softmax(inputPtr: number, n: number): number
+	vecadd(aPtr: number, bPtr: number, n: number): number
+	vecscale(arrPtr: number, scalar: number, n: number): number
+	matmul(aPtr: number, bPtr: number, m: number, n: number, p: number): number
+	matadd(aPtr: number, bPtr: number, m: number, n: number): number
+	matscale(aPtr: number, s: number, m: number, n: number): number
+	mattranspose(aPtr: number, m: number, n: number): number
+
+	reluBackward(doutPtr: number, inputPtr: number, n: number): number
+	sigmoidBackward(doutPtr: number, outputPtr: number, n: number): number
+	softmaxBackward(doutPtr: number, outputPtr: number, n: number): number
+	matmulBackwardA(doutPtr: number, bPtr: number, m: number, n: number, p: number): number
+	matmulBackwardB(aPtr: number, doutPtr: number, m: number, n: number, p: number): number
+
+	sgdUpdate(weightsPtr: number, gradsPtr: number, lr: number, n: number): number
+
+	normalize(ptr: number, n: number): number
+	batchRelu(ptr: number, n: number): number
+	batchSigmoid(ptr: number, n: number): number
+	batchSoftmax(ptr: number, rows: number, cols: number): number
+	batchNormalize(ptr: number, nSamples: number, nFeatures: number): number
+
+	mseBackward(predPtr: number, targetsPtr: number, n: number): number
+	crossEntropyBackward(predPtr: number, targetsPtr: number, nSamples: number, nClasses: number): number
+
+	randomUniform(min: number, max: number, n: number): number
+	randomNormal(mean: number, std: number, n: number): number
+
+	denseForward(inputPtr: number, weightsPtr: number, m: number, n: number, p: number, activation: Activation): ForwardResult
+	denseBackward(doutPtr: number, inputPtr: number, weightsPtr: number, cachePtr: number, m: number, n: number, p: number, activation: Activation): BackwardResult
+
+	mseLoss(predPtr: number, targetsPtr: number, n: number): number
+	crossEntropy(predPtr: number, targetsPtr: number, n: number): number
+	accuracy(predPtr: number, labelsPtr: number, nSamples: number, nClasses: number): number
+
+	clear(): void
+	destroy(): void
+}
+
+export interface OpenDI {
+	// Primitives
+	add(...nums: number[]): number
+	subtract(...nums: number[]): number
+	multiply(...nums: number[]): number
+	divide(...nums: number[]): number
+	abs(x: number): number
+	min(...nums: number[]): number
+	max(...nums: number[]): number
+	round(mode: 'floor' | 'ceil', x: number): number
+	pow(base: number, exp: number): number
+
+	// Activations
+	relu(x: number): number
+	sigmoid(x: number): number
+	softmax(arr: ArrayLike<number>): Float64Array
+
+	// Vectors
+	vecadd(a: ArrayLike<number>, b: ArrayLike<number>): Float64Array
+	vecscale(arr: ArrayLike<number>, scalar: number): Float64Array
+	veccross(a: ArrayLike<number>, b: ArrayLike<number>): Float64Array
+	vecdot(a: ArrayLike<number>, b: ArrayLike<number>): number
+	vecnorm(arr: ArrayLike<number>): number
+
+	// Matrices
+	matmul(a: ArrayLike<number>, b: ArrayLike<number>, m: number, n: number, p: number): Float64Array
+	matadd(a: ArrayLike<number>, b: ArrayLike<number>, m: number, n: number): Float64Array
+	matscale(a: ArrayLike<number>, s: number, m: number, n: number): Float64Array
+	mattranspose(a: ArrayLike<number>, m: number, n: number): Float64Array
+
+	// Loss
+	mseLoss(pred: ArrayLike<number>, targets: ArrayLike<number>): number
+	crossEntropy(pred: ArrayLike<number>, targets: ArrayLike<number>): number
+
+	// Backward
+	reluBackward(dout: ArrayLike<number>, input: ArrayLike<number>): Float64Array
+	sigmoidBackward(dout: ArrayLike<number>, output: ArrayLike<number>): Float64Array
+	softmaxBackward(dout: ArrayLike<number>, output: ArrayLike<number>): Float64Array
+	matmulBackwardA(dout: ArrayLike<number>, b: ArrayLike<number>, m: number, n: number, p: number): Float64Array
+	matmulBackwardB(a: ArrayLike<number>, dout: ArrayLike<number>, m: number, n: number, p: number): Float64Array
+
+	// Optimizer
+	sgdUpdate(weights: ArrayLike<number>, grads: ArrayLike<number>, lr: number): Float64Array
+
+	// Random
+	randomSeed(seed: number): void
+	randomUniform(min: number, max: number, n: number): Float64Array
+	randomNormal(mean: number, std: number, n: number): Float64Array
+
+	// Statistics
+	normalize(arr: ArrayLike<number>): Float64Array
+
+	// Calculus
+	forwarddiff(f: (x: number) => number, x: number, h: number): number
+	backwarddiff(f: (x: number) => number, x: number, h: number): number
+	centralDifference(f: (x: number) => number, x: number, h: number): number
+	secondDerivative(f: (x: number) => number, x: number, h: number): number
+	centralNth(f: (x: number) => number, x: number, h: number, n: number): number
+	rombergIntegrate(f: (x: number) => number, a: number, b: number, eps: number, kMax: number): number
+
+	// Pipeline
+	batchRelu(input: ArrayLike<number>): Float64Array
+	batchSigmoid(input: ArrayLike<number>): Float64Array
+	batchSoftmax(input: ArrayLike<number>, rows: number, cols: number): Float64Array
+	batchNormalize(features: ArrayLike<number>, nSamples: number, nFeatures: number): Float64Array
+	mseBackward(pred: ArrayLike<number>, targets: ArrayLike<number>): Float64Array
+	crossEntropyBackward(pred: ArrayLike<number>, targets: ArrayLike<number>, nSamples: number, nClasses: number): Float64Array
+	accuracy(pred: ArrayLike<number>, labels: ArrayLike<number>, nSamples: number, nClasses: number): number
+
+	// Weights
+	initWeights(n: number, mean: number, std: number): Weights
+
+	// Session
+	createSession(arenaBytes?: number): Session
+
+	// Constants
+	readonly ACTIVATION_NONE: 0
+	readonly ACTIVATION_RELU: 1
+	readonly ACTIVATION_SIGMOID: 2
+	readonly ACTIVATION_SOFTMAX: 3
+}
+
+export function init(wasmUrl?: string): Promise<OpenDI>
+export default init

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "opendi-js",
+	"version": "0.1.0",
+	"description": "WASM + JS bindings for the OpenDI math/ML library",
+	"type": "module",
+	"main": "./src/opendi.cjs",
+	"module": "./src/opendi.mjs",
+	"types": "./opendi.d.ts",
+	"exports": {
+		".": {
+			"import": "./src/opendi.mjs",
+			"require": "./src/opendi.cjs"
+		}
+	},
+	"scripts": {
+		"build": "bash scripts/build.sh"
+	},
+	"files": [
+		"src/opendi.mjs",
+		"src/opendi.cjs",
+		"build/",
+		"opendi.d.ts"
+	],
+	"keywords": [
+		"wasm",
+		"math",
+		"ml",
+		"linear-algebra",
+		"neural-network",
+		"opendi"
+	],
+	"license": "MIT",
+	"author": "itscool2b",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/itscool2b/OpenDI.git",
+		"directory": "opendi-js"
+	},
+	"homepage": "https://github.com/itscool2b/OpenDI/tree/master/opendi-js"
+}

package/src/opendi.cjs

@@ -0,0 +1,4 @@
+module.exports.init = async function(wasmUrl) {
+	const { init } = await import('./opendi.mjs')
+	return init(wasmUrl)
+}

package/src/opendi.mjs

@@ -0,0 +1,613 @@
+import createOpenDI from '../build/opendi.js'
+
+// Activation enum values matching C ActivationType
+const ACT = { none: 0, relu: 1, sigmoid: 2, softmax: 3 }
+
+function actEnum(str) {
+	if (typeof str === 'number') return str
+	const v = ACT[(str || 'none').toLowerCase()]
+	if (v === undefined) throw new Error(`Unknown activation: ${str}`)
+	return v
+}
+
+// ── Heap helpers ──
+
+function writeF64(wasm, arena, arr) {
+	const bytes = arr.length * 8
+	const ptr = wasm._glue_arena_push(arena, bytes)
+	if (!ptr) throw new Error('Arena out of memory')
+	const heap = new Float64Array(wasm.wasmMemory.buffer, ptr, arr.length)
+	heap.set(arr)
+	return ptr
+}
+
+function readF64(wasm, ptr, n) {
+	const offset = ptr / 8
+	return new Float64Array(wasm.wasmMemory.buffer.slice(ptr, ptr + n * 8))
+}
+
+function writeI32(wasm, arena, arr) {
+	const bytes = arr.length * 4
+	const ptr = wasm._glue_arena_push(arena, bytes)
+	if (!ptr) throw new Error('Arena out of memory')
+	const heap = new Int32Array(wasm.wasmMemory.buffer, ptr, arr.length)
+	heap.set(arr)
+	return ptr
+}
+
+function readI32(wasm, ptr, n) {
+	return new Int32Array(wasm.wasmMemory.buffer.slice(ptr, ptr + n * 4))
+}
+
+// ── Temp arena pattern ──
+
+function withTempArena(wasm, bytes, fn) {
+	const arena = wasm._glue_arena_create(bytes)
+	try {
+		return fn(arena)
+	} finally {
+		wasm._glue_arena_destroy(arena)
+	}
+}
+
+// ── Function pointer helpers for calculus ──
+// Cache function pointers to avoid removeFunction bugs in Emscripten.
+// Each unique JS function gets one WASM table slot.
+const fpCache = new Map()
+
+function withFunctionPointer(wasm, jsFn, cb) {
+	let fp = fpCache.get(jsFn)
+	if (fp === undefined) {
+		fp = wasm.addFunction(jsFn, 'dd')
+		fpCache.set(jsFn, fp)
+	}
+	return cb(fp)
+}
+
+// ── Main init ──
+
+export async function init(wasmUrl) {
+	const opts = {}
+	if (wasmUrl) {
+		opts.locateFile = () => wasmUrl
+	}
+	const wasm = await createOpenDI(opts)
+
+	const api = {}
+
+	// ── Primitives (variadic → array-based via glue) ──
+
+	api.add = (...nums) => {
+		const arr = nums.flat()
+		return withTempArena(wasm, arr.length * 8 + 64, (arena) => {
+			const ptr = writeF64(wasm, arena, arr)
+			return wasm._glue_add(ptr, arr.length)
+		})
+	}
+
+	api.subtract = (...nums) => {
+		const arr = nums.flat()
+		return withTempArena(wasm, arr.length * 8 + 64, (arena) => {
+			const ptr = writeF64(wasm, arena, arr)
+			return wasm._glue_subtract(ptr, arr.length)
+		})
+	}
+
+	api.multiply = (...nums) => {
+		const arr = nums.flat()
+		return withTempArena(wasm, arr.length * 8 + 64, (arena) => {
+			const ptr = writeF64(wasm, arena, arr)
+			return wasm._glue_multiply(ptr, arr.length)
+		})
+	}
+
+	api.divide = (...nums) => {
+		const arr = nums.flat()
+		return withTempArena(wasm, arr.length * 8 + 64, (arena) => {
+			const ptr = writeF64(wasm, arena, arr)
+			return wasm._glue_divide(ptr, arr.length)
+		})
+	}
+
+	api.abs = (x) => wasm._absolute(x)
+
+	api.min = (...nums) => {
+		const arr = nums.flat()
+		return withTempArena(wasm, arr.length * 8 + 64, (arena) => {
+			const ptr = writeF64(wasm, arena, arr)
+			return wasm._glue_min(ptr, arr.length)
+		})
+	}
+
+	api.max = (...nums) => {
+		const arr = nums.flat()
+		return withTempArena(wasm, arr.length * 8 + 64, (arena) => {
+			const ptr = writeF64(wasm, arena, arr)
+			return wasm._glue_max(ptr, arr.length)
+		})
+	}
+
+	api.round = (mode, x) => {
+		return withTempArena(wasm, 64, (arena) => {
+			const strBytes = wasm.lengthBytesUTF8(mode) + 1
+			const strPtr = wasm._glue_arena_push(arena, strBytes)
+			wasm.stringToUTF8(mode, strPtr, strBytes)
+			return wasm._roundval(strPtr, x)
+		})
+	}
+
+	api.pow = (base, exp) => wasm._exponents(base, exp)
+
+	// ── Activations ──
+
+	api.relu = (x) => wasm._relu(x)
+
+	api.sigmoid = (x) => wasm._sigmoid(x)
+
+	api.softmax = (arr) => {
+		const input = Array.isArray(arr) ? arr : Array.from(arr)
+		const n = input.length
+		return withTempArena(wasm, n * 8 * 3 + 256, (arena) => {
+			const inPtr = writeF64(wasm, arena, input)
+			const outPtr = wasm._softmax(arena, inPtr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	// ── Vectors ──
+
+	api.vecadd = (a, b) => {
+		const n = a.length
+		return withTempArena(wasm, n * 8 * 3 + 256, (arena) => {
+			const aPtr = writeF64(wasm, arena, a)
+			const bPtr = writeF64(wasm, arena, b)
+			const outPtr = wasm._vecadd(arena, aPtr, bPtr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	api.vecscale = (arr, scalar) => {
+		const n = arr.length
+		return withTempArena(wasm, n * 8 * 2 + 256, (arena) => {
+			const ptr = writeF64(wasm, arena, arr)
+			const outPtr = wasm._vecscale(arena, ptr, scalar, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	api.veccross = (a, b) => {
+		return withTempArena(wasm, 6 * 8 + 256, (arena) => {
+			const aPtr = writeF64(wasm, arena, a)
+			const bPtr = writeF64(wasm, arena, b)
+			const outPtr = wasm._veccross(arena, aPtr, bPtr)
+			return readF64(wasm, outPtr, 3)
+		})
+	}
+
+	api.vecdot = (a, b) => {
+		const n = a.length
+		return withTempArena(wasm, n * 8 * 2 + 256, (arena) => {
+			const aPtr = writeF64(wasm, arena, a)
+			const bPtr = writeF64(wasm, arena, b)
+			return wasm._vecdot(aPtr, bPtr, n)
+		})
+	}
+
+	api.vecnorm = (arr) => {
+		const n = arr.length
+		return withTempArena(wasm, n * 8 + 256, (arena) => {
+			const ptr = writeF64(wasm, arena, arr)
+			return wasm._vecnorm(ptr, n)
+		})
+	}
+
+	// ── Matrices ──
+
+	api.matmul = (a, b, m, n, p) => {
+		return withTempArena(wasm, (m * n + n * p + m * p) * 8 + 256, (arena) => {
+			const aPtr = writeF64(wasm, arena, a)
+			const bPtr = writeF64(wasm, arena, b)
+			const outPtr = wasm._matmul(arena, aPtr, bPtr, m, n, p)
+			return readF64(wasm, outPtr, m * p)
+		})
+	}
+
+	api.matadd = (a, b, m, n) => {
+		return withTempArena(wasm, m * n * 3 * 8 + 256, (arena) => {
+			const aPtr = writeF64(wasm, arena, a)
+			const bPtr = writeF64(wasm, arena, b)
+			const outPtr = wasm._matadd(arena, aPtr, bPtr, m, n)
+			return readF64(wasm, outPtr, m * n)
+		})
+	}
+
+	api.matscale = (a, s, m, n) => {
+		return withTempArena(wasm, m * n * 2 * 8 + 256, (arena) => {
+			const aPtr = writeF64(wasm, arena, a)
+			const outPtr = wasm._matscale(arena, aPtr, s, m, n)
+			return readF64(wasm, outPtr, m * n)
+		})
+	}
+
+	api.mattranspose = (a, m, n) => {
+		return withTempArena(wasm, m * n * 2 * 8 + 256, (arena) => {
+			const aPtr = writeF64(wasm, arena, a)
+			const outPtr = wasm._mattranspose(arena, aPtr, m, n)
+			return readF64(wasm, outPtr, n * m)
+		})
+	}
+
+	// ── Loss ──
+
+	api.mseLoss = (pred, targets) => {
+		const n = pred.length
+		return withTempArena(wasm, n * 8 * 2 + 256, (arena) => {
+			const pPtr = writeF64(wasm, arena, pred)
+			const tPtr = writeF64(wasm, arena, targets)
+			return wasm._mse_loss(pPtr, tPtr, n)
+		})
+	}
+
+	api.crossEntropy = (pred, targets) => {
+		const n = pred.length
+		return withTempArena(wasm, n * 8 * 2 + 256, (arena) => {
+			const pPtr = writeF64(wasm, arena, pred)
+			const tPtr = writeF64(wasm, arena, targets)
+			return wasm._cross_entropy(pPtr, tPtr, n)
+		})
+	}
+
+	// ── Backward ──
+
+	api.reluBackward = (dout, input) => {
+		const n = dout.length
+		return withTempArena(wasm, n * 8 * 3 + 256, (arena) => {
+			const dPtr = writeF64(wasm, arena, dout)
+			const iPtr = writeF64(wasm, arena, input)
+			const outPtr = wasm._relu_backward(arena, dPtr, iPtr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	api.sigmoidBackward = (dout, output) => {
+		const n = dout.length
+		return withTempArena(wasm, n * 8 * 3 + 256, (arena) => {
+			const dPtr = writeF64(wasm, arena, dout)
+			const oPtr = writeF64(wasm, arena, output)
+			const outPtr = wasm._sigmoid_backward(arena, dPtr, oPtr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	api.softmaxBackward = (dout, output) => {
+		const n = dout.length
+		return withTempArena(wasm, n * 8 * 3 + 256, (arena) => {
+			const dPtr = writeF64(wasm, arena, dout)
+			const oPtr = writeF64(wasm, arena, output)
+			const outPtr = wasm._softmax_backward(arena, dPtr, oPtr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	api.matmulBackwardA = (dout, b, m, n, p) => {
+		return withTempArena(wasm, (m * p + n * p + m * n) * 8 + 256, (arena) => {
+			const dPtr = writeF64(wasm, arena, dout)
+			const bPtr = writeF64(wasm, arena, b)
+			const outPtr = wasm._matmul_backward_a(arena, dPtr, bPtr, m, n, p)
+			return readF64(wasm, outPtr, m * n)
+		})
+	}
+
+	api.matmulBackwardB = (a, dout, m, n, p) => {
+		return withTempArena(wasm, (m * n + m * p + n * p) * 8 + 256, (arena) => {
+			const aPtr = writeF64(wasm, arena, a)
+			const dPtr = writeF64(wasm, arena, dout)
+			const outPtr = wasm._matmul_backward_b(arena, aPtr, dPtr, m, n, p)
+			return readF64(wasm, outPtr, n * p)
+		})
+	}
+
+	// ── Optimizer ──
+
+	api.sgdUpdate = (weights, grads, lr) => {
+		const n = weights.length
+		return withTempArena(wasm, n * 8 * 3 + 256, (arena) => {
+			const wPtr = writeF64(wasm, arena, weights)
+			const gPtr = writeF64(wasm, arena, grads)
+			const outPtr = wasm._sgd_update(arena, wPtr, gPtr, lr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	// ── Random ──
+
+	api.randomSeed = (seed) => wasm._random_seed(seed)
+
+	api.randomUniform = (min, max, n) => {
+		return withTempArena(wasm, n * 8 + 256, (arena) => {
+			const outPtr = wasm._random_uniform(arena, min, max, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	api.randomNormal = (mean, std, n) => {
+		return withTempArena(wasm, n * 8 + 256, (arena) => {
+			const outPtr = wasm._random_normal(arena, mean, std, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	// ── Statistics ──
+
+	api.normalize = (arr) => {
+		const n = arr.length
+		return withTempArena(wasm, n * 8 * 2 + 256, (arena) => {
+			const ptr = writeF64(wasm, arena, arr)
+			const outPtr = wasm._normalize(arena, ptr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	// ── Calculus (function pointer based) ──
+
+	api.forwarddiff = (f, x, h) => {
+		return withFunctionPointer(wasm, f, (fp) => {
+			return wasm._forwarddiff(fp, x, h)
+		})
+	}
+
+	api.backwarddiff = (f, x, h) => {
+		return withFunctionPointer(wasm, f, (fp) => {
+			return wasm._backwarddiff(fp, x, h)
+		})
+	}
+
+	api.centralDifference = (f, x, h) => {
+		return withFunctionPointer(wasm, f, (fp) => {
+			return wasm._central_difference(fp, x, h)
+		})
+	}
+
+	api.secondDerivative = (f, x, h) => {
+		return withFunctionPointer(wasm, f, (fp) => {
+			return wasm._secondderivative(fp, x, h)
+		})
+	}
+
+	api.centralNth = (f, x, h, n) => {
+		return withFunctionPointer(wasm, f, (fp) => {
+			return wasm._centralnth(fp, x, h, n)
+		})
+	}
+
+	api.rombergIntegrate = (f, a, b, eps, kMax) => {
+		return withFunctionPointer(wasm, f, (fp) => {
+			return wasm._romberg_integrate(fp, a, b, eps, kMax)
+		})
+	}
+
+	// ── Pipeline (batch operations) ──
+
+	api.batchRelu = (input) => {
+		const n = input.length
+		return withTempArena(wasm, n * 8 * 2 + 256, (arena) => {
+			const ptr = writeF64(wasm, arena, input)
+			const outPtr = wasm._batch_relu(arena, ptr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	api.batchSigmoid = (input) => {
+		const n = input.length
+		return withTempArena(wasm, n * 8 * 2 + 256, (arena) => {
+			const ptr = writeF64(wasm, arena, input)
+			const outPtr = wasm._batch_sigmoid(arena, ptr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	api.batchSoftmax = (input, rows, cols) => {
+		return withTempArena(wasm, rows * cols * 8 * 2 + 256, (arena) => {
+			const ptr = writeF64(wasm, arena, input)
+			const outPtr = wasm._batch_softmax(arena, ptr, rows, cols)
+			return readF64(wasm, outPtr, rows * cols)
+		})
+	}
+
+	api.batchNormalize = (features, nSamples, nFeatures) => {
+		return withTempArena(wasm, nSamples * nFeatures * 8 * 2 + 256, (arena) => {
+			const ptr = writeF64(wasm, arena, features)
+			const outPtr = wasm._batch_normalize(arena, ptr, nSamples, nFeatures)
+			return readF64(wasm, outPtr, nSamples * nFeatures)
+		})
+	}
+
+	api.mseBackward = (pred, targets) => {
+		const n = pred.length
+		return withTempArena(wasm, n * 8 * 3 + 256, (arena) => {
+			const pPtr = writeF64(wasm, arena, pred)
+			const tPtr = writeF64(wasm, arena, targets)
+			const outPtr = wasm._mse_backward(arena, pPtr, tPtr, n)
+			return readF64(wasm, outPtr, n)
+		})
+	}
+
+	api.crossEntropyBackward = (pred, targets, nSamples, nClasses) => {
+		const total = nSamples * nClasses
+		return withTempArena(wasm, total * 8 * 3 + 256, (arena) => {
+			const pPtr = writeF64(wasm, arena, pred)
+			const tPtr = writeF64(wasm, arena, targets)
+			const outPtr = wasm._cross_entropy_backward(arena, pPtr, tPtr, nSamples, nClasses)
+			return readF64(wasm, outPtr, total)
+		})
+	}
+
+	api.accuracy = (pred, labels, nSamples, nClasses) => {
+		return withTempArena(wasm, nSamples * nClasses * 8 + nSamples * 4 + 256, (arena) => {
+			const pPtr = writeF64(wasm, arena, pred)
+			const lPtr = writeI32(wasm, arena, labels)
+			return wasm._accuracy(pPtr, lPtr, nSamples, nClasses)
+		})
+	}
+
+	// ── Weights (uses malloc, not arena) ──
+
+	api.initWeights = (n, mean, std) => {
+		const ptr = wasm._init_weights(n, mean, std)
+		const data = readF64(wasm, ptr, n)
+		return {
+			_ptr: ptr,
+			data,
+			length: n,
+			free() { wasm._glue_free(ptr) }
+		}
+	}
+
+	// ── Session API (pointer-level control for training loops) ──
+
+	api.createSession = (arenaBytes) => {
+		const arena = wasm._glue_arena_create(arenaBytes || 65536)
+		const session = {}
+
+		session.writeArray = (arr) => writeF64(wasm, arena, arr)
+		session.writeI32Array = (arr) => writeI32(wasm, arena, arr)
+		session.readArray = (ptr, n) => readF64(wasm, ptr, n)
+
+		session.copyToPtr = (destPtr, srcArray) => {
+			const heap = new Float64Array(wasm.wasmMemory.buffer, destPtr, srcArray.length)
+			heap.set(srcArray)
+		}
+
+		session.softmax = (inputPtr, n) => {
+			return wasm._softmax(arena, inputPtr, n)
+		}
+
+		session.vecadd = (aPtr, bPtr, n) => {
+			return wasm._vecadd(arena, aPtr, bPtr, n)
+		}
+
+		session.vecscale = (arrPtr, scalar, n) => {
+			return wasm._vecscale(arena, arrPtr, scalar, n)
+		}
+
+		session.matmul = (aPtr, bPtr, m, n, p) => {
+			return wasm._matmul(arena, aPtr, bPtr, m, n, p)
+		}
+
+		session.matadd = (aPtr, bPtr, m, n) => {
+			return wasm._matadd(arena, aPtr, bPtr, m, n)
+		}
+
+		session.matscale = (aPtr, s, m, n) => {
+			return wasm._matscale(arena, aPtr, s, m, n)
+		}
+
+		session.mattranspose = (aPtr, m, n) => {
+			return wasm._mattranspose(arena, aPtr, m, n)
+		}
+
+		session.reluBackward = (doutPtr, inputPtr, n) => {
+			return wasm._relu_backward(arena, doutPtr, inputPtr, n)
+		}
+
+		session.sigmoidBackward = (doutPtr, outputPtr, n) => {
+			return wasm._sigmoid_backward(arena, doutPtr, outputPtr, n)
+		}
+
+		session.softmaxBackward = (doutPtr, outputPtr, n) => {
+			return wasm._softmax_backward(arena, doutPtr, outputPtr, n)
+		}
+
+		session.matmulBackwardA = (doutPtr, bPtr, m, n, p) => {
+			return wasm._matmul_backward_a(arena, doutPtr, bPtr, m, n, p)
+		}
+
+		session.matmulBackwardB = (aPtr, doutPtr, m, n, p) => {
+			return wasm._matmul_backward_b(arena, aPtr, doutPtr, m, n, p)
+		}
+
+		session.sgdUpdate = (weightsPtr, gradsPtr, lr, n) => {
+			return wasm._sgd_update(arena, weightsPtr, gradsPtr, lr, n)
+		}
+
+		session.normalize = (ptr, n) => {
+			return wasm._normalize(arena, ptr, n)
+		}
+
+		session.batchRelu = (ptr, n) => {
+			return wasm._batch_relu(arena, ptr, n)
+		}
+
+		session.batchSigmoid = (ptr, n) => {
+			return wasm._batch_sigmoid(arena, ptr, n)
+		}
+
+		session.batchSoftmax = (ptr, rows, cols) => {
+			return wasm._batch_softmax(arena, ptr, rows, cols)
+		}
+
+		session.batchNormalize = (ptr, nSamples, nFeatures) => {
+			return wasm._batch_normalize(arena, ptr, nSamples, nFeatures)
+		}
+
+		session.mseBackward = (predPtr, targetsPtr, n) => {
+			return wasm._mse_backward(arena, predPtr, targetsPtr, n)
+		}
+
+		session.crossEntropyBackward = (predPtr, targetsPtr, nSamples, nClasses) => {
+			return wasm._cross_entropy_backward(arena, predPtr, targetsPtr, nSamples, nClasses)
+		}
+
+		session.randomUniform = (min, max, n) => {
+			return wasm._random_uniform(arena, min, max, n)
+		}
+
+		session.randomNormal = (mean, std, n) => {
+			return wasm._random_normal(arena, mean, std, n)
+		}
+
+		session.denseForward = (inputPtr, weightsPtr, m, n, p, activation) => {
+			const act = actEnum(activation)
+			const outPtr = wasm._glue_dense_forward(arena, inputPtr, weightsPtr, m, n, p, act)
+			const cachePtr = wasm._glue_get_cache_ptr()
+			return { outputPtr: outPtr, cachePtr }
+		}
+
+		session.denseBackward = (doutPtr, inputPtr, weightsPtr, cachePtr, m, n, p, activation) => {
+			const act = actEnum(activation)
+			wasm._glue_dense_backward(arena, doutPtr, inputPtr, weightsPtr, cachePtr, m, n, p, act)
+			return {
+				dWeightsPtr: wasm._glue_get_dw_ptr(),
+				dInputPtr: wasm._glue_get_di_ptr()
+			}
+		}
+
+		session.mseLoss = (predPtr, targetsPtr, n) => {
+			return wasm._mse_loss(predPtr, targetsPtr, n)
+		}
+
+		session.crossEntropy = (predPtr, targetsPtr, n) => {
+			return wasm._cross_entropy(predPtr, targetsPtr, n)
+		}
+
+		session.accuracy = (predPtr, labelsPtr, nSamples, nClasses) => {
+			return wasm._accuracy(predPtr, labelsPtr, nSamples, nClasses)
+		}
+
+		session.clear = () => wasm._glue_arena_clear(arena)
+
+		session.destroy = () => wasm._glue_arena_destroy(arena)
+
+		return session
+	}
+
+	// ── Expose constants ──
+	api.ACTIVATION_NONE = 0
+	api.ACTIVATION_RELU = 1
+	api.ACTIVATION_SIGMOID = 2
+	api.ACTIVATION_SOFTMAX = 3
+
+	return api
+}
+
+export default init