@3driseai/3drise-viewer 0.1.1

package/dist/components/cursor/clickActions/ImplosionAction.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uBandCount;
+  uniform vec3  uColor;
+  varying vec2  vUv;
+
+  void main() {
+    vec2 p = (vUv - 0.5) * 2.0;
+    float r = length(p);
+
+    // Two phases: convergence (0 → 0.65) and bloom + fade (0.65 → 1.0)
+    float convergeT = clamp(uProgress / 0.65, 0.0, 1.0);
+    float bloomT    = clamp((uProgress - 0.65) / 0.35, 0.0, 1.0);
+
+    // ── Converging ring ────────────────────────────────────────────────────
+    // Ease-in inward so the ring decelerates as it tightens — feels gravitational.
+    float ringR = 1.0 - pow(convergeT, 2.0);
+    // Width narrows as it converges; ring brightens as it tightens.
+    float w = 0.07 * (1.0 - convergeT * 0.6);
+    float ring = smoothstep(ringR - w, ringR - w * 0.4, r)
+               * (1.0 - smoothstep(ringR + w * 0.4, ringR + w, r));
+    ring *= (0.6 + convergeT * 0.8);
+
+    // Chromatic banding inside the ring — gentle radial waves
+    float band = 0.5 + 0.5 * sin(r * uBandCount - uProgress * 14.0);
+    band = pow(band, 6.0) * 0.35;
+    float bandMask = (1.0 - smoothstep(0.0, ringR + w, r)); // bands live inside the ring
+    float bands = band * bandMask;
+
+    // ── Central bloom ──────────────────────────────────────────────────────
+    // Activates after convergence completes. Bright at center, soft falloff.
+    float bloomRadius = 0.05 + bloomT * 0.6;
+    float bloom = pow(max(0.0, 1.0 - r / bloomRadius), 3.0);
+    bloom *= (1.0 - pow(bloomT, 2.0)); // ease-out fade as it expands
+
+    // ── Compose ────────────────────────────────────────────────────────────
+    float intensity = ring * 1.4 + bands * 0.9 + bloom * 1.8;
+
+    // Hot center → uColor outer
+    vec3 col = mix(vec3(1.0), uColor, smoothstep(0.0, ringR + 0.2, r));
+    col *= 1.0 + intensity * 0.8;
+
+    float fade = 1.0 - smoothstep(0.85, 1.0, uProgress);
+    float alpha = intensity * fade;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const ImplosionAction = ({ worldPos, config, onDone }) => {
+    const startRef = useRef(null);
+    const meshRef = useRef(null);
+    const { camera } = useThree();
+    const size = (config.scale ?? 1) * 2.5;
+    const geometry = useMemo(() => new THREE.PlaneGeometry(size, size, 1, 1), [size]);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uProgress: { value: 0 },
+            uBandCount: { value: Math.max(2, config.bandCount ?? 18) },
+            uColor: { value: new THREE.Color(config.color) },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        side: THREE.DoubleSide,
+        blending: THREE.AdditiveBlending,
+    }), []);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state) => {
+        if (startRef.current === null)
+            startRef.current = state.clock.getElapsedTime();
+        const elapsedMs = (state.clock.getElapsedTime() - startRef.current) * 1000;
+        const p = Math.min(elapsedMs / config.durationMs, 1);
+        material.uniforms.uProgress.value = p;
+        if (meshRef.current)
+            meshRef.current.lookAt(camera.position);
+        if (p >= 1)
+            onDone();
+    });
+    return _jsx("mesh", { ref: meshRef, position: worldPos, geometry: geometry, material: material });
+};
+export default ImplosionAction;

package/dist/components/cursor/clickActions/PhaseShiftAction.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import React from "react";
+import type { PhaseShiftActionConfig } from "@3driseai/3drise-core";
+interface PhaseShiftActionProps {
+    worldPos: THREE.Vector3;
+    config: PhaseShiftActionConfig;
+    onDone: () => void;
+}
+declare const PhaseShiftAction: React.FC<PhaseShiftActionProps>;
+export default PhaseShiftAction;
+//# sourceMappingURL=PhaseShiftAction.d.ts.map

package/dist/components/cursor/clickActions/PhaseShiftAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhaseShiftAction.d.ts","sourceRoot":"","sources":["../../../../src/components/cursor/clickActions/PhaseShiftAction.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,UAAU,qBAAqB;IAC3B,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AAsCD,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CA8BrD,CAAC;AACF,eAAe,gBAAgB,CAAC"}

