@vib3code/sdk 2.0.3-canary.89c05e0 → 2.0.3-canary.d0c4221

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vib3code/sdk",
-  "version": "2.0.3-canary.89c05e0",
+  "version": "2.0.3-canary.d0c4221",
   "description": "VIB3+ 4D Visualization SDK - Unified engine with 6D rotation, MCP agentic integration, and cross-platform support",
   "type": "module",
   "main": "src/core/VIB3Engine.js",

package/src/geometry/generators/Crystal.js

@@ -61,8 +61,8 @@ export function generate24CellVertices(size = 1) {
             ];
             for (const [s1, s2] of signs) {
                 const v = new Vec4(0, 0, 0, 0);
-                v.setComponent(i, s1 * s);
-                v.setComponent(j, s2 * s);
+                v.data[i] = s1 * s;
+                v.data[j] = s2 * s;
                 vertices.push(v);
             }
         }

package/src/math/Mat4x4.js

@@ -547,122 +547,6 @@ export class Mat4x4 {
         return new Mat4x4(json.data);
     }
 
-    // ========== IN-PLACE ROTATIONS ==========
-
-    /**
-     * Rotate in XY plane in place
-     * @param {number} angle
-     * @returns {Mat4x4} this
-     */
-    rotateXY(angle) {
-        const c = Math.cos(angle);
-        const s = Math.sin(angle);
-        const m = this.data;
-
-        for (let i = 0; i < 4; i++) {
-            const a0 = m[i];      // Col 0
-            const a1 = m[i + 4];  // Col 1
-            m[i]     = a0 * c + a1 * s;
-            m[i + 4] = -a0 * s + a1 * c;
-        }
-        return this;
-    }
-
-    /**
-     * Rotate in XZ plane in place
-     * @param {number} angle
-     * @returns {Mat4x4} this
-     */
-    rotateXZ(angle) {
-        const c = Math.cos(angle);
-        const s = Math.sin(angle);
-        const m = this.data;
-
-        for (let i = 0; i < 4; i++) {
-            const a0 = m[i];      // Col 0
-            const a2 = m[i + 8];  // Col 2
-            m[i]     = a0 * c - a2 * s;
-            m[i + 8] = a0 * s + a2 * c;
-        }
-        return this;
-    }
-
-    /**
-     * Rotate in YZ plane in place
-     * @param {number} angle
-     * @returns {Mat4x4} this
-     */
-    rotateYZ(angle) {
-        const c = Math.cos(angle);
-        const s = Math.sin(angle);
-        const m = this.data;
-
-        for (let i = 0; i < 4; i++) {
-            const a1 = m[i + 4];  // Col 1
-            const a2 = m[i + 8];  // Col 2
-            m[i + 4] = a1 * c + a2 * s;
-            m[i + 8] = -a1 * s + a2 * c;
-        }
-        return this;
-    }
-
-    /**
-     * Rotate in XW plane in place
-     * @param {number} angle
-     * @returns {Mat4x4} this
-     */
-    rotateXW(angle) {
-        const c = Math.cos(angle);
-        const s = Math.sin(angle);
-        const m = this.data;
-
-        for (let i = 0; i < 4; i++) {
-            const a0 = m[i];       // Col 0
-            const a3 = m[i + 12];  // Col 3
-            m[i]      = a0 * c + a3 * s;
-            m[i + 12] = -a0 * s + a3 * c;
-        }
-        return this;
-    }
-
-    /**
-     * Rotate in YW plane in place
-     * @param {number} angle
-     * @returns {Mat4x4} this
-     */
-    rotateYW(angle) {
-        const c = Math.cos(angle);
-        const s = Math.sin(angle);
-        const m = this.data;
-
-        for (let i = 0; i < 4; i++) {
-            const a1 = m[i + 4];   // Col 1
-            const a3 = m[i + 12];  // Col 3
-            m[i + 4]  = a1 * c + a3 * s;
-            m[i + 12] = -a1 * s + a3 * c;
-        }
-        return this;
-    }
-
-    /**
-     * Rotate in ZW plane in place
-     * @param {number} angle
-     * @returns {Mat4x4} this
-     */
-    rotateZW(angle) {
-        const c = Math.cos(angle);
-        const s = Math.sin(angle);
-        const m = this.data;
-
-        for (let i = 0; i < 4; i++) {
-            const a2 = m[i + 8];   // Col 2
-            const a3 = m[i + 12];  // Col 3
-            m[i + 8]  = a2 * c + a3 * s;
-            m[i + 12] = -a2 * s + a3 * c;
-        }
-        return this;
-    }
-
     // ========== ROTATION MATRICES FOR ALL 6 PLANES ==========
 
     /**
@@ -797,12 +681,12 @@ export class Mat4x4 {
     static rotationFromAngles(angles) {
         let result = Mat4x4.identity();
 
-        if (angles.xy) result.rotateXY(angles.xy);
-        if (angles.xz) result.rotateXZ(angles.xz);
-        if (angles.yz) result.rotateYZ(angles.yz);
-        if (angles.xw) result.rotateXW(angles.xw);
-        if (angles.yw) result.rotateYW(angles.yw);
-        if (angles.zw) result.rotateZW(angles.zw);
+        if (angles.xy) result = result.multiply(Mat4x4.rotationXY(angles.xy));
+        if (angles.xz) result = result.multiply(Mat4x4.rotationXZ(angles.xz));
+        if (angles.yz) result = result.multiply(Mat4x4.rotationYZ(angles.yz));
+        if (angles.xw) result = result.multiply(Mat4x4.rotationXW(angles.xw));
+        if (angles.yw) result = result.multiply(Mat4x4.rotationYW(angles.yw));
+        if (angles.zw) result = result.multiply(Mat4x4.rotationZW(angles.zw));
 
         return result;
     }

package/src/math/Rotor4D.js

@@ -323,17 +323,14 @@ export class Rotor4D {
     /**
      * Rotate a 4D vector using sandwich product: v' = R v R†
      *
-     * Matrix math is inlined to avoid allocating a temporary Float32Array(16).
-     * Pass an optional target Vec4 to eliminate all allocations.
-     *
      * @param {Vec4} v - Vector to rotate
-     * @param {Vec4} [target] - Optional pre-allocated Vec4 to write result into
-     * @returns {Vec4} Rotated vector (target if provided, otherwise new Vec4)
+     * @param {Vec4} [target] - Optional target vector to write result to
+     * @returns {Vec4} Rotated vector
      */
     rotate(v, target) {
-        const x = v.x, y = v.y, z = v.z, w = v.w;
+        // Direct matrix multiplication without allocation
 
-        // Normalize for numerical stability (same as toMatrix)
+        // Normalize components for stability (same as toMatrix)
         const n = this.norm();
         const invN = n > 1e-10 ? 1 / n : 1;
 
@@ -346,7 +343,7 @@ export class Rotor4D {
         const zw = this.zw * invN;
         const xyzw = this.xyzw * invN;
 
-        // Squared terms
+        // Pre-compute products
         const s2 = s * s;
         const xy2 = xy * xy;
         const xz2 = xz * xz;
@@ -356,20 +353,22 @@ export class Rotor4D {
         const zw2 = zw * zw;
         const xyzw2 = xyzw * xyzw;
 
-        // Cross terms (pre-multiplied by 2)
+        // Cross terms
         const sxy = 2 * s * xy;
         const sxz = 2 * s * xz;
         const syz = 2 * s * yz;
         const sxw = 2 * s * xw;
         const syw = 2 * s * yw;
         const szw = 2 * s * zw;
+        // const sxyzw = 2 * s * xyzw; // Unused in rotation matrix
 
-        const xzyz = 2 * xz * yz;
-        const xyyz = 2 * xy * yz;
         const xyxz = 2 * xy * xz;
+        const xyyz = 2 * xy * yz;
         const xyxw = 2 * xy * xw;
         const xyyw = 2 * xy * yw;
+        // const xyzw_c = 2 * xy * zw; // Unused in rotation matrix
 
+        const xzyz = 2 * xz * yz;
         const xzxw = 2 * xz * xw;
         const xzyw = 2 * xz * yw;
         const xzzw = 2 * xz * zw;
@@ -389,33 +388,40 @@ export class Rotor4D {
         const ywxyzw = 2 * yw * xyzw;
         const zwxyzw = 2 * zw * xyzw;
 
-        // Column-major 4x4 rotation matrix entries (inlined from toMatrix)
-        // Column 0
-        const m0  = s2 - xy2 - xz2 + yz2 - xw2 + yw2 + zw2 - xyzw2;
-        const m1  = sxy + xzyz + xwyw - zwxyzw;
-        const m2  = sxz - xyyz + xwzw + ywxyzw;
-        const m3  = sxw - xyyw - xzzw - yzxyzw;
-        // Column 1
-        const m4  = -sxy + xzyz + xwyw + zwxyzw;
-        const m5  = s2 - xy2 + xz2 - yz2 + xw2 - yw2 + zw2 - xyzw2;
-        const m6  = syz + xyxz + ywzw - xwxyzw;
-        const m7  = syw + xyxw - yzzw + xzxyzw;
-        // Column 2
-        const m8  = -sxz - xyyz + xwzw - ywxyzw;
-        const m9  = -syz + xyxz + ywzw + xwxyzw;
-        const m10 = s2 + xy2 - xz2 - yz2 + xw2 + yw2 - zw2 - xyzw2;
-        const m11 = szw + xzxw + yzyw - xyxyzw;
-        // Column 3
-        const m12 = -sxw - xyyw - xzzw + yzxyzw;
-        const m13 = -syw + xyxw - yzzw - xzxyzw;
-        const m14 = -szw + xzxw + yzyw + xyxyzw;
-        const m15 = s2 + xy2 + xz2 + yz2 - xw2 - yw2 - zw2 - xyzw2;
-
-        // Matrix-vector multiply
-        const rx = m0 * x + m4 * y + m8  * z + m12 * w;
-        const ry = m1 * x + m5 * y + m9  * z + m13 * w;
-        const rz = m2 * x + m6 * y + m10 * z + m14 * w;
-        const rw = m3 * x + m7 * y + m11 * z + m15 * w;
+        // Matrix elements
+        // Col 0
+        const m00 = s2 - xy2 - xz2 + yz2 - xw2 + yw2 + zw2 - xyzw2;
+        const m01 = sxy + xzyz + xwyw - zwxyzw;
+        const m02 = sxz - xyyz + xwzw + ywxyzw;
+        const m03 = sxw - xyyw - xzzw - yzxyzw;
+
+        // Col 1
+        const m10 = -sxy + xzyz + xwyw + zwxyzw;
+        const m11 = s2 - xy2 + xz2 - yz2 + xw2 - yw2 + zw2 - xyzw2;
+        const m12 = syz + xyxz + ywzw - xwxyzw;
+        const m13 = syw + xyxw - yzzw + xzxyzw;
+
+        // Col 2
+        const m20 = -sxz - xyyz + xwzw - ywxyzw;
+        const m21 = -syz + xyxz + ywzw + xwxyzw;
+        const m22 = s2 + xy2 - xz2 - yz2 + xw2 + yw2 - zw2 - xyzw2;
+        const m23 = szw + xzxw + yzyw - xyxyzw;
+
+        // Col 3
+        const m30 = -sxw - xyyw - xzzw + yzxyzw;
+        const m31 = -syw + xyxw - yzzw - xzxyzw;
+        const m32 = -szw + xzxw + yzyw + xyxyzw;
+        const m33 = s2 + xy2 + xz2 + yz2 - xw2 - yw2 - zw2 - xyzw2;
+
+        const x = v.x;
+        const y = v.y;
+        const z = v.z;
+        const w = v.w;
+
+        const rx = m00 * x + m10 * y + m20 * z + m30 * w;
+        const ry = m01 * x + m11 * y + m21 * z + m31 * w;
+        const rz = m02 * x + m12 * y + m22 * z + m32 * w;
+        const rw = m03 * x + m13 * y + m23 * z + m33 * w;
 
         if (target) {
             target.x = rx;
@@ -424,6 +430,7 @@ export class Rotor4D {
             target.w = rw;
             return target;
         }
+
         return new Vec4(rx, ry, rz, rw);
     }
 

package/src/math/Vec4.js

@@ -2,8 +2,7 @@
  * Vec4 - 4D Vector Class
  *
  * Represents a point or direction in 4-dimensional space.
- * Uses plain numeric properties internally for minimal allocation overhead.
- * GPU-compatible Float32Array created on demand via toFloat32Array().
+ * Uses Float32Array for GPU compatibility and potential SIMD optimization.
  *
  * @example
  * const v = new Vec4(1, 2, 3, 0.5);
@@ -20,66 +19,26 @@ export class Vec4 {
      * @param {number} w - W component (4th dimension)
      */
     constructor(x = 0, y = 0, z = 0, w = 0) {
-        this._x = x;
-        this._y = y;
-        this._z = z;
-        this._w = w;
+        // Use Float32Array for GPU compatibility
+        this.data = new Float32Array(4);
+        this.data[0] = x;
+        this.data[1] = y;
+        this.data[2] = z;
+        this.data[3] = w;
     }
 
-    // Property accessors
-    get x() { return this._x; }
-    set x(v) { this._x = v; }
+    // Property accessors for readability
+    get x() { return this.data[0]; }
+    set x(v) { this.data[0] = v; }
 
-    get y() { return this._y; }
-    set y(v) { this._y = v; }
+    get y() { return this.data[1]; }
+    set y(v) { this.data[1] = v; }
 
-    get z() { return this._z; }
-    set z(v) { this._z = v; }
+    get z() { return this.data[2]; }
+    set z(v) { this.data[2] = v; }
 
-    get w() { return this._w; }
-    set w(v) { this._w = v; }
-
-    /**
-     * Backward-compatible .data getter.
-     * Returns a Float32Array snapshot of current values.
-     * Note: writes to the returned array do NOT propagate back.
-     * Use setComponent(index, value) for index-based mutation.
-     * @returns {Float32Array}
-     */
-    get data() {
-        return new Float32Array([this._x, this._y, this._z, this._w]);
-    }
-
-    /**
-     * Set a component by index (0=x, 1=y, 2=z, 3=w)
-     * @param {number} index - Component index (0-3)
-     * @param {number} value - New value
-     * @returns {Vec4} this
-     */
-    setComponent(index, value) {
-        switch (index) {
-            case 0: this._x = value; break;
-            case 1: this._y = value; break;
-            case 2: this._z = value; break;
-            case 3: this._w = value; break;
-        }
-        return this;
-    }
-
-    /**
-     * Get a component by index (0=x, 1=y, 2=z, 3=w)
-     * @param {number} index - Component index (0-3)
-     * @returns {number}
-     */
-    getComponent(index) {
-        switch (index) {
-            case 0: return this._x;
-            case 1: return this._y;
-            case 2: return this._z;
-            case 3: return this._w;
-            default: return 0;
-        }
-    }
+    get w() { return this.data[3]; }
+    set w(v) { this.data[3] = v; }
 
     /**
      * Create a Vec4 from an array
@@ -95,7 +54,7 @@ export class Vec4 {
      * @returns {Vec4}
      */
     clone() {
-        return new Vec4(this._x, this._y, this._z, this._w);
+        return new Vec4(this.x, this.y, this.z, this.w);
     }
 
     /**
@@ -104,10 +63,10 @@ export class Vec4 {
      * @returns {Vec4} this (for chaining)
      */
     copy(v) {
-        this._x = v._x;
-        this._y = v._y;
-        this._z = v._z;
-        this._w = v._w;
+        this.data[0] = v.data[0];
+        this.data[1] = v.data[1];
+        this.data[2] = v.data[2];
+        this.data[3] = v.data[3];
         return this;
     }
 
@@ -120,10 +79,10 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     set(x, y, z, w) {
-        this._x = x;
-        this._y = y;
-        this._z = z;
-        this._w = w;
+        this.data[0] = x;
+        this.data[1] = y;
+        this.data[2] = z;
+        this.data[3] = w;
         return this;
     }
 
@@ -134,10 +93,10 @@ export class Vec4 {
      */
     add(v) {
         return new Vec4(
-            this._x + v._x,
-            this._y + v._y,
-            this._z + v._z,
-            this._w + v._w
+            this.x + v.x,
+            this.y + v.y,
+            this.z + v.z,
+            this.w + v.w
         );
     }
 
@@ -147,10 +106,10 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     addInPlace(v) {
-        this._x += v._x;
-        this._y += v._y;
-        this._z += v._z;
-        this._w += v._w;
+        this.data[0] += v.data[0];
+        this.data[1] += v.data[1];
+        this.data[2] += v.data[2];
+        this.data[3] += v.data[3];
         return this;
     }
 
@@ -161,10 +120,10 @@ export class Vec4 {
      */
     sub(v) {
         return new Vec4(
-            this._x - v._x,
-            this._y - v._y,
-            this._z - v._z,
-            this._w - v._w
+            this.x - v.x,
+            this.y - v.y,
+            this.z - v.z,
+            this.w - v.w
         );
     }
 
@@ -174,10 +133,10 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     subInPlace(v) {
-        this._x -= v._x;
-        this._y -= v._y;
-        this._z -= v._z;
-        this._w -= v._w;
+        this.data[0] -= v.data[0];
+        this.data[1] -= v.data[1];
+        this.data[2] -= v.data[2];
+        this.data[3] -= v.data[3];
         return this;
     }
 
@@ -188,10 +147,10 @@ export class Vec4 {
      */
     scale(s) {
         return new Vec4(
-            this._x * s,
-            this._y * s,
-            this._z * s,
-            this._w * s
+            this.x * s,
+            this.y * s,
+            this.z * s,
+            this.w * s
         );
     }
 
@@ -201,10 +160,10 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     scaleInPlace(s) {
-        this._x *= s;
-        this._y *= s;
-        this._z *= s;
-        this._w *= s;
+        this.data[0] *= s;
+        this.data[1] *= s;
+        this.data[2] *= s;
+        this.data[3] *= s;
         return this;
     }
 
@@ -215,10 +174,10 @@ export class Vec4 {
      */
     multiply(v) {
         return new Vec4(
-            this._x * v._x,
-            this._y * v._y,
-            this._z * v._z,
-            this._w * v._w
+            this.x * v.x,
+            this.y * v.y,
+            this.z * v.z,
+            this.w * v.w
         );
     }
 
@@ -227,7 +186,7 @@ export class Vec4 {
      * @returns {Vec4} New vector
      */
     negate() {
-        return new Vec4(-this._x, -this._y, -this._z, -this._w);
+        return new Vec4(-this.x, -this.y, -this.z, -this.w);
     }
 
     /**
@@ -235,10 +194,10 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     negateInPlace() {
-        this._x = -this._x;
-        this._y = -this._y;
-        this._z = -this._z;
-        this._w = -this._w;
+        this.data[0] = -this.data[0];
+        this.data[1] = -this.data[1];
+        this.data[2] = -this.data[2];
+        this.data[3] = -this.data[3];
         return this;
     }
 
@@ -248,7 +207,7 @@ export class Vec4 {
      * @returns {number}
      */
     dot(v) {
-        return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
+        return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
     }
 
     /**
@@ -256,7 +215,7 @@ export class Vec4 {
      * @returns {number}
      */
     lengthSquared() {
-        return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
+        return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
     }
 
     /**
@@ -318,10 +277,10 @@ export class Vec4 {
      */
     lerp(v, t) {
         return new Vec4(
-            this._x + (v._x - this._x) * t,
-            this._y + (v._y - this._y) * t,
-            this._z + (v._z - this._z) * t,
-            this._w + (v._w - this._w) * t
+            this.x + (v.x - this.x) * t,
+            this.y + (v.y - this.y) * t,
+            this.z + (v.z - this.z) * t,
+            this.w + (v.w - this.w) * t
         );
     }
 
@@ -333,10 +292,10 @@ export class Vec4 {
      */
     equals(v, epsilon = 1e-6) {
         return (
-            Math.abs(this._x - v._x) < epsilon &&
-            Math.abs(this._y - v._y) < epsilon &&
-            Math.abs(this._z - v._z) < epsilon &&
-            Math.abs(this._w - v._w) < epsilon
+            Math.abs(this.x - v.x) < epsilon &&
+            Math.abs(this.y - v.y) < epsilon &&
+            Math.abs(this.z - v.z) < epsilon &&
+            Math.abs(this.w - v.w) < epsilon
         );
     }
 
@@ -362,10 +321,10 @@ export class Vec4 {
             d = options.distance ?? options.d ?? 2;
         }
         const epsilon = options.epsilon ?? 1e-5;
-        const denom = d - this._w;
+        const denom = d - this.w;
         const clamped = Math.abs(denom) < epsilon ? (denom >= 0 ? epsilon : -epsilon) : denom;
         const scale = 1 / clamped;
-        return new Vec4(this._x * scale, this._y * scale, this._z * scale, 0);
+        return new Vec4(this.x * scale, this.y * scale, this.z * scale, 0);
     }
 
     /**
@@ -376,10 +335,10 @@ export class Vec4 {
      */
     projectStereographic(options = {}) {
         const epsilon = options.epsilon ?? 1e-5;
-        const denom = 1 - this._w;
+        const denom = 1 - this.w;
         const clamped = Math.abs(denom) < epsilon ? (denom >= 0 ? epsilon : -epsilon) : denom;
         const scale = 1 / clamped;
-        return new Vec4(this._x * scale, this._y * scale, this._z * scale, 0);
+        return new Vec4(this.x * scale, this.y * scale, this.z * scale, 0);
     }
 
     /**
@@ -388,7 +347,7 @@ export class Vec4 {
      * @returns {Vec4} Projected point (w component is 0)
      */
     projectOrthographic() {
-        return new Vec4(this._x, this._y, this._z, 0);
+        return new Vec4(this.x, this.y, this.z, 0);
     }
 
     /**
@@ -396,7 +355,7 @@ export class Vec4 {
      * @returns {number[]}
      */
     toArray() {
-        return [this._x, this._y, this._z, this._w];
+        return [this.x, this.y, this.z, this.w];
     }
 
     /**
@@ -404,7 +363,7 @@ export class Vec4 {
      * @returns {Float32Array}
      */
     toFloat32Array() {
-        return new Float32Array([this._x, this._y, this._z, this._w]);
+        return new Float32Array(this.data);
     }
 
     /**
@@ -412,7 +371,7 @@ export class Vec4 {
      * @returns {number[]}
      */
     toArray3() {
-        return [this._x, this._y, this._z];
+        return [this.x, this.y, this.z];
     }
 
     /**
@@ -421,7 +380,7 @@ export class Vec4 {
      * @returns {string}
      */
     toString(precision = 3) {
-        return `Vec4(${this._x.toFixed(precision)}, ${this._y.toFixed(precision)}, ${this._z.toFixed(precision)}, ${this._w.toFixed(precision)})`;
+        return `Vec4(${this.x.toFixed(precision)}, ${this.y.toFixed(precision)}, ${this.z.toFixed(precision)}, ${this.w.toFixed(precision)})`;
     }
 
     /**
@@ -429,7 +388,7 @@ export class Vec4 {
      * @returns {object}
      */
     toJSON() {
-        return { x: this._x, y: this._y, z: this._z, w: this._w };
+        return { x: this.x, y: this.y, z: this.z, w: this.w };
     }
 
     // Static factory methods for common vectors