@aura3d/physics 1.4.0 → 1.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aura3d/physics",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -13,5 +13,37 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     }
-  }
+  },
+  "description": "Deterministic rigid-body simulation, collision shapes, contacts, constraints, raycasts, fixed stepping, scene/ECS bridges, and debug draw extraction.",
+  "keywords": [
+    "aura3d",
+    "3d",
+    "browser-3d",
+    "web-3d",
+    "typescript",
+    "physics",
+    "rigid-body",
+    "collision",
+    "raycast",
+    "constraints",
+    "fixed-step",
+    "game-physics"
+  ],
+  "homepage": "https://aura3d.auraone.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/auraoneai/aura3d.git",
+    "directory": "packages/physics"
+  },
+  "bugs": {
+    "url": "https://github.com/auraoneai/aura3d/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ]
 }

package/src/CharacterController.ts

@@ -1,304 +0,0 @@
-import type { Collider } from "./Collider.js";
-import { KinematicBody, type KinematicBodyDescriptor, type KinematicBodyEvent, type KinematicBodySnapshot, type KinematicStepOptions } from "./KinematicBody.js";
-import type { PhysicsWorld } from "./PhysicsWorld.js";
-import type { RigidBody } from "./RigidBody.js";
-import { Shape, normalizeVec3, type Vec3 } from "./Shape.js";
-
-export type CharacterControllerDescriptor = {
-  readonly position?: Vec3;
-  readonly radius?: number;
-  readonly halfHeight?: number;
-  readonly maxSpeed?: number;
-  readonly acceleration?: number;
-  readonly jumpSpeed?: number;
-  readonly groundProbeDistance?: number;
-  readonly maxSlopeAngleRadians?: number;
-  readonly collisionMask?: number;
-};
-
-export type CharacterControllerMoveInput = {
-  readonly x: number;
-  readonly z?: number;
-};
-
-export type CharacterControllerState = {
-  readonly grounded: boolean;
-  readonly groundNormal: Vec3;
-  readonly groundColliderId: number | null;
-  readonly desiredVelocity: Vec3;
-  readonly velocity: Vec3;
-  readonly speed: number;
-  readonly jumpedThisFrame: boolean;
-};
-
-export type FightingCharacterControllerState =
-  | "idle"
-  | "walk"
-  | "dash"
-  | "jump"
-  | "fast-fall"
-  | "crouch"
-  | "landing";
-
-export type FightingCharacterControllerDescriptor = KinematicBodyDescriptor & {
-  readonly walkSpeed?: number;
-  readonly crouchSpeed?: number;
-  readonly fastFallSpeed?: number;
-};
-
-export type FightingCharacterControllerSnapshot = KinematicBodySnapshot & {
-  readonly state: FightingCharacterControllerState;
-  readonly walkSpeed: number;
-  readonly crouchSpeed: number;
-  readonly fastFallSpeed: number;
-};
-
-export class FightingCharacterController {
-  readonly body: KinematicBody;
-  readonly walkSpeed: number;
-  readonly crouchSpeed: number;
-  readonly fastFallSpeed: number;
-  private state: FightingCharacterControllerState = "idle";
-
-  constructor(descriptor: FightingCharacterControllerDescriptor = {}) {
-    this.walkSpeed = positiveFinite(descriptor.walkSpeed ?? descriptor.maxSpeed ?? 4.5, "fighting controller walkSpeed");
-    this.crouchSpeed = positiveFinite(descriptor.crouchSpeed ?? this.walkSpeed * 0.45, "fighting controller crouchSpeed");
-    this.fastFallSpeed = positiveFinite(descriptor.fastFallSpeed ?? descriptor.maxFallSpeed ?? 20, "fighting controller fastFallSpeed");
-    this.body = new KinematicBody({
-      ...descriptor,
-      id: descriptor.id ?? "fighter",
-      halfExtents: descriptor.halfExtents ?? [0.32, 0.9, 0.25],
-      maxSpeed: descriptor.maxSpeed ?? this.walkSpeed,
-      acceleration: descriptor.acceleration ?? 54,
-      airAcceleration: descriptor.airAcceleration ?? 24,
-      groundFriction: descriptor.groundFriction ?? 56,
-      airFriction: descriptor.airFriction ?? 4,
-      gravity: descriptor.gravity ?? 26,
-      jumpSpeed: descriptor.jumpSpeed ?? 9.4,
-      maxFallSpeed: descriptor.maxFallSpeed ?? Math.max(this.fastFallSpeed, 20),
-      dashSpeed: descriptor.dashSpeed ?? 8.6,
-      dashDuration: descriptor.dashDuration ?? 0.12,
-      dashCooldown: descriptor.dashCooldown ?? 0.18,
-      groundSnapDistance: descriptor.groundSnapDistance ?? 0.06,
-      lockDepth: descriptor.lockDepth ?? true
-    });
-  }
-
-  walk(direction: number, speed?: number): void {
-    const magnitude = Math.min(1, Math.abs(finiteOrZero(direction)));
-    const facing = direction < 0 ? -1 : 1;
-    const targetSpeed = speed ?? (this.body.snapshot().crouching ? this.crouchSpeed : this.walkSpeed);
-    const normalizedSpeed = this.body.maxSpeed > 0 ? Math.min(1, positiveFinite(targetSpeed, "fighting controller walk speed") / this.body.maxSpeed) : 0;
-    this.body.move(facing * magnitude * normalizedSpeed);
-    this.state = magnitude > 0 ? "walk" : this.deriveState([]);
-  }
-
-  stop(): void {
-    this.body.move(0);
-    this.state = this.deriveState([]);
-  }
-
-  jump(): void {
-    this.body.jump();
-    this.state = "jump";
-  }
-
-  dash(direction?: number): void {
-    this.body.dash(direction);
-    this.state = "dash";
-  }
-
-  fastFall(speed = this.fastFallSpeed): void {
-    this.body.fastFall(speed);
-    if (!this.body.grounded) {
-      this.state = "fast-fall";
-    }
-  }
-
-  crouch(active = true): void {
-    this.body.crouch(active);
-    this.state = active ? "crouch" : this.deriveState([]);
-  }
-
-  step(dt: number, options: KinematicStepOptions = {}): readonly KinematicBodyEvent[] {
-    const events = this.body.step(dt, options);
-    this.state = this.deriveState(events);
-    return events;
-  }
-
-  snapshot(): FightingCharacterControllerSnapshot {
-    return {
-      ...this.body.snapshot(),
-      state: this.state,
-      walkSpeed: this.walkSpeed,
-      crouchSpeed: this.crouchSpeed,
-      fastFallSpeed: this.fastFallSpeed
-    };
-  }
-
-  private deriveState(events: readonly KinematicBodyEvent[]): FightingCharacterControllerState {
-    if (events.some((event) => event.type === "land")) return "landing";
-    const snapshot = this.body.snapshot();
-    if (snapshot.crouching) return "crouch";
-    if (snapshot.dashFramesRemaining > 0) return "dash";
-    if (!snapshot.grounded) return snapshot.velocity[1] < -this.fastFallSpeed * 0.5 ? "fast-fall" : "jump";
-    return Math.abs(snapshot.velocity[0]) > 0.05 ? "walk" : "idle";
-  }
-}
-
-export function createFightingCharacterController(descriptor: FightingCharacterControllerDescriptor = {}): FightingCharacterController {
-  return new FightingCharacterController(descriptor);
-}
-
-export class CharacterController {
-  readonly body: RigidBody;
-  readonly collider: Collider;
-  readonly radius: number;
-  readonly halfHeight: number;
-  readonly maxSpeed: number;
-  readonly acceleration: number;
-  readonly jumpSpeed: number;
-  readonly groundProbeDistance: number;
-  readonly maxSlopeAngleRadians: number;
-  private readonly collisionMask: number | undefined;
-  private moveInput: [number, number] = [0, 0];
-  private jumpQueued = false;
-  private state: CharacterControllerState = {
-    grounded: false,
-    groundNormal: [0, 1, 0],
-    groundColliderId: null,
-    desiredVelocity: [0, 0, 0],
-    velocity: [0, 0, 0],
-    speed: 0,
-    jumpedThisFrame: false
-  };
-
-  constructor(private readonly world: PhysicsWorld, descriptor: CharacterControllerDescriptor = {}) {
-    this.radius = positiveFinite(descriptor.radius ?? 0.24, "character radius");
-    this.halfHeight = positiveFinite(descriptor.halfHeight ?? 0.38, "character halfHeight");
-    this.maxSpeed = positiveFinite(descriptor.maxSpeed ?? 3.5, "character maxSpeed");
-    this.acceleration = positiveFinite(descriptor.acceleration ?? 32, "character acceleration");
-    this.jumpSpeed = positiveFinite(descriptor.jumpSpeed ?? 4.2, "character jumpSpeed");
-    this.groundProbeDistance = positiveFinite(descriptor.groundProbeDistance ?? 0.12, "character groundProbeDistance");
-    this.maxSlopeAngleRadians = positiveFinite(descriptor.maxSlopeAngleRadians ?? Math.PI / 3, "character maxSlopeAngleRadians");
-    this.collisionMask = descriptor.collisionMask;
-    this.body = world.createRigidBody({
-      type: "dynamic",
-      position: descriptor.position ?? [0, this.halfHeight + this.radius, 0],
-      mass: 1,
-      linearDamping: 0.02,
-      angularDamping: 1
-    });
-    this.collider = world.createCollider(this.body, {
-      shape: Shape.capsule(this.radius, this.halfHeight),
-      material: { friction: 0.05, restitution: 0 }
-    });
-  }
-
-  setMoveInput(input: CharacterControllerMoveInput): void {
-    const x = finiteOrZero(input.x);
-    const z = finiteOrZero(input.z ?? 0);
-    const length = Math.hypot(x, z);
-    this.moveInput = length > 1 ? [x / length, z / length] : [x, z];
-  }
-
-  jump(): void {
-    this.jumpQueued = true;
-  }
-
-  teleport(position: Vec3): void {
-    this.body.setPosition(position);
-    this.body.setVelocity([0, 0, 0]);
-    this.state = {
-      ...this.state,
-      grounded: false,
-      groundColliderId: null,
-      velocity: [0, 0, 0],
-      speed: 0,
-      jumpedThisFrame: false
-    };
-  }
-
-  step(dt: number): CharacterControllerState {
-    if (!Number.isFinite(dt) || dt <= 0) {
-      throw new Error("CharacterController.step dt must be finite and positive.");
-    }
-    const ground = this.probeGround();
-    const desiredVelocity: Vec3 = [
-      this.moveInput[0] * this.maxSpeed,
-      this.body.velocity[1],
-      this.moveInput[1] * this.maxSpeed
-    ];
-    const nextVelocity: [number, number, number] = [
-      moveToward(this.body.velocity[0], desiredVelocity[0], this.acceleration * dt),
-      this.body.velocity[1],
-      moveToward(this.body.velocity[2], desiredVelocity[2], this.acceleration * dt)
-    ];
-    let jumpedThisFrame = false;
-    if (ground.grounded && nextVelocity[1] < 0) {
-      nextVelocity[1] = 0;
-    }
-    if (this.jumpQueued && ground.grounded) {
-      nextVelocity[1] = this.jumpSpeed;
-      jumpedThisFrame = true;
-    }
-    this.jumpQueued = false;
-    this.body.setVelocity(nextVelocity);
-    this.state = {
-      grounded: ground.grounded && !jumpedThisFrame,
-      groundNormal: ground.normal,
-      groundColliderId: ground.colliderId,
-      desiredVelocity,
-      velocity: [...nextVelocity],
-      speed: Math.hypot(nextVelocity[0], nextVelocity[2]),
-      jumpedThisFrame
-    };
-    return this.state;
-  }
-
-  snapshot(): CharacterControllerState {
-    return {
-      ...this.state,
-      groundNormal: [...this.state.groundNormal],
-      desiredVelocity: [...this.state.desiredVelocity],
-      velocity: [...this.state.velocity]
-    };
-  }
-
-  private probeGround(): { readonly grounded: boolean; readonly normal: Vec3; readonly colliderId: number | null } {
-    const origin: Vec3 = [
-      this.body.position[0],
-      this.body.position[1] - this.halfHeight + this.groundProbeDistance,
-      this.body.position[2]
-    ];
-    const hit = this.world.sphereCast(origin, this.radius * 0.92, [0, -1, 0], {
-      maxDistance: this.groundProbeDistance + this.radius * 0.35,
-      includeSensors: false,
-      ...(this.collisionMask === undefined ? {} : { mask: this.collisionMask })
-    });
-    const minGroundNormalY = Math.cos(this.maxSlopeAngleRadians);
-    if (!hit || hit.normal[1] < minGroundNormalY) {
-      return { grounded: false, normal: [0, 1, 0], colliderId: null };
-    }
-    return { grounded: true, normal: normalizeVec3(hit.normal), colliderId: hit.colliderId };
-  }
-}
-
-function positiveFinite(value: number, name: string): number {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${name} must be a finite positive number.`);
-  }
-  return value;
-}
-
-function finiteOrZero(value: number): number {
-  return Number.isFinite(value) ? value : 0;
-}
-
-function moveToward(current: number, target: number, maxDelta: number): number {
-  const delta = target - current;
-  if (Math.abs(delta) <= maxDelta) {
-    return target;
-  }
-  return current + Math.sign(delta) * maxDelta;
-}

package/src/ClothFixtures.ts

@@ -1,359 +0,0 @@
-export interface ClothSimulationFixtureOptions {
-  readonly seed?: number;
-  readonly elapsedSeconds?: number;
-  readonly segmentsX?: number;
-  readonly segmentsY?: number;
-}
-
-export interface ClothSampleParticle {
-  readonly index: number;
-  readonly grid: readonly [number, number];
-  readonly pinned: boolean;
-  readonly position: readonly [number, number, number];
-  readonly uv: readonly [number, number];
-}
-
-export interface ClothSimulationFixture {
-  readonly id: "external-parity-old-branch-cloth-simulation-fixture";
-  readonly source: "origin-master-cloth-pbd-material-adapted";
-  readonly sourceFiles: readonly [
-    "origin/master:src/simulation/cloth/ClothSimulation.ts",
-    "origin/master:src/simulation/cloth/ClothCollisionSystem.ts",
-    "origin/master:src/simulation/cloth/ClothTearingSystem.ts",
-    "origin/master:src/materials/ClothMaterial.ts"
-  ];
-  readonly config: {
-    readonly width: number;
-    readonly height: number;
-    readonly segmentsX: number;
-    readonly segmentsY: number;
-    readonly particleMass: number;
-    readonly structuralStiffness: number;
-    readonly shearStiffness: number;
-    readonly bendingStiffness: number;
-    readonly solverIterations: number;
-    readonly damping: number;
-  };
-  readonly mesh: {
-    readonly particleCount: number;
-    readonly triangleCount: number;
-    readonly normalCount: number;
-    readonly uvCount: number;
-    readonly indexCount: number;
-    readonly pinnedCount: number;
-    readonly pinnedPattern: "top-edge";
-    readonly sampleParticles: readonly ClothSampleParticle[];
-  };
-  readonly constraints: {
-    readonly structural: number;
-    readonly shear: number;
-    readonly bending: number;
-    readonly total: number;
-    readonly maxStrain: number;
-    readonly tearThreshold: number;
-    readonly tearCandidates: number;
-    readonly cutPlaneConstraintCandidates: number;
-  };
-  readonly wind: {
-    readonly direction: readonly [number, number, number];
-    readonly turbulence: number;
-    readonly frequency: number;
-    readonly maxOffset: number;
-    readonly affectedParticles: number;
-  };
-  readonly collision: {
-    readonly shape: "sphere";
-    readonly center: readonly [number, number, number];
-    readonly radius: number;
-    readonly penetrationCount: number;
-    readonly resolvedParticles: number;
-    readonly maxPenetration: number;
-    readonly friction: number;
-    readonly restitution: number;
-  };
-  readonly material: {
-    readonly preset: "coarse-wool-flag";
-    readonly sheenIntensity: number;
-    readonly sheenRoughness: number;
-    readonly subsurfaceIntensity: number;
-    readonly anisotropyStrength: number;
-    readonly fuzzIntensity: number;
-    readonly roughness: number;
-    readonly tiling: readonly [number, number];
-  };
-  readonly blockedClaims: readonly string[];
-  readonly hash: string;
-  readonly claimBoundary: string;
-}
-
-const sourceFiles = [
-  "origin/master:src/simulation/cloth/ClothSimulation.ts",
-  "origin/master:src/simulation/cloth/ClothCollisionSystem.ts",
-  "origin/master:src/simulation/cloth/ClothTearingSystem.ts",
-  "origin/master:src/materials/ClothMaterial.ts"
-] as const;
-
-const blockedClaims = [
-  "GPU cloth compute parity",
-  "100k particle cloth performance",
-  "production PBD solver parity",
-  "cloth self-collision",
-  "mesh-splitting topology tearing",
-  "fabric shader parity",
-  "Unity Cloth parity",
-  "Unreal Chaos Cloth parity"
-] as const;
-
-export function sampleClothSimulationFixture(options: ClothSimulationFixtureOptions = {}): ClothSimulationFixture {
-  const seed = integer(options.seed ?? 0x3d2025, "seed");
-  const elapsedSeconds = finiteNonNegative(options.elapsedSeconds ?? 0.4, "elapsedSeconds");
-  const segmentsX = integerInRange(options.segmentsX ?? 12, "segmentsX", 2, 64);
-  const segmentsY = integerInRange(options.segmentsY ?? 8, "segmentsY", 2, 64);
-  const width = 2.4;
-  const height = 1.5;
-  const particleCount = (segmentsX + 1) * (segmentsY + 1);
-  const triangleCount = segmentsX * segmentsY * 2;
-  const structural = segmentsX * (segmentsY + 1) + (segmentsX + 1) * segmentsY;
-  const shear = segmentsX * segmentsY * 2;
-  const bending = Math.max(0, (segmentsX - 1) * (segmentsY + 1) + (segmentsY - 1) * (segmentsX + 1));
-  const pinnedCount = segmentsX + 1;
-  const windDirection = [3.2, 0.35, 1.15] as const;
-  const turbulence = 0.35;
-  const frequency = 1.8;
-  const collisionCenter = [0.08, -0.18, 0.06] as const;
-  const collisionRadius = 0.34;
-  let maxOffset = 0;
-  let affectedParticles = 0;
-  let penetrationCount = 0;
-  let resolvedParticles = 0;
-  let maxPenetration = 0;
-  let maxStrain = 1;
-  let tearCandidates = 0;
-  let cutPlaneConstraintCandidates = 0;
-
-  const positions = new Map<number, readonly [number, number, number]>();
-  const sampleParticles: ClothSampleParticle[] = [];
-  const sampleKeys = new Set([
-    particleIndex(0, 0, segmentsX),
-    particleIndex(Math.floor(segmentsX / 2), 0, segmentsX),
-    particleIndex(segmentsX, 0, segmentsX),
-    particleIndex(0, Math.floor(segmentsY / 2), segmentsX),
-    particleIndex(Math.floor(segmentsX / 2), Math.floor(segmentsY / 2), segmentsX),
-    particleIndex(segmentsX, Math.floor(segmentsY / 2), segmentsX),
-    particleIndex(0, segmentsY, segmentsX),
-    particleIndex(Math.floor(segmentsX / 2), segmentsY, segmentsX),
-    particleIndex(segmentsX, segmentsY, segmentsX)
-  ]);
-
-  for (let y = 0; y <= segmentsY; y += 1) {
-    for (let x = 0; x <= segmentsX; x += 1) {
-      const index = particleIndex(x, y, segmentsX);
-      const vertical = y / segmentsY;
-      const horizontal = x / segmentsX;
-      const pinned = y === 0;
-      const baseX = (horizontal - 0.5) * width;
-      const sag = pinned ? 0 : Math.pow(vertical, 1.42) * (0.28 + hash01(seed, 7) * 0.08 + elapsedSeconds * 0.045);
-      const gust = pinned ? 0 : Math.sin(elapsedSeconds * frequency + x * 0.73 + y * 0.41 + hash01(seed, x + y + 11) * 2) * turbulence * vertical;
-      const xOffset = pinned ? 0 : windDirection[0] * 0.018 * vertical + gust * 0.06;
-      const zOffset = pinned ? 0 : windDirection[2] * 0.035 * vertical + gust * 0.1;
-      let position: readonly [number, number, number] = [
-        round4(baseX + xOffset),
-        round4(height * 0.5 - vertical * height - sag),
-        round4(zOffset)
-      ];
-      const penetration = spherePenetration(position, collisionCenter, collisionRadius);
-      if (penetration > 0) {
-        penetrationCount += 1;
-        resolvedParticles += 1;
-        maxPenetration = Math.max(maxPenetration, penetration);
-        position = resolveSphere(position, collisionCenter, collisionRadius);
-      }
-      const offset = Math.hypot(position[0] - baseX, position[2]);
-      if (offset > 0.002 && !pinned) affectedParticles += 1;
-      maxOffset = Math.max(maxOffset, offset);
-      positions.set(index, position);
-      if (sampleKeys.has(index)) {
-        sampleParticles.push({
-          index,
-          grid: [x, y],
-          pinned,
-          position,
-          uv: [round4(horizontal), round4(vertical)]
-        });
-      }
-    }
-  }
-
-  for (let y = 0; y <= segmentsY; y += 1) {
-    for (let x = 0; x <= segmentsX; x += 1) {
-      const current = positions.get(particleIndex(x, y, segmentsX));
-      if (!current) continue;
-      if (x < segmentsX) {
-        const strain = constraintStrain(current, positions.get(particleIndex(x + 1, y, segmentsX)), width / segmentsX);
-        maxStrain = Math.max(maxStrain, strain);
-        if (strain >= 1.035 && y >= segmentsY - 2) tearCandidates += 1;
-        if (x < segmentsX / 2 && x + 1 >= segmentsX / 2 && y > 0) cutPlaneConstraintCandidates += 1;
-      }
-      if (y < segmentsY) {
-        const strain = constraintStrain(current, positions.get(particleIndex(x, y + 1, segmentsX)), height / segmentsY);
-        maxStrain = Math.max(maxStrain, strain);
-        if (strain >= 1.05 && y >= segmentsY - 3) tearCandidates += 1;
-      }
-    }
-  }
-
-  const metricsForHash = [
-    seed,
-    elapsedSeconds,
-    segmentsX,
-    segmentsY,
-    particleCount,
-    triangleCount,
-    structural,
-    shear,
-    bending,
-    pinnedCount,
-    maxOffset,
-    affectedParticles,
-    penetrationCount,
-    maxPenetration,
-    maxStrain,
-    tearCandidates,
-    cutPlaneConstraintCandidates
-  ];
-
-  return {
-    id: "external-parity-old-branch-cloth-simulation-fixture",
-    source: "origin-master-cloth-pbd-material-adapted",
-    sourceFiles,
-    config: {
-      width,
-      height,
-      segmentsX,
-      segmentsY,
-      particleMass: 0.1,
-      structuralStiffness: 0.9,
-      shearStiffness: 0.8,
-      bendingStiffness: 0.12,
-      solverIterations: 6,
-      damping: 0.01
-    },
-    mesh: {
-      particleCount,
-      triangleCount,
-      normalCount: particleCount,
-      uvCount: particleCount,
-      indexCount: triangleCount * 3,
-      pinnedCount,
-      pinnedPattern: "top-edge",
-      sampleParticles
-    },
-    constraints: {
-      structural,
-      shear,
-      bending,
-      total: structural + shear + bending,
-      maxStrain: round4(maxStrain),
-      tearThreshold: 1.035,
-      tearCandidates,
-      cutPlaneConstraintCandidates
-    },
-    wind: {
-      direction: windDirection,
-      turbulence,
-      frequency,
-      maxOffset: round4(maxOffset),
-      affectedParticles
-    },
-    collision: {
-      shape: "sphere",
-      center: collisionCenter,
-      radius: collisionRadius,
-      penetrationCount,
-      resolvedParticles,
-      maxPenetration: round4(maxPenetration),
-      friction: 0.42,
-      restitution: 0.04
-    },
-    material: {
-      preset: "coarse-wool-flag",
-      sheenIntensity: 0.56,
-      sheenRoughness: 0.34,
-      subsurfaceIntensity: 0.24,
-      anisotropyStrength: 0.42,
-      fuzzIntensity: 0.22,
-      roughness: 0.74,
-      tiling: [3, 2]
-    },
-    blockedClaims,
-    hash: hashNumbers(metricsForHash),
-    claimBoundary: "Deterministic bounded cloth telemetry adapted from old PBD cloth, collision, tearing, and cloth-material concepts. It proves a pinned cloth grid, structural/shear/bending constraint counts, wind displacement, sphere-collision response, tear-candidate metrics, and fabric material parameters; it does not claim GPU cloth, self-collision, topology tearing, fabric shader parity, Unity Cloth parity, or Unreal Chaos Cloth parity."
-  };
-}
-
-function particleIndex(x: number, y: number, segmentsX: number): number {
-  return y * (segmentsX + 1) + x;
-}
-
-function constraintStrain(left: readonly [number, number, number], right: readonly [number, number, number] | undefined, restLength: number): number {
-  if (!right) return 1;
-  const length = Math.hypot(left[0] - right[0], left[1] - right[1], left[2] - right[2]);
-  return restLength > 0 ? length / restLength : 1;
-}
-
-function spherePenetration(position: readonly [number, number, number], center: readonly [number, number, number], radius: number): number {
-  const distance = Math.hypot(position[0] - center[0], position[1] - center[1], position[2] - center[2]);
-  return Math.max(0, radius - distance);
-}
-
-function resolveSphere(position: readonly [number, number, number], center: readonly [number, number, number], radius: number): readonly [number, number, number] {
-  const dx = position[0] - center[0];
-  const dy = position[1] - center[1];
-  const dz = position[2] - center[2];
-  const length = Math.max(0.0001, Math.hypot(dx, dy, dz));
-  return [
-    round4(center[0] + dx / length * radius),
-    round4(center[1] + dy / length * radius),
-    round4(center[2] + dz / length * radius)
-  ];
-}
-
-function hash01(seed: number, salt: number): number {
-  let value = Math.imul(seed + salt * 1013904223, 1664525) + 1013904223;
-  value = Math.imul(value ^ (value >>> 13), 1274126177);
-  return ((value ^ (value >>> 16)) >>> 0) / 4294967296;
-}
-
-function hashNumbers(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;
-    hash ^= (scaled >>> 16) & 0xff;
-    hash = Math.imul(hash, 0x01000193) >>> 0;
-  }
-  return hash.toString(16).padStart(8, "0");
-}
-
-function round4(value: number): number {
-  return Number(value.toFixed(4));
-}
-
-function finiteNonNegative(value: number, label: string): number {
-  if (!Number.isFinite(value) || value < 0) throw new RangeError(`Cloth fixture ${label} must be finite and non-negative.`);
-  return value;
-}
-
-function integer(value: number, label: string): number {
-  if (!Number.isInteger(value)) throw new RangeError(`Cloth fixture ${label} must be an integer.`);
-  return value;
-}
-
-function integerInRange(value: number, label: string, min: number, max: number): number {
-  const parsed = integer(value, label);
-  if (parsed < min || parsed > max) throw new RangeError(`Cloth fixture ${label} must be in the [${min}, ${max}] range.`);
-  return parsed;
-}