package/dist/components/cursor/clickActions/PhaseShiftAction.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uMaxRadius;
+  varying vec3 vPos;
+  void main() {
+    vPos = position;
+    vec3 pos = position * (uMaxRadius * uProgress);
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uTime;
+  uniform vec3  uColor;
+  varying vec3 vPos;
+  void main() {
+    // Scanline pattern on the sphere surface
+    float scan = sin(vPos.y * 80.0 + uTime * 20.0) * 0.5 + 0.5;
+    // Chromatic shift: red/blue separation based on direction
+    vec3 dir = normalize(vPos);
+    vec3 chroma = vec3(
+      0.4 + dir.x * 0.5,
+      0.6,
+      0.4 - dir.x * 0.5
+    );
+    vec3 col = mix(uColor, chroma, 0.6);
+    col += scan * 0.2;
+    // Fresnel-ish thinner shell: brightest near grazing angles
+    float shell = pow(1.0 - abs(dot(normalize(vPos), vec3(0.0, 0.0, 1.0))), 2.0);
+    float fade = 1.0 - uProgress;
+    float alpha = fade * 0.55 * shell;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col * (1.0 + fade * 0.4), alpha);
+  }
+`;
+const PhaseShiftAction = ({ worldPos, config, onDone }) => {
+    const startRef = useRef(null);
+    const { clock } = useThree();
+    const geometry = useMemo(() => new THREE.SphereGeometry(1, 36, 24), []);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uProgress: { value: 0 },
+            uTime: { value: 0 },
+            uMaxRadius: { value: (config.radius ?? config.scale ?? 1) * 3 },
+            uColor: { value: new THREE.Color(config.color) },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        side: THREE.BackSide,
+        blending: THREE.AdditiveBlending,
+    }), []);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state) => {
+        if (startRef.current === null)
+            startRef.current = state.clock.getElapsedTime();
+        const elapsedMs = (state.clock.getElapsedTime() - startRef.current) * 1000;
+        const p = Math.min(elapsedMs / config.durationMs, 1);
+        material.uniforms.uProgress.value = p;
+        material.uniforms.uTime.value = clock.getElapsedTime();
+        if (p >= 1)
+            onDone();
+    });
+    return _jsx("mesh", { position: worldPos, geometry: geometry, material: material });
+};
+export default PhaseShiftAction;

package/dist/components/cursor/clickActions/PlasmaBombAction.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import React from "react";
+import type { PlasmaBombActionConfig } from "@3driseai/3drise-core";
+interface PlasmaBombActionProps {
+    worldPos: THREE.Vector3;
+    config: PlasmaBombActionConfig;
+    onDone: () => void;
+}
+declare const PlasmaBombAction: React.FC<PlasmaBombActionProps>;
+export default PlasmaBombAction;
+//# sourceMappingURL=PlasmaBombAction.d.ts.map

package/dist/components/cursor/clickActions/PlasmaBombAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlasmaBombAction.d.ts","sourceRoot":"","sources":["../../../../src/components/cursor/clickActions/PlasmaBombAction.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,UAAU,qBAAqB;IAC3B,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AA+DD,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CAgCrD,CAAC;AACF,eAAe,gBAAgB,CAAC"}

package/dist/components/cursor/clickActions/PlasmaBombAction.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uMaxRadius;
+  varying vec2 vUv;
+  varying float vRadial;
+  void main() {
+    vUv = uv;
+    vRadial = length(position.xy);
+    vec3 pos = position * (uMaxRadius * uProgress);
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uTime;
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  varying vec2 vUv;
+
+  // 2D hash + FBM noise
+  float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+  float noise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    return mix(
+      mix(hash(i + vec2(0,0)), hash(i + vec2(1,0)), f.x),
+      mix(hash(i + vec2(0,1)), hash(i + vec2(1,1)), f.x),
+      f.y);
+  }
+  float fbm(vec2 p) {
+    float v = 0.0;
+    float a = 0.5;
+    for (int i = 0; i < 4; i++) {
+      v += a * noise(p);
+      p *= 2.03;
+      a *= 0.5;
+    }
+    return v;
+  }
+
+  void main() {
+    // vUv.y is across the ring's tube; vUv.x is around the ring.
+    float t = uTime * 2.0;
+    vec2 p = vec2(vUv.x * 6.0 - t * 0.4, vUv.y * 2.0 + t * 0.3);
+    float n = fbm(p);
+
+    // Plasma gradient: deep magenta → uColor → near-white core
+    vec3 hot   = vec3(1.0, 0.95, 0.7);
+    vec3 cold  = uColor * 0.4 + vec3(0.15, 0.0, 0.25);
+    vec3 plasma = mix(cold, uColor, smoothstep(0.2, 0.7, n));
+    plasma = mix(plasma, hot, smoothstep(0.7, 0.95, n));
+
+    float fade  = 1.0 - uProgress;
+    float corona = exp(-uProgress * 4.0);
+    float alpha = fade * uOpacity * (0.5 + corona * 0.8);
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(plasma * (1.0 + corona * 0.5), alpha);
+  }
+`;
+const PlasmaBombAction = ({ worldPos, config, onDone }) => {
+    const startRef = useRef(null);
+    const { clock } = useThree();
+    const tubeRadius = (config.ringWidth ?? 0.08);
+    const geometry = useMemo(() => new THREE.TorusGeometry(1, tubeRadius, 16, 96), [tubeRadius]);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uProgress: { value: 0 },
+            uTime: { value: 0 },
+            uMaxRadius: { value: config.scale },
+            uColor: { value: new THREE.Color(config.color) },
+            uOpacity: { value: 1 },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.DoubleSide,
+    }), []);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state) => {
+        if (startRef.current === null)
+            startRef.current = state.clock.getElapsedTime();
+        const elapsedMs = (state.clock.getElapsedTime() - startRef.current) * 1000;
+        const p = Math.min(elapsedMs / config.durationMs, 1);
+        material.uniforms.uProgress.value = p;
+        material.uniforms.uTime.value = clock.getElapsedTime();
+        if (p >= 1)
+            onDone();
+    });
+    return (_jsx("mesh", { position: worldPos, rotation: [-Math.PI / 2, 0, 0], geometry: geometry, material: material }));
+};
+export default PlasmaBombAction;

