@adatechnology/game-vehicles-three 0.6.4 → 0.8.0

package/dist/index.d.ts

@@ -1,9 +1,11 @@
-import { E as EngineProfile, V as VehicleSoundKeys, B as BuiltVehicle } from './testing-C-BgV7gj.js';
-export { a as BIKE_ENGINE, b as BuildVehicleOptions, C as CAR_ENGINE, c as CRASH_SPEEDS, D as DEFAULT_TEST_VEHICLES, d as DEFAULT_TEST_WRECKS, e as DEFAULT_VEHICLE_SOUND_KEYS, f as DocumentLike, g as ENGINE_PROFILES, h as EffectsLike, i as EngineLayer, j as EngineLoadLayer, F as FleetDims, M as ModuleRoomLike, P as PAGE_ITEM_ALIASES, k as PAGE_SCENARIO_ALIASES, l as PROVING_AREA_ID, m as PROVING_TEXT, n as ProvingModuleOptions, o as ProvingRoomLike, p as ProvingText, T as TRUCK_ENGINE, q as VEHICLES_AREA_ID, r as VEHICLE_SCENARIO_IDS, s as VehicleEffectIds, t as VehicleFleetContent, u as VehicleQuality, v as VehicleSoundIds, w as VehicleWreck, x as VehiclesContext, y as VehiclesRoom, z as VehiclesTestFleet, A as VehiclesTestOptions, G as VehiclesThree, H as VehiclesThreeOptions, I as createProvingModule, J as createVehiclesTestModule, K as createVehiclesThree, L as defaultEffectIds, N as defaultSoundIds, O as loadProvingModule, Q as loadVehiclesTestModule } from './testing-C-BgV7gj.js';
-import { EffectSink, Vec3, AudioSink } from '@adatechnology/game-contracts';
-import { CabinSource } from '@adatechnology/game-vehicles';
-import { LoopRecipe, Falloff, SoundRecipe, SoundBank } from '@adatechnology/game-audio';
-import { Object3D, CanvasTexture, CircleGeometry, MeshBasicMaterial, Mesh, Vector3 } from 'three';
+import { E as EngineProfile, V as VehicleSoundKeys, B as BuiltVehicle } from './testing-Cb10i9fm.js';
+export { a as BIKE_ENGINE, b as BuildVehicleOptions, C as CAR_ENGINE, c as CRASH_SPEEDS, D as DEFAULT_TEST_VEHICLES, d as DEFAULT_TEST_WRECKS, e as DEFAULT_VEHICLE_SOUND_KEYS, f as DocumentLike, g as ENGINE_PROFILES, h as EffectsLike, i as EngineLayer, j as EngineLoadLayer, F as FleetDims, M as ModuleRoomLike, P as PAGE_ITEM_ALIASES, k as PAGE_SCENARIO_ALIASES, l as PROVING_AREA_ID, m as PROVING_TEXT, n as ProvingModuleOptions, o as ProvingRoomLike, p as ProvingText, T as TRUCK_ENGINE, q as VEHICLES_AREA_ID, r as VEHICLE_SCENARIO_IDS, s as VehicleEffectIds, t as VehicleFleetContent, u as VehicleQuality, v as VehicleSoundIds, w as VehicleWreck, x as VehiclesContext, y as VehiclesRoom, z as VehiclesTestFleet, A as VehiclesTestOptions, G as VehiclesThree, H as VehiclesThreeOptions, I as createProvingModule, J as createVehiclesTestModule, K as createVehiclesThree, L as defaultEffectIds, N as defaultSoundIds, O as loadProvingModule, Q as loadVehiclesTestModule } from './testing-Cb10i9fm.js';
+import { EffectSink, Vec3, AudioSink, AnimationClipSpec } from '@adatechnology/game-contracts';
+import { CabinSource, VehicleContext } from '@adatechnology/game-vehicles';
+import { LoopRecipe, Falloff, SampleAlias, SoundRecipe, SoundBank } from '@adatechnology/game-audio';
+import * as THREE_NS from 'three';
+import { Texture, Material, Color, Object3D, Matrix4, MeshStandardMaterial, MeshBasicMaterial, Mesh, CanvasTexture, CircleGeometry, Vector3, BufferGeometry, Side } from 'three';
+import '@adatechnology/game-vehicles-driving';
 import '@adatechnology/game-vehicles-proving';
 
 /**
@@ -33,8 +35,62 @@ declare const VEHICLE_LOOP_FALLOFF: Falloff;
 declare const VEHICLE_LOOPS: readonly LoopRecipe[];
 /** The one-shots: the starter, the engine stopping, crashes by speed, and the doors, trunk and hood of a car. */
 declare const VEHICLE_SOUNDS: readonly SoundRecipe[];
