simple-circuit-engine 0.0.11 → 0.0.13

package/dist/scene/shared/components/GroupedFactoryRegistry.d.ts

@@ -0,0 +1,153 @@
+import { ComponentType } from '../../../core/index.ts';
+import { AnimationContext } from '../types.js';
+import { IComponentVisualFactory, IFactoryRegistry } from './ComponentVisualFactory.js';
+/**
+ * Describes a named group of component types
+ */
+export interface ComponentGroup {
+    readonly id: string;
+    readonly label: string;
+}
+/**
+ * Builder interface for adding components to a group.
+ * Used as the callback parameter type in addGroup().
+ *
+ * @example
+ * ```typescript
+ * registry.addGroup('basic', 'Basic Components', (group: IComponentGroupBuilder) => {
+ *   group
+ *     .add(ComponentType.Battery, new BatteryVisualFactory())
+ *     .add(ComponentType.Switch, new SwitchVisualFactory());
+ * });
+ * ```
+ */
+export interface IComponentGroupBuilder {
+    add(type: ComponentType, factory: IComponentVisualFactory): IComponentGroupBuilder;
+}
+/**
+ * Extended registry interface with grouping support.
+ *
+ * Adds group management on top of the basic factory retrieval,
+ * allowing client UIs to build organized component palettes.
+ */
+export interface IGroupedFactoryRegistry {
+    addGroup(id: string, label: string, builderCallback: (group: IComponentGroupBuilder) => void): IGroupedFactoryRegistry;
+    get(type: ComponentType): IComponentVisualFactory;
+    has(type: ComponentType): boolean;
+    getFallbackFactory(): IComponentVisualFactory;
+    getGroups(): ComponentGroup[];
+    getGroupOf(type: ComponentType): ComponentGroup | undefined;
+    getRegisteredTypes(groupId?: string): ComponentType[];
+    unregister(type: ComponentType): boolean;
+}
+/**
+ * Factory registry with named group support.
+ *
+ * Implements both IFactoryRegistry (backward compat) and IGroupedFactoryRegistry.
+ * Components may only be registered inside a group context via addGroup().
+ *
+ * Group insertion order is preserved (Map maintains insertion order).
+ * Duplicate group ids merge their components; the label from the first
+ * registration is preserved.
+ *
+ * @example
+ * ```typescript
+ * const registry = new GroupedFactoryRegistry(new DefaultVisualFactory())
+ *   .addGroup('basic', 'Basic Components', group => group
+ *     .add(ComponentType.Battery, new BatteryVisualFactory())
+ *     .add(ComponentType.Switch, new SwitchVisualFactory())
+ *   )
+ *   .addGroup('outputs', 'Output Components', group => group
+ *     .add(ComponentType.Lightbulb, new LightbulbVisualFactory())
+ *   );
+ *
+ * registry.getGroups();                        // [{ id: 'basic', ... }, { id: 'outputs', ... }]
+ * registry.getGroupOf(ComponentType.Battery);  // { id: 'basic', label: 'Basic Components' }
+ * registry.getRegisteredTypes('basic');        // [ComponentType.Battery, ComponentType.Switch]
+ * registry.get(ComponentType.Battery);         // BatteryVisualFactory instance
+ * ```
+ */
+export declare class GroupedFactoryRegistry implements IFactoryRegistry, IGroupedFactoryRegistry {
+    private readonly _factories;
+    private readonly _fallbackFactory;
+    private readonly _groups;
+    private readonly _typeToGroupId;
+    /**
+     * Create a new grouped factory registry.
+     *
+     * @param fallbackFactory - Factory to use for unregistered component types
+     * @throws {TypeError} If fallbackFactory is null or undefined
+     */
+    constructor(fallbackFactory: IComponentVisualFactory);
+    /**
+     * Add a named group and register component factories within it.
+     *
+     * If a group with the same id already exists, the new components are merged
+     * into it and the original label is preserved.
+     *
+     * @param id - Unique group identifier
+     * @param label - Human-readable group display name
+     * @param builderCallback - Callback receiving a builder for adding components
+     * @throws {TypeError} If id or label is empty/whitespace
+     * @returns this (for chaining)
+     */
+    addGroup(id: string, label: string, builderCallback: (group: IComponentGroupBuilder) => void): this;
+    /**
+     * Retrieve the factory for a component type.
+     *
+     * @returns Factory, or the fallback factory if type not registered.
+     * Never returns null or undefined.
+     */
+    get(type: ComponentType): IComponentVisualFactory;
+    /**
+     * Check if a factory is registered for a component type.
+     *
+     * @returns true if explicitly registered, false if would use fallback
+     */
+    has(type: ComponentType): boolean;
+    /**
+     * Get the fallback factory used for unregistered types.
+     */
+    getFallbackFactory(): IComponentVisualFactory;
+    /**
+     * Get all defined groups in insertion order.
+     *
+     * @returns New array of ComponentGroup objects (safe to mutate)
+     */
+    getGroups(): ComponentGroup[];
+    /**
+     * Get the group a component type belongs to.
+     *
+     * @param type - Component type to look up
+     * @returns ComponentGroup, or undefined if type is not registered
+     */
+    getGroupOf(type: ComponentType): ComponentGroup | undefined;
+    /**
+     * Get registered component types, optionally filtered by group.
+     *
+     * @param groupId - If provided, returns only types in that group
+     * @returns New array of ComponentType values (safe to mutate).
+     *          Returns empty array if groupId is unknown.
+     */
+    getRegisteredTypes(groupId?: string): ComponentType[];
+    /**
+     * Unregister a factory for a component type.
+     *
+     * The type is removed from its group's list and from the reverse lookup.
+     * The group record itself is preserved even if it becomes empty.
+     *
+     * @param type - Component type to remove
+     * @returns true if factory was registered and removed, false otherwise
+     */
+    unregister(type: ComponentType): boolean;
+    /**
+     * Fan out animation context to all registered factories and the fallback.
+     */
+    setAnimationContext(ctx: AnimationContext | null): void;
+    /**
+     * Not supported. Use addGroup() to register components within a named group.
+     *
+     * @throws {Error} Always throws
+     */
+    register(_type: ComponentType, _factory: IComponentVisualFactory): IFactoryRegistry;
+}

