@naniteninja/trait-visual 1.0.2 → 1.0.4

package/index.d.ts

@@ -1,162 +1,5 @@
-import * as i0 from '@angular/core';
-import { OnInit, AfterViewInit, OnDestroy, OnChanges, ElementRef, Renderer2, NgZone, SimpleChanges } from '@angular/core';
-import * as THREE from 'three';
-import { Vector3 } from 'three';
-import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
-
-interface IHumanAttributes {
-    [key: string]: number;
-}
-interface INodeData {
-    id: number;
-    name: string;
-    initialPosition: [number, number, number];
-    isSun: boolean;
-    color: string;
-    attributes: IHumanAttributes;
-    preferences: IHumanAttributes;
-}
-interface ISwapAnimation {
-    start: Vector3;
-    end: Vector3;
-    startTime: number;
-    duration: number;
-}
-interface IPlanetConfigs {
-    attraction: number;
-    repulsion: number;
-    repulsionInitializationThreshold: number;
-}
-interface ISunConfigs {
-    attraction: number;
-    repulsion: number;
-    repulsionInitializationThreshold: number;
-}
-interface ISimulationConfigs {
-    sun: ISunConfigs;
-    planet: IPlanetConfigs;
-    maxVelocity: number;
-    velocityDamping: number;
-    minAttributeValue: number;
-    minPreferenceValue: number;
-    maxAttributeValue: number;
-    maxPreferenceValue: number;
-}
-
-declare class Node extends THREE.Object3D {
-    options: ISimulationConfigs;
-    velocity: THREE.Vector3;
-    isSun: boolean;
-    attributes: number[];
-    preferences: number[];
-    preference: number;
-    mesh: THREE.Mesh;
-    swap: ISwapAnimation | null;
-    static attributeWeights: number[];
-    static preferenceWeights: number[];
-    private static normalizeWeights;
-    private sunBaseScale;
-    private halo;
-    private coreSprite;
-    private haloSprite;
-    private readonly baseSphereRadius;
-    private clock;
-    constructor(data: INodeData, options: ISimulationConfigs);
-    updatePhysics(nodes: Node[], central: Node | null, deltaTime: number): void;
-    setSun(state?: boolean, preference?: number): void;
-    calculatePreferredCompatibility(sun: Node): number;
-    calculateAttributeCompatibility(other: Node): number;
-    update(nodes: Node[], cursorPosition?: THREE.Vector3, scene?: THREE.Scene, camera?: THREE.Camera): void;
-    private createBillboardGlow;
-    private calculateSunForce;
-    private calculatePlanetAttraction;
-    private calculatePlanetRepulsion;
-    private applyForces;
-    private handleSwapAnimation;
-}
-
-declare class Cluster extends THREE.Object3D {
-    options: ISimulationConfigs;
-    nodes: Node[];
-    constructor(nodeData: INodeData[], options?: Partial<ISimulationConfigs>);
-    setUp(nodeData: INodeData[]): void;
-    update(cursorPosition?: THREE.Vector3, scene?: THREE.Scene, camera?: THREE.Camera): void;
-}
-
-declare class TraitVisualComponent implements OnInit, AfterViewInit, OnDestroy, OnChanges {
-    private renderer2;
-    private ngZone;
-    canvasRef: ElementRef;
-    nodeData: INodeData[];
-    attributeWeights: number[];
-    preferenceWeights: number[];
-    attributeCount?: number;
-    preferenceCount?: number;
-    scene: THREE.Scene;
-    camera: THREE.PerspectiveCamera;
-    renderer: THREE.WebGLRenderer;
-    controls: OrbitControls;
-    raycaster: THREE.Raycaster;
-    mouse: THREE.Vector2;
-    cluster: Cluster;
-    selectedNode: Node | null;
-    draggingNode: Node | null;
-    dragPlane: THREE.Plane;
-    dragOffset: THREE.Vector3;
-    newNodeCounter: number;
-    isCameraLocked: boolean;
-    private nodeAuras;
-    private starFieldNear;
-    private starFieldFar;
-    private starTexture;
-    private dustField;
-    private readonly pointerPitchAxis;
-    private readonly pointerYawAxis;
-    private pointerPitchCurrent;
-    private pointerPitchTarget;
-    private pointerYawCurrent;
-    private pointerYawTarget;
-    private pointerYawAccumulated;
-    private readonly pointerOffset;
-    private readonly pointerPitchMax;
-    private readonly pointerYawMax;
-    private readonly pointerYawSpeed;
-    private readonly pointerPitchDamping;
-    private readonly pointerYawDamping;
-    constructor(renderer2: Renderer2, ngZone: NgZone);
-    ngOnInit(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    currentCentral(): Node | null;
-    nonSuns(): Node[];
-    private syncNodeWeightGlobals;
-    private initScene;
-    private loadNodes;
-    private onWindowResize;
-    private onRightClick;
-    private onMouseMove;
-    private onDragStart;
-    private onDragMove;
-    private onDragEnd;
-    private onCanvasLeave;
-    private resetPointerPitch;
-    private updateCameraOrbitFromPointer;
-    private animate;
-    private ensureNodeAuras;
-    private createStarField;
-    private getStarTexture;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TraitVisualComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TraitVisualComponent, "tv-trait-visual", never, { "nodeData": { "alias": "nodeData"; "required": false; }; "attributeWeights": { "alias": "attributeWeights"; "required": false; }; "preferenceWeights": { "alias": "preferenceWeights"; "required": false; }; "attributeCount": { "alias": "attributeCount"; "required": false; }; "preferenceCount": { "alias": "preferenceCount"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-declare let dynamicCounts: {
-    attributes: number;
-    preferences: number;
-};
-declare function updateCounts(attrCount: number, prefCount: number): void;
-declare const nodeData: INodeData[];
-declare const attributeWeights: number[];
-
-export { TraitVisualComponent, attributeWeights, dynamicCounts, nodeData, updateCounts };
-export type { IHumanAttributes, INodeData, IPlanetConfigs, ISimulationConfigs, ISunConfigs, ISwapAnimation };
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@naniteninja/trait-visual" />
+export * from './public-api';

package/lib/app.types.d.ts

@@ -0,0 +1,124 @@
+import { Vector3 } from 'three';
+/** userData attached to blackhole meshes (aura core radius, occluder mesh). */
+export interface IBlackholeUserData {
+    id?: number;
+    _auraCoreRadius?: number;
+    _occluder?: unknown;
+}
+export interface IHumanAttributes {
+    [key: string]: number;
+}
+export interface INodeData {
+    id: number;
+    name: string;
+    initialPosition: [number, number, number];
+    isSupermassiveBlackhole: boolean;
+    /** Node sphere color: 6-digit hex (#RRGGBB) or 8-digit hex with alpha (#RRGGBBAA). Alpha 0 hides the sphere so particles show (like SMBH). */
+    color: string;
+    attributes: IHumanAttributes;
+    preferences: IHumanAttributes;
+}
+export interface ISwapAnimation {
+    start: Vector3;
+    end: Vector3;
+    startTime: number;
+    duration: number;
+}
+export interface IBlackholeConfigs {
+    attraction: number;
+    repulsion: number;
+    repulsionInitializationThreshold: number;
+    pairwiseRepulsionMain: number;
+    pairwiseRepulsionSecondary: number;
+    /** Multiplier for BH-BH repulsion (1 = normal; small changes give visible effect). Default 1. */
+    pairwiseRepulsionMultiplier?: number;
+    dissimilarityRepulsionExponent?: number;
+}
+export interface ISupermassiveBlackHoleConfigs {
+    attraction: number;
+    repulsion: number;
+    repulsionInitializationThreshold: number;
+    /** Min distance from central in SMBHW (supermassive black hole widths); high compat. Default 0.25. */
+    minDistanceWidths?: number;
+    /** Max distance from central in SMBHW; low compat; viewport radius 7 = diameter 14 SMBHW. Default 7. */
+    maxDistanceWidths?: number;
+}
+export interface ISimulationConfigs {
+    supermassiveBlackHole: ISupermassiveBlackHoleConfigs;
+    blackhole: IBlackholeConfigs;
+    maxVelocity: number;
+    velocityDamping: number;
+    minAttributeValue: number;
+    minPreferenceValue: number;
+    maxAttributeValue: number;
+    maxPreferenceValue: number;
+    /** Simulation speed multiplier (1 = real time). */
+    simulationSpeed?: number;
+}
+/** Preset entry for config sidenav (name + data to apply). */
+export interface IPresetConfig {
+    name: string;
+    centralPreferences: number[];
+    nodeAttributes: number[][];
+}
+/** Optional appearance fields for host (e.g. test app background/galaxy colors). */
+export interface IAppearanceConfig {
+    backgroundColor?: string;
+    primaryColor?: string;
+    secondaryColor?: string;
+}
+/** Full config state for the config sidenav: what it reads and what changes it emits. */
+export interface ITraitVisualConfigState {
+    nodeData: INodeData[];
+    attributeWeights: number[];
+    preferenceWeights: number[];
+    simulation?: Partial<ISimulationConfigs>;
+    appearance?: IAppearanceConfig;
+    selectedPreset: string;
+    availablePresets: IPresetConfig[];
+    /** When true, right-click on a node shows the context menu. Default false. */
+    showContextMenu?: boolean;
+    /** Default zoom level: multiplier on initial camera distance (1 = normal, 1.25 = zoom out 25%). */
+    defaultZoomLevel?: number;
+}
+/** Discriminated union for config change events from the sidenav. */
+export type ConfigChangePayload = {
+    type: 'weights';
+    attributeWeights?: number[];
+    preferenceWeights?: number[];
+} | {
+    type: 'simulation';
+    simulation: Partial<ISimulationConfigs>;
+} | {
+    type: 'nodeData';
+    nodeData: INodeData[];
+} | {
+    type: 'preset';
+    selectedPreset: string;
+} | {
+    type: 'appearance';
+    appearance: Partial<IAppearanceConfig>;
+} | {
+    type: 'addNode';
+} | {
+    type: 'removeNode';
+    nodeId: number;
+} | {
+    type: 'setTraitCount';
+    count: number;
+} | {
+    type: 'centralPreferenceChange';
+    index: number;
+    value: number;
+} | {
+    type: 'nodeAttributeChange';
+    nodeId: number;
+    attrIndex: number;
+    value: number;
+} | {
+    type: 'showContextMenu';
+    value: boolean;
+} | {
+    type: 'defaultZoomLevel';
+    value: number;
+};

package/lib/config-sidenav/config-sidenav.component.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from '@angular/core';
+import type { ITraitVisualConfigState, ConfigChangePayload, INodeData } from '../app.types';
+import * as i0 from "@angular/core";
+export declare class ConfigSidenavComponent {
+    config: ITraitVisualConfigState;
+    open: boolean;
+    configChange: EventEmitter<ConfigChangePayload>;
+    /** Active tab: 'docs' shows documentation, 'configs' shows configuration UI. */
+    activeTab: 'docs' | 'configs';
+    setActiveTab(tab: 'docs' | 'configs'): void;
+    get centralNode(): INodeData | null;
+    get nonSupermassiveBlackholeNodes(): INodeData[];
+    traitCount(): number;
+    centralPrefsArray(): number[];
+    nodeAttrsArray(node: INodeData): number[];
+    onPresetChange(value: string): void;
+    onWeightChange(index: number, value: number): void;
+    onPrefWeightChange(index: number, value: number): void;
+    onSimulationSpeedChange(value: number): void;
+    onBlackholeRepulsionChange(value: number): void;
+    onTraitCountChange(count: number): void;
+    onCentralPreferenceChange(index: number, value: number): void;
+    onNodeAttributeChange(nodeId: number, attrIndex: number, value: number): void;
+    onAddNode(): void;
+    onRemoveNode(nodeId: number): void;
+    onShowContextMenuChange(value: boolean): void;
+    onDefaultZoomLevelChange(value: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigSidenavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigSidenavComponent, "tv-config-sidenav", never, { "config": { "alias": "config"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "configChange": "configChange"; }, never, ["[config-appearance]", "[config-simulation-extra]"], true, never>;
+}

package/lib/data/nodes.data.d.ts

@@ -0,0 +1,20 @@
+import { INodeData } from '../app.types';
+/** Minimal PCA model interface for 3D projection. */
+export interface IPCAModel {
+    predict(data: number[][], opts: {
+        nComponents: number;
+    }): {
+        to2DArray(): number[][];
+    };
+    getLoadings(): {
+        to2DArray(): number[][];
+    };
+}
+export declare let dynamicCounts: {
+    attributes: number;
+    preferences: number;
+};
+export declare function updateCounts(attrCount: number, prefCount: number): void;
+export declare function projectTo3D(vec: number[]): [number, number, number];
+export declare const nodeData: INodeData[];
+export declare const attributeWeights: number[];

package/lib/objects/Blackhole.d.ts

@@ -0,0 +1,45 @@
+import * as THREE from 'three';
+import { ISimulationConfigs, INodeData, ISwapAnimation } from '../app.types';
+export declare class Blackhole extends THREE.Object3D {
+    options: ISimulationConfigs;
+    velocity: THREE.Vector3;
+    isSupermassiveBlackhole: boolean;
+    attributes: number[];
+    preferences: number[];
+    preference: number;
+    mesh: THREE.Mesh;
+    swap: ISwapAnimation | null;
+    nodeMaterial: THREE.Material | null;
+    private fixedY;
+    static attributeWeights: number[];
+    static preferenceWeights: number[];
+    private static toNumberArray;
+    private static normalizeWeights;
+    private supermassiveBlackholeBaseScale;
+    private readonly baseSphereRadius;
+    private clock;
+    /** Used by Cluster for deltaTime. */
+    getClockDelta(): number;
+    makeCoreGlowMaterial: (color: THREE.Color, opacity?: number, power?: number, base?: number) => THREE.ShaderMaterial;
+    makeRimGlowMaterial: (color: THREE.Color, opacity?: number, c?: number, power?: number) => THREE.ShaderMaterial;
+    /** Reused force vectors per blackhole index (avoids N² allocations per frame). */
+    private _forces;
+    private readonly _scratchD;
+    private readonly _scratchDir;
+    private readonly _scratchF;
+    constructor(data: INodeData, options: ISimulationConfigs);
+    private enforceFixedY;
+    updatePhysics(blackholes: Blackhole[], central: Blackhole | null, deltaTime: number): void;
+    setSupermassiveBlackhole(state?: boolean, preference?: number): void;
+    /** Preferred compatibility via PCA: map preferences and attributes to 3D (each trait its own dimension, then PCA to 3D) and use distance. */
+    calculatePreferredCompatibility(supermassiveBlackhole: Blackhole): number;
+    private fallbackPreferredCompatibility;
+    calculateAttributeCompatibility(other: Blackhole): number;
+    update(blackholes: Blackhole[], cursorPosition?: THREE.Vector3, scene?: THREE.Scene, camera?: THREE.Camera): void;
+    private createBillboardGlow;
+    private calculateSupermassiveBlackHoleForce;
+    private calculateBlackholeAttraction;
+    private calculateBlackholeRepulsion;
+    private applyForces;
+    private handleSwapAnimation;
+}

package/lib/objects/Cluster.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import { ISimulationConfigs, INodeData } from '../app.types';
+import { Blackhole } from './Blackhole';
+export declare class Cluster extends THREE.Object3D {
+    options: ISimulationConfigs;
+    blackholes: Blackhole[];
+    private _lastLogDist;
+    constructor(nodeData: INodeData[], options?: Partial<ISimulationConfigs>);
+    setUp(nodeData: INodeData[]): void;
+    update(cursorPosition?: THREE.Vector3, scene?: THREE.Scene, camera?: THREE.Camera): void;
+}

package/lib/services/black-hole-particle-field.d.ts

@@ -0,0 +1,74 @@
+import * as THREE from 'three';
+import { IParticleFieldOptions } from '../types/particle-field.types';
+export declare class BlackHoleParticleField {
+    private scene;
+    private particles;
+    private particleSystem;
+    private particleCount;
+    private coreRadius;
+    private readonly FIELD_RADIUS_FACTOR;
+    private readonly NEON_PURPLE;
+    private readonly PINK_RED;
+    private palette;
+    private useSurface;
+    private seedCounter;
+    private speedScale;
+    private readonly MIN_SPEED;
+    private readonly MAX_SPEED;
+    private get FRONT_MIN();
+    private readonly OMEGA_K;
+    private readonly OMEGA_MAX_RIM;
+    private readonly OMEGA_MAX_CAP;
+    private readonly OMEGA_SURFACE_K;
+    private readonly OMEGA_SURFACE_MAX;
+    private readonly OMEGA_SURFACE_BASE_MIN;
+    private readonly OMEGA_SURFACE_BASE_MAX;
+    private readonly SPEED_EPS;
+    private readonly SHIMMER_FRAC;
+    private debugBands;
+    private lastDebugLogMs;
+    private bandCounts;
+    private readonly MIN_LIFETIME;
+    private readonly MAX_LIFETIME;
+    private targetAnchor;
+    private anchor;
+    private readonly anchorLerp;
+    private lastRight;
+    private flowSpeedScale;
+    private prevTargetAnchor;
+    private readonly worldUp;
+    private particleSizeMax;
+    private particleSizeScale;
+    private surfaceRadiusMin;
+    private surfaceRadiusMax;
+    private rimMinShellFactor;
+    constructor(scene: THREE.Scene, opts?: IParticleFieldOptions);
+    /**
+     * Update particle field anchored at `anchorPosition`, advected by `flow`.
+     */
+    update(anchorPosition: THREE.Vector3, flow: THREE.Vector3, deltaTime: number, camera?: THREE.Camera): void;
+    /**
+     * Resize the field to a new `coreRadius` while preserving particle distribution.
+     * Scales all radius-like parameters so visuals stay consistent.
+     */
+    resizeCoreRadius(newRadius: number): void;
+    setDebugBands(enabled: boolean): void;
+    toggleDebugBands(): boolean;
+    setPalette(newPalette: 'supermassiveBlackhole' | 'blackhole'): void;
+    /** Set global particle size scale (affects shader uniform). */
+    setParticleSizeScale(value: number): void;
+    /** Set how far rim particles can go inside the node (0.7 = 30% inside, 1 = on surface). */
+    setRimMinShellFactor(value: number): void;
+    /** Set surface shell radius range (factors of coreRadius). */
+    setSurfaceRadiusMin(value: number): void;
+    setSurfaceRadiusMax(value: number): void;
+    dispose(): void;
+    private initializeParticleField;
+    private generateParticles;
+    /** Base size: mostly 0.8–1.8, ~12% chance of small 0.4–0.7, clamped by particleSizeMax. */
+    private nextParticleSize;
+    private createNewParticle;
+    private createParticleSystem;
+    private getLocalOrbitPos;
+    private getDebugColorForType;
+}

package/lib/services/node-actions.d.ts

@@ -0,0 +1,4 @@
+import { Blackhole } from '../objects/Blackhole';
+import { Cluster } from '../objects/Cluster';
+export declare function addNode(cluster: Cluster, newNodeCounter: number): number;
+export declare function removeNode(cluster: Cluster, selectedBlackhole: Blackhole | null, hiddenBlackholes: Blackhole[], contextMenuElement: HTMLElement): void;

package/lib/services/stellar-dust-field.d.ts

@@ -0,0 +1,102 @@
+import * as THREE from 'three';
+import { DustMode, IDustOptions } from '../types/dust-field.types';
+export type { DustMode, DustOptions, DustPaletteOptions, DustPaletteStop } from '../types/dust-field.types';
+/**
+ * StellarDustField
+ *
+ * A true 3D, GPU‑animated particle disk that orbits a given center (the supermassive black hole).
+ * It uses two draw calls: a dense mid/far bed of tiny points and a sparse
+ * foreground bokeh cohort of large, soft discs. Motion is computed fully on
+ * the GPU (vertex shader) from per‑particle attributes; the CPU only updates
+ * a few uniforms per frame.
+ */
+export declare class StellarDustField {
+    private scene;
+    private group;
+    private points;
+    private readonly MAX_ATTRACTORS;
+    private readonly MAX_PALETTE_STOPS;
+    private attractorWorldPos;
+    private attractorWorldRad;
+    private attractorLocalPos;
+    private attractorRadius;
+    private nearRadiusFactor;
+    private stickEpsRel;
+    private stickEpsMin;
+    private stickEpsMax;
+    private attractStrength;
+    private tangentialBias;
+    private debugDustTouch;
+    private lastDustLogMs;
+    private useAttract;
+    private debugLogPalette;
+    private debugLogBands;
+    private debugEdgeMix;
+    private debugDimLights;
+    private whitenScale;
+    private alphaScale;
+    private paletteStops;
+    private paletteHueBiasScale;
+    private paletteBackgroundLift;
+    private paletteCoreIntensity;
+    private paletteUniformColors;
+    private paletteUniformStops;
+    private paletteUniformIntensities;
+    private paletteUniformCount;
+    private diskFraction;
+    private diskBokehFraction;
+    private haloRadiusMultiplier;
+    private armCount;
+    private armPopulation;
+    private armSpread;
+    private armTwist;
+    private haloArmPopulation;
+    private haloArmSpread;
+    private haloArmTwist;
+    private dustMode;
+    private sphereJitter;
+    private static readonly DEFAULT_PALETTE;
+    private opts;
+    private time;
+    private viewportHeight;
+    constructor(scene: THREE.Scene, options?: IDustOptions);
+    setBrightnessScale(scale: number): void;
+    setWhitenScale(scale: number): void;
+    setBrightness(value01: number): void;
+    applyOptions(o: IDustOptions): void;
+    setMode(mode: DustMode): void;
+    setSphereParameters(params: {
+        jitter?: number;
+    }): void;
+    setDiskNormal(normal: THREE.Vector3): void;
+    setViewportHeight(h: number): void;
+    private buildPaletteFromLegacyColors;
+    private applyPalette;
+    private syncLegacyColorsFromPalette;
+    private updatePaletteUniformsOnMaterials;
+    private samplePaletteAt;
+    private colorToHexString;
+    logPaletteRamp(samples?: number): void;
+    private logDiskBandStats;
+    private refreshPaletteUniformData;
+    update(dt: number, center: THREE.Vector3): void;
+    dispose(): void;
+    /**
+     * Provide world-space node centers and radii; internally converted to
+     * dust-local coordinates and pushed to shader uniforms.
+     * @param usedCount If set, only the first usedCount entries of attractors are read (allows reusing a buffer).
+     */
+    setAttractorsWorld(attractors: {
+        position: THREE.Vector3;
+        radius: number;
+    }[], usedCount?: number): void;
+    setAttractEnabled(enabled: boolean): void;
+    private build;
+    private makeCohort;
+    private makeMaterial;
+    private valueNoise2D;
+    private samplePeriodicFbm;
+    private sampleAndLogContacts;
+    private hashFloat;
+    private syncAttractorUniforms;
+}

package/lib/trait-visual.component.d.ts

@@ -0,0 +1,85 @@
+import { ElementRef, EventEmitter, OnInit, AfterViewInit, OnDestroy, Renderer2, NgZone, OnChanges, SimpleChanges } from '@angular/core';
+import * as THREE from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { INodeData, ISimulationConfigs } from './app.types';
+import { Cluster } from './objects/Cluster';
+import { Blackhole } from './objects/Blackhole';
+import * as i0 from "@angular/core";
+export declare class TraitVisualComponent implements OnInit, AfterViewInit, OnDestroy, OnChanges {
+    private renderer2;
+    private ngZone;
+    canvasRef: ElementRef;
+    nodeData: INodeData[];
+    attributeWeights: number[];
+    preferenceWeights: number[];
+    attributeCount?: number;
+    preferenceCount?: number;
+    simulationOptions?: Partial<ISimulationConfigs>;
+    /** When true, right-click on a node can show the context menu (when implemented). Default false. */
+    showContextMenu: boolean;
+    /** Default zoom level: multiplier on initial camera distance (1 = normal, > 1 = zoom out more). Default 1.25. */
+    defaultZoomLevel: number;
+    /** Emits when the user selects a blackhole (e.g. via right-click). Host app can use this for context menu or sidenav. */
+    blackholeSelected: EventEmitter<Blackhole | null>;
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    renderer: THREE.WebGLRenderer;
+    controls: OrbitControls;
+    raycaster: THREE.Raycaster;
+    mouse: THREE.Vector2;
+    cluster: Cluster;
+    selectedNode: Blackhole | null;
+    draggingNode: Blackhole | null;
+    dragPlane: THREE.Plane;
+    dragOffset: THREE.Vector3;
+    newNodeCounter: number;
+    isCameraLocked: boolean;
+    private nodeAuras;
+    private starFieldNear;
+    private starFieldFar;
+    private starTexture;
+    private dustField;
+    private readonly pointerPitchAxis;
+    private readonly pointerYawAxis;
+    private pointerPitchCurrent;
+    private pointerPitchTarget;
+    private pointerYawCurrent;
+    private pointerYawTarget;
+    private pointerYawAccumulated;
+    private readonly pointerOffset;
+    private readonly pointerPitchMax;
+    private readonly pointerYawMax;
+    private readonly pointerYawSpeed;
+    private readonly pointerPitchDamping;
+    private readonly pointerYawDamping;
+    /** Reused buffer for dust-field attractors (avoids per-frame allocations). */
+    private readonly _attractorsBuffer;
+    private readonly _centerFallback;
+    constructor(renderer2: Renderer2, ngZone: NgZone);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Apply defaultZoomLevel to camera: same direction from target, scaled distance. */
+    private applyDefaultZoomLevel;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    currentSupermassiveBlackhole(): Blackhole | null;
+    nonSupermassiveBlackholes(): Blackhole[];
+    private syncNodeWeightGlobals;
+    private initScene;
+    private loadNodes;
+    private onWindowResize;
+    private onRightClick;
+    private onMouseMove;
+    private onDragStart;
+    private onDragMove;
+    private onDragEnd;
+    private onCanvasLeave;
+    private resetPointerPitch;
+    private updateCameraOrbitFromPointer;
+    private animate;
+    private ensureNodeAuras;
+    private createStarField;
+    private getStarTexture;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TraitVisualComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TraitVisualComponent, "tv-trait-visual", never, { "nodeData": { "alias": "nodeData"; "required": false; }; "attributeWeights": { "alias": "attributeWeights"; "required": false; }; "preferenceWeights": { "alias": "preferenceWeights"; "required": false; }; "attributeCount": { "alias": "attributeCount"; "required": false; }; "preferenceCount": { "alias": "preferenceCount"; "required": false; }; "simulationOptions": { "alias": "simulationOptions"; "required": false; }; "showContextMenu": { "alias": "showContextMenu"; "required": false; }; "defaultZoomLevel": { "alias": "defaultZoomLevel"; "required": false; }; }, { "blackholeSelected": "blackholeSelected"; }, never, never, true, never>;
+}