@aura3d/rendering 1.4.0 → 1.4.2

package/src/VoxelWorldFixtures.ts

@@ -1,280 +0,0 @@
-export type VoxelFixtureBlockType =
-  | "air"
-  | "stone"
-  | "dirt"
-  | "grass"
-  | "sand"
-  | "water"
-  | "wood"
-  | "leaves"
-  | "glass"
-  | "coal-ore"
-  | "iron-ore"
-  | "gold-ore"
-  | "diamond-ore"
-  | "bedrock"
-  | "cobblestone"
-  | "planks"
-  | "brick"
-  | "snow"
-  | "ice"
-  | "lava";
-
-export type VoxelFixtureLod = "near" | "mid" | "far" | "culled";
-
-export interface VoxelFixtureOptions {
-  readonly seed?: number;
-  readonly chunkSize?: number;
-  readonly viewDistance?: number;
-  readonly cameraChunkX?: number;
-  readonly cameraChunkZ?: number;
-}
-
-export interface VoxelBlockDescriptor {
-  readonly type: VoxelFixtureBlockType;
-  readonly color: readonly [number, number, number, number];
-  readonly hardness: number;
-  readonly toolRequired: string | null;
-  readonly drops: VoxelFixtureBlockType | null;
-  readonly sound: string;
-  readonly animated: boolean;
-  readonly lightLevel: number;
-  readonly transparent: boolean;
-  readonly solid: boolean;
-}
-
-export interface VoxelVisibleBlock {
-  readonly id: string;
-  readonly type: VoxelFixtureBlockType;
-  readonly x: number;
-  readonly y: number;
-  readonly z: number;
-  readonly lod: VoxelFixtureLod;
-}
-
-export interface VoxelWorldFixture {
-  readonly id: "external-parity-old-branch-voxel-world-fixture";
-  readonly source: "origin-master-voxel-world-adapted";
-  readonly seed: number;
-  readonly chunkSize: number;
-  readonly viewDistance: number;
-  readonly registry: readonly VoxelBlockDescriptor[];
-  readonly blockTypeCount: number;
-  readonly solidBlockTypes: number;
-  readonly transparentBlockTypes: number;
-  readonly animatedBlockTypes: number;
-  readonly emittingBlockTypes: number;
-  readonly chunkQueueSize: number;
-  readonly generatingChunks: number;
-  readonly meshingChunks: number;
-  readonly lodCounts: Record<VoxelFixtureLod, number>;
-  readonly blockCounts: Partial<Record<VoxelFixtureBlockType, number>>;
-  readonly visibleBlocks: readonly VoxelVisibleBlock[];
-  readonly visibleFaceEstimate: number;
-  readonly memoryBytes: number;
-  readonly hash: string;
-  readonly claimBoundary: string;
-}
-
-const registry: readonly VoxelBlockDescriptor[] = [
-  block("air", [0, 0, 0, 0], 0, null, null, "none", false, 0, true, false),
-  block("stone", [0.5, 0.5, 0.5, 1], 1.5, "pickaxe", "cobblestone", "stone", false, 0, false, true),
-  block("dirt", [0.4, 0.25, 0.15, 1], 0.5, null, "dirt", "dirt", false, 0, false, true),
-  block("grass", [0.3, 0.7, 0.3, 1], 0.6, null, "dirt", "grass", false, 0, false, true),
-  block("sand", [0.9, 0.85, 0.6, 1], 0.5, null, "sand", "sand", false, 0, false, true),
-  block("water", [0.15, 0.4, 0.8, 0.6], 100, null, null, "water", true, 0, true, false),
-  block("wood", [0.4, 0.25, 0.1, 1], 2, "axe", "wood", "wood", false, 0, false, true),
-  block("leaves", [0.2, 0.6, 0.2, 0.9], 0.2, null, null, "grass", false, 0, true, true),
-  block("glass", [0.7, 0.9, 1, 0.3], 0.3, null, "glass", "glass", false, 0, true, true),
-  block("coal-ore", [0.12, 0.12, 0.12, 1], 3, "pickaxe", "coal-ore", "stone", false, 0, false, true),
-  block("iron-ore", [0.72, 0.5, 0.34, 1], 3, "pickaxe", "iron-ore", "stone", false, 0, false, true),
-  block("gold-ore", [1, 0.78, 0.2, 1], 3, "pickaxe", "gold-ore", "stone", false, 0, false, true),
-  block("diamond-ore", [0.2, 0.85, 1, 1], 3, "pickaxe", "diamond-ore", "stone", false, 0, false, true),
-  block("bedrock", [0.05, 0.05, 0.06, 1], 1000, null, null, "stone", false, 0, false, true),
-  block("cobblestone", [0.38, 0.38, 0.38, 1], 2, "pickaxe", "cobblestone", "stone", false, 0, false, true),
-  block("planks", [0.64, 0.42, 0.2, 1], 2, "axe", "planks", "wood", false, 0, false, true),
-  block("brick", [0.62, 0.24, 0.18, 1], 2, "pickaxe", "brick", "stone", false, 0, false, true),
-  block("snow", [0.92, 0.96, 1, 1], 0.2, null, "snow", "snow", false, 0, false, true),
-  block("ice", [0.64, 0.88, 1, 0.72], 0.5, null, "ice", "glass", false, 0, true, true),
-  block("lava", [1, 0.28, 0.02, 0.95], 100, null, null, "lava", true, 12, true, false)
-];
-
-export function sampleVoxelWorldFixture(options: VoxelFixtureOptions = {}): VoxelWorldFixture {
-  const seed = integer(options.seed ?? 0x3d2025, "seed");
-  const chunkSize = integer(options.chunkSize ?? 16, "chunkSize");
-  if (chunkSize < 8 || chunkSize > 64) throw new RangeError("Voxel fixture chunkSize must be between 8 and 64.");
-  const viewDistance = integer(options.viewDistance ?? 4, "viewDistance");
-  if (viewDistance < 1 || viewDistance > 16) throw new RangeError("Voxel fixture viewDistance must be between 1 and 16.");
-  const cameraChunkX = Math.trunc(options.cameraChunkX ?? 0);
-  const cameraChunkZ = Math.trunc(options.cameraChunkZ ?? 0);
-  const blockCounts: Partial<Record<VoxelFixtureBlockType, number>> = {};
-  const visibleBlocks: VoxelVisibleBlock[] = [];
-  let visibleFaceEstimate = 0;
-
-  for (let x = 0; x < chunkSize; x += 1) {
-    for (let z = 0; z < chunkSize; z += 1) {
-      const worldX = cameraChunkX * chunkSize + x;
-      const worldZ = cameraChunkZ * chunkSize + z;
-      const height = terrainHeight(worldX, worldZ, seed, chunkSize);
-      const surface = surfaceBlock(worldX, worldZ, seed, height, chunkSize);
-      addCount(blockCounts, "bedrock", 1);
-      addCount(blockCounts, "stone", Math.max(0, height - 4));
-      addCount(blockCounts, "dirt", 3);
-      addCount(blockCounts, surface, 1);
-      if (height < chunkSize * 0.38) addCount(blockCounts, "water", Math.ceil(chunkSize * 0.38 - height));
-      if (noise(worldX * 0.19 + 31, worldZ * 0.19 - 17, seed) > 0.9) addCount(blockCounts, oreBlock(height), 1);
-      if (surface === "grass" && noise(worldX * 0.13 + 1000, worldZ * 0.13 + 1000, seed) > 0.88) {
-        addCount(blockCounts, "wood", 3);
-        addCount(blockCounts, "leaves", 6);
-      }
-      visibleFaceEstimate += 4 + Math.round(Math.abs(height - chunkSize * 0.5) * 0.8);
-      if (visibleBlocks.length < 28 && (x + z) % 3 === 0) {
-        const distance = Math.hypot(x - chunkSize / 2, z - chunkSize / 2) / chunkSize * viewDistance;
-        visibleBlocks.push({
-          id: `voxel-${x}-${z}`,
-          type: surface,
-          x: Number(((x / chunkSize - 0.5) * 2.3).toFixed(4)),
-          y: Number(((height / chunkSize) * 0.72 - 0.64).toFixed(4)),
-          z: Number(((z / chunkSize - 0.5) * 0.44 - 0.22).toFixed(4)),
-          lod: lodForDistance(distance)
-        });
-      }
-    }
-  }
-
-  const lodCounts = chunkLodCounts(viewDistance);
-  const chunkQueueSize = Object.values(lodCounts).reduce((sum, count) => sum + count, 0);
-  const memoryBytes = chunkQueueSize * chunkSize * chunkSize * chunkSize * 2;
-  return {
-    id: "external-parity-old-branch-voxel-world-fixture",
-    source: "origin-master-voxel-world-adapted",
-    seed,
-    chunkSize,
-    viewDistance,
-    registry,
-    blockTypeCount: registry.length,
-    solidBlockTypes: registry.filter((entry) => entry.solid).length,
-    transparentBlockTypes: registry.filter((entry) => entry.transparent).length,
-    animatedBlockTypes: registry.filter((entry) => entry.animated).length,
-    emittingBlockTypes: registry.filter((entry) => entry.lightLevel > 0).length,
-    chunkQueueSize,
-    generatingChunks: Math.min(2, chunkQueueSize),
-    meshingChunks: Math.min(3, chunkQueueSize),
-    lodCounts,
-    blockCounts,
-    visibleBlocks,
-    visibleFaceEstimate,
-    memoryBytes,
-    hash: hashVoxel(seed, chunkSize, viewDistance, blockCounts, lodCounts, visibleFaceEstimate),
-    claimBoundary: "Deterministic block registry, chunk queue, terrain columns, LOD buckets, and visible block markers adapted from the old voxel-world example; this is not a production voxel engine, mesh builder, collision system, multiplayer sandbox, or Minecraft parity claim."
-  };
-}
-
-function block(
-  type: VoxelFixtureBlockType,
-  color: readonly [number, number, number, number],
-  hardness: number,
-  toolRequired: string | null,
-  drops: VoxelFixtureBlockType | null,
-  sound: string,
-  animated: boolean,
-  lightLevel: number,
-  transparent: boolean,
-  solid: boolean
-): VoxelBlockDescriptor {
-  return { type, color, hardness, toolRequired, drops, sound, animated, lightLevel, transparent, solid };
-}
-
-function terrainHeight(x: number, z: number, seed: number, chunkSize: number): number {
-  const base = noise(x * 0.08, z * 0.08, seed);
-  const detail = noise(x * 0.21 + 11, z * 0.21 - 7, seed) * 0.32;
-  return Math.max(3, Math.min(chunkSize - 2, Math.round(chunkSize * (0.34 + base * 0.34 + detail))));
-}
-
-function surfaceBlock(x: number, z: number, seed: number, height: number, chunkSize: number): VoxelFixtureBlockType {
-  if (height < chunkSize * 0.38) return "sand";
-  if (height > chunkSize * 0.78) return noise(x * 0.13, z * 0.13, seed) > 0.45 ? "snow" : "stone";
-  const biome = noise(x * 0.05 - 20, z * 0.05 + 30, seed);
-  if (biome < 0.18) return "sand";
-  if (biome > 0.82) return "stone";
-  return "grass";
-}
-
-function oreBlock(height: number): VoxelFixtureBlockType {
-  if (height < 6) return "diamond-ore";
-  if (height < 9) return "gold-ore";
-  if (height < 12) return "iron-ore";
-  return "coal-ore";
-}
-
-function lodForDistance(distance: number): VoxelFixtureLod {
-  if (distance <= 1.25) return "near";
-  if (distance <= 2.5) return "mid";
-  if (distance <= 4) return "far";
-  return "culled";
-}
-
-function chunkLodCounts(viewDistance: number): Record<VoxelFixtureLod, number> {
-  const counts: Record<VoxelFixtureLod, number> = { near: 0, mid: 0, far: 0, culled: 0 };
-  const unloadDistance = viewDistance * 1.5;
-  for (let x = -viewDistance; x <= viewDistance; x += 1) {
-    for (let z = -viewDistance; z <= viewDistance; z += 1) {
-      const distance = Math.hypot(x, z);
-      if (distance <= viewDistance) counts[lodForDistance(distance)] += 1;
-      else if (distance <= unloadDistance) counts.culled += 1;
-    }
-  }
-  return counts;
-}
-
-function addCount(counts: Partial<Record<VoxelFixtureBlockType, number>>, type: VoxelFixtureBlockType, count: number): void {
-  counts[type] = (counts[type] ?? 0) + count;
-}
-
-function noise(x: number, z: number, seed: number): number {
-  const xi = Math.floor(x);
-  const zi = Math.floor(z);
-  const xf = x - xi;
-  const zf = z - zi;
-  const top = lerp(hash(xi, zi, seed), hash(xi + 1, zi, seed), smoothstep(xf));
-  const bottom = lerp(hash(xi, zi + 1, seed), hash(xi + 1, zi + 1, seed), smoothstep(xf));
-  return lerp(top, bottom, smoothstep(zf));
-}
-
-function hash(x: number, z: number, seed: number): number {
-  let value = Math.imul(x, 374761393) + Math.imul(z, 668265263) + seed;
-  value = Math.imul(value ^ (value >>> 13), 1274126177);
-  return ((value ^ (value >>> 16)) >>> 0) / 4294967296;
-}
-
-function hashVoxel(
-  seed: number,
-  chunkSize: number,
-  viewDistance: number,
-  blockCounts: Partial<Record<VoxelFixtureBlockType, number>>,
-  lodCounts: Record<VoxelFixtureLod, number>,
-  visibleFaceEstimate: number
-): string {
-  let value = 0x811c9dc5;
-  for (const entry of [seed, chunkSize, viewDistance, visibleFaceEstimate, ...Object.values(blockCounts), ...Object.values(lodCounts)]) {
-    const scaled = Math.round((entry ?? 0) * 10);
-    value ^= scaled & 0xff;
-    value = Math.imul(value, 0x01000193) >>> 0;
-    value ^= (scaled >>> 8) & 0xff;
-    value = Math.imul(value, 0x01000193) >>> 0;
-  }
-  return value.toString(16).padStart(8, "0");
-}
-
-function integer(value: number, label: string): number {
-  if (!Number.isInteger(value)) throw new RangeError(`Voxel fixture ${label} must be an integer.`);
-  return value;
-}
-
-function lerp(left: number, right: number, t: number): number {
-  return left + (right - left) * t;
-}
-
-function smoothstep(value: number): number {
-  return value * value * (3 - 2 * value);
-}

