@backbay/glia 0.2.0-alpha.1

package/dist/primitives/three/AmbientField/AmbientField.js

@@ -0,0 +1,156 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * AmbientField - 3D reactive background field
+ *
+ * A shader-based ambient layer that responds to Backbay domain events,
+ * creating visual impulses, anchors, and hover effects.
+ */
+import * as React from "react";
+import { Canvas, useFrame, useThree } from "@react-three/fiber";
+import { createFieldUniforms, createPlaneMaterial, createPointsMaterial, createPointsGeometry, } from "./shaders/constellation";
+import { useFieldBus, useFieldState, FieldProvider } from "./FieldProvider";
+import { DEFAULT_FIELD_CONFIG } from "./types";
+function FieldPlane({ uniforms, width, height }) {
+    const meshRef = React.useRef(null);
+    const materialRef = React.useRef(null);
+    // Create material once
+    if (!materialRef.current) {
+        materialRef.current = createPlaneMaterial(uniforms);
+    }
+    // Cleanup on unmount
+    React.useEffect(() => {
+        return () => {
+            materialRef.current?.dispose();
+        };
+    }, []);
+    return (_jsxs("mesh", { ref: meshRef, position: [0, 0, 0], children: [_jsx("planeGeometry", { args: [width, height] }), _jsx("primitive", { object: materialRef.current, attach: "material" })] }));
+}
+function FieldPoints({ uniforms, count, width, height }) {
+    const pointsRef = React.useRef(null);
+    const geometryRef = React.useRef(null);
+    const materialRef = React.useRef(null);
+    // Create geometry and material once
+    if (!geometryRef.current) {
+        geometryRef.current = createPointsGeometry(count, width, height);
+    }
+    if (!materialRef.current) {
+        materialRef.current = createPointsMaterial(uniforms);
+    }
+    // Cleanup on unmount
+    React.useEffect(() => {
+        return () => {
+            geometryRef.current?.dispose();
+            materialRef.current?.dispose();
+        };
+    }, []);
+    // Recreate geometry when dimensions change
+    React.useEffect(() => {
+        if (geometryRef.current) {
+            geometryRef.current.dispose();
+            geometryRef.current = createPointsGeometry(count, width, height);
+        }
+    }, [count, width, height]);
+    return (_jsxs("points", { ref: pointsRef, position: [0, 0, 0.02], children: [_jsx("primitive", { object: geometryRef.current, attach: "geometry" }), _jsx("primitive", { object: materialRef.current, attach: "material" })] }));
+}
+function FieldScene({ enablePoints = true, pointsCount = 3000, probeRadius = 0.08, }) {
+    const bus = useFieldBus();
+    const state = useFieldState();
+    const { size, viewport } = useThree();
+    // Create uniforms once
+    const uniformsRef = React.useRef(null);
+    if (!uniformsRef.current) {
+        uniformsRef.current = createFieldUniforms();
+    }
+    const uniforms = uniformsRef.current;
+    // Update resolution
+    React.useEffect(() => {
+        uniforms.uResolution.value.x = size.width;
+        uniforms.uResolution.value.y = size.height;
+    }, [size, uniforms]);
+    // Update probe radius
+    React.useEffect(() => {
+        uniforms.uProbeRadius.value = probeRadius;
+    }, [probeRadius, uniforms]);
+    // Animation frame
+    useFrame((frameState, delta) => {
+        const now = Date.now();
+        // Update time
+        uniforms.uTime.value = frameState.clock.elapsedTime;
+        // Tick the bus
+        bus.tick(delta * 1000, now);
+        // Update hover state
+        const hover = state.hover;
+        uniforms.uHover.value.x = hover.uv.x;
+        uniforms.uHover.value.y = hover.uv.y;
+        uniforms.uHover.value.z = hover.intent === "etch" ? 1 : 0;
+        uniforms.uHover.value.w = hover.active ? 1 : 0;
+        // Update impulses
+        const impulses = state.impulses;
+        const config = bus.getConfig();
+        const decayMs = config.impulseDecayMs;
+        uniforms.uImpulseCount.value = Math.min(impulses.length, 24);
+        for (let i = 0; i < 24; i++) {
+            if (i < impulses.length) {
+                const imp = impulses[i];
+                uniforms.uImpulses.value[i].x = imp.uv.x;
+                uniforms.uImpulses.value[i].y = imp.uv.y;
+                uniforms.uImpulses.value[i].z = imp.radius;
+                uniforms.uImpulses.value[i].w = imp.amplitude;
+                // Calculate age (0-1)
+                const age = Math.min(1, (now - imp.startTs) / decayMs);
+                uniforms.uImpulsesAge.value[i] = age;
+            }
+            else {
+                uniforms.uImpulsesAge.value[i] = 1;
+            }
+        }
+        // Update anchors
+        const anchors = Array.from(state.anchors.values());
+        uniforms.uAnchorCount.value = Math.min(anchors.length, 8);
+        for (let i = 0; i < 8; i++) {
+            if (i < anchors.length) {
+                const anchor = anchors[i];
+                uniforms.uAnchors.value[i].x = anchor.uv.x;
+                uniforms.uAnchors.value[i].y = anchor.uv.y;
+                uniforms.uAnchors.value[i].z = anchor.strength;
+                uniforms.uAnchors.value[i].w = (now - anchor.createdTs) * 0.001; // Phase
+                // Color mapping (simplified)
+                const colorMap = {
+                    cyan: [0, 0.94, 1],
+                    emerald: [0, 1, 0.53],
+                    amber: [1, 0.76, 0],
+                    rose: [1, 0.2, 0.5],
+                    violet: [0.56, 0.2, 1],
+                    slate: [0.4, 0.45, 0.5],
+                };
+                const rgb = colorMap[anchor.color] || colorMap.cyan;
+                uniforms.uAnchorColors.value[i].x = rgb[0];
+                uniforms.uAnchorColors.value[i].y = rgb[1];
+                uniforms.uAnchorColors.value[i].z = rgb[2];
+                uniforms.uAnchorColors.value[i].w = 1;
+            }
+        }
+    });
+    // Calculate plane dimensions based on viewport
+    const planeWidth = viewport.width * 1.2;
+    const planeHeight = viewport.height * 1.2;
+    return (_jsxs(_Fragment, { children: [_jsx(FieldPlane, { uniforms: uniforms, width: planeWidth, height: planeHeight }), enablePoints && (_jsx(FieldPoints, { uniforms: uniforms, count: pointsCount, width: planeWidth, height: planeHeight }))] }));
+}
+export function AmbientField({ className, style, fov = DEFAULT_FIELD_CONFIG.fov, cameraZ = DEFAULT_FIELD_CONFIG.cameraZ, dpr = DEFAULT_FIELD_CONFIG.dpr, enablePoints = DEFAULT_FIELD_CONFIG.enablePoints, pointsCount = DEFAULT_FIELD_CONFIG.pointsCount, probeRadius = DEFAULT_FIELD_CONFIG.probeRadius, useGlobalBus = false, children, }) {
+    return (_jsx("div", { className: className, style: {
+            position: "absolute",
+            inset: 0,
+            overflow: "hidden",
+            ...style,
+        }, children: _jsxs(FieldProvider, { useGlobal: useGlobalBus, children: [_jsx(Canvas, { dpr: dpr, camera: {
+                        fov,
+                        position: [0, 0, cameraZ],
+                        near: 0.1,
+                        far: 100,
+                    }, style: { background: "transparent" }, children: _jsx(FieldScene, { enablePoints: enablePoints, pointsCount: pointsCount, probeRadius: probeRadius }) }), children] }) }));
+}
+// -----------------------------------------------------------------------------
+// Hook to access field bus from outside Canvas
+// -----------------------------------------------------------------------------
+export { useFieldBus, useFieldState } from "./FieldProvider";