package/dist/components/cursor/clickActions/RealityTearAction.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import React from "react";
+import type { RealityTearActionConfig } from "@3driseai/3drise-core";
+interface RealityTearActionProps {
+    worldPos: THREE.Vector3;
+    config: RealityTearActionConfig;
+    onDone: () => void;
+}
+declare const RealityTearAction: React.FC<RealityTearActionProps>;
+export default RealityTearAction;
+//# sourceMappingURL=RealityTearAction.d.ts.map

package/dist/components/cursor/clickActions/RealityTearAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RealityTearAction.d.ts","sourceRoot":"","sources":["../../../../src/components/cursor/clickActions/RealityTearAction.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AACrE,UAAU,sBAAsB;IAC5B,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,uBAAuB,CAAC;IAChC,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AAgDD,QAAA,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,sBAAsB,CAyCvD,CAAC;AACF,eAAe,iBAAiB,CAAC"}

package/dist/components/cursor/clickActions/RealityTearAction.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  uniform float uOpenX;
+  uniform float uOpenY;
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    vec3 pos = vec3(position.x * uOpenX, position.y * uOpenY, position.z);
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uTime;
+  uniform float uProgress;
+  uniform float uOpenY;
+  uniform vec3  uColor;
+  varying vec2 vUv;
+
+  float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+  float noise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    return mix(
+      mix(hash(i + vec2(0,0)), hash(i + vec2(1,0)), f.x),
+      mix(hash(i + vec2(0,1)), hash(i + vec2(1,1)), f.x),
+      f.y);
+  }
+
+  void main() {
+    // Static / VHS noise inside the slit
+    float n = noise(vUv * vec2(180.0, 9.0) + vec2(uTime * 60.0, 0.0));
+    float scan = sin(vUv.y * 600.0 + uTime * 40.0) * 0.5 + 0.5;
+    float band = smoothstep(0.0, 0.05, vUv.y) * smoothstep(0.0, 0.05, 1.0 - vUv.y);
+
+    // Bright bleeding edges
+    float edge = pow(1.0 - abs(vUv.x * 2.0 - 1.0), 6.0);
+    vec3 col = mix(vec3(n) * uColor, vec3(1.0), edge);
+    col += scan * 0.15;
+
+    float fade = 1.0 - smoothstep(0.7, 1.0, uProgress);
+    float alpha = band * (0.85 + edge * 0.6) * fade;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const RealityTearAction = ({ worldPos, config, onDone }) => {
+    const startRef = useRef(null);
+    const meshRef = useRef(null);
+    const { camera, clock } = useThree();
+    const tearWidth = config.tearWidth ?? 1.6;
+    const tearHeight = config.scale ?? 1;
+    const geometry = useMemo(() => new THREE.PlaneGeometry(tearWidth, tearHeight, 1, 1), [tearWidth, tearHeight]);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uTime: { value: 0 },
+            uProgress: { value: 0 },
+            uOpenX: { value: 0 },
+            uOpenY: { value: 0.02 },
+            uColor: { value: new THREE.Color(config.color) },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        side: THREE.DoubleSide,
+        blending: THREE.AdditiveBlending,
+    }), []);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state) => {
+        if (startRef.current === null)
+            startRef.current = state.clock.getElapsedTime();
+        const elapsedMs = (state.clock.getElapsedTime() - startRef.current) * 1000;
+        const p = Math.min(elapsedMs / config.durationMs, 1);
+        material.uniforms.uProgress.value = p;
+        material.uniforms.uTime.value = clock.getElapsedTime();
+        // Triangular envelope: open 0..0.5, close 0.5..1
+        const open = p < 0.5 ? p * 2 : (1 - p) * 2;
+        material.uniforms.uOpenX.value = open;
+        material.uniforms.uOpenY.value = 0.04 + open * 0.96;
+        // Billboard toward camera
+        if (meshRef.current)
+            meshRef.current.lookAt(camera.position);
+        if (p >= 1)
+            onDone();
+    });
+    return (_jsx("mesh", { ref: meshRef, position: worldPos, geometry: geometry, material: material }));
+};
+export default RealityTearAction;