package/src/WeatherFixtures.ts

@@ -1,223 +0,0 @@
-export type WeatherFixtureType = "clear" | "cloudy" | "rain" | "heavy-rain" | "thunderstorm" | "snow";
-
-export interface WeatherFixtureOptions {
-  readonly type?: WeatherFixtureType;
-  readonly elapsedSeconds?: number;
-  readonly seed?: number;
-  readonly cameraX?: number;
-  readonly cameraZ?: number;
-  readonly maxVisualDrops?: number;
-}
-
-export interface WeatherVisualDrop {
-  readonly x: number;
-  readonly y: number;
-  readonly z: number;
-  readonly length: number;
-  readonly alpha: number;
-}
-
-export interface WeatherPuddlePatch {
-  readonly x: number;
-  readonly z: number;
-  readonly radius: number;
-  readonly depth: number;
-}
-
-export interface WeatherFixtureSample {
-  readonly type: WeatherFixtureType;
-  readonly cloudCoverage: number;
-  readonly fogDensity: number;
-  readonly rainIntensity: number;
-  readonly snowIntensity: number;
-  readonly windSpeed: number;
-  readonly windDirectionX: number;
-  readonly windDirectionZ: number;
-  readonly lightningFrequency: number;
-  readonly visibleDropCount: number;
-  readonly splashCount: number;
-  readonly puddleDepth: number;
-  readonly wetness: number;
-  readonly ambientIntensity: number;
-  readonly visibilityMeters: number;
-  readonly visualDrops: readonly WeatherVisualDrop[];
-  readonly puddlePatches: readonly WeatherPuddlePatch[];
-  readonly hash: string;
-  readonly source: "origin-master-weather-system-adapted";
-  readonly claimBoundary: string;
-}
-
-export function sampleWeatherFixture(options: WeatherFixtureOptions = {}): WeatherFixtureSample {
-  const type = options.type ?? "rain";
-  const preset = weatherPreset(type);
-  const elapsedSeconds = Math.max(0, finite(options.elapsedSeconds ?? 1, "elapsedSeconds"));
-  const seed = Math.floor(options.seed ?? 0x5ea50a);
-  if (!Number.isInteger(seed)) {
-    throw new RangeError("Weather fixture seed must be an integer.");
-  }
-  const cameraX = finite(options.cameraX ?? 0, "cameraX");
-  const cameraZ = finite(options.cameraZ ?? 0, "cameraZ");
-  const windGust = (seeded01(seed + Math.floor(elapsedSeconds * 17)) * 2 - 1) * preset.windGustiness;
-  const windSpeed = Math.max(0, preset.windSpeed * (1 + windGust));
-  const weatherLoad = preset.rainIntensity + preset.snowIntensity;
-  const visibleDropCount = Math.round(weatherLoad * 420 + windSpeed * 8 + Math.abs(cameraX + cameraZ) * 3);
-  const splashCount = Math.round(preset.rainIntensity * elapsedSeconds * 180);
-  const puddleDepth = clamp(preset.rainIntensity * elapsedSeconds * 0.018 + preset.wetnessRate * 0.08, 0, 1);
-  const wetness = clamp(preset.wetnessRate + puddleDepth * 0.45, 0, 1);
-  const visualDrops = sampleVisualDrops({
-    count: Math.min(Math.max(0, Math.floor(options.maxVisualDrops ?? 36)), visibleDropCount),
-    seed,
-    elapsedSeconds,
-    cameraX,
-    cameraZ,
-    intensity: weatherLoad,
-    windSpeed
-  });
-  const puddlePatches = samplePuddlePatches({
-    count: preset.rainIntensity > 0 ? Math.max(1, Math.min(8, Math.round(preset.rainIntensity * 8))) : 0,
-    seed,
-    cameraX,
-    cameraZ,
-    depth: puddleDepth
-  });
-  const hash = hashWeather([
-    preset.cloudCoverage,
-    preset.fogDensity,
-    preset.rainIntensity,
-    preset.snowIntensity,
-    windSpeed,
-    visibleDropCount,
-    splashCount,
-    puddleDepth,
-    wetness,
-    preset.visibility,
-    visualDrops.length,
-    puddlePatches.length
-  ]);
-  return {
-    type,
-    cloudCoverage: preset.cloudCoverage,
-    fogDensity: preset.fogDensity,
-    rainIntensity: preset.rainIntensity,
-    snowIntensity: preset.snowIntensity,
-    windSpeed: Number(windSpeed.toFixed(4)),
-    windDirectionX: preset.windDirectionX,
-    windDirectionZ: preset.windDirectionZ,
-    lightningFrequency: preset.lightningFrequency,
-    visibleDropCount,
-    splashCount,
-    puddleDepth: Number(puddleDepth.toFixed(4)),
-    wetness: Number(wetness.toFixed(4)),
-    ambientIntensity: preset.ambientIntensity,
-    visibilityMeters: preset.visibility,
-    visualDrops,
-    puddlePatches,
-    hash,
-    source: "origin-master-weather-system-adapted",
-    claimBoundary: "Deterministic weather, wind, rain/snow particle-count, splash, puddle, wetness, fog, and cloud telemetry adapted from the old weather system; this is bounded scene evidence, not volumetric clouds, full precipitation rendering, atmospheric scattering, or weather simulation parity."
-  };
-}
-
-function weatherPreset(type: WeatherFixtureType): {
-  readonly cloudCoverage: number;
-  readonly fogDensity: number;
-  readonly rainIntensity: number;
-  readonly snowIntensity: number;
-  readonly windSpeed: number;
-  readonly windDirectionX: number;
-  readonly windDirectionZ: number;
-  readonly windGustiness: number;
-  readonly lightningFrequency: number;
-  readonly ambientIntensity: number;
-  readonly wetnessRate: number;
-  readonly visibility: number;
-} {
-  switch (type) {
-    case "clear":
-      return { cloudCoverage: 0.1, fogDensity: 0, rainIntensity: 0, snowIntensity: 0, windSpeed: 2, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.1, lightningFrequency: 0, ambientIntensity: 0.8, wetnessRate: 0, visibility: 50_000 };
-    case "cloudy":
-      return { cloudCoverage: 0.85, fogDensity: 0.1, rainIntensity: 0, snowIntensity: 0, windSpeed: 5, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.3, lightningFrequency: 0, ambientIntensity: 0.6, wetnessRate: 0, visibility: 20_000 };
-    case "heavy-rain":
-      return { cloudCoverage: 1, fogDensity: 0.3, rainIntensity: 0.9, snowIntensity: 0, windSpeed: 9, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.5, lightningFrequency: 1.5, ambientIntensity: 0.4, wetnessRate: 0.9, visibility: 5_000 };
-    case "thunderstorm":
-      return { cloudCoverage: 1, fogDensity: 0.35, rainIntensity: 1, snowIntensity: 0, windSpeed: 12, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.7, lightningFrequency: 3, ambientIntensity: 0.35, wetnessRate: 1, visibility: 3_000 };
-    case "snow":
-      return { cloudCoverage: 0.95, fogDensity: 0.2, rainIntensity: 0, snowIntensity: 0.6, windSpeed: 5.5, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.35, lightningFrequency: 0, ambientIntensity: 0.6, wetnessRate: 0.2, visibility: 8_000 };
-    case "rain":
-      return { cloudCoverage: 0.9, fogDensity: 0.2, rainIntensity: 0.6, snowIntensity: 0, windSpeed: 6.5, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.4, lightningFrequency: 0.5, ambientIntensity: 0.5, wetnessRate: 0.6, visibility: 10_000 };
-  }
-}
-
-function hashWeather(values: readonly number[]): string {
-  let hash = 0x811c9dc5;
-  for (const value of values) {
-    const scaled = Math.round(value * 10_000);
-    hash ^= scaled & 0xff;
-    hash = Math.imul(hash, 0x01000193) >>> 0;
-    hash ^= (scaled >>> 8) & 0xff;
-    hash = Math.imul(hash, 0x01000193) >>> 0;
-  }
-  return hash.toString(16).padStart(8, "0");
-}
-
-function sampleVisualDrops(options: {
-  readonly count: number;
-  readonly seed: number;
-  readonly elapsedSeconds: number;
-  readonly cameraX: number;
-  readonly cameraZ: number;
-  readonly intensity: number;
-  readonly windSpeed: number;
-}): readonly WeatherVisualDrop[] {
-  return Array.from({ length: options.count }, (_, index): WeatherVisualDrop => {
-    const lane = seeded01(options.seed + index * 97);
-    const fall = (seeded01(options.seed ^ (index * 131)) + options.elapsedSeconds * (0.42 + options.intensity * 0.18)) % 1;
-    const x = options.cameraX - 1.25 + lane * 2.5 + Math.sin(options.elapsedSeconds * 1.7 + index) * 0.025;
-    const z = options.cameraZ - 0.38 + seeded01(options.seed + index * 53) * 0.76;
-    const y = 0.78 - fall * 1.38;
-    return {
-      x: Number(x.toFixed(4)),
-      y: Number(y.toFixed(4)),
-      z: Number(z.toFixed(4)),
-      length: Number((0.055 + options.intensity * 0.055 + options.windSpeed * 0.003).toFixed(4)),
-      alpha: Number((0.28 + options.intensity * 0.36).toFixed(4))
-    };
-  });
-}
-
-function samplePuddlePatches(options: {
-  readonly count: number;
-  readonly seed: number;
-  readonly cameraX: number;
-  readonly cameraZ: number;
-  readonly depth: number;
-}): readonly WeatherPuddlePatch[] {
-  return Array.from({ length: options.count }, (_, index): WeatherPuddlePatch => {
-    const x = options.cameraX - 1.08 + seeded01(options.seed + index * 19) * 2.16;
-    const z = options.cameraZ - 0.32 + seeded01(options.seed + index * 47) * 0.64;
-    const radius = 0.035 + seeded01(options.seed ^ (index * 83)) * 0.05 + options.depth * 0.08;
-    return {
-      x: Number(x.toFixed(4)),
-      z: Number(z.toFixed(4)),
-      radius: Number(radius.toFixed(4)),
-      depth: Number(options.depth.toFixed(4))
-    };
-  });
-}
-
-function seeded01(seed: number): number {
-  let value = seed >>> 0;
-  value ^= value << 13;
-  value ^= value >>> 17;
-  value ^= value << 5;
-  return ((value >>> 0) % 10_000) / 10_000;
-}
-
-function finite(value: number, label: string): number {
-  if (!Number.isFinite(value)) throw new RangeError(`Weather fixture ${label} must be finite.`);
-  return value;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}