+/**
+ * The RPM each car recording runs at, measured on the files (the crank turning at 16.7 and 42 Hz, the firing at four times that: a V8). A layer
+ * plays its file at `rpm / recorded rpm`.
+ */
+declare const CAR_RECORDED_RPM: {
+    readonly idle: 1000;
+    readonly high: 2520;
+};
+/** Where the start and the stop sit in the recording of a car starting, running and stopping (`engine_start_run_stop`), in seconds. */
+declare const CAR_START_RUN_STOP: {
+    /** The take the times below were measured on. */
+    readonly take: "_01.";
+    /** The starter and the engine catching (at 0.58 s) and flaring; the loops take over at the crank time of the vehicle. */
+    readonly start: {
+        readonly offset: 0;
+        readonly duration: 1.3;
+    };
+    /** The ignition off: the engine running down to the end of the file. */
+    readonly stop: {
+        readonly offset: 9.96;
+        readonly duration: 0.64;
+    };
+};
+/**
+ * The vehicle ids answered by the recordings of the kit's manifest (files kept by the game, never in the SDK): the car engine layers by RPM, the
+ * start and the stop cut out of one recording, the door and the trunk. Each recipe above stays as the fallback while the files load or where the
+ * game has none. `car_door_open` is a file id of its own and needs no alias; the hood, the truck, the bike, the tyres, crashes and horns have no
+ * recording yet.
+ */
+declare const VEHICLE_SAMPLE_ALIASES: readonly SampleAlias[];
+/** The ids a host should decode as the vehicles load (`AudioSink.preload`): every aliased recording and the door's own file id. */
+declare const VEHICLE_PRELOAD_SOUNDS: readonly string[];
 declare const VEHICLE_SOUND_BANK: SoundBank;
 