package/dist/components/cursor/clickActions/ShockwaveAction.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import React from "react";
+import type { ClickActionConfig } from "@3driseai/3drise-core";
+export interface ShockwaveActionProps {
+    worldPos: THREE.Vector3;
+    config: ClickActionConfig;
+    onDone: () => void;
+}
+declare const ShockwaveAction: React.FC<ShockwaveActionProps>;
+export default ShockwaveAction;
+//# sourceMappingURL=ShockwaveAction.d.ts.map

package/dist/components/cursor/clickActions/ShockwaveAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShockwaveAction.d.ts","sourceRoot":"","sources":["../../../../src/components/cursor/clickActions/ShockwaveAction.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AAwBD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA4BnD,CAAC;AACF,eAAe,eAAe,CAAC"}

package/dist/components/cursor/clickActions/ShockwaveAction.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uMaxRadius;
+  void main() {
+    vec3 pos = position * (uMaxRadius * uProgress);
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  void main() {
+    float fade = 1.0 - uProgress;
+    float corona = exp(-uProgress * 5.0);
+    float alpha = fade * uOpacity * (0.6 + corona * 0.8);
+    if (alpha < 0.005) discard;
+    vec3 col = uColor * (1.0 + corona * 0.6);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const ShockwaveAction = ({ worldPos, config, onDone }) => {
+    const startRef = useRef(null);
+    const geometry = useMemo(() => new THREE.TorusGeometry(1, 0.04, 8, 80), []);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uProgress: { value: 0 },
+            uMaxRadius: { value: config.scale },
+            uColor: { value: new THREE.Color(config.color) },
+            uOpacity: { value: 1 },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        blending: THREE.AdditiveBlending,
+        side: THREE.DoubleSide,
+    }), []);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state) => {
+        if (startRef.current === null)
+            startRef.current = state.clock.getElapsedTime();
+        const elapsedMs = (state.clock.getElapsedTime() - startRef.current) * 1000;
+        const p = Math.min(elapsedMs / config.durationMs, 1);
+        material.uniforms.uProgress.value = p;
+        if (p >= 1)
+            onDone();
+    });
+    return (_jsx("mesh", { position: worldPos, rotation: [-Math.PI / 2, 0, 0], geometry: geometry, material: material }));
+};
+export default ShockwaveAction;

package/dist/components/cursor/clickActions/SparklesBurstAction.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import React from "react";
+import type { SparklesBurstActionConfig } from "@3driseai/3drise-core";
+interface SparklesBurstActionProps {
+    worldPos: THREE.Vector3;
+    config: SparklesBurstActionConfig;
+    onDone: () => void;
+}
+declare const SparklesBurstAction: React.FC<SparklesBurstActionProps>;
+export default SparklesBurstAction;
+//# sourceMappingURL=SparklesBurstAction.d.ts.map

package/dist/components/cursor/clickActions/SparklesBurstAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparklesBurstAction.d.ts","sourceRoot":"","sources":["../../../../src/components/cursor/clickActions/SparklesBurstAction.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,UAAU,wBAAwB;IAC9B,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,yBAAyB,CAAC;IAClC,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AA8DD,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CAkC3D,CAAC;AACF,eAAe,mBAAmB,CAAC"}

package/dist/components/cursor/clickActions/SparklesBurstAction.js