package/dist/scene/shared/components/arithmetic/AdderVisualFactory.d.ts

@@ -0,0 +1,54 @@
+import { ComponentVisualFactoryBase } from '../ComponentVisualFactory';
+import { Component, ComponentState } from '../../../../core/index.ts';
+import { ConfigFormDefinition, VisualContext } from '../../types';
+import * as THREE from 'three';
+/**
+ * Visual factory for Adder components.
+ *
+ * Creates:
+ * - An `envelope` rectangular frame (EmptyRectangleGeometry)
+ * - A horizontal `separator` box dividing upper/lower chambers
+ * - A `sumFiller` (RectangleWithNailGeometry) in the upper chamber;
+ *   its material is animated blue↔red following the sum output state
+ * - A `plus` box inside the sumFiller (visual cue)
+ * - A `carryFiller` (RectangleWithNailGeometry) box in the lower chamber; its material is animated
+ *   blue↔red following the carry output state
+ * - pin groups for vcc, inputA, inputB, sum, carry, gnd
+ *
+ * Animation:
+ * - sumFiller ↔ blue/red based on sum output (current/next state)
+ * - carryFiller ↔ blue/red based on carry output (current/next state)
+ */
+export declare class AdderVisualFactory extends ComponentVisualFactoryBase {
+    private readonly ENVELOPE_GEOM;
+    /** Horizontal separator splitting upper/lower chambers at Z=0 */
+    private readonly SEPARATOR_GEOM;
+    private readonly SEPARATOR_SIDE_GEOM;
+    private readonly CELL_FILLER_GEOM;
+    /** Small box inside sumFiller (visual cue for the XOR "+") */
+    private readonly PLUS_GEOM;
+    protected readonly FILLER_COLOR_HIGH: THREE.Color;
+    protected readonly FILLER_COLOR_LOW: THREE.Color;
+    protected readonly FILLER_EMISSIVE_HIGH_INTENSITY = 0.5;
+    protected readonly FILLER_EMISSIVE_LOW_INTENSITY = 0.2;
+    constructor();
+    createVisual(component: Component, context: VisualContext): THREE.Object3D;
+    protected createPinsVisual(component: Component, context: VisualContext, group: THREE.Group): void;
+    getConfigFormDefinition(config?: Map<string, string>): ConfigFormDefinition | null;
+    mapCoreConfigToForm(config: Map<string, string>): Map<string, any>;
+    mapFormToCoreConfig(formData: Map<string, any>): Map<string, string>;
+    updateAnimation(object3D: THREE.Object3D, state: ComponentState | null): void;
+    private _setFillerColor;
+    private _ensureClonedFillerMaterial;
+    private _restoreSharedFillerMaterial;
+    private _cleanupMixer;
+    /**
+     * Animate sumFiller and carryFiller fill colors over the transition span.
+     * Builds a single AnimationClip with up to two target tracks per filler
+     * (color, emissive, emissiveIntensity) — only for fillers whose value changes.
+     */
+    private _animateFillers;
+    private _pushFillerTracks;
+    /** Find a child mesh by its userData.part name */
+    protected findPartMesh(object3D: THREE.Object3D, part: string): THREE.Mesh | null;
+}

