@vib3code/sdk 2.0.3-canary.60bc0f0 → 2.0.3-canary.74aebb4

package/src/experimental/VIB3Orchestrator.js

@@ -0,0 +1,146 @@
+/**
+ * VIB3Orchestrator - The Core of the VIB3 Universe
+ *
+ * Manages the lifecycle and coordination of multiple VIB3+ entities (visualizers).
+ * Implements the "Universe" concept where multiple instances share a clock,
+ * physics, and event bus.
+ *
+ * @experimental
+ */
+export class VIB3Orchestrator {
+    constructor() {
+        this.entities = new Map(); // id -> Entity
+        this.nextEntityId = 1;
+
+        // Master Clock
+        this.time = 0;
+        this.lastFrameTime = 0;
+        this.paused = false;
+
+        // Systems
+        this.eventBus = new EventTarget();
+
+        // Bind loop
+        this.tick = this.tick.bind(this);
+    }
+
+    /**
+     * Start the universe simulation loop.
+     */
+    start() {
+        if (this.running) return;
+        this.running = true;
+        this.lastFrameTime = performance.now();
+        requestAnimationFrame(this.tick);
+        console.log('VIB3Orchestrator: Universe started.');
+    }
+
+    /**
+     * Stop the universe simulation loop.
+     */
+    stop() {
+        this.running = false;
+        console.log('VIB3Orchestrator: Universe stopped.');
+    }
+
+    /**
+     * Spawn a new VIB3 entity.
+     * @param {string} type - 'actor', 'prop', 'environment'
+     * @param {object} config - Configuration for the entity
+     * @returns {string} Entity ID
+     */
+    spawn(type, config = {}) {
+        const id = `vib3_entity_${this.nextEntityId++}`;
+
+        // In a real implementation, this would instantiate VIB3Actor or VIB3Prop
+        // For now, we store a mock object representing the entity state
+        const entity = {
+            id,
+            type,
+            config,
+            position: config.position || { x: 0, y: 0, z: 0 },
+            rotation: config.rotation || { x: 0, y: 0, z: 0, w: 0 }, // 4D rotation
+            active: true,
+
+            // Mock VIB3Engine interface
+            engine: {
+                setParameter: (k, v) => console.log(`[${id}] set ${k}=${v}`),
+                getParameter: (k) => 0
+            },
+
+            update: (dt) => {
+                // Default update logic
+                // e.g., apply basic physics or script behavior
+            }
+        };
+
+        this.entities.set(id, entity);
+        this.emit('entitySpawned', { id, type });
+        console.log(`VIB3Orchestrator: Spawned ${type} (${id})`);
+
+        return id;
+    }
+
+    /**
+     * Remove an entity from the universe.
+     * @param {string} id
+     */
+    kill(id) {
+        if (this.entities.has(id)) {
+            const entity = this.entities.get(id);
+            // Cleanup logic (e.g., destroy VIB3Engine instance)
+            if (entity.destroy) entity.destroy();
+
+            this.entities.delete(id);
+            this.emit('entityDespawned', { id });
+            console.log(`VIB3Orchestrator: Killed entity ${id}`);
+        }
+    }
+
+    /**
+     * The main simulation loop.
+     * Prioritizes Physics -> Narrative -> Visuals.
+     * @param {number} timestamp
+     */
+    tick(timestamp) {
+        if (!this.running) return;
+
+        const dt = (timestamp - this.lastFrameTime) / 1000;
+        this.lastFrameTime = timestamp;
+        this.time += dt;
+
+        // 1. Physics / Logic Update
+        this.entities.forEach(entity => {
+            if (entity.active && entity.update) {
+                entity.update(this.time, dt);
+            }
+        });
+
+        // 2. Event Processing (Mock)
+        // Check for collisions, triggers, etc.
+
+        // 3. Visual Sync (Mock)
+        // Ensure all entities are rendering the current frame
+
+        requestAnimationFrame(this.tick);
+    }
+
+    /**
+     * Emit a global universe event.
+     * @param {string} name
+     * @param {object} detail
+     */
+    emit(name, detail) {
+        const event = new CustomEvent(name, { detail });
+        this.eventBus.dispatchEvent(event);
+    }
+
+    /**
+     * Listen for global universe events.
+     * @param {string} name
+     * @param {function} callback
+     */
+    on(name, callback) {
+        this.eventBus.addEventListener(name, (e) => callback(e.detail));
+    }
+}