@@ -0,0 +1,99 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uTime;
+  uniform float uRayCount;
+  uniform vec3  uColor;
+  varying vec2  vUv;
+
+  #define PI 3.14159265359
+
+  void main() {
+    // Polar coords centered on the quad
+    vec2 p = (vUv - 0.5) * 2.0;
+    float r = length(p);
+    float theta = atan(p.y, p.x);
+
+    // Ease-out expansion: front of the wave reaches r=1 at uProgress=1
+    float expand = 1.0 - pow(1.0 - uProgress, 3.0);
+
+    // N rays radiating outward, each as a tapered bright slice
+    float angularPhase = theta * uRayCount * 0.5 / PI;
+    float rays = pow(0.5 + 0.5 * cos(angularPhase * 2.0 * PI), 12.0);
+
+    // Thin wavefront ring at r = expand
+    float wf = smoothstep(expand - 0.04, expand - 0.005, r)
+             * (1.0 - smoothstep(expand + 0.005, expand + 0.04, r));
+
+    // Tapered ray length: bright at base, fades at the leading edge
+    float rayLen = rays
+      * smoothstep(0.02, 0.18, r)
+      * (1.0 - smoothstep(expand * 0.4, expand * 1.05, r));
+
+    // Bright soft core that fades during the latter half
+    float core = pow(max(0.0, 1.0 - r * 4.0), 4.0)
+               * (1.0 - smoothstep(0.25, 0.7, uProgress));
+
+    // Tiny sparkles travelling along each ray
+    float sparkleR = fract(r * 4.5 - uTime * 1.2);
+    float sparkle = pow(1.0 - 2.0 * abs(sparkleR - 0.5), 18.0) * rays;
+
+    float intensity = wf * 1.4 + rayLen * 1.0 + core * 1.2 + sparkle * 0.9;
+
+    // Color: hot white inner → uColor outer
+    vec3 col = mix(vec3(1.0), uColor, smoothstep(0.05, expand * 0.9, r));
+    col *= 1.0 + intensity * 0.9;
+
+    // Overall fade-out across the action lifetime
+    float fade = 1.0 - smoothstep(0.7, 1.0, uProgress);
+    float alpha = intensity * fade;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const SparklesBurstAction = ({ worldPos, config, onDone }) => {
+    const startRef = useRef(null);
+    const meshRef = useRef(null);
+    const { camera, clock } = useThree();
+    const size = (config.scale ?? 1) * 2.5;
+    const geometry = useMemo(() => new THREE.PlaneGeometry(size, size, 1, 1), [size]);
+    const material = useMemo(() => new THREE.ShaderMaterial({
+        uniforms: {
+            uProgress: { value: 0 },
+            uTime: { value: 0 },
+            uRayCount: { value: Math.max(3, config.rayCount ?? 8) },
+            uColor: { value: new THREE.Color(config.color) },
+        },
+        vertexShader,
+        fragmentShader,
+        transparent: true,
+        depthWrite: false,
+        side: THREE.DoubleSide,
+        blending: THREE.AdditiveBlending,
+    }), []);
+    useEffect(() => () => { geometry.dispose(); material.dispose(); }, [geometry, material]);
+    useFrame((state) => {
+        if (startRef.current === null)
+            startRef.current = state.clock.getElapsedTime();
+        const elapsedMs = (state.clock.getElapsedTime() - startRef.current) * 1000;
+        const p = Math.min(elapsedMs / config.durationMs, 1);
+        material.uniforms.uProgress.value = p;
+        material.uniforms.uTime.value = clock.getElapsedTime();
+        if (meshRef.current)
+            meshRef.current.lookAt(camera.position);
+        if (p >= 1)
+            onDone();
+    });
+    return _jsx("mesh", { ref: meshRef, position: worldPos, geometry: geometry, material: material });
+};
+export default SparklesBurstAction;

package/dist/components/cursor/clickActions/VoronoiFractureAction.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import React from "react";
+import type { VoronoiFractureActionConfig } from "@3driseai/3drise-core";
+interface VoronoiFractureActionProps {
+    worldPos: THREE.Vector3;
+    config: VoronoiFractureActionConfig;
+    onDone: () => void;
+}
+declare const VoronoiFractureAction: React.FC<VoronoiFractureActionProps>;
+export default VoronoiFractureAction;
+//# sourceMappingURL=VoronoiFractureAction.d.ts.map

package/dist/components/cursor/clickActions/VoronoiFractureAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoronoiFractureAction.d.ts","sourceRoot":"","sources":["../../../../src/components/cursor/clickActions/VoronoiFractureAction.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AACzE,UAAU,0BAA0B;IAChC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,2BAA2B,CAAC;IACpC,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AAuED,QAAA,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC,0BAA0B,CA2E/D,CAAC;AACF,eAAe,qBAAqB,CAAC"}