Using performance.now() in the throttle function but comparing against a timestamp that starts at 0. The first call will always execute, but subsequent calls within the throttle limit will be skipped even if they're the first real call. Consider initializing lastCall to -Infinity or performance.now() - limit to ensure consistent behavior.

⚠️ Potential issue | 🟡 Minor

hexToRgb silently treats non‑6‑digit hex (like #F00) as black

hexToRgb only matches 6‑digit hex via HEX_COLOR_REGEX, returning {r: 0, g: 0, b: 0} for anything else. Since the sign‑in story passes baseColor="#F00", the base RGB used for proximity blending becomes black instead of the intended red, which subtly changes the effect.

Recommend normalizing 3‑digit hex to 6‑digit before matching, so both forms work:

 function hexToRgb(hex: string): RgbColor {
-  const m = hex.match(HEX_COLOR_REGEX);
+  let value = hex.trim();
+
+  // Expand 3-digit #rgb to 6-digit #rrggbb for convenience.
+  if (value.length === 4 && value[0] === '#') {
+    value = `#${value[1]}${value[1]}${value[2]}${value[2]}${value[3]}${value[3]}`;
+  }
+
+  const m = value.match(HEX_COLOR_REGEX);
   if (!m) return {r: 0, g: 0, b: 0};
   return {
     r: parseInt(m[1], 16),
     g: parseInt(m[2], 16),
     b: parseInt(m[3], 16),
   };
 }

This keeps the existing regex and behavior while making the API friendlier to callers.

In libs/react/ui/src/components/dot-grid/dot-grid.tsx around lines 51 to 59,
hexToRgb currently only accepts 6‑digit hex and returns black for 3‑digit inputs
like "#F00"; normalize 3‑digit shorthand to 6‑digit before applying the existing
HEX_COLOR_REGEX (e.g. expand "#F00" to "#FF0000"), then run the same match/parse
logic and keep the current fallback of {r:0,g:0,b:0} for invalid values.

The canvas is cleared using logical dimensions (canvas.width, canvas.height) but should use physical dimensions. After scaling the context by dpr, you should clear using the logical dimensions:

ctx.clearRect(0, 0, canvas.width / (window.devicePixelRatio || 1), canvas.height / (window.devicePixelRatio || 1));

or store the logical width/height and use those instead.

The velocity calculation divides by dt which could be very small or even zero on the first call (when pr.lastTime is 0), potentially resulting in extremely large or infinite velocity values. While the maxSpeed clamping helps, it's safer to add a guard:

const dt = pr.lastTime ? Math.max(now - pr.lastTime, 1) : 16;

This ensures dt is never too small.

Duplicate code: The inertia animation and return-to-origin logic is duplicated between the mouse move handler (lines 237-248) and click handler (lines 267-278). Consider extracting this into a reusable function to improve maintainability.