+/** How many vehicles are heard at once: the nearest `max` to the listener keep their loops, the others are silent until they come closer. */
+type EngineBudget = {
+    /** Reports where a vehicle is this frame; true when it is among the nearest `max` (it may sound). */
+    admit(vehicle: object, position: Vec3): boolean;
+    /** Forgets a vehicle (it left the scene). */
+    release(vehicle: object): void;
+    /** Vehicles being tracked. */
+    readonly size: number;
+};
+type EngineBudgetOptions = {
+    /** Default 6: a street of idling cars is a hum, not a wall of a hundred engines. */
+    readonly max?: number;
+    /** Where the listener is (the camera or the player). */
+    readonly listener: () => Vec3;
+};
+/**
+ * A level of detail for vehicle sound, shared by every `createVehicleSound` of a scene (`VehicleSoundOptions.budget`): each vehicle reports its
+ * place every frame and only the nearest `max` keep their engine and tyre loops. A vehicle that falls out fades its loops to silence; its one-shots
+ * (a crash, the starter) still play, since they are rare and the engine's voice limiter already ranks them.
+ */
+declare function createEngineBudget(options: EngineBudgetOptions): EngineBudget;
+
 /** What one engine loop is set to this frame. `frequency` is absent for the load layer (noise has no pitch). */
 type EngineLayerSetting = {
     readonly sound: string;
@@ -80,6 +136,12 @@ type VehicleSoundFrame = {
     readonly slip?: number;
     /** What the tyres are on: `dirt` for earth, gravel, sand or grass; anything else squeals as asphalt. */
     readonly surface?: 'asphalt' | 'dirt';
+    /** 0..1, how hard the brakes are pressed: the pads squeal as the car comes to a stop without skidding. */
+    readonly brake?: number;
+    /** An emergency vehicle's siren: `wail` sweeps 650–1500 Hz in ~4 s, `yelp` in a quarter second; absent or `off`, silent. */
+    readonly siren?: 'off' | 'wail' | 'yelp';
+    /** 0..1, how fast a helicopter's rotor turns (the blades spool up and down with it). */
+    readonly rotor?: number;
 };
 type VehicleSoundOptions = {
     readonly profile?: EngineProfile;
@@ -87,6 +149,8 @@ type VehicleSoundOptions = {
     readonly sounds?: Partial<VehicleSoundKeys>;
     /** Seconds the starter turns before the engine catches (the `engine_start` recipe catches at 0.75 s). */
     readonly crankSeconds?: number;
+    /** Shared by the vehicles of a scene: only the nearest few keep their loops (`createEngineBudget`). */
+    readonly budget?: EngineBudget;
 };
 /** What was asked of the sink, for the checks and the bench: the RPM in use and the level of each loop. */
 type VehicleSoundReading = {
@@ -103,6 +167,8 @@ type VehicleSound = {
     stop(position: Vec3): void;
     /** A hit at `speed` m/s: light, medium or heavy by speed, louder with it. */
     crash(speed: number, position: Vec3): 'light' | 'medium' | 'heavy';
+    /** A body hit at `speed` m/s (a person, an animal; `sound` names another id, a zombie in a game), louder with the speed. */
+    hit(speed: number, position: Vec3, sound?: string): void;
     update(frame: VehicleSoundFrame): void;
     readonly reading: VehicleSoundReading;
     dispose(): void;
@@ -118,11 +184,30 @@ declare function createVehicleSound(audio: AudioSink | undefined, options?: Vehi
  * with the meshes nobody sees from outside left out. A literal port: the classes, the thresholds (3 cm prune, 0.99 opacity, 0.5 metalness,
  * 0.25 and 0.45 emissive) and the colours are the team's.
  */
+
+type Three = typeof THREE_NS;
 /** The six classes of a fused vehicle, in the order they are added to the group. */
 declare const LITE_CLASSES: readonly ["paint", "trim", "metal", "glass", "light", "plate"];
 type LiteClass = (typeof LITE_CLASSES)[number];
 /** Smallest extent in metres a piece needs to survive the fusion (the plate is always kept). */
 declare const PRUNE_BELOW = 0.03;
+/** A material of the built vehicle as the fusion reads it (standard, basic or line materials alike). */
+type LiteSourceMaterial = Material & {
+    map?: Texture | null;
+    color: Color;
+    metalness?: number;
+    roughness?: number;
+    emissive?: Color;
+    emissiveIntensity?: number;
+    isMeshBasicMaterial?: boolean;
+};
+/** What the fusion reads of the built vehicle: its root and the paints (`c.paints`). */
+interface LiteSource {
+    vehicle: Object3D;
+    paints?: ReadonlySet<Material> | null;
+}
+/** A material of the fused vehicle (`liteMaterials`). */
+type LiteMaterial = MeshStandardMaterial | MeshBasicMaterial;
 interface Accumulator {
     P: number[];
     N: number[];
@@ -132,25 +217,25 @@ interface Accumulator {
     nv: number;
     alpha: boolean;
     uv: boolean;
-    map: any;
+    map: Texture | null | undefined;
 }
 interface LiteFusion {
     acc: Record<LiteClass, Accumulator>;
     pruned: number;
 }
 /** Which class a material belongs to, or `null` when it is left out. */
-declare function classify(mat: any, mesh: any, c: any): LiteClass | null;
+declare function classify(mat: LiteSourceMaterial, mesh: Object3D, c: LiteSource): LiteClass | null;
 /** The vertex colour of a piece of a class. `paintColor` replaces the primary paint. */
-declare function classColor(mat: any, cls: LiteClass, primary: any, paintColor: any, out: any): any;
+declare function classColor(mat: LiteSourceMaterial, cls: LiteClass, primary: Material | null | undefined, paintColor: Color | null | undefined, out: Color): Color;
 /** The material of each class (vertex colours; glass blends; light is unlit; the plate keeps its canvas texture). */
-declare function liteMaterials(THREE: any, environment: any): Record<LiteClass, any>;
+declare function liteMaterials(THREE: Three, environment: Texture | null): Record<LiteClass, LiteMaterial>;
 /**
  * Walks the built vehicle and collects every visible mesh, in the frame of `pivot`, into one set of arrays per class.
  * `hidden` is the set of materials nobody sees from outside (`kit.lodHiddenMaterials()`).
  */
-declare function fuse(THREE: any, c: any, pivot: any, paintColor: any, primary: any, hidden: ReadonlySet<any>): LiteFusion;
+declare function fuse(THREE: Three, c: LiteSource, pivot: Matrix4, paintColor: Color | null, primary: Material | null | undefined, hidden: ReadonlySet<Material>): LiteFusion;
 /** One mesh per class that has triangles. */
-declare function liteMeshes(THREE: any, fusion: LiteFusion, materials: Record<LiteClass, any>): any[];
+declare function liteMeshes(THREE: Three, fusion: LiteFusion, materials: Record<LiteClass, LiteMaterial>): Mesh[];
 
 /** Past this distance (m) an untouched vehicle draws fused: nobody sees a door seam from here, and the full model costs hundreds of draw calls. */
 declare const VEHICLE_LOD_DISTANCE = 14;
@@ -164,8 +249,14 @@ type VehicleLod = {
     readonly fused: boolean;
     dispose(): void;
 };
+/** What the level of detail reads of the vehicle kit: its three.js, the materials nobody sees from outside and the studio environment. */
+type VehicleLodKit = {
+    readonly THREE: typeof THREE_NS;
+    lodHiddenMaterials(): ReadonlySet<Material>;
+    studioEnvironment(): Texture | null;
+};
 /** Shows `full` near and the kit's fused light mode (one mesh per class of material) far, in `root`'s own space. Hit tests read the full model, visible or not. */
-declare function createVehicleLod(kit: any, context: any, root: any, full: any, options?: VehicleLodOptions): VehicleLod;
+declare function createVehicleLod(kit: VehicleLodKit, context: VehicleContext, root: Object3D, full: Object3D, options?: VehicleLodOptions): VehicleLod;
 
 type LampSwitch = {
     mode: 'off' | 'position' | 'low' | 'high';
@@ -176,6 +267,8 @@ type LampSwitch = {
     /** Indicator lamps lit this instant (the controls blink them). */
     left: boolean;
     right: boolean;
+    /** The beacon: the side lit this instant (0 or 1), null with it off. Default off. */
+    beacon?: 0 | 1 | null;
 };
 /** Glow of the lamp glass by switch, as a share of what the kit drew (the kit draws them lit), and the beams. */
 declare const LAMP_RULES: {
@@ -199,6 +292,11 @@ declare const LAMP_RULES: {
             readonly off: 0.1;
             readonly on: 2.2;
         };
+        readonly beacon: {
+            readonly off: 0.35;
+            readonly dark: 0.12;
+            readonly lit: 2.8;
+        };
     };
     readonly low: {
         readonly color: 16773584;
@@ -247,6 +345,7 @@ interface VehicleLamps {
         tail: boolean;
         fog: boolean;
         indicators: boolean;
+        beacon: boolean;
     };
     set(lamps: LampSwitch): void;
     readonly state: LampSwitch;
@@ -259,6 +358,112 @@ declare function createVehicleLamps(THREE: {
     owner?: string;
 }): VehicleLamps;
 
+/**
+ * The openings of a built vehicle worked by hand: each door, the hood and the trunk lid swing on the hinges the vehicle destructible draws (their open
+ * pose is the one of its `open_*` clips, so the door takes its skin, glass and trim with it), each side window slides down into its door, a sunroof
+ * slides back when the model has one, the wiper blades sweep, and the central locking keeps the doors and the lid shut. It moves only what the kit
+ * drew and puts every part back on `dispose`.
+ */
+
+type Vec$1 = {
+    x: number;
+    y: number;
+    z: number;
+    copy(v: Vec$1): Vec$1;
+    clone(): Vec$1;
+    sub(v: Vec$1): Vec$1;
+    add(v: Vec$1): Vec$1;
+    applyQuaternion(q: Quat$1): Vec$1;
+};
+type Quat$1 = {
+    copy(q: Quat$1): Quat$1;
+    clone(): Quat$1;
+    setFromAxisAngle(axis: Vec$1, angle: number): Quat$1;
+    multiply(q: Quat$1): Quat$1;
+};
+/** What the body needs of three.js: vectors and quaternions to turn a wiper about its spindle. */
+type BodyThree = {
+    Vector3: new (x?: number, y?: number, z?: number) => Vec$1;
+    Quaternion: new () => Quat$1;
+};
+/** A side window by where it sits: `front_left`, `rear_right`... */
+type WindowId = `${'front' | 'rear'}_${'left' | 'right'}`;
+type BodyEvent = {
+    type: 'sound';
+    key: string;
+    part: string;
+} | {
+    type: 'refused';
+    part: string;
+    reason: 'locked' | 'missing';
+};
+interface VehicleBodyOptions {
+    THREE: BodyThree;
+    /** The open and close clips of the vehicle destructible (`animations()`): the open pose of each door, the hood and the lid. */
+    clips: readonly AnimationClipSpec[];
+    /** Seconds a door, the hood or the lid takes to open. Default 1.2 (the clips'). */
+    swingSeconds?: number;
+    /** Seconds a window takes from shut to open. Default 3.5. */
+    windowSeconds?: number;
+    /** Share of the pane's height that goes into the door. Default 0.92 (the top edge stays in the seal). */
+    windowTravel?: number;
+}
+interface VehicleBody {
+    /** Part ids the body can open: `door_front_left`..., `hood`, `lid`. */
+    readonly parts: readonly string[];
+    readonly windows: readonly WindowId[];
+    readonly hasSunroof: boolean;
+    readonly wipers: number;
+    readonly locked: boolean;
+    /** 0 shut to 1 open. */
+    openness(part: string): number;
+    /** Opens a shut part or shuts an open one. Locked doors and lid refuse. */
+    toggle(part: string): BodyEvent[];
+    /** Window opening, 0 shut to 1 down. */
+    window(id: WindowId): number;
+    toggleWindow(id: WindowId): void;
+    setWindow(id: WindowId, open: number): void;
+    toggleSunroof(): void;
+    /** Locks or unlocks the doors and the lid (the key or the remote). */
+    lock(locked: boolean): BodyEvent[];
+    /** Advances the moving parts; `wipe` is the wipers' sweeps per second (0 parked). */
+    update(dt: number, wipe?: number): BodyEvent[];
+    dispose(): void;
+}
+declare function createVehicleBody(built: BuiltVehicle, options: VehicleBodyOptions): VehicleBody;
+
+/**
+ * The wheels of a built vehicle turning as it moves: each wheel the kit drew (`context.wheels`) rolls about its axle by the distance travelled over
+ * its radius, and the front ones turn with the steering. The turn is applied over the wheel's own rest pose, so a mirrored or tilted wheel rolls the
+ * right way, and `dispose` puts every wheel back exactly as it was drawn.
+ */
+
+type Vec = {
+    x: number;
+    y: number;
+    z: number;
+};
+type Quat = {
+    copy(q: Quat): Quat;
+    clone(): Quat;
+    setFromAxisAngle(axis: Vec, angle: number): Quat;
+    multiply(q: Quat): Quat;
+    premultiply(q: Quat): Quat;
+};
+/** What the wheels need of three.js. */
+type WheelRollThree = {
+    Vector3: new (x?: number, y?: number, z?: number) => Vec;
+    Quaternion: new () => Quat;
+};
+interface WheelRoll {
+    /** Wheels found on the vehicle. */
+    readonly count: number;
+    /** The vehicle went `distance` metres forward (negative backwards) with the front wheels steered `steer` radians (positive to the left). */
+    roll(distance: number, steer: number): void;
+    dispose(): void;
+}
+declare function createWheelRoll(THREE: WheelRollThree, built: BuiltVehicle): WheelRoll;
+
 /** What the cluster shows this instant. */
 type DashboardReading = {
     kmh: number;
@@ -279,6 +484,15 @@ type DashboardReading = {
     temperature?: number;
     /** Fuel, 0 (empty) to 1 (full); leave out while the vehicle has no fuel model. */
     fuel?: number;
+    /** Cruise control holding a speed. */
+    cruise?: boolean;
+    /** Drive profile shown by its letter (E economy, S sport; nothing for normal). */
+    profile?: 'eco' | 'normal' | 'sport';
+    /** The aids switched off light their amber lamps. */
+    tractionOff?: boolean;
+    absOff?: boolean;
+    /** The alternator does not keep up (the battery drains with the engine running). */
+    charging?: boolean;
 };
 /** The scale of the dials and how often the faces are redrawn. */
 type DashboardOptions = {
@@ -331,4 +545,43 @@ declare const DASHBOARD_LOOK: {
 };
 declare function createVehicleDashboard(THREE: ThreeLib, built: BuiltVehicle, options: DashboardOptions): VehicleDashboard;
 
-export { BuiltVehicle, type CabinSmoke, DASHBOARD_LOOK, type DashboardOptions, type DashboardReading, type EngineLayerSetting, type EngineMixInput, EngineProfile, LAMP_RULES, LITE_CLASSES, type LampSwitch, type LiteClass, type LiteFusion, PRUNE_BELOW, VEHICLE_LOD_DISTANCE, VEHICLE_LOOPS, VEHICLE_LOOP_FALLOFF, VEHICLE_SOUNDS, VEHICLE_SOUND_BANK, type VehicleDashboard, type VehicleLamps, type VehicleLod, type VehicleSound, type VehicleSoundFrame, VehicleSoundKeys, type VehicleSoundOptions, type VehicleSoundReading, classColor, classify, createCabinSmoke, createGearGuess, createVehicleDashboard, createVehicleLamps, createVehicleLod, createVehicleSound, engineMix, firingHz, fuse, layerWeight, liteMaterials, liteMeshes, rpmShare };
+/**
+ * The mist on the inside of a built vehicle's glass, drawn from the fog share of `createWindshieldFog` (`game-vehicles-driving`). Each pane the kit drew
+ * (`context.glass`) gets a thin pale film that follows it (a side window going down, a door swinging), on the pane's own geometry; the windshield shows
+ * the whole share and the other panes a little less, since the demister blows on the windshield first. The film is never hit by a shot (it has no
+ * raycast) and never writes depth. `dispose` takes the films away and frees their materials; the geometry is the pane's and stays.
+ */
+
+/** What the mist needs of three.js. */
+type MistThree = {
+    Mesh: new (geometry: BufferGeometry, material: Material) => Mesh;
+    MeshBasicMaterial: new (parameters: {
+        color: number;
+        transparent: boolean;
+        opacity: number;
+        depthWrite: boolean;
+        side: Side;
+        polygonOffset: boolean;
+        polygonOffsetFactor: number;
+        polygonOffsetUnits: number;
+    }) => Material & {
+        opacity: number;
+    };
+};
+/** How the mist looks: its colour, how opaque full fog is, and the share of it on the side and rear panes. */
+declare const MIST_RULES: {
+    readonly color: 15001836;
+    readonly opacity: 0.72;
+    readonly others: 0.8;
+};
+interface WindshieldMist {
+    /** Panes with a film. */
+    readonly panes: number;
+    /** Shows `fog` (0 clear to 1 misted over). */
+    set(fog: number): void;
+    readonly fog: number;
+    dispose(): void;
+}
+declare function createWindshieldMist(THREE: MistThree, built: BuiltVehicle): WindshieldMist;
+
+export { type BodyEvent, type BodyThree, BuiltVehicle, CAR_RECORDED_RPM, CAR_START_RUN_STOP, type CabinSmoke, DASHBOARD_LOOK, type DashboardOptions, type DashboardReading, type EngineBudget, type EngineBudgetOptions, type EngineLayerSetting, type EngineMixInput, EngineProfile, LAMP_RULES, LITE_CLASSES, type LampSwitch, type LiteClass, type LiteFusion, MIST_RULES, type MistThree, PRUNE_BELOW, VEHICLE_LOD_DISTANCE, VEHICLE_LOOPS, VEHICLE_LOOP_FALLOFF, VEHICLE_PRELOAD_SOUNDS, VEHICLE_SAMPLE_ALIASES, VEHICLE_SOUNDS, VEHICLE_SOUND_BANK, type VehicleBody, type VehicleBodyOptions, type VehicleDashboard, type VehicleLamps, type VehicleLod, type VehicleLodKit, type VehicleSound, type VehicleSoundFrame, VehicleSoundKeys, type VehicleSoundOptions, type VehicleSoundReading, type WheelRoll, type WheelRollThree, type WindowId, type WindshieldMist, classColor, classify, createCabinSmoke, createEngineBudget, createGearGuess, createVehicleBody, createVehicleDashboard, createVehicleLamps, createVehicleLod, createVehicleSound, createWheelRoll, createWindshieldMist, engineMix, firingHz, fuse, layerWeight, liteMaterials, liteMeshes, rpmShare };