@aura3d/animation 1.0.6

package/src/Keyframe.ts

@@ -0,0 +1,159 @@
+export type Vec3 = readonly [number, number, number];
+export type Quat = readonly [number, number, number, number];
+export type Mat4 = readonly [
+  number, number, number, number,
+  number, number, number, number,
+  number, number, number, number,
+  number, number, number, number
+];
+
+export type NumberArray = readonly number[];
+
+export type AnimationValue = number | boolean | string | Vec3 | Quat | NumberArray;
+
+export type InterpolationMode = "step" | "linear" | "cubicspline";
+
+export type Keyframe<T extends AnimationValue = AnimationValue> = {
+  readonly time: number;
+  readonly value: T;
+  readonly interpolation?: InterpolationMode;
+  readonly inTangent?: T;
+  readonly outTangent?: T;
+};
+
+export type SerializedKeyframe<T extends AnimationValue = AnimationValue> = {
+  readonly time: number;
+  readonly value: T;
+  readonly interpolation?: InterpolationMode;
+  readonly inTangent?: T;
+  readonly outTangent?: T;
+};
+
+export function validateKeyframes<T extends AnimationValue>(keyframes: readonly Keyframe<T>[]): void {
+  if (keyframes.length === 0) {
+    throw new Error("Animation track requires at least one keyframe.");
+  }
+  let previous = -Number.MAX_VALUE;
+  for (const keyframe of keyframes) {
+    if (!Number.isFinite(keyframe.time) || keyframe.time < 0) {
+      throw new Error("Keyframe time must be finite and non-negative.");
+    }
+    if (keyframe.time <= previous) {
+      throw new Error("Keyframes must be sorted by strictly increasing time.");
+    }
+    previous = keyframe.time;
+  }
+}
+
+export function serializeKeyframe<T extends AnimationValue>(keyframe: Keyframe<T>): SerializedKeyframe<T> {
+  return {
+    time: keyframe.time,
+    value: cloneAnimationValue(keyframe.value),
+    ...(keyframe.interpolation ? { interpolation: keyframe.interpolation } : {}),
+    ...(keyframe.inTangent !== undefined ? { inTangent: cloneAnimationValue(keyframe.inTangent) } : {}),
+    ...(keyframe.outTangent !== undefined ? { outTangent: cloneAnimationValue(keyframe.outTangent) } : {})
+  };
+}
+
+export function deserializeKeyframe<T extends AnimationValue>(keyframe: SerializedKeyframe<T>): Keyframe<T> {
+  return serializeKeyframe(keyframe);
+}
+
+export function cloneAnimationValue<T extends AnimationValue>(value: T): T {
+  return Array.isArray(value) ? ([...value] as unknown as T) : value;
+}
+
+export function lerpNumber(a: number, b: number, t: number): number {
+  return a + (b - a) * t;
+}
+
+export function lerpVec3(a: Vec3, b: Vec3, t: number): Vec3 {
+  return [lerpNumber(a[0], b[0], t), lerpNumber(a[1], b[1], t), lerpNumber(a[2], b[2], t)];
+}
+
+export function normalizeQuat(q: Quat): Quat {
+  const length = Math.hypot(q[0], q[1], q[2], q[3]);
+  if (length <= 1e-9) {
+    return [0, 0, 0, 1];
+  }
+  return [q[0] / length, q[1] / length, q[2] / length, q[3] / length];
+}
+
+export function slerpQuat(a: Quat, b: Quat, t: number): Quat {
+  let bx = b[0];
+  let by = b[1];
+  let bz = b[2];
+  let bw = b[3];
+  let cos = a[0] * bx + a[1] * by + a[2] * bz + a[3] * bw;
+  if (cos < 0) {
+    cos = -cos;
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+  }
+  if (cos > 0.9995) {
+    return normalizeQuat([lerpNumber(a[0], bx, t), lerpNumber(a[1], by, t), lerpNumber(a[2], bz, t), lerpNumber(a[3], bw, t)]);
+  }
+  const theta = Math.acos(Math.max(-1, Math.min(1, cos)));
+  const sinTheta = Math.sin(theta);
+  const wa = Math.sin((1 - t) * theta) / sinTheta;
+  const wb = Math.sin(t * theta) / sinTheta;
+  return [a[0] * wa + bx * wb, a[1] * wa + by * wb, a[2] * wa + bz * wb, a[3] * wa + bw * wb];
+}
+
+export function identityMat4(): Mat4 {
+  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+
+export function composeMat4(translation: Vec3 = [0, 0, 0], rotation: Quat = [0, 0, 0, 1], scale: Vec3 = [1, 1, 1]): Mat4 {
+  const [x, y, z, w] = normalizeQuat(rotation);
+  const x2 = x + x;
+  const y2 = y + y;
+  const z2 = z + z;
+  const xx = x * x2;
+  const xy = x * y2;
+  const xz = x * z2;
+  const yy = y * y2;
+  const yz = y * z2;
+  const zz = z * z2;
+  const wx = w * x2;
+  const wy = w * y2;
+  const wz = w * z2;
+  return [
+    (1 - (yy + zz)) * scale[0], (xy + wz) * scale[0], (xz - wy) * scale[0], 0,
+    (xy - wz) * scale[1], (1 - (xx + zz)) * scale[1], (yz + wx) * scale[1], 0,
+    (xz + wy) * scale[2], (yz - wx) * scale[2], (1 - (xx + yy)) * scale[2], 0,
+    translation[0], translation[1], translation[2], 1
+  ];
+}
+
+export function multiplyMat4(a: Mat4, b: Mat4): Mat4 {
+  const out = new Array<number>(16).fill(0);
+  for (let row = 0; row < 4; row += 1) {
+    for (let col = 0; col < 4; col += 1) {
+      const a0 = a[row * 4]!;
+      const a1 = a[row * 4 + 1]!;
+      const a2 = a[row * 4 + 2]!;
+      const a3 = a[row * 4 + 3]!;
+      out[col + row * 4] =
+        a0 * b[col]! +
+        a1 * b[col + 4]! +
+        a2 * b[col + 8]! +
+        a3 * b[col + 12]!;
+    }
+  }
+  return out as unknown as Mat4;
+}
+
+export function invertTranslationMat4(matrix: Mat4): Mat4 {
+  return [
+    matrix[0], matrix[4], matrix[8], 0,
+    matrix[1], matrix[5], matrix[9], 0,
+    matrix[2], matrix[6], matrix[10], 0,
+    -(matrix[12] * matrix[0] + matrix[13] * matrix[1] + matrix[14] * matrix[2]),
+    -(matrix[12] * matrix[4] + matrix[13] * matrix[5] + matrix[14] * matrix[6]),
+    -(matrix[12] * matrix[8] + matrix[13] * matrix[9] + matrix[14] * matrix[10]),
+    1
+  ];
+}

package/src/LocomotionController.ts

@@ -0,0 +1,149 @@
+import { AnimationClip } from "./AnimationClip.js";
+import { AnimationTrack } from "./AnimationTrack.js";
+import { applyRootMotion, extractRootMotion } from "./RootMotion.js";
+
+export interface LocomotionControllerState {
+  speed: number;
+  inPlace: boolean;
+  paused: boolean;
+  pathRadius: number;
+}
+
+export interface LocomotionControllerSample {
+  clipName: string;
+  clipTime: number;
+  worldX: number;
+  worldZ: number;
+  heading: number;
+  stride: number;
+  rootMotionDistance: number;
+}
+
+export interface LocomotionControllerOptions {
+  readonly clip: AnimationClip;
+  readonly rootMotionTrack?: string;
+  readonly speed?: number;
+  readonly inPlace?: boolean;
+  readonly paused?: boolean;
+  readonly pathRadius?: number;
+  readonly strideAmplitude?: number;
+  readonly rootMotionScale?: number;
+}
+
+export interface ProceduralWalkClipOptions {
+  readonly name?: string;
+  readonly duration?: number;
+  readonly distance?: number;
+  readonly rootMotionTrack?: string;
+}
+
+export class LocomotionController {
+  readonly clip: AnimationClip;
+  readonly rootMotionTrack: string;
+  readonly strideAmplitude: number;
+  readonly rootMotionScale: number;
+  readonly state: LocomotionControllerState;
+
+  constructor(options: LocomotionControllerOptions) {
+    if (!Number.isFinite(options.clip.duration) || options.clip.duration <= 0) {
+      throw new Error("LocomotionController requires a clip with positive finite duration.");
+    }
+    this.clip = options.clip;
+    this.rootMotionTrack = options.rootMotionTrack ?? "root.position";
+    this.strideAmplitude = options.strideAmplitude ?? 1;
+    this.rootMotionScale = options.rootMotionScale ?? 1;
+    this.state = {
+      speed: options.speed ?? 1,
+      inPlace: options.inPlace ?? false,
+      paused: options.paused ?? false,
+      pathRadius: options.pathRadius ?? 1
+    };
+  }
+
+  setSpeed(speed: number): this {
+    if (!Number.isFinite(speed) || speed < 0) {
+      throw new Error("LocomotionController speed must be finite and non-negative.");
+    }
+    this.state.speed = speed;
+    return this;
+  }
+
+  setInPlace(inPlace: boolean): this {
+    this.state.inPlace = inPlace;
+    return this;
+  }
+
+  setPaused(paused: boolean): this {
+    this.state.paused = paused;
+    return this;
+  }
+
+  setPathRadius(pathRadius: number): this {
+    if (!Number.isFinite(pathRadius) || pathRadius <= 0) {
+      throw new Error("LocomotionController pathRadius must be positive and finite.");
+    }
+    this.state.pathRadius = pathRadius;
+    return this;
+  }
+
+  sample(elapsedSeconds: number): LocomotionControllerSample {
+    if (!Number.isFinite(elapsedSeconds) || elapsedSeconds < 0) {
+      throw new Error("LocomotionController elapsed time must be finite and non-negative.");
+    }
+    const scaledTime = this.state.paused ? 0 : elapsedSeconds * this.state.speed;
+    const previousTime = Math.max(0, scaledTime - 1 / 60);
+    const clipTime = wrapTime(scaledTime, this.clip.duration);
+    const previousClipTime = wrapTime(previousTime, this.clip.duration);
+    const target = { position: [0, 0, 0] as [number, number, number] };
+    const rootMotion = extractRootMotion(this.clip, {
+      target: this.rootMotionTrack,
+      fromTime: previousClipTime,
+      toTime: clipTime,
+      loop: true
+    });
+    applyRootMotion(target, rootMotion, this.state.inPlace ? 0 : this.rootMotionScale);
+    const rootMotionDistance = this.state.inPlace ? 0 : scaledTime * this.rootMotionScale;
+    const pathAngle = this.state.inPlace ? -0.9 : rootMotionDistance / Math.max(0.1, this.state.pathRadius);
+    return {
+      clipName: this.clip.name,
+      clipTime,
+      worldX: this.state.inPlace ? 0 : Math.sin(pathAngle) * this.state.pathRadius,
+      worldZ: this.state.inPlace ? 0 : Math.cos(pathAngle) * this.state.pathRadius,
+      heading: this.state.inPlace ? 0 : pathAngle + Math.PI / 2,
+      stride: Math.sin((clipTime / this.clip.duration) * Math.PI * 2) * this.strideAmplitude,
+      rootMotionDistance: Math.hypot(target.position[0], target.position[2]) + rootMotionDistance
+    };
+  }
+}
+
+export function createRootMotionWalkClip(options: ProceduralWalkClipOptions = {}): AnimationClip {
+  const name = options.name ?? "a3d-procedural-root-walk";
+  const duration = options.duration ?? 1.2;
+  const distance = options.distance ?? 1.28;
+  const target = options.rootMotionTrack ?? "root.position";
+  if (!Number.isFinite(duration) || duration <= 0 || !Number.isFinite(distance) || distance <= 0) {
+    throw new Error("Root-motion walk clip duration and distance must be positive finite values.");
+  }
+  return new AnimationClip({
+    name,
+    duration,
+    tracks: [
+      new AnimationTrack({
+        target,
+        valueType: "vector3",
+        keyframes: [
+          { time: 0, value: [0, 0, 0], interpolation: "linear" },
+          { time: duration * 0.25, value: [0, 0, distance * 0.25], interpolation: "linear" },
+          { time: duration * 0.5, value: [0, 0, distance * 0.5], interpolation: "linear" },
+          { time: duration * 0.75, value: [0, 0, distance * 0.75], interpolation: "linear" },
+          { time: duration, value: [0, 0, distance], interpolation: "linear" }
+        ]
+      })
+    ]
+  });
+}
+
+function wrapTime(time: number, duration: number): number {
+  const wrapped = time % duration;
+  return wrapped < 0 ? wrapped + duration : wrapped;
+}

package/src/MotionMatchingFixtures.ts

@@ -0,0 +1,254 @@
+import type { Vec3 } from "./Keyframe.js";
+
+export interface MotionMatchingFixtureOptions {
+  readonly currentPosition?: Vec3;
+  readonly moveDirection?: Vec3;
+  readonly facingDirection?: Vec3;
+  readonly speed?: number;
+  readonly elapsedSeconds?: number;
+  readonly previousPoseId?: string;
+  readonly seed?: number;
+}
+
+export interface MotionMatchingTrajectorySample {
+  readonly time: number;
+  readonly position: Vec3;
+  readonly direction: Vec3;
+}
+
+export interface MotionMatchingPoseCandidate {
+  readonly id: string;
+  readonly clip: "idle" | "walk" | "run" | "strafe" | "turn" | "jump";
+  readonly time: number;
+  readonly tags: readonly string[];
+  readonly rootVelocity: Vec3;
+  readonly footLeft: Vec3;
+  readonly footRight: Vec3;
+  readonly trajectory: readonly MotionMatchingTrajectorySample[];
+}
+
+export interface MotionMatchingCandidateScore {
+  readonly poseId: string;
+  readonly clip: MotionMatchingPoseCandidate["clip"];
+  readonly tags: readonly string[];
+  readonly velocityCost: number;
+  readonly facingCost: number;
+  readonly trajectoryCost: number;
+  readonly continuityCost: number;
+  readonly totalCost: number;
+}
+
+export interface MotionMatchingFixtureSample {
+  readonly id: "external-parity-old-branch-motion-matching-fixture";
+  readonly source: "origin-master-motion-matching-system-adapted";
+  readonly databasePoseCount: number;
+  readonly candidateScores: readonly MotionMatchingCandidateScore[];
+  readonly selectedPoseId: string;
+  readonly selectedClip: MotionMatchingPoseCandidate["clip"];
+  readonly selectedTags: readonly string[];
+  readonly selectedTime: number;
+  readonly transitioned: boolean;
+  readonly blendWeight: number;
+  readonly transitionDurationSeconds: number;
+  readonly queryTrajectory: readonly MotionMatchingTrajectorySample[];
+  readonly querySpeed: number;
+  readonly queryFacingAlignment: number;
+  readonly bestCost: number;
+  readonly secondBestCost: number;
+  readonly costMargin: number;
+  readonly hash: string;
+  readonly claimBoundary: string;
+}
+
+const predictionTimes = [0.2, 0.45, 0.75] as const;
+
+export function sampleMotionMatchingFixture(options: MotionMatchingFixtureOptions = {}): MotionMatchingFixtureSample {
+  const seed = options.seed ?? 0x3d2025;
+  if (!Number.isInteger(seed)) throw new RangeError("Motion matching fixture seed must be an integer.");
+  const currentPosition = vec3(options.currentPosition ?? [0, 0, 0], "currentPosition");
+  const moveDirection = normalize(vec3(options.moveDirection ?? [1, 0, 0.18], "moveDirection"));
+  const facingDirection = normalize(vec3(options.facingDirection ?? [1, 0, 0], "facingDirection"));
+  const speed = clamp(finite(options.speed ?? 0.74, "speed"), 0, 1);
+  const elapsedSeconds = Math.max(0, finite(options.elapsedSeconds ?? 0, "elapsedSeconds"));
+  const maxSpeed = 6.2;
+  const queryVelocity = scale(moveDirection, speed * maxSpeed);
+  const queryTrajectory = predictionTimes.map((time) => ({
+    time,
+    position: roundVec3(add(currentPosition, scale(queryVelocity, time))),
+    direction: roundVec3(normalize(lerpVec3(moveDirection, facingDirection, Math.min(1, time * 0.8))))
+  }));
+  const database = createMotionDatabase(seed);
+  const previousPoseId = options.previousPoseId ?? database[0]?.id ?? "idle-0";
+  const scored = database
+    .map((candidate) => scoreCandidate(candidate, queryVelocity, facingDirection, queryTrajectory, previousPoseId))
+    .sort((left, right) => left.totalCost - right.totalCost);
+  const selected = scored[0];
+  if (!selected) throw new Error("Motion matching fixture database is empty.");
+  const selectedPose = database.find((candidate) => candidate.id === selected.poseId);
+  if (!selectedPose) throw new Error("Motion matching fixture selected an unknown pose.");
+  const secondBestCost = scored[1]?.totalCost ?? selected.totalCost;
+  const transitioned = selected.poseId !== previousPoseId;
+  const transitionDurationSeconds = 0.18;
+  const blendWeight = transitioned ? clamp(elapsedSeconds / transitionDurationSeconds, 0, 1) : 1;
+  return {
+    id: "external-parity-old-branch-motion-matching-fixture",
+    source: "origin-master-motion-matching-system-adapted",
+    databasePoseCount: database.length,
+    candidateScores: scored.slice(0, 6),
+    selectedPoseId: selected.poseId,
+    selectedClip: selected.clip,
+    selectedTags: selected.tags,
+    selectedTime: selectedPose.time,
+    transitioned,
+    blendWeight: Number(blendWeight.toFixed(4)),
+    transitionDurationSeconds,
+    queryTrajectory,
+    querySpeed: Number(length(queryVelocity).toFixed(4)),
+    queryFacingAlignment: Number(dot(moveDirection, facingDirection).toFixed(4)),
+    bestCost: selected.totalCost,
+    secondBestCost,
+    costMargin: Number((secondBestCost - selected.totalCost).toFixed(5)),
+    hash: hashMotionFixture(scored, queryTrajectory),
+    claimBoundary: "Deterministic pose-database scoring, trajectory prediction, tag filtering, continuity cost, and transition telemetry adapted from the old motion-matching system; this is bounded runtime evidence, not a full animation database, inertialization, pose application, foot locking, or Unity/Unreal animation middleware parity."
+  };
+}
+
+function createMotionDatabase(seed: number): readonly MotionMatchingPoseCandidate[] {
+  const clips: readonly MotionMatchingPoseCandidate["clip"][] = ["idle", "walk", "run", "strafe", "turn", "jump"];
+  return clips.flatMap((clip, clipIndex) => {
+    const speed = clip === "idle" ? 0 : clip === "walk" ? 2.1 : clip === "run" ? 5.8 : clip === "strafe" ? 3.2 : clip === "turn" ? 0.9 : 3.8;
+    const angle = clip === "strafe" ? Math.PI / 2 : clip === "turn" ? 0.62 : seeded01(seed + clipIndex * 41) * 0.14 - 0.07;
+    const direction: Vec3 = [Math.cos(angle), 0, Math.sin(angle)];
+    return [0, 1, 2].map((poseIndex) => {
+      const time = Number((poseIndex * 0.18 + seeded01(seed + clipIndex * 101 + poseIndex) * 0.04).toFixed(4));
+      const phase = poseIndex / 3;
+      return {
+        id: `${clip}-${poseIndex}`,
+        clip,
+        time,
+        tags: clip === "idle" ? ["idle"] : clip === "jump" ? ["action", "airborne"] : ["locomotion", clip],
+        rootVelocity: roundVec3(scale(direction, speed * (0.92 + phase * 0.12))),
+        footLeft: roundVec3([-0.16, Math.sin(phase * Math.PI * 2) * 0.08, 0.08]),
+        footRight: roundVec3([0.16, Math.sin((phase + 0.5) * Math.PI * 2) * 0.08, -0.08]),
+        trajectory: predictionTimes.map((predictionTime) => ({
+          time: predictionTime,
+          position: roundVec3(scale(direction, speed * predictionTime)),
+          direction: roundVec3(direction)
+        }))
+      };
+    });
+  });
+}
+
+function scoreCandidate(
+  candidate: MotionMatchingPoseCandidate,
+  queryVelocity: Vec3,
+  facingDirection: Vec3,
+  queryTrajectory: readonly MotionMatchingTrajectorySample[],
+  previousPoseId: string
+): MotionMatchingCandidateScore {
+  const velocityCost = distance(candidate.rootVelocity, queryVelocity);
+  const facingCost = 1 - clamp(dot(normalize(candidate.trajectory[0]?.direction ?? [1, 0, 0]), facingDirection), -1, 1);
+  const trajectoryCost = queryTrajectory.reduce((sum, query, index) => {
+    const candidateSample = candidate.trajectory[index] ?? candidate.trajectory[candidate.trajectory.length - 1]!;
+    return sum + distance(candidateSample.position, subtract(query.position, queryTrajectory[0]?.position ?? [0, 0, 0]));
+  }, 0) / Math.max(1, queryTrajectory.length);
+  const continuityCost = candidate.id === previousPoseId ? 0 : candidate.clip === previousPoseId.split("-")[0] ? 0.12 : 0.34;
+  const totalCost = velocityCost * 0.46 + facingCost * 1.2 + trajectoryCost * 0.38 + continuityCost;
+  return {
+    poseId: candidate.id,
+    clip: candidate.clip,
+    tags: candidate.tags,
+    velocityCost: Number(velocityCost.toFixed(5)),
+    facingCost: Number(facingCost.toFixed(5)),
+    trajectoryCost: Number(trajectoryCost.toFixed(5)),
+    continuityCost: Number(continuityCost.toFixed(5)),
+    totalCost: Number(totalCost.toFixed(5))
+  };
+}
+
+function hashMotionFixture(scores: readonly MotionMatchingCandidateScore[], trajectory: readonly MotionMatchingTrajectorySample[]): string {
+  let hash = 0x811c9dc5;
+  for (const score of scores) {
+    for (const char of `${score.poseId}:${score.totalCost}:${score.velocityCost}`) {
+      hash ^= char.charCodeAt(0);
+      hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+  }
+  for (const sample of trajectory) {
+    for (const value of [sample.time, ...sample.position, ...sample.direction]) {
+      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 vec3(value: readonly number[], label: string): Vec3 {
+  if (value.length !== 3 || value.some((entry) => !Number.isFinite(entry))) {
+    throw new RangeError(`Motion matching fixture ${label} must contain three finite numbers.`);
+  }
+  return [value[0]!, value[1]!, value[2]!];
+}
+
+function roundVec3(value: Vec3): Vec3 {
+  return [Number(value[0].toFixed(4)), Number(value[1].toFixed(4)), Number(value[2].toFixed(4))];
+}
+
+function add(left: Vec3, right: Vec3): Vec3 {
+  return [left[0] + right[0], left[1] + right[1], left[2] + right[2]];
+}
+
+function subtract(left: Vec3, right: Vec3): Vec3 {
+  return [left[0] - right[0], left[1] - right[1], left[2] - right[2]];
+}
+
+function scale(value: Vec3, scalar: number): Vec3 {
+  return [value[0] * scalar, value[1] * scalar, value[2] * scalar];
+}
+
+function lerpVec3(left: Vec3, right: Vec3, weight: number): Vec3 {
+  return [
+    left[0] + (right[0] - left[0]) * weight,
+    left[1] + (right[1] - left[1]) * weight,
+    left[2] + (right[2] - left[2]) * weight
+  ];
+}
+
+function dot(left: Vec3, right: Vec3): number {
+  return left[0] * right[0] + left[1] * right[1] + left[2] * right[2];
+}
+
+function length(value: Vec3): number {
+  return Math.hypot(value[0], value[1], value[2]);
+}
+
+function distance(left: Vec3, right: Vec3): number {
+  return length(subtract(left, right));
+}
+
+function normalize(value: Vec3): Vec3 {
+  const valueLength = length(value);
+  if (valueLength <= 1e-6) return [1, 0, 0];
+  return scale(value, 1 / valueLength);
+}
+
+function finite(value: number, label: string): number {
+  if (!Number.isFinite(value)) throw new RangeError(`Motion matching fixture ${label} must be finite.`);
+  return value;
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}
+
+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;
+}