package/dist/scene/shared/components/arithmetic/EightBitAdderVisualFactory.d.ts

@@ -0,0 +1,45 @@
+import { ComponentVisualFactoryBase } from '../ComponentVisualFactory';
+import { Component, ComponentState } from '../../../../core/index.ts';
+import { ConfigFormDefinition, VisualContext } from '../../types';
+import * as THREE from 'three';
+/**
+ * Visual factory for EightBitAdder components.
+ *
+ * Creates:
+ * - An `envelope` frame (KuKoGeometry)
+ * - A vertical `separator` dividing carry/sum cells
+ * - 7 horizontal separators dividing ith cells
+ * - 16 cells carry i / sum i representing state
+ *   cells materials are animated blue↔red following the component state
+ * - pin groups for vcc, 2*8 inputs, 8*sums, carryIn, carryOut and gnd
+ *
+ */
+export declare class EightBitAdderVisualFactory extends ComponentVisualFactoryBase {
+    private readonly ENVELOPE_GEOM;
+    private readonly VERTICAL_SEPARATOR_GEOM;
+    private readonly HORIZONTAL_SEPARATOR_GEOM;
+    private readonly CELL_FILLER_GEOM;
+    protected readonly FILLER_COLOR_HIGH: THREE.Color;
+    protected readonly FILLER_COLOR_LOW: THREE.Color;
+    protected readonly FILLER_EMISSIVE_HIGH_INTENSITY = 0.5;
+    protected readonly FILLER_EMISSIVE_LOW_INTENSITY = 0.2;
+    constructor();
+    createVisual(component: Component, context: VisualContext): THREE.Object3D;
+    protected createPinsVisual(component: Component, context: VisualContext, group: THREE.Group): void;
+    getConfigFormDefinition(config?: Map<string, string>): ConfigFormDefinition | null;
+    mapCoreConfigToForm(config: Map<string, string>): Map<string, any>;
+    mapFormToCoreConfig(formData: Map<string, any>): Map<string, string>;
+    updateAnimation(object3D: THREE.Object3D, state: ComponentState | null): void;
+    private _setCellColor;
+    private _ensureClonedMaterial;
+    private _restoreSharedMaterial;
+    private _cleanupMixer;
+    /** Collect all 16 cell meshes with their state bit position. */
+    private _findCellMeshes;
+    /**
+     * Animate the 16 cells over the transition span.
+     * Builds a single AnimationClip with tracks only for cells whose bit changes.
+     */
+    private _animateCells;
+    private _pushCellTracks;
+}

package/dist/scene/shared/components/arithmetic/EightBitOnesComplementVisualFactory.d.ts