package/src/experimental/VIB3Universe.js

@@ -0,0 +1,109 @@
+/**
+ * VIB3Universe - High-Level Entry Point for VIB3+ Ultra
+ *
+ * Combines Orchestrator (Logic) and Compositor (Visuals) into a single API.
+ * Manages the "World" where multiple VIB3+ instances coexist.
+ *
+ * @experimental
+ */
+import { VIB3Orchestrator } from './VIB3Orchestrator.js';
+import { VIB3Compositor } from './VIB3Compositor.js';
+import { VIB3Actor } from './VIB3Actor.js';
+import { VIB3Engine } from '../core/VIB3Engine.js';
+
+export class VIB3Universe {
+    /**
+     * @param {string} containerId - DOM ID for the universe container
+     */
+    constructor(containerId = 'vib3-universe') {
+        this.orchestrator = new VIB3Orchestrator();
+        this.compositor = new VIB3Compositor(containerId);
+        this.actors = new Map(); // id -> VIB3Actor
+    }
+
+    /**
+     * Start the universe simulation.
+     */
+    start() {
+        this.orchestrator.start();
+    }
+
+    /**
+     * Stop the universe simulation.
+     */
+    stop() {
+        this.orchestrator.stop();
+    }
+
+    /**
+     * Spawn a new actor into the universe.
+     * @param {object} config
+     * @param {string} config.personality - Actor personality profile
+     * @param {string} config.system - Visualization system ('quantum', 'faceted', 'holographic')
+     * @param {number} config.geometry - Initial geometry index
+     * @param {object} config.layer - Layer options { zIndex, blendMode, opacity, position }
+     * @returns {Promise<VIB3Actor>} The spawned actor
+     */
+    async spawnActor(config = {}) {
+        const actorId = `actor_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+
+        // 1. Create a container for this actor's engine
+        const container = document.createElement('div');
+        container.id = `container_${actorId}`;
+        container.style.width = '100%';
+        container.style.height = '100%';
+        container.style.pointerEvents = 'none'; // Default to pass-through events
+
+        // 2. Add to compositor (visual layer)
+        this.compositor.addInstance(actorId, container, config.layer || {});
+
+        // 3. Initialize VIB3 Engine
+        const engine = new VIB3Engine({
+            system: config.system || 'holographic',
+            preferWebGPU: true // Ultra tier defaults to high perf
+        });
+
+        // Initialize engine within the container
+        // Note: VIB3Engine.initialize expects a container ID
+        await engine.initialize(container.id);
+
+        // Set initial state
+        if (config.geometry !== undefined) {
+            engine.setParameter('geometry', config.geometry);
+        }
+
+        // 4. Wrap in Actor (logic layer)
+        const actor = new VIB3Actor(engine, config.personality || 'neutral');
+        actor.id = actorId;
+
+        // 5. Register with Orchestrator (simulation loop)
+        this.orchestrator.entities.set(actorId, actor);
+        this.actors.set(actorId, actor);
+
+        console.log(`VIB3Universe: Spawned actor ${actorId}`);
+        return actor;
+    }
+
+    /**
+     * Remove an actor from the universe.
+     * @param {string} actorId
+     */
+    despawnActor(actorId) {
+        const actor = this.actors.get(actorId);
+        if (actor) {
+            // Remove from logic
+            this.orchestrator.kill(actorId);
+
+            // Cleanup engine
+            if (actor.engine && actor.engine.destroy) {
+                actor.engine.destroy();
+            }
+
+            // Remove from visuals
+            this.compositor.removeInstance(actorId);
+            this.actors.delete(actorId);
+
+            console.log(`VIB3Universe: Despawned actor ${actorId}`);
+        }
+    }
+}

package/src/experimental/demos/CrystalLabyrinth.js

@@ -0,0 +1,202 @@
+/**
+ * CrystalLabyrinth.js - Vertical Slice Demo
+ *
+ * Implements the full "Ultra" stack:
+ * - VIB3Universe (Multi-instance)
+ * - VIB3Orchestrator (Game Loop)
+ * - VIB3Compositor (Visuals)
+ * - LatticePhysics (4D Collision)
+ * - PlayerController4D (Input)
+ * - LiveDirector (AI Pacing)
+ *
+ * @experimental
+ */
+import { VIB3Universe } from '../VIB3Universe.js';
+import { GameLoop } from '../GameLoop.js';
+import { LatticePhysics } from '../LatticePhysics.js';
+import { PlayerController4D } from '../PlayerController4D.js';
+import { LiveDirector } from '../LiveDirector.js';
+
+class CrystalLabyrinthGame {
+    constructor() {
+        this.universe = new VIB3Universe('vib3-universe');
+        this.physics = new LatticePhysics();
+        this.director = new LiveDirector(this.universe);
+
+        // Game State
+        this.score = 0;
+        this.health = 100;
+        this.isPlaying = false;
+
+        // Entities
+        this.player = null; // The "Camera"
+        this.crystals = [];
+        this.shadows = [];
+
+        // UI
+        this.ui = {
+            score: document.getElementById('score'),
+            health: document.getElementById('health'),
+            overlay: document.getElementById('overlay'),
+            startBtn: document.getElementById('start-btn')
+        };
+
+        // Bind input
+        this.controller = new PlayerController4D(document.body, {
+            setParameter: (k, v) => this.updatePlayerView(k, v)
+        });
+
+        // Setup Loop
+        this.loop = new GameLoop(
+            (dt) => this.update(dt),
+            (alpha) => this.render(alpha)
+        );
+
+        this.init();
+    }
+
+    async init() {
+        // Create the "World" (Background Layer)
+        // A deep, slow-moving Holographic system representing the void
+        const world = await this.universe.spawnActor({
+            personality: 'neutral',
+            system: 'holographic',
+            geometry: 11, // Hypersphere
+            layer: { zIndex: 0, opacity: 0.4 }
+        });
+
+        // Setup UI listeners
+        this.ui.startBtn.addEventListener('click', () => this.start());
+    }
+
+    start() {
+        this.isPlaying = true;
+        this.ui.overlay.classList.add('hidden');
+
+        // Start Systems
+        this.universe.start();
+        this.loop.start();
+        this.director.start();
+
+        // Spawn Level
+        this.spawnLevel();
+    }
+
+    async spawnLevel() {
+        // Spawn 5 Crystals (Pickups)
+        for (let i = 0; i < 5; i++) {
+            const crystal = await this.universe.spawnActor({
+                personality: 'heroic', // Bright, positive
+                system: 'faceted',
+                geometry: 7, // Crystal
+                layer: { zIndex: 10, blendMode: 'screen', opacity: 0.9 }
+            });
+
+            // Random position in 4D space (mock)
+            crystal.physics = {
+                pos: {
+                    x: (Math.random() - 0.5) * 20,
+                    y: (Math.random() - 0.5) * 5,
+                    z: (Math.random() - 0.5) * 20
+                },
+                vel: { x: 0, y: 0, z: 0 },
+                acc: { x: 0, y: 0, z: 0 }
+            };
+
+            this.crystals.push(crystal);
+        }
+
+        // Spawn 3 Shadows (Enemies)
+        for (let i = 0; i < 3; i++) {
+            const shadow = await this.universe.spawnActor({
+                personality: 'glitch', // Chaotic, negative
+                system: 'quantum',
+                geometry: 16, // Spiky
+                layer: { zIndex: 5, blendMode: 'multiply', opacity: 0.7 }
+            });
+
+            shadow.physics = {
+                pos: { x: 0, y: 0, z: -30 }, // Start far away
+                vel: { x: 0, y: 0, z: 0 },
+                acc: { x: 0, y: 0, z: 0 }
+            };
+
+            this.shadows.push(shadow);
+        }
+    }
+
+    /**
+     * Physics Update (Fixed Timestep)
+     */
+    update(dt) {
+        if (!this.isPlaying) return;
+
+        // 1. Update Player Controls
+        this.controller.update(dt);
+
+        // 2. Update Physics World
+        // Sync player controller state to physics engine?
+        // For now, controller handles movement directly.
+
+        // 3. AI Logic (Shadows hunt player)
+        this.shadows.forEach(shadow => {
+            // Move towards player (0,0,0 relative to camera)
+            // In a real engine, we'd have absolute coordinates.
+            // Here, we simulate relative motion by updating parameters
+
+            // Mock: Oscillate shadow intensity based on "proximity"
+            shadow.emote('panic', 0.5);
+        });
+
+        // 4. Check Collisions (Mock)
+        // If player is close to a crystal -> Collect
+        if (Math.random() < 0.005 && this.crystals.length > 0) {
+            this.collectCrystal(this.crystals.pop());
+        }
+    }
+
+    /**
+     * Render Update (Variable Timestep)
+     */
+    render(alpha) {
+        // Visual interpolation could happen here
+    }
+
+    updatePlayerView(key, value) {
+        // Broadcast player view changes to the World actor
+        // This makes the world rotate around the player
+        const world = this.universe.actors.get(this.universe.orchestrator.entities.keys().next().value);
+        if (world && world.engine) {
+            world.engine.setParameter(key, value);
+        }
+    }
+
+    collectCrystal(actor) {
+        this.score++;
+        this.ui.score.innerText = this.score;
+
+        // FX
+        actor.emote('joy', 1.0, 500);
+        setTimeout(() => {
+            this.universe.despawnActor(actor.id);
+        }, 500);
+
+        if (this.score >= 5) {
+            this.win();
+        }
+    }
+
+    win() {
+        this.isPlaying = false;
+        this.ui.overlay.innerHTML = `
+            <h1 style="color: #0f0; text-shadow: 0 0 20px #0f0;">SECTOR STABILIZED</h1>
+            <p>The lattice is secure.</p>
+            <button onclick="location.reload()">Re-enter</button>
+        `;
+        this.ui.overlay.classList.remove('hidden');
+        this.loop.stop();
+    }
+}
+
+// Start Game
+new CrystalLabyrinthGame();

package/src/faceted/FacetedSystem.js

@@ -160,10 +160,16 @@ const FRAGMENT_SHADER_GLSL = `
         int geomType = int(clamp(floor(baseGeomFloat + 0.5), 0.0, totalBase - 1.0));
 
         if (geomType == 0) {
-            // Tetrahedron lattice
-            vec4 pos = fract(p * u_gridDensity * 0.08);
-            vec4 dist = min(pos, 1.0 - pos);
-            return min(min(dist.x, dist.y), min(dist.z, dist.w)) * u_morphFactor;
+            // Tetrahedron lattice — tetrahedral symmetry planes
+            float d = u_gridDensity * 0.08;
+            vec3 c1 = normalize(vec3(1.0, 1.0, 1.0));
+            vec3 c2 = normalize(vec3(-1.0, -1.0, 1.0));
+            vec3 c3 = normalize(vec3(-1.0, 1.0, -1.0));
+            vec3 c4 = normalize(vec3(1.0, -1.0, -1.0));
+            vec3 q = fract(p.xyz * d + 0.5) - 0.5;
+            float minPlane = min(min(abs(dot(q, c1)), abs(dot(q, c2))),
+                                 min(abs(dot(q, c3)), abs(dot(q, c4))));
+            return (1.0 - smoothstep(0.0, 0.05, minPlane)) * u_morphFactor;
         }
         else if (geomType == 1) {
             // Hypercube lattice
@@ -429,8 +435,15 @@ fn geometryFunction_w(p: vec4<f32>) -> f32 {
     let gt = i32(clamp(floor(baseFloat + 0.5), 0.0, 7.0));
     let d = u.gridDensity * 0.08;
     if (gt == 0) {
-        let pos = fract(p * d); let dist = min(pos, 1.0 - pos);
-        return min(min(dist.x, dist.y), min(dist.z, dist.w)) * u.morphFactor;
+        // Tetrahedron — tetrahedral symmetry planes
+        let c1 = normalize(vec3<f32>(1.0, 1.0, 1.0));
+        let c2 = normalize(vec3<f32>(-1.0, -1.0, 1.0));
+        let c3 = normalize(vec3<f32>(-1.0, 1.0, -1.0));
+        let c4 = normalize(vec3<f32>(1.0, -1.0, -1.0));
+        let q = fract(p.xyz * d + 0.5) - 0.5;
+        let minPlane = min(min(abs(dot(q, c1)), abs(dot(q, c2))),
+                           min(abs(dot(q, c3)), abs(dot(q, c4))));
+        return (1.0 - smoothstep(0.0, 0.05, minPlane)) * u.morphFactor;
     } else if (gt == 1) {
         let pos = fract(p * d); let dist = min(pos, 1.0 - pos);
         return min(min(dist.x, dist.y), min(dist.z, dist.w)) * u.morphFactor;

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.data[i] = s1 * s;
-                v.data[j] = s2 * s;
+                v.setComponent(i, s1 * s);
+                v.setComponent(j, s2 * s);
                 vertices.push(v);
             }
         }