@3driseai/3drise-viewer 0.1.4 → 0.1.6

package/dist/hooks/useSequenceAnimation.js

@@ -4,12 +4,7 @@ import { AnimationsManager, findById } from '@3driseai/3drise-core';
 import { useAnimationEvents } from './useAnimationEvents.js';
 import { usePathAnimation } from './usePathAnimation.js';
 import { snapshotMaterialValues, interpolateMaterialProps } from '../utils/materialUtils.js';
-const DEBUG_SEQUENCE_ANIMATION = true;
-const debugLog = (...args) => {
-    if (DEBUG_SEQUENCE_ANIMATION) {
-        console.log('[useSequenceAnimation]', ...args);
-    }
-};
+import { resolveObject3D } from '../utils/resolveObject3D.js';
 // ─────────────────────────────────────────────────────────────────────────────
 // Helpers
 // ─────────────────────────────────────────────────────────────────────────────
@@ -39,15 +34,12 @@ function extractMaterialProps(props) {
  * Designed to be called inside useObjectAnimation so that AnimatedObject stays
  * a thin group wrapper.
  */
-export const useSequenceAnimation = (objectId, objectRef) => {
+export const useSequenceAnimation = (objectId, objectSource) => {
     const { startPathAnimation, updatePathAnimation, stopPathAnimation, isAnimating: isPathAnimating } = usePathAnimation();
     const resolveObject = () => {
-        const resolved = objectRef ?? (objectId ? findById(objectId) : null);
-        // console.log('Resolved object for sequence animation', {
-        //   objectId,
-        //   hasRefArg: !!objectRef,
-        //   resolved: resolved ? { name: resolved.name, id: resolved.userData?.id } : null,
-        // });
+        // Called from the frame loop, so a ref resolves as soon as React
+        // attaches it. findById stays as a fallback for id-only callers.
+        const resolved = resolveObject3D(objectSource) ?? (objectId ? findById(objectId) : null);
         return resolved;
     };
     // Active step state. Null = no sequence step currently animating.
@@ -56,7 +48,6 @@ export const useSequenceAnimation = (objectId, objectRef) => {
     const progressRef = useRef(1);
     const updateProgressRef = (p) => {
         progressRef.current = p;
-        // console.log('Progress update', { objectId, progress: p });
     };
     const updateStepRef = (state) => {
         stepRef.current = state;
@@ -65,51 +56,20 @@ export const useSequenceAnimation = (objectId, objectRef) => {
     useAnimationEvents({
         onStepStart: (event) => {
             if (!objectId || !event.step?.transitions) {
-                // debugLog('stepStart ignored: missing objectId or transitions', {
-                //   objectId,
-                //   hasTransitions: !!event.step?.transitions,
-                //   sequenceId: event.sequenceId,
-                //   stepIndex: event.stepIndex,
-                // });
                 return;
             }
-            // debugLog('stepStart received', {
-            //   objectId,
-            //   sequenceId: event.sequenceId,
-            //   stepIndex: event.stepIndex,
-            //   transitionStates: event.step.transitions.map(t => t.state),
-            //   resolvedObject: resolvedObject ? {
-            //     name: resolvedObject.name,
-            //     id: resolvedObject.userData?.id,
-            //   } : null,
-            // });
             // Find the transition targeting this object
             const transitionIndex = event.step.transitions.findIndex(t => t.state === objectId);
             if (transitionIndex === -1) {
-                // debugLog('no matching transition for objectId', {
-                //   objectId,
-                //   availableStates: event.step.transitions.map(t => t.state),
-                // });
                 return;
             }
-            console.log('TRANSTITION START', objectId);
             const resolvedObject = resolveObject();
-            console.log(objectId, resolvedObject?.name);
             const transition = event.step.transitions[transitionIndex];
             const stagger = event.step.stagger || 0;
             const staggerOffsetMs = transitionIndex * stagger * 1000;
             const d = event.step.duration || 1;
             const ease = event.step.ease || 'linear';
             const { properties, pathId = null } = transition;
-            console.log('Starting sequence step', resolvedObject?.name, properties);
-            // debugLog('matched transition', {
-            //   objectId,
-            //   pathId,
-            //   duration: d,
-            //   ease,
-            //   fromKeys: Object.keys(properties.from || {}),
-            //   toKeys: Object.keys(properties.to || {}),
-            // });
             // Visibility shortcut
             if (properties.to?.visible === false) {
                 if (resolvedObject)
@@ -145,13 +105,6 @@ export const useSequenceAnimation = (objectId, objectRef) => {
                 ? snapshotMaterialValues(resolvedObject, missingFromKeys)
                 : {};
             const materialFrom = { ...materialFromExplicit };
-            // debugLog('material from/to', {
-            //   objectId,
-            //   materialFromExplicit,
-            //   snapshotted,
-            //   materialFrom,
-            //   materialToProps,
-            // });
             updateStepRef({
                 startTime: performance.now() + staggerOffsetMs,
                 duration: d,
@@ -167,10 +120,8 @@ export const useSequenceAnimation = (objectId, objectRef) => {
                 visibilityOverride: null,
                 pathId,
             });
-            // console.log(stepRef.current)
             updateProgressRef(0);
             if (pathId) {
-                debugLog('starting path animation', { objectId, pathId, duration: d, ease });
                 startPathAnimation(pathId, d, { ease });
             }
             else {
@@ -184,11 +135,6 @@ export const useSequenceAnimation = (objectId, objectRef) => {
             const isForThisObject = event.step.transitions.some(t => t.state === objectId);
             if (!isForThisObject)
                 return;
-            // debugLog('stepEnd received', {
-            //   objectId,
-            //   sequenceId: event.sequenceId,
-            //   stepIndex: event.stepIndex,
-            // });
             // Let useFrame finish the last frame at p=1 naturally; just clear step
             // after a microtask so the final interpolated position is applied.
             // Promise.resolve().then(() => {
@@ -204,7 +150,6 @@ export const useSequenceAnimation = (objectId, objectRef) => {
             const isForThisObject = event.sequence.steps.some(s => s.transitions.some(t => t.state === objectId));
             if (!isForThisObject)
                 return;
-            debugLog('sequenceEnd received', { objectId, sequenceId: event.sequenceId });
             updateStepRef(null);
             updateProgressRef(1);
         }
@@ -213,13 +158,11 @@ export const useSequenceAnimation = (objectId, objectRef) => {
     useFrame((_state, delta) => {
         const resolvedObject = resolveObject();
         // Only skip if truly finished (p>=1). During stagger wait, p=0 and we still need to apply fromPosition.
-        // console.log(stepRef.current)
         if (!stepRef.current || !resolvedObject)
             return;
         const step = stepRef.current;
         // Time-based progress drives property interpolation regardless of transform mode.
         const p = AnimationsManager.getProgressFromTime(step.startTime, step.duration, step.ease);
-        // console.log(p)
         // updateProgressRef(p);
         // Path-based: delegate to usePathAnimation
         if (step.pathId) {
@@ -241,14 +184,6 @@ export const useSequenceAnimation = (objectId, objectRef) => {
             resolvedObject.rotation.set(...rot);
             resolvedObject.scale.set(...sca);
         }
-        if (p === 0 || p >= 0.99) {
-            // debugLog('frame progress', {
-            //   objectId,
-            //   progress: p,
-            //   materialKeys: Object.keys(step.materialTo),
-            //   pathId: step.pathId,
-            // });
-        }
         // — Material properties —
         interpolateMaterialProps(resolvedObject, step.materialFrom, step.materialTo, p);
         if (p >= 1) {

package/dist/hooks/useShadowApplication.d.ts

@@ -1,3 +1,3 @@
-import { Object3D } from "three";
-export declare const useShadowApplication: (obj: Object3D | null | undefined, castShadow: boolean | undefined, receiveShadow: boolean | undefined, triggerKey?: unknown) => void;
+import type { Object3DSource } from "../utils/resolveObject3D";
+export declare const useShadowApplication: (source: Object3DSource, castShadow: boolean | undefined, receiveShadow: boolean | undefined, triggerKey?: unknown) => void;
 //# sourceMappingURL=useShadowApplication.d.ts.map

package/dist/hooks/useShadowApplication.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useShadowApplication.d.ts","sourceRoot":"","sources":["../../src/hooks/useShadowApplication.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEjC,eAAO,MAAM,oBAAoB,GAAI,KAAK,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,YAAY,OAAO,GAAG,SAAS,EAAE,eAAe,OAAO,GAAG,SAAS,EAAE,aAAa,OAAO,KAAG,IAalK,CAAC"}
+{"version":3,"file":"useShadowApplication.d.ts","sourceRoot":"","sources":["../../src/hooks/useShadowApplication.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,eAAO,MAAM,oBAAoB,GAAI,QAAQ,cAAc,EAAE,YAAY,OAAO,GAAG,SAAS,EAAE,eAAe,OAAO,GAAG,SAAS,EAAE,aAAa,OAAO,KAAG,IAgBxJ,CAAC"}

package/dist/hooks/useShadowApplication.js

@@ -15,8 +15,12 @@
 //
 import { useEffect } from 'react';
 import { traverseSkippingEdgesAndEffects } from '@3driseai/3drise-core';
-export const useShadowApplication = (obj, castShadow, receiveShadow, triggerKey) => {
+import { resolveObject3D } from "../utils/resolveObject3D.js";
+export const useShadowApplication = (source, castShadow, receiveShadow, triggerKey) => {
     useEffect(() => {
+        // Read the ref here, not at the call site: effects run after React has
+        // attached refs, so this is the first point the object reliably exists.
+        const obj = resolveObject3D(source);
         if (!obj)
             return;
         const cast = castShadow ?? false;
@@ -27,5 +31,5 @@ export const useShadowApplication = (obj, castShadow, receiveShadow, triggerKey)
                 child.receiveShadow = receive;
             }
         });
-    }, [obj, castShadow, receiveShadow, triggerKey]);
+    }, [source, castShadow, receiveShadow, triggerKey]);
 };

package/dist/hooks/useSkyAnimation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSkyAnimation.d.ts","sourceRoot":"","sources":["../../src/hooks/useSkyAnimation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,MAAM,WAAW,aAAa;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAMD,wBAAgB,eAAe,IAAI;IAC3B,oBAAoB,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAClL,CA8BJ"}
+{"version":3,"file":"useSkyAnimation.d.ts","sourceRoot":"","sources":["../../src/hooks/useSkyAnimation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,MAAM,WAAW,aAAa;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAMD,wBAAgB,eAAe,IAAI;IAC3B,oBAAoB,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAClL,CA6BJ"}

package/dist/hooks/useSkyAnimation.js

@@ -29,7 +29,6 @@ export function useSkyAnimation() {
         }
     });
     const animateSkyTransition = useCallback((from, to, onUpdate, onComplete, duration = 3) => {
-        console.log('Initiating sky animation', { from, to, duration });
         animRef.current = { from, to, duration, elapsed: 0, onUpdate, onComplete };
     }, []);
     return { animateSkyTransition };

package/dist/hooks/useSkySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSkySystem.d.ts","sourceRoot":"","sources":["../../src/hooks/useSkySystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAIpC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACxF,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE7C,MAAM,WAAW,mBAAmB;IAChC,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC7C,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACrE,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC;IAC5B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC;CACxC;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CAsD7E;AACD,eAAe,YAAY,CAAC"}
+{"version":3,"file":"useSkySystem.d.ts","sourceRoot":"","sources":["../../src/hooks/useSkySystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAIpC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACxF,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE7C,MAAM,WAAW,mBAAmB;IAChC,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC7C,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACrE,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC;IAC5B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC;CACxC;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CAqD7E;AACD,eAAe,YAAY,CAAC"}

package/dist/hooks/useSkySystem.js

@@ -27,7 +27,6 @@ export function useSkySystem(options) {
         if (!enabled || !timeSettings.enabled || !timeSettings.autoAnimate)
             return;
         const state = skySystemManager.getState();
-        // console.log(state.timeInHours)
         if (previousTimeOfDayRef.current !== null &&
             previousTimeOfDayRef.current !== state.timeOfDay) {
             onTimeOfDayChange?.(state.timeOfDay, state.elapsedTime);

package/dist/index.d.ts

@@ -8,8 +8,10 @@ export { cameraManager } from './utils/CameraSingleton';
 export { applyAnchorSettings, createCurves, createSunPosition, randomRange, } from './utils/utils3d';
 export { applyAnchorSettings as applyAnchorSettingsLegacy } from './utils/anchorUtils';
 export * from './utils/shapes';
-export { DEBUG_GENERATIVE_EFFECTS, applyGenerativeAnimations, } from './utils/handleGenerativeEffectsAnimations';
+export { applyGenerativeAnimations } from './utils/handleGenerativeEffectsAnimations';
 export { hasHoverAnimation } from './utils/hasHoverAnimation';
 export { findById } from './utils/sceneQuery';
+export { resolveObject3D } from './utils/resolveObject3D';
+export type { Object3DRefLike, Object3DSource } from './utils/resolveObject3D';
 export * from './utils/textEffects';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAG1F,OAAO,EAAE,iBAAiB,IAAI,iBAAiB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAG5F,cAAc,SAAS,CAAC;AAGxB,cAAc,cAAc,CAAC;AAG7B,cAAc,SAAS,CAAC;AAExB,YAAY,EAAE,oBAAoB,IAAI,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAGjG,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,GAAG,MAAM,iBAAiB,CAAC;AACrG,OAAO,EAAE,mBAAmB,IAAI,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACvF,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,GAAG,MAAM,2CAA2C,CAAC;AACjH,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAG1F,OAAO,EAAE,iBAAiB,IAAI,iBAAiB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAG5F,cAAc,SAAS,CAAC;AAGxB,cAAc,cAAc,CAAC;AAG7B,cAAc,SAAS,CAAC;AAExB,YAAY,EAAE,oBAAoB,IAAI,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAGjG,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,GAAG,MAAM,iBAAiB,CAAC;AACrG,OAAO,EAAE,mBAAmB,IAAI,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACvF,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AACtF,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC/E,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -11,7 +11,8 @@ export { cameraManager } from './utils/CameraSingleton.js';
 export { applyAnchorSettings, createCurves, createSunPosition, randomRange, } from './utils/utils3d.js';
 export { applyAnchorSettings as applyAnchorSettingsLegacy } from './utils/anchorUtils.js';
 export * from './utils/shapes.js';
-export { DEBUG_GENERATIVE_EFFECTS, applyGenerativeAnimations, } from './utils/handleGenerativeEffectsAnimations.js';
+export { applyGenerativeAnimations } from './utils/handleGenerativeEffectsAnimations.js';
 export { hasHoverAnimation } from './utils/hasHoverAnimation.js';
 export { findById } from './utils/sceneQuery.js';
+export { resolveObject3D } from './utils/resolveObject3D.js';
 export * from './utils/textEffects.js';

package/dist/services/AnimationsManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationsManager.d.ts","sourceRoot":"","sources":["../../src/services/AnimationsManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAC3F,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG,aAAa,GAAG,WAAW,GAAG,SAAS,CAAC;AAE3F,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AAEhD;;;;GAIG;AACH,cAAM,iBAAiB;IACnB,OAAO,CAAC,SAAS,CAKd;IACH,OAAO,CAAC,KAAK,CAAa;IAC1B,EAAE,CAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAGtD,GAAG,CAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAGvD,IAAI,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAUjC,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,MAAiB,GAAG,MAAM;IAIzF,YAAY,CAAC,QAAQ,EAAE,iBAAiB,GAAG,iBAAiB;IAY5D,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAC/B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAC3C,WAAW,IAAI,UAAU,EAAE;IAC3B,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI;IAKtE,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAC5B,UAAU,IAAI,IAAI;CACrB;;AACD,wBAAuC"}
+{"version":3,"file":"AnimationsManager.d.ts","sourceRoot":"","sources":["../../src/services/AnimationsManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAC3F,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG,aAAa,GAAG,WAAW,GAAG,SAAS,CAAC;AAE3F,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AAEhD;;;;GAIG;AACH,cAAM,iBAAiB;IACnB,OAAO,CAAC,SAAS,CAKd;IACH,OAAO,CAAC,KAAK,CAAa;IAC1B,EAAE,CAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAGtD,GAAG,CAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAGvD,IAAI,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IASjC,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,MAAiB,GAAG,MAAM;IAIzF,YAAY,CAAC,QAAQ,EAAE,iBAAiB,GAAG,iBAAiB;IAY5D,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAC/B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAC3C,WAAW,IAAI,UAAU,EAAE;IAC3B,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI;IAKtE,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAC5B,UAAU,IAAI,IAAI;CACrB;;AACD,wBAAuC"}

package/dist/services/AnimationsManager.js

@@ -24,7 +24,6 @@ class AnimationsManager {
                 l(event);
             }
             catch (e) {
-                console.error('[AnimationsManager] listener error:', e);
             }
         });
     }

package/dist/shaders/CircuitGridMaterial.d.ts

@@ -0,0 +1,76 @@
+import * as THREE from 'three';
+export interface CircuitGridMaterialUniforms {
+    u_time: number;
+    /** size of one Truchet tile, in world units */
+    u_cellSize: number;
+    /** trace thickness, in pixels */
+    u_lineWidth: number;
+    /** unused by the tiling; kept so the section knobs line up with the other grids */
+    u_sectionSize: number;
+    /** pad/chip outline thickness, in pixels */
+    u_sectionWidth: number;
+    u_lineColor: THREE.Color;
+    u_sectionColor: THREE.Color;
+    u_cellColor: THREE.Color;
+    u_glowColor: THREE.Color;
+    u_bgColor: THREE.Color;
+    u_bgOpacity: number;
+    u_lineMode: number;
+    u_cellMode: number;
+    u_animSpeed: number;
+    u_animScale: number;
+    u_animIntensity: number;
+    u_fadeDistance: number;
+    u_fadeStrength: number;
+    u_focus: THREE.Vector2;
+    u_mouse: THREE.Vector2;
+    u_displace: number;
+    /**
+     * 0..1 assemble/dissolve. The build boundary sweeps outward from u_focus
+     * with a bright leading edge; 1 is fully built, 0 is gone. Animate it
+     * downward to dissolve.
+     */
+    u_reveal: number;
+    /** 0..1 — fraction of tiles carrying a powered trace */
+    u_powered: number;
+    /** 0..1 — fraction of tiles replaced by an IC package */
+    u_chipChance: number;
+    /** solder-pad radius as a fraction of a tile; 0 disables pads */
+    u_padSize: number;
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        circuitGridMaterial: ThreeElements['shaderMaterial'] & Partial<CircuitGridMaterialUniforms>;
+    }
+}
+export declare const circuitGridMaterialDefaults: CircuitGridMaterialUniforms;
+export declare const CircuitGridMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_time: number;
+    u_cellSize: number;
+    u_lineWidth: number;
+    u_sectionSize: number;
+    u_sectionWidth: number;
+    u_lineColor: THREE.Color;
+    u_sectionColor: THREE.Color;
+    u_cellColor: THREE.Color;
+    u_glowColor: THREE.Color;
+    u_bgColor: THREE.Color;
+    u_bgOpacity: number;
+    u_lineMode: number;
+    u_cellMode: number;
+    u_animSpeed: number;
+    u_animScale: number;
+    u_animIntensity: number;
+    u_fadeDistance: number;
+    u_fadeStrength: number;
+    u_focus: THREE.Vector2;
+    u_mouse: THREE.Vector2;
+    u_displace: number;
+    u_reveal: number;
+    u_powered: number;
+    u_chipChance: number;
+    u_padSize: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=CircuitGridMaterial.d.ts.map

package/dist/shaders/CircuitGridMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CircuitGridMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/CircuitGridMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,MAAM,WAAW,2BAA2B;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,mFAAmF;IACnF,aAAa,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,cAAc,EAAE,KAAK,CAAC,KAAK,CAAC;IAC5B,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,mBAAmB,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;KAC/F;CACJ;AAED,eAAO,MAAM,2BAA2B,EAAE,2BA0BzC,CAAC;AAqPF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B/B,CAAC"}

package/dist/shaders/CircuitGridMaterial.js

@@ -0,0 +1,298 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+export const circuitGridMaterialDefaults = {
+    u_time: 0,
+    u_cellSize: 1.0,
+    u_lineWidth: 1.6,
+    u_sectionSize: 5.0,
+    u_sectionWidth: 1.4,
+    u_lineColor: new THREE.Color(0.09, 0.42, 0.36),
+    u_sectionColor: new THREE.Color(0.55, 0.95, 0.7),
+    u_cellColor: new THREE.Color(0.03, 0.14, 0.12),
+    u_glowColor: new THREE.Color(0.35, 1.0, 0.72),
+    u_bgColor: new THREE.Color(0.01, 0.04, 0.03),
+    u_bgOpacity: 0.0,
+    u_lineMode: 2,
+    u_cellMode: 0,
+    u_animSpeed: 1.0,
+    u_animScale: 0.5,
+    u_animIntensity: 1.0,
+    u_fadeDistance: 25.0,
+    u_fadeStrength: 0.7,
+    u_focus: new THREE.Vector2(0, 0),
+    u_mouse: new THREE.Vector2(0, 0),
+    u_displace: 0.0,
+    u_reveal: 1.0,
+    u_powered: 0.65,
+    u_chipChance: 0.06,
+    u_padSize: 1.0,
+};
+const circuitCommon = /*glsl*/ `
+  const float PI  = 3.14159265359;
+  const float TAU = 6.28318530718;
+
+  float hash21(vec2 p){
+    p = fract(p * vec2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+  }
+`;
+const vertex = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_displace;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+
+  varying vec2 vGridPos;
+
+  ${circuitCommon}
+
+  void main(){
+    vGridPos = position.xy;
+    vec3 pos = position;
+    if (u_displace > 0.0){
+      float t = u_time * u_animSpeed;
+      vec2 coord = position.xy / max(u_cellSize, 1e-4);
+      // board flex: a slow low-frequency swell rather than per-tile steps, so
+      // traces stay continuous across tile borders
+      float h = sin(coord.x * u_animScale * 0.5 - t) * cos(coord.y * u_animScale * 0.5 + t * 0.7);
+      pos.z += h * u_displace;
+    }
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragment = /*glsl*/ `
+  precision highp float;
+
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_lineWidth;
+  uniform float u_sectionSize;
+  uniform float u_sectionWidth;
+  uniform vec3  u_lineColor;
+  uniform vec3  u_sectionColor;
+  uniform vec3  u_cellColor;
+  uniform vec3  u_glowColor;
+  uniform vec3  u_bgColor;
+  uniform float u_bgOpacity;
+  uniform float u_lineMode;
+  uniform float u_cellMode;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+  uniform float u_animIntensity;
+  uniform float u_fadeDistance;
+  uniform float u_fadeStrength;
+  uniform vec2  u_focus;
+  uniform float u_reveal;
+  uniform float u_powered;
+  uniform float u_chipChance;
+  uniform float u_padSize;
+
+  varying vec2 vGridPos;
+
+  ${circuitCommon}
+
+  /** signed distance to a rounded box of half-extent b and corner radius r */
+  float sdRoundBox(vec2 p, vec2 b, float r){
+    vec2 q = abs(p) - b + r;
+    return length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - r;
+  }
+
+  /** straight axis-aligned lines on a lattice, same maths as the square grid */
+  float gridLines(vec2 c, float width){
+    vec2 d = fwidth(c);
+    vec2 g = abs(fract(c - 0.5) - 0.5) / max(d * width, 1e-5);
+    return 1.0 - clamp(min(g.x, g.y), 0.0, 1.0);
+  }
+
+  /** IC legs: short lines bridging the package edge to the tile edge */
+  float chipPins(vec2 gv, float hw, float px){
+    float dy = abs(fract(gv.y * 4.0) - 0.5) * 0.25;
+    float dx = abs(fract(gv.x * 4.0) - 0.5) * 0.25;
+    float horiz = (1.0 - smoothstep(hw, hw + px, dy)) * step(0.30, abs(gv.x));
+    float vert  = (1.0 - smoothstep(hw, hw + px, dx)) * step(0.30, abs(gv.y));
+    return max(horiz, vert);
+  }
+
+  void main(){
+    vec2 coord = vGridPos / max(u_cellSize, 1e-4);
+    vec2 focus = u_focus / max(u_cellSize, 1e-4);
+    float t  = u_time * u_animSpeed;
+    float px = max(length(fwidth(coord)), 1e-6);
+
+    vec2 id = floor(coord);
+    vec2 gv = fract(coord) - 0.5;
+
+    float seed = hash21(id);
+    // Mirroring half the tiles is what turns isolated quarter-arcs into long
+    // meandering paths: the two orientations chain across tile borders.
+    if (seed < 0.5) gv.x = -gv.x;
+
+    bool isChip = hash21(id + 7.77) < u_chipChance;
+    bool powered = hash21(id + 11.31) < u_powered;
+
+    float hw = px * max(u_lineWidth, 0.05) * 0.5;
+
+    // ---- Truchet traces --------------------------------------------------
+    vec2 c1 = vec2( 0.5,  0.5);
+    vec2 c2 = vec2(-0.5, -0.5);
+    float d1 = abs(length(gv - c1) - 0.5);
+    float d2 = abs(length(gv - c2) - 0.5);
+    float traceDist = min(d1, d2);
+    float trace = isChip ? 0.0 : 1.0 - smoothstep(hw, hw + px, traceDist);
+
+    // Position along whichever arc we are nearest, normalised over its quarter
+    // turn. Arc 1 spans atan in [-PI, -PI/2]; arc 2 spans [0, PI/2].
+    bool onA = d1 < d2;
+    vec2 rel = onA ? (gv - c1) : (gv - c2);
+    float ang = atan(rel.y, rel.x);
+    float along = onA ? (ang + PI) / (PI * 0.5) : ang / (PI * 0.5);
+    // per-arc offset so the whole board does not pulse in lockstep
+    float arcSeed = hash21(id + (onA ? vec2(0.0) : vec2(3.71, 1.09)));
+
+    // ---- trace animation -------------------------------------------------
+    float lineAnim = 1.0;
+    float head = 0.0;
+    if (u_lineMode > 0.5 && u_lineMode < 1.5){
+      float dist = length(coord - focus);
+      lineAnim = 0.5 + 0.5 * sin(dist * u_animScale - t);
+    } else if (u_lineMode < 2.5){
+      // signal pulses running along the traces themselves
+      lineAnim = 0.6;
+      float phase = fract(arcSeed + along * 0.25 - t * 0.18 * max(u_animScale, 0.05));
+      head = pow(phase, 16.0);
+    } else if (u_lineMode < 3.5){
+      // a data wavefront crossing the board diagonally
+      float s = fract((coord.x + coord.y) * 0.05 * u_animScale - t * 0.15);
+      lineAnim = 0.25 + smoothstep(0.0, 0.15, s) * (1.0 - smoothstep(0.15, 0.35, s));
+    } else if (u_lineMode < 4.5){
+      lineAnim = 0.5 + 0.5 * sin(t + seed * TAU);
+    }
+    if (!powered){ lineAnim *= 0.25; head = 0.0; }
+    lineAnim = mix(1.0, lineAnim, u_animIntensity);
+    head *= u_animIntensity;
+
+    // ---- bus lines -------------------------------------------------------
+    // Straight power/data buses every sectionSize tiles, cutting across the
+    // Truchet weave the way a real board's supply rails do.
+    float bus = 0.0;
+    if (u_sectionWidth > 0.0 && u_sectionSize > 0.0){
+      bus = gridLines(coord / u_sectionSize, u_sectionWidth);
+    }
+
+    // ---- solder pads / vias ---------------------------------------------
+    // Every arc terminates on an edge midpoint, so that is where the pads go.
+    // Neighbouring tiles draw the same pad twice at the same point, which is
+    // exactly right — it is one via shared by both.
+    // A via on every junction turns the board into a dot field that drowns out
+    // the traces, so only a minority of tiles get one.
+    float pad = 0.0;
+    if (u_padSize > 0.0 && !isChip && hash21(id + 21.73) < 0.3){
+      float dp = min(
+        min(length(gv - vec2(0.5, 0.0)), length(gv + vec2(0.5, 0.0))),
+        min(length(gv - vec2(0.0, 0.5)), length(gv + vec2(0.0, 0.5)))
+      );
+      float pr = 0.05 * u_padSize;
+      pad = 1.0 - smoothstep(pr, pr + px * 1.5, dp);
+      pad *= smoothstep(pr * 0.30, pr * 0.50, dp); // punch the drill hole
+    }
+
+    // ---- IC packages -----------------------------------------------------
+    float chipBody = 0.0, chipEdge = 0.0, chipCore = 0.0, pins = 0.0;
+    if (isChip){
+      float b = sdRoundBox(gv, vec2(0.30), 0.06);
+      chipBody = 1.0 - smoothstep(0.0, px * 2.0, b);
+      chipEdge = 1.0 - smoothstep(hw, hw + px, abs(b));
+      pins = chipPins(gv, hw, px);
+      float beat = 0.5 + 0.5 * sin(t * (1.0 + hash21(id + 2.3) * 2.0));
+      chipCore = (1.0 - smoothstep(0.0, px * 2.0, sdRoundBox(gv, vec2(0.10), 0.02))) * beat;
+    }
+
+    // ---- substrate fill --------------------------------------------------
+    float cell = 0.0;
+    if (u_cellMode > 0.5 && u_cellMode < 1.5){
+      cell = 0.5 + 0.5 * sin(dot(id, vec2(0.7, 0.3)) * u_animScale - t);
+    } else if (u_cellMode < 2.5){
+      cell = 0.5 + 0.5 * sin(t * (0.6 + seed) + seed * TAU);
+    } else if (u_cellMode < 3.5){
+      float d = length(id + 0.5 - focus);
+      cell = smoothstep(0.6, 1.0, sin(d * u_animScale - t));
+    } else if (u_cellMode < 4.5){
+      cell = mod(id.x + id.y, 2.0) * (0.5 + 0.5 * sin(t));
+    }
+    cell *= u_animIntensity;
+    vec2 f = abs(gv);
+    cell *= smoothstep(0.5, 0.4, max(f.x, f.y));
+
+    float r = length(vGridPos) / max(u_fadeDistance, 1e-4);
+    float fade = 1.0 - smoothstep(1.0 - u_fadeStrength, 1.0, r);
+
+    vec3 col = u_bgColor * u_bgOpacity;
+    float a  = u_bgOpacity;
+
+    col += u_cellColor * (cell + chipBody * 0.8);
+    a = max(a, max(cell * 0.9, chipBody * 0.85));
+
+    float traceI = trace * lineAnim;
+    float busI   = bus * lineAnim;
+    col += u_lineColor * traceI;                       a = max(a, traceI);
+    col += u_glowColor * trace * head * 2.2;           a = max(a, trace * head);
+    col += u_sectionColor * busI * 0.8;                a = max(a, busI * 0.8);
+    float padI = pad * 0.7;
+    col += u_sectionColor * (padI + chipEdge + pins);  a = max(a, max(padI, max(chipEdge, pins)));
+    col += u_glowColor * chipCore * 1.5;               a = max(a, chipCore);
+    col += u_glowColor * traceI * 0.15 * u_animIntensity;
+
+    col *= fade;
+    a   *= fade;
+
+    // ---- reveal ----------------------------------------------------------
+    // The build boundary sweeps outward from the focus point. Its leading band
+    // mostly brightens whatever is already there rather than painting a solid
+    // disc, so the grid reads as assembling itself rather than fading in.
+    if (u_reveal < 0.999){
+      float rd = length(vGridPos - u_focus) / max(u_fadeDistance, 1e-4);
+      // 1.1, not 1.25: the boundary has to clear the fade radius by just the
+      // width of its own soft edge. Overshooting further finishes the build
+      // before reveal reaches 1 and leaves the tail of the range doing nothing.
+      float edge = u_reveal * 1.1;
+      float mask = 1.0 - smoothstep(edge - 0.05, edge, rd);
+      float front = mask * smoothstep(edge - 0.22, edge - 0.05, rd);
+      col = col * mask + u_glowColor * front * (a * 1.8 + 0.08);
+      a   = max(a * mask, front * 0.10);
+    }
+
+    if (a < 0.002) discard;
+    gl_FragColor = vec4(col, a);
+  }
+`;
+export const CircuitGridMaterial = shaderMaterial({
+    u_time: circuitGridMaterialDefaults.u_time,
+    u_cellSize: circuitGridMaterialDefaults.u_cellSize,
+    u_lineWidth: circuitGridMaterialDefaults.u_lineWidth,
+    u_sectionSize: circuitGridMaterialDefaults.u_sectionSize,
+    u_sectionWidth: circuitGridMaterialDefaults.u_sectionWidth,
+    u_lineColor: circuitGridMaterialDefaults.u_lineColor.clone(),
+    u_sectionColor: circuitGridMaterialDefaults.u_sectionColor.clone(),
+    u_cellColor: circuitGridMaterialDefaults.u_cellColor.clone(),
+    u_glowColor: circuitGridMaterialDefaults.u_glowColor.clone(),
+    u_bgColor: circuitGridMaterialDefaults.u_bgColor.clone(),
+    u_bgOpacity: circuitGridMaterialDefaults.u_bgOpacity,
+    u_lineMode: circuitGridMaterialDefaults.u_lineMode,
+    u_cellMode: circuitGridMaterialDefaults.u_cellMode,
+    u_animSpeed: circuitGridMaterialDefaults.u_animSpeed,
+    u_animScale: circuitGridMaterialDefaults.u_animScale,
+    u_animIntensity: circuitGridMaterialDefaults.u_animIntensity,
+    u_fadeDistance: circuitGridMaterialDefaults.u_fadeDistance,
+    u_fadeStrength: circuitGridMaterialDefaults.u_fadeStrength,
+    u_focus: circuitGridMaterialDefaults.u_focus.clone(),
+    u_mouse: circuitGridMaterialDefaults.u_mouse.clone(),
+    u_displace: circuitGridMaterialDefaults.u_displace,
+    u_reveal: circuitGridMaterialDefaults.u_reveal,
+    u_powered: circuitGridMaterialDefaults.u_powered,
+    u_chipChance: circuitGridMaterialDefaults.u_chipChance,
+    u_padSize: circuitGridMaterialDefaults.u_padSize,
+}, vertex, fragment);
+extend({ CircuitGridMaterial });