@@ -0,0 +1,63 @@
+import { ComponentVisualFactoryBase } from '../ComponentVisualFactory';
+import { Component, ComponentState } from '../../../../core/index.ts';
+import { ConfigFormDefinition, VisualContext } from '../../types';
+import * as THREE from 'three';
+/**
+ * Visual factory for EightBitOnesComplement components.
+ *
+ * Creates:
+ * - An `envelope` frame (EmptyRectangleGeometry)
+ * - A vertical `separator` dividing flag area / outputs cells
+ * - 7 horizontal separators dividing ith cells
+ * - 2 rectangles with nail filler, 3 animated box geometry and 2 filler boxes for flag area
+ * - 8 cells outputs i representing output state
+ *   cells materials are animated blue↔red following the component state
+ * - pin groups for vcc, 8 inputs, 8*outputs and gnd
+ *
+ */
+export declare class EightBitOnesComplementVisualFactory extends ComponentVisualFactoryBase {
+    private readonly ENVELOPE_GEOM;
+    private readonly VERTICAL_SEPARATOR_GEOM;
+    private readonly HORIZONTAL_SEPARATOR_GEOM;
+    private readonly CELL_FILLER_GEOM;
+    private readonly INDICATOR_MINUS_GEOM;
+    private readonly INDICATOR_PLUS_GEOM;
+    private readonly INDICATOR_FILLER_GEOM;
+    protected readonly FILLER_COLOR_HIGH: THREE.Color;
+    protected readonly FILLER_COLOR_LOW: THREE.Color;
+    protected readonly FILLER_COLOR_NEUTRAL: THREE.Color;
+    protected readonly FILLER_EMISSIVE_BLACK: THREE.Color;
+    protected readonly FILLER_EMISSIVE_HIGH_INTENSITY = 0.5;
+    protected readonly FILLER_EMISSIVE_LOW_INTENSITY = 0.2;
+    protected readonly FILLER_EMISSIVE_NEUTRAL_INTENSITY = 0;
+    constructor();
+    createVisual(component: Component, context: VisualContext): THREE.Object3D;
+    protected createPinsVisual(component: Component, context: VisualContext, group: THREE.Group): void;
+    getConfigFormDefinition(config?: Map<string, string>): ConfigFormDefinition | null;
+    mapCoreConfigToForm(config: Map<string, string>): Map<string, any>;
+    mapFormToCoreConfig(formData: Map<string, any>): Map<string, string>;
+    updateAnimation(object3D: THREE.Object3D, state: ComponentState | null): void;
+    /**
+     * Resolve the target color state for a cell given its kind and the bit value:
+     * - `output`: high→red, low→blue
+     * - `minus`:  high→blue, low→red (inverted vs output — blue minus = complement active)
+     * - `plus`:   high→white (blends with envelope, hiding the +), low→red
+     */
+    private _cellTarget;
+    private _setCellColor;
+    private _ensureClonedMaterial;
+    private _restoreSharedMaterial;
+    private _cleanupMixer;
+    /**
+     * Collect all animated cells (8 outputs + minus + 2 plus parts).
+     * Output cells read bits 0–7; the three indicator cells all read bit 8
+     * (the invert flag) but render it with different color rules.
+     */
+    private _findCellMeshes;
+    /**
+     * Animate all cells over the transition span.
+     * Builds a single AnimationClip with tracks only for cells whose bit changes.
+     */
+    private _animateCells;
+    private _pushCellTracks;
+}

package/dist/scene/shared/components/arithmetic/HalfAdderVisualFactory.d.ts

@@ -0,0 +1,55 @@
+import { ComponentVisualFactoryBase } from '../ComponentVisualFactory';
+import { Component, ComponentState } from '../../../../core/index.ts';
+import { ConfigFormDefinition, VisualContext } from '../../types';
+import * as THREE from 'three';
+/**
+ * Visual factory for Half Adder components.
+ *
+ * Creates:
+ * - An `envelope` rectangular frame (EmptyRectangleGeometry)
+ * - A horizontal `separator` box dividing upper/lower chambers
+ * - A `sumFiller` (RectangleWithNailGeometry) in the upper chamber;
+ *   its material is animated blue↔red following the sum output state
+ * - A `halfPlus` small box inside the sumFiller (visual cue)
+ * - A `carryFiller` box in the lower chamber; its material is animated
+ *   blue↔red following the carry output state
+ * - pin groups for vcc, inputA, inputB, sum, carry, gnd
+ *
+ * Animation:
+ * - sumFiller ↔ blue/red based on sum output (current/next state)
+ * - carryFiller ↔ blue/red based on carry output (current/next state)
+ */
+export declare class HalfAdderVisualFactory extends ComponentVisualFactoryBase {
+    private readonly ENVELOPE_GEOM;
+    /** Horizontal separator splitting upper/lower chambers at Z=0 */
+    private readonly SEPARATOR_GEOM;
+    private readonly SEPARATOR_SIDE_GEOM;
+    private readonly SUM_FILLER_GEOM;
+    /** Small box inside sumFiller (visual cue for the XOR "+") */
+    private readonly HALF_PLUS_GEOM;
+    private readonly CARRY_FILLER_GEOM;
+    protected readonly FILLER_COLOR_HIGH: THREE.Color;
+    protected readonly FILLER_COLOR_LOW: THREE.Color;
+    protected readonly FILLER_EMISSIVE_HIGH_INTENSITY = 0.5;
+    protected readonly FILLER_EMISSIVE_LOW_INTENSITY = 0.2;
+    constructor();
+    createVisual(component: Component, context: VisualContext): THREE.Object3D;
+    protected createPinsVisual(component: Component, context: VisualContext, group: THREE.Group): void;
+    getConfigFormDefinition(config?: Map<string, string>): ConfigFormDefinition | null;
+    mapCoreConfigToForm(config: Map<string, string>): Map<string, any>;
+    mapFormToCoreConfig(formData: Map<string, any>): Map<string, string>;
+    updateAnimation(object3D: THREE.Object3D, state: ComponentState | null): void;
+    private _setFillerColor;
+    private _ensureClonedFillerMaterial;
+    private _restoreSharedFillerMaterial;
+    private _cleanupMixer;
+    /**
+     * Animate sumFiller and carryFiller fill colors over the transition span.
+     * Builds a single AnimationClip with up to two target tracks per filler
+     * (color, emissive, emissiveIntensity) — only for fillers whose value changes.
+     */
+    private _animateFillers;
+    private _pushFillerTracks;
+    /** Find a child mesh by its userData.part name */
+    protected findPartMesh(object3D: THREE.Object3D, part: string): THREE.Mesh | null;
+}