package/dist/primitives/three/AmbientField/BackbayFieldBus.d.ts

@@ -0,0 +1,10 @@
+/**
+ * BackbayFieldBus - Event bus for Ambient Field
+ *
+ * Manages state for the reactive field, translating Backbay domain events
+ * into visual impulses, anchors, and hover effects.
+ */
+import type { BackbayFieldBus, FieldConfig } from "./types";
+export declare function createBackbayFieldBus(initialConfig?: Partial<FieldConfig>): BackbayFieldBus;
+export declare function getGlobalFieldBus(): BackbayFieldBus;
+//# sourceMappingURL=BackbayFieldBus.d.ts.map

package/dist/primitives/three/AmbientField/BackbayFieldBus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackbayFieldBus.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/AmbientField/BackbayFieldBus.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAEV,eAAe,EAEf,WAAW,EAIZ,MAAM,SAAS,CAAC;AAiCjB,wBAAgB,qBAAqB,CACnC,aAAa,GAAE,OAAO,CAAC,WAAW,CAAM,GACvC,eAAe,CAqQjB;AAQD,wBAAgB,iBAAiB,IAAI,eAAe,CAKnD"}

package/dist/primitives/three/AmbientField/BackbayFieldBus.js

@@ -0,0 +1,264 @@
+/**
+ * BackbayFieldBus - Event bus for Ambient Field
+ *
+ * Manages state for the reactive field, translating Backbay domain events
+ * into visual impulses, anchors, and hover effects.
+ */
+import { DEFAULT_FIELD_CONFIG } from "./types";
+// -----------------------------------------------------------------------------
+// Initial State
+// -----------------------------------------------------------------------------
+function createInitialState() {
+    return {
+        impulses: [],
+        anchors: new Map(),
+        hover: {
+            active: false,
+            uv: { x: 0.5, y: 0.5 },
+            intent: "probe",
+            velocity: { x: 0, y: 0 },
+            lastTs: 0,
+            sourceId: null,
+        },
+        frame: 0,
+        pendingEvents: [],
+    };
+}
+// -----------------------------------------------------------------------------
+// Bus Factory
+// -----------------------------------------------------------------------------
+let idCounter = 0;
+function generateId() {
+    return `field-${Date.now()}-${idCounter++}`;
+}
+export function createBackbayFieldBus(initialConfig = {}) {
+    let state = createInitialState();
+    let config = { ...DEFAULT_FIELD_CONFIG, ...initialConfig };
+    const listeners = new Set();
+    // Notify all listeners
+    const notify = () => {
+        listeners.forEach((listener) => listener(state));
+    };
+    // Generate random UV position
+    const randomUv = () => ({
+        x: 0.1 + Math.random() * 0.8,
+        y: 0.1 + Math.random() * 0.8,
+    });
+    // Handle impulse event
+    const handleImpulse = (event) => {
+        const impulse = {
+            id: event.id,
+            uv: event.position || randomUv(),
+            startTs: Date.now(),
+            amplitude: event.intensity,
+            radius: 0.1,
+            color: event.color || "cyan",
+            source: event.source,
+        };
+        // Add impulse, capping at max
+        const newImpulses = [...state.impulses, impulse].slice(-config.maxImpulses);
+        state = {
+            ...state,
+            impulses: newImpulses,
+        };
+    };
+    // Handle anchor create
+    const handleAnchorCreate = (event) => {
+        const newAnchors = new Map(state.anchors);
+        const anchor = {
+            id: event.id,
+            entityId: event.entityId,
+            source: event.source,
+            uv: event.position || randomUv(),
+            strength: event.intensity,
+            color: event.color || "cyan",
+            createdTs: Date.now(),
+        };
+        newAnchors.set(event.entityId, anchor);
+        // Cap anchors
+        if (newAnchors.size > config.maxAnchors) {
+            const entries = Array.from(newAnchors.entries());
+            const trimmed = entries.slice(-config.maxAnchors);
+            newAnchors.clear();
+            trimmed.forEach(([k, v]) => newAnchors.set(k, v));
+        }
+        state = {
+            ...state,
+            anchors: newAnchors,
+        };
+    };
+    // Handle anchor update
+    const handleAnchorUpdate = (event) => {
+        const existing = state.anchors.get(event.entityId);
+        if (!existing) {
+            // Create if doesn't exist
+            handleAnchorCreate(event);
+            return;
+        }
+        const newAnchors = new Map(state.anchors);
+        newAnchors.set(event.entityId, {
+            ...existing,
+            strength: event.intensity,
+            color: event.color || existing.color,
+        });
+        state = {
+            ...state,
+            anchors: newAnchors,
+        };
+    };
+    // Handle anchor remove
+    const handleAnchorRemove = (event) => {
+        const newAnchors = new Map(state.anchors);
+        newAnchors.delete(event.entityId);
+        state = {
+            ...state,
+            anchors: newAnchors,
+        };
+    };
+    // Handle ripple (creates multiple impulses)
+    const handleRipple = (event) => {
+        const center = event.position || randomUv();
+        // event.duration available for future animation timing
+        const now = Date.now();
+        // Create 3 expanding impulses
+        const impulses = [
+            {
+                id: `${event.id}-1`,
+                uv: center,
+                startTs: now,
+                amplitude: event.intensity,
+                radius: 0.08,
+                color: event.color || "rose",
+                source: event.source,
+            },
+            {
+                id: `${event.id}-2`,
+                uv: center,
+                startTs: now + 200,
+                amplitude: event.intensity * 0.7,
+                radius: 0.12,
+                color: event.color || "rose",
+                source: event.source,
+            },
+            {
+                id: `${event.id}-3`,
+                uv: center,
+                startTs: now + 400,
+                amplitude: event.intensity * 0.5,
+                radius: 0.16,
+                color: event.color || "rose",
+                source: event.source,
+            },
+        ];
+        const newImpulses = [...state.impulses, ...impulses].slice(-config.maxImpulses);
+        state = {
+            ...state,
+            impulses: newImpulses,
+        };
+    };
+    // Handle tether (creates anchor pair + visual connection)
+    const handleTether = (event) => {
+        // For now, just create an impulse along the tether path
+        handleImpulse(event);
+    };
+    return {
+        emit(event) {
+            switch (event.type) {
+                case "impulse":
+                    handleImpulse(event);
+                    break;
+                case "anchor_create":
+                    handleAnchorCreate(event);
+                    break;
+                case "anchor_update":
+                    handleAnchorUpdate(event);
+                    break;
+                case "anchor_remove":
+                    handleAnchorRemove(event);
+                    break;
+                case "ripple":
+                    handleRipple(event);
+                    break;
+                case "tether":
+                    handleTether(event);
+                    break;
+            }
+            notify();
+        },
+        emitBackbayEvent(params) {
+            const event = {
+                id: generateId(),
+                type: params.type,
+                source: params.source,
+                entityId: params.entityId,
+                intensity: params.intensity ?? 0.8,
+                color: params.color ?? "cyan",
+                duration: params.duration,
+            };
+            this.emit(event);
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        getSnapshot() {
+            return state;
+        },
+        getServerSnapshot() {
+            return createInitialState();
+        },
+        setConfig(newConfig) {
+            config = { ...config, ...newConfig };
+        },
+        getConfig() {
+            return config;
+        },
+        tick(_deltaMs, currentTs) {
+            // Decay impulses
+            const decayThreshold = config.impulseDecayMs;
+            const activeImpulses = state.impulses.filter((imp) => currentTs - imp.startTs < decayThreshold);
+            // Only update if something changed
+            if (activeImpulses.length !== state.impulses.length) {
+                state = {
+                    ...state,
+                    impulses: activeImpulses,
+                    frame: state.frame + 1,
+                };
+                notify();
+            }
+            else {
+                state = {
+                    ...state,
+                    frame: state.frame + 1,
+                };
+            }
+        },
+        clear() {
+            state = createInitialState();
+            notify();
+        },
+        processPendingWithUv(_computeUv) {
+            const pending = state.pendingEvents;
+            if (pending.length === 0)
+                return;
+            // Process and clear pending events
+            state = {
+                ...state,
+                pendingEvents: [],
+            };
+            notify();
+        },
+    };
+}
+// -----------------------------------------------------------------------------
+// Singleton Instance
+// -----------------------------------------------------------------------------
+let globalBus = null;
+export function getGlobalFieldBus() {
+    if (!globalBus) {
+        globalBus = createBackbayFieldBus();
+    }
+    return globalBus;
+}

package/dist/primitives/three/AmbientField/FieldProvider.d.ts

@@ -0,0 +1,21 @@
+/**
+ * FieldProvider - React context for BackbayFieldBus
+ */
+import * as React from "react";
+import type { BackbayFieldBus, FieldConfig } from "./types";
+export interface FieldProviderProps {
+    children: React.ReactNode;
+    /** Custom bus instance (if not provided, creates a new one) */
+    bus?: BackbayFieldBus;
+    /** Initial config for auto-created bus */
+    config?: Partial<FieldConfig>;
+    /** Use global singleton bus instead of creating new one */
+    useGlobal?: boolean;
+}
+export declare function FieldProvider({ children, bus: propBus, config, useGlobal, }: FieldProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFieldBus(): BackbayFieldBus;
+/**
+ * Hook to subscribe to field state changes
+ */
+export declare function useFieldState(): import("./types").FieldRuntimeState;
+//# sourceMappingURL=FieldProvider.d.ts.map

package/dist/primitives/three/AmbientField/FieldProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldProvider.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/AmbientField/FieldProvider.tsx"],"names":[],"mappings":"AAEA;;GAEG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAY5D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,+DAA+D;IAC/D,GAAG,CAAC,EAAE,eAAe,CAAC;IACtB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAC9B,2DAA2D;IAC3D,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,GAAG,EAAE,OAAO,EACZ,MAAM,EACN,SAAiB,GAClB,EAAE,kBAAkB,2CAmBpB;AAMD,wBAAgB,WAAW,IAAI,eAAe,CAQ7C;AAED;;GAEG;AACH,wBAAgB,aAAa,wCAS5B"}

package/dist/primitives/three/AmbientField/FieldProvider.js

@@ -0,0 +1,48 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * FieldProvider - React context for BackbayFieldBus
+ */
+import * as React from "react";
+import { createBackbayFieldBus, getGlobalFieldBus } from "./BackbayFieldBus";
+// -----------------------------------------------------------------------------
+// Context
+// -----------------------------------------------------------------------------
+const FieldBusContext = React.createContext(null);
+export function FieldProvider({ children, bus: propBus, config, useGlobal = false, }) {
+    const busRef = React.useRef(null);
+    // Initialize bus
+    if (!busRef.current) {
+        if (propBus) {
+            busRef.current = propBus;
+        }
+        else if (useGlobal) {
+            busRef.current = getGlobalFieldBus();
+        }
+        else {
+            busRef.current = createBackbayFieldBus(config);
+        }
+    }
+    return (_jsx(FieldBusContext.Provider, { value: busRef.current, children: children }));
+}
+// -----------------------------------------------------------------------------
+// Hook
+// -----------------------------------------------------------------------------
+export function useFieldBus() {
+    const bus = React.useContext(FieldBusContext);
+    if (!bus) {
+        throw new Error("useFieldBus must be used within a FieldProvider");
+    }
+    return bus;
+}
+/**
+ * Hook to subscribe to field state changes
+ */
+export function useFieldState() {
+    const bus = useFieldBus();
+    const [state, setState] = React.useState(bus.getSnapshot());
+    React.useEffect(() => {
+        return bus.subscribe(setState);
+    }, [bus]);
+    return state;
+}

package/dist/primitives/three/AmbientField/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AmbientField Module Exports
+ */
+export { AmbientField, useFieldBus, useFieldState } from "./AmbientField";
+export type { AmbientFieldProps } from "./AmbientField";
+export { FieldProvider } from "./FieldProvider";
+export type { FieldProviderProps } from "./FieldProvider";
+export { createBackbayFieldBus, getGlobalFieldBus } from "./BackbayFieldBus";
+export { createFieldUniforms, createPlaneMaterial, createPointsMaterial, createPointsGeometry, VERTEX_SHADER, FRAGMENT_SHADER, POINTS_VERTEX_SHADER, POINTS_FRAGMENT_SHADER, } from "./shaders/constellation";
+export type { Anchor, BackbayFieldBus, FieldBusListener, FieldConfig, FieldRuntimeState, FieldUniforms, HoverState, Impulse, PendingEvent, UVPosition, } from "./types";
+export { DEFAULT_FIELD_CONFIG } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/primitives/three/AmbientField/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/AmbientField/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC1E,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE7E,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,MAAM,EACN,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,OAAO,EACP,YAAY,EACZ,UAAU,GACX,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC"}

package/dist/primitives/three/AmbientField/index.js

@@ -0,0 +1,8 @@
+/**
+ * AmbientField Module Exports
+ */
+export { AmbientField, useFieldBus, useFieldState } from "./AmbientField";
+export { FieldProvider } from "./FieldProvider";
+export { createBackbayFieldBus, getGlobalFieldBus } from "./BackbayFieldBus";
+export { createFieldUniforms, createPlaneMaterial, createPointsMaterial, createPointsGeometry, VERTEX_SHADER, FRAGMENT_SHADER, POINTS_VERTEX_SHADER, POINTS_FRAGMENT_SHADER, } from "./shaders/constellation";
+export { DEFAULT_FIELD_CONFIG } from "./types";

package/dist/primitives/three/AmbientField/shaders/constellation.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Constellation Style Shaders
+ *
+ * A faint lattice with iridescent interference, harmonic burst rings,
+ * and constellation-like points that brighten near interactions.
+ */
+import * as THREE from "three";
+import type { FieldUniforms } from "../types";
+export declare const VERTEX_SHADER = "\nvarying vec2 vUv;\nvarying vec3 vPosition;\n\nvoid main() {\n  vUv = uv;\n  vPosition = position;\n  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n}\n";
+export declare const FRAGMENT_SHADER = "\nuniform float uTime;\nuniform vec2 uResolution;\nuniform vec4 uHover;\nuniform vec4 uImpulses[24];\nuniform float uImpulsesAge[24];\nuniform int uImpulseCount;\nuniform vec4 uAnchors[8];\nuniform vec4 uAnchorColors[8];\nuniform int uAnchorCount;\nuniform float uProbeRadius;\n\nvarying vec2 vUv;\n\nconst float PI = 3.14159265359;\nconst float TAU = 6.28318530718;\n\n// Noise functions\nfloat hash(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);\n}\n\nfloat noise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  f = f * f * (3.0 - 2.0 * f);\n  float a = hash(i);\n  float b = hash(i + vec2(1.0, 0.0));\n  float c = hash(i + vec2(0.0, 1.0));\n  float d = hash(i + vec2(1.0, 1.0));\n  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\nfloat fbm(vec2 p) {\n  float value = 0.0;\n  float amplitude = 0.5;\n  for (int i = 0; i < 4; i++) {\n    value += amplitude * noise(p);\n    p *= 2.0;\n    amplitude *= 0.5;\n  }\n  return value;\n}\n\n// Hex lattice\nfloat hexDist(vec2 p) {\n  p = abs(p);\n  return max(p.x, dot(p, vec2(0.5, 0.866025)));\n}\n\nfloat hexLattice(vec2 uv, float scale) {\n  uv *= scale;\n  vec2 r = vec2(1.0, 1.732);\n  vec2 h = r * 0.5;\n  vec2 a = mod(uv, r) - h;\n  vec2 b = mod(uv - h, r) - h;\n  return min(hexDist(a), hexDist(b));\n}\n\n// Shapes\nfloat circle(vec2 uv, vec2 center, float radius, float softness) {\n  float d = length(uv - center);\n  return 1.0 - smoothstep(radius - softness, radius + softness, d);\n}\n\nfloat ring(vec2 uv, vec2 center, float radius, float thickness, float softness) {\n  float d = length(uv - center);\n  float inner = smoothstep(radius - thickness - softness, radius - thickness, d);\n  float outer = 1.0 - smoothstep(radius, radius + softness, d);\n  return inner * outer;\n}\n\n// Iridescence\nvec3 iridescence(float t, float intensity) {\n  vec3 a = vec3(0.5);\n  vec3 b = vec3(0.5);\n  vec3 c = vec3(1.0);\n  vec3 d = vec3(0.0, 0.33, 0.67);\n  return a + b * cos(TAU * (c * t + d)) * intensity;\n}\n\nvoid main() {\n  vec2 uv = vUv;\n\n  // Base: dark with subtle hex lattice\n  vec3 baseColor = vec3(0.01, 0.015, 0.025);\n\n  float hexVal = hexLattice(uv, 12.0);\n  float hexLine = smoothstep(0.06, 0.03, hexVal);\n  float latticeBase = hexLine * 0.03;\n  vec3 latticeColor = vec3(0.1, 0.3, 0.4) * latticeBase;\n\n  float drift = fbm(uv * 3.0 + uTime * 0.1) * 0.015;\n  vec3 color = baseColor + latticeColor + drift;\n\n  // Hover probe effect\n  if (uHover.w > 0.5) {\n    vec2 hoverUv = uHover.xy;\n    float isEtch = uHover.z;\n    float hoverDist = length(uv - hoverUv);\n\n    float revealZone = 1.0 - smoothstep(uProbeRadius * 0.5, uProbeRadius * 1.5, hoverDist);\n    float revealedLattice = hexLine * revealZone;\n    vec3 revealColor = isEtch > 0.5\n      ? vec3(0.9, 0.2, 0.5)\n      : vec3(0.1, 0.9, 0.95);\n\n    color += revealColor * revealedLattice * (isEtch > 0.5 ? 0.5 : 0.3);\n\n    float centralGlow = circle(uv, hoverUv, uProbeRadius * 0.3, uProbeRadius * 0.2);\n    color += revealColor * centralGlow * (isEtch > 0.5 ? 0.4 : 0.2);\n\n    float interference = sin((hoverDist - uTime * 0.3) * 40.0) * 0.5 + 0.5;\n    vec3 iriColor = iridescence(interference + hoverDist * 2.0, 0.4);\n    float iriZone = smoothstep(uProbeRadius * 1.5, uProbeRadius * 0.3, hoverDist);\n    color += iriColor * iriZone * 0.15;\n  }\n\n  // Impulse rings\n  for (int i = 0; i < 24; i++) {\n    if (i >= uImpulseCount) break;\n\n    vec4 imp = uImpulses[i];\n    float age = uImpulsesAge[i];\n    if (age >= 1.0) continue;\n\n    vec2 impUv = imp.xy;\n    float baseRadius = imp.z;\n    float amp = imp.w;\n\n    float expandedRadius = baseRadius + age * 0.35;\n    float thickness = 0.008 + (1.0 - age) * 0.015;\n    float primaryRing = ring(uv, impUv, expandedRadius, thickness, 0.003);\n    float secondaryRing = ring(uv, impUv, expandedRadius * 0.7, thickness * 0.7, 0.002);\n\n    float fade = (1.0 - age * age) * amp;\n    float dist = length(uv - impUv);\n    float interference = sin((dist - uTime * 0.8) * 80.0) * 0.5 + 0.5;\n    vec3 ringColor = iridescence(interference + age, 0.7);\n\n    color += ringColor * primaryRing * fade;\n    color += ringColor * secondaryRing * fade * 0.5;\n\n    float flash = (1.0 - age) * (1.0 - age);\n    float flashGlow = circle(uv, impUv, baseRadius * (1.0 - age * 0.5), 0.02);\n    color += vec3(1.0, 0.9, 0.95) * flashGlow * flash * amp * 0.3;\n  }\n\n  // Anchors\n  for (int i = 0; i < 8; i++) {\n    if (i >= uAnchorCount) break;\n\n    vec4 anchor = uAnchors[i];\n    vec4 anchorColor = uAnchorColors[i];\n    vec2 anchorUv = anchor.xy;\n    float strength = anchor.z;\n    float phase = anchor.w;\n\n    float anchorDist = length(uv - anchorUv);\n\n    float pulse = 0.6 + 0.4 * sin(uTime * 2.5 + phase);\n    float coreGlow = circle(uv, anchorUv, 0.025, 0.015) * strength * pulse;\n\n    float halo1 = ring(uv, anchorUv, 0.04 + sin(uTime * 1.5 + phase) * 0.01, 0.003, 0.002);\n    float halo2 = ring(uv, anchorUv, 0.06 + cos(uTime * 1.2 + phase) * 0.01, 0.002, 0.002);\n\n    float activationZone = smoothstep(0.12, 0.03, anchorDist);\n    float activatedLattice = hexLine * activationZone * strength;\n\n    vec3 aColor = anchorColor.rgb;\n    color += aColor * coreGlow;\n    color += aColor * (halo1 + halo2) * strength * pulse * 0.6;\n    color += aColor * activatedLattice * 0.2;\n  }\n\n  // Vignette\n  vec2 vignetteUv = uv * 2.0 - 1.0;\n  float vignette = 1.0 - dot(vignetteUv, vignetteUv) * 0.15;\n  color *= vignette;\n\n  color = pow(color, vec3(0.95));\n\n  gl_FragColor = vec4(color, 1.0);\n}\n";
+export declare const POINTS_VERTEX_SHADER = "\nuniform float uTime;\nuniform vec4 uHover;\nuniform vec4 uAnchors[8];\nuniform int uAnchorCount;\nuniform float uProbeRadius;\n\nattribute float aPhase;\nattribute float aSize;\n\nvarying float vBrightness;\nvarying float vPhase;\n\nvoid main() {\n  vec3 pos = position;\n  vec2 posUv = pos.xy * 0.5 + 0.5;\n\n  float brightness = 0.3;\n\n  if (uHover.w > 0.5) {\n    float hoverDist = length(posUv - uHover.xy);\n    float hoverBoost = 1.0 - smoothstep(uProbeRadius * 0.5, uProbeRadius * 2.0, hoverDist);\n    brightness += hoverBoost * 0.7;\n    vec2 toHover = uHover.xy - posUv;\n    pos.xy += toHover * hoverBoost * 0.02;\n  }\n\n  for (int i = 0; i < 8; i++) {\n    if (i >= uAnchorCount) break;\n    vec2 anchorUv = uAnchors[i].xy;\n    float strength = uAnchors[i].z;\n    float anchorDist = length(posUv - anchorUv);\n    float anchorBoost = 1.0 - smoothstep(0.05, 0.15, anchorDist);\n    brightness += anchorBoost * strength * 0.5;\n  }\n\n  float drift = sin(uTime * 0.5 + aPhase * 6.28) * 0.003;\n  pos.xy += drift;\n\n  vBrightness = brightness;\n  vPhase = aPhase;\n\n  vec4 mvPosition = modelViewMatrix * vec4(pos, 1.0);\n  gl_Position = projectionMatrix * mvPosition;\n\n  float baseSizeScale = aSize * (0.8 + brightness * 0.4);\n  gl_PointSize = baseSizeScale * (300.0 / -mvPosition.z);\n}\n";
+export declare const POINTS_FRAGMENT_SHADER = "\nuniform float uTime;\n\nvarying float vBrightness;\nvarying float vPhase;\n\nvoid main() {\n  vec2 center = gl_PointCoord - 0.5;\n  float dist = length(center);\n\n  if (dist > 0.5) discard;\n\n  float alpha = 1.0 - smoothstep(0.3, 0.5, dist);\n  float twinkle = 0.7 + 0.3 * sin(uTime * 3.0 + vPhase * 6.28);\n\n  vec3 color = mix(\n    vec3(0.15, 0.4, 0.5),\n    vec3(0.4, 0.95, 1.0),\n    vBrightness\n  );\n\n  if (vBrightness > 0.7) {\n    color = mix(color, vec3(1.0, 0.9, 0.8), (vBrightness - 0.7) * 2.0);\n  }\n\n  gl_FragColor = vec4(color, alpha * vBrightness * twinkle);\n}\n";
+export declare function createFieldUniforms(): FieldUniforms;
+export declare function createPlaneMaterial(uniforms: FieldUniforms): THREE.ShaderMaterial;
+export declare function createPointsMaterial(uniforms: FieldUniforms): THREE.ShaderMaterial;
+export declare function createPointsGeometry(count: number, planeWidth: number, planeHeight: number): THREE.BufferGeometry;
+//# sourceMappingURL=constellation.d.ts.map

package/dist/primitives/three/AmbientField/shaders/constellation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constellation.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/three/AmbientField/shaders/constellation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAM9C,eAAO,MAAM,aAAa,wLASzB,CAAC;AAMF,eAAO,MAAM,eAAe,u8KAwL3B,CAAC;AAMF,eAAO,MAAM,oBAAoB,kyCAgDhC,CAAC;AAEF,eAAO,MAAM,sBAAsB,glBA2BlC,CAAC;AAMF,wBAAgB,mBAAmB,IAAI,aAAa,CAmBnD;AAMD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAQjF;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAelF;AAMD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB,KAAK,CAAC,cAAc,CAqBtB"}