package/dist/scene/shared/components/arithmetic/index.d.ts

@@ -0,0 +1,4 @@
+export { AdderVisualFactory } from './AdderVisualFactory';
+export { HalfAdderVisualFactory } from './HalfAdderVisualFactory';
+export { EightBitAdderVisualFactory } from './EightBitAdderVisualFactory';
+export { EightBitOnesComplementVisualFactory } from './EightBitOnesComplementVisualFactory';

package/dist/scene/shared/components/basic/BatteryVisualFactory.d.ts

@@ -0,0 +1,13 @@
+import { ComponentVisualFactoryBase } from '../ComponentVisualFactory';
+import { Component } from '../../../../core/index.ts';
+import { VisualContext } from '../../types';
+import * as THREE from 'three';
+/**
+ * Visual factory for Battery components
+ */
+export declare class BatteryVisualFactory extends ComponentVisualFactoryBase {
+    private readonly BATTERY_GEOMETRY;
+    constructor();
+    createVisual(component: Component, context: VisualContext): THREE.Object3D;
+    private createPinsVisual;
+}

package/dist/scene/shared/components/basic/ClockVisualFactory.d.ts

@@ -0,0 +1,79 @@
+import { ComponentVisualFactoryBase } from '../ComponentVisualFactory';
+import { Component, ComponentState } from '../../../../core/index.ts';
+import { ConfigFormDefinition, VisualContext } from '../../types';
+import * as THREE from 'three';
+/**
+ * Visual factory for Clock
+ */
+export declare class ClockVisualFactory extends ComponentVisualFactoryBase {
+    /** Shared Clock envelope geometry */
+    private readonly ENVELOPE_GEOMETRY;
+    /** Shared Clock hand geometry */
+    private readonly HAND_GEOMETRY;
+    /** Shared Clock area geometry */
+    private readonly AREA_GEOMETRY;
+    private readonly RED_AREA_MAT;
+    private readonly BLUE_AREA_MAT;
+    private readonly HIGH_TICK_ROTATION;
+    private readonly LOW_TICK_ROTATION;
+    constructor();
+    createVisual(component: Component, context: VisualContext): THREE.Object3D;
+    private createPinsVisual;
+    private createHandGroup;
+    /**
+     * Get config form definition for Clock
+     *
+     * @param config - config
+     * @returns Form definition
+     */
+    getConfigFormDefinition(_config?: Map<string, string>): ConfigFormDefinition | null;
+    /**
+     * Map core config to form data
+     *
+     * @param config - Core component config
+     * @returns Form data
+     */
+    mapCoreConfigToForm(config: Map<string, string>): Map<string, any>;
+    /**
+     * Map form data to core config
+     *
+     * @param formData - Form data
+     * @returns Core config
+     */
+    mapFormToCoreConfig(formData: Map<string, any>): Map<string, string>;
+    updateFromConfiguration(object3D: THREE.Object3D, config: Map<string, string>): void;
+    /**
+     * Update Clock animation based on simulation state.
+     *
+     * When state is non-null: animates hand rotation toward the current state's target.
+     * If the state has a planned transition (hasExpiration), creates a smooth animation
+     * from the current visual rotation to the target using Three.js AnimationMixer.
+     * Otherwise snaps to the target position.
+     *
+     * When state is null (leaving simulation): stops all animations, cleans up mixer,
+     * and resets hand to config-based default rotation.
+     *
+     * @param object3D - The Object3D created by createVisual()
+     * @param state - The Clock's current simulation state, or null to reset
+     */
+    updateAnimation(object3D: THREE.Object3D, state: ComponentState | null): void;
+    /**
+     * Create a smooth animation from current hand rotation to targetRotation
+     */
+    private _animateHand;
+    /**
+     * Stop all animations, clean up mixer, and reset hand to config-based default rotation.
+     */
+    private _cleanupMixer;
+    private getStateRotation;
+    /**
+     * Find the hand group mesh within the component group
+     *
+     * @param object3D - The Object3D group created by createVisual()
+     * @returns The hand mesh if found, null otherwise
+     *
+     * @remarks
+     * Searches for a mesh with userData.part === 'hand'
+     */
+    private findHandGroup;
+}

package/dist/scene/shared/components/basic/DoubleThrowSwitchVisualFactory.d.ts

@@ -0,0 +1,87 @@
+import { ComponentVisualFactoryBase } from '../ComponentVisualFactory';
+import { Component, ComponentState } from '../../../../core/index.ts';
+import { ConfigFormDefinition, VisualContext } from '../../types';
+import * as THREE from 'three';
+/**
+ * Visual factory for DoubleThrowSwitch (SPDT) components
+ *
+ * Creates:
+ * - Input1 pin group
+ * - Input2 pin group
+ * - Output pin group
+ * - Contactor (box, rotatable for animation)
+ * - Component hitbox for raycasting
+ *
+ * Animation:
+ * - Smooth rotation of contactor between input1/input2 via AnimationMixer
+ * - Contactor material color reflects output pin state (voltage/current)
+ * - Supports mid-transition interruption (re-toggle during transition)
+ */
+export declare class DoubleThrowSwitchVisualFactory extends ComponentVisualFactoryBase {
+    /** Rotation for switch connected to input1 */
+    private readonly INPUT1_ROTATION;
+    /** Rotation for switch connected to input2 */
+    private readonly INPUT2_ROTATION;
+    private readonly CONTACTOR_GEOMETRY;
+    /** Contactor color when output has both voltage and current */
+    private readonly COLOR_VOLTAGE_CURRENT;
+    /** Contactor color when output has current only */
+    private readonly COLOR_CURRENT;
+    /** Contactor color when output has voltage only */
+    private readonly COLOR_VOLTAGE;
+    /** Contactor color when output has neither */
+    private readonly COLOR_NONE;
+    constructor();
+    createVisual(component: Component, context: VisualContext): THREE.Object3D;
+    private createPinsVisual;
+    /**
+     * Get config form definition for DoubleThrowSwitch
+     *
+     * @returns Form definition with initialState, transitionSpan and size
+     */
+    getConfigFormDefinition(): ConfigFormDefinition | null;
+    /**
+     * Map core config to form data
+     * Converts "input1"/"input2" strings to boolean
+     */
+    mapCoreConfigToForm(config: Map<string, string>): Map<string, any>;
+    /**
+     * Map form data to core config
+     * Converts boolean to "input1"/"input2" strings
+     */
+    mapFormToCoreConfig(formData: Map<string, any>): Map<string, string>;
+    updateFromConfiguration(object3D: THREE.Object3D, config: Map<string, string>): void;
+    /**
+     * Update switch animation based on simulation state.
+     *
+     * - null state / no context: cleanup mixer, reset to config default
+     * - paused/initial + transitional: snap to start rotation
+     * - paused/initial + stable: snap to state rotation
+     * - playing + transitional: smooth rotation animation
+     * - playing + stable: snap to final rotation, cleanup mixer
+     */
+    updateAnimation(object3D: THREE.Object3D, state: ComponentState | null): void;
+    /** Maps stable state → target rotation */
+    private _getStateRotation;
+    /** Maps transitional state → the rotation it came FROM */
+    private _getStartRotation;
+    /**
+     * Create smooth rotation + color animations for transitional states.
+     * Rotation clip: current → target state rotation (persists across updateAnimation calls)
+     * Color clip: current contactor color → white (stopped on next updateAnimation so pin state takes over)
+     */
+    private _animateContactor;
+    /**
+     * Stop the color fade animation so _updateContactorColor can set color from pin state.
+     */
+    private _stopColorAnimation;
+    /**
+     * Stop all animations, clean up mixer, reset to config default rotation.
+     */
+    private _cleanupMixer;
+    private _ensureClonedMaterial;
+    private _restoreSharedMaterial;
+    private _updateContactorColor;
+    private findContactorGroup;
+    private _findContactorMesh;
+}