This is a comment left during a code review.
Path: web/src/utils/dashboard/convertTableData.ts
Line: 28:49

Comment:
**logic:** Cache doesn't handle all mapping types - `regex` type mappings are missing

The original `findFirstValidMappedValue` function supports three mapping types: `value`, `range`, and `regex`. The new cache only handles direct value and range mappings, but completely omits regex pattern matching.

```suggestion
const buildValueMappingCache = (mappings: any) => {
  if (!mappings || !Array.isArray(mappings)) {
    return null;
  }

  const cache = new Map<any, string>();
  const regexMappings: Array<{pattern: RegExp, text: string}> = [];

  mappings.forEach((mapping: any) => {
    if (mapping && mapping.text) {
      // Handle regex mappings separately
      if (mapping.type === "regex" && mapping.pattern) {
        regexMappings.push({ pattern: new RegExp(mapping.pattern), text: mapping.text });
      }
      // Handle range mappings
      else if ((mapping.type === "range" || mapping.from !== undefined) && mapping.to !== undefined) {
        // Store range info for later lookup
        cache.set(`__range_${mapping.from}_${mapping.to}`, mapping.text);
      } else if ((mapping.type === "value" || mapping.value !== undefined) && mapping.value !== null) {
        // Direct value mapping
        cache.set(mapping.value, mapping.text);
      }
    }
  });

  if (cache.size === 0 && regexMappings.length === 0) return null;
  
  return { cache, regexMappings };
};
```

How can I resolve this? If you propose a fix, please make it concise.

This is a comment left during a code review.
Path: web/src/utils/dashboard/convertTableData.ts
Line: 64:89

Comment:
**logic:** Lookup function needs to support regex mappings and check explicit types

Update to handle regex mappings and properly check `type` field:

```suggestion
const lookupValueMapping = (value: any, cacheObj: {cache: Map<any, string>, regexMappings: Array<{pattern: RegExp, text: string}>} | null) => {
  if (!cacheObj) return null;
  
  const { cache, regexMappings } = cacheObj;

  // Direct lookup first
  if (cache.has(value)) {
    return cache.get(value);
  }

  // Check range mappings
  if (typeof value === 'number') {
    const entries = Array.from(cache.entries());
    for (let i = 0; i < entries.length; i++) {
      const [key, text] = entries[i];
      if (typeof key === 'string' && key.startsWith('__range_')) {
        const parts = key.split('_');
        const from = parseFloat(parts[2]);
        const to = parseFloat(parts[3]);
        if (!isNaN(from) && !isNaN(to) && value >= from && value <= to) {
          return text;
        }
      }
    }
  }
  
  // Check regex mappings
  for (const {pattern, text} of regexMappings) {
    if (pattern.test(value)) {
      return text;
    }
  }

  return null;
};
```

How can I resolve this? If you propose a fix, please make it concise.

This is a comment left during a code review.
Path: web/src/utils/dashboard/convertTableData.ts
Line: 135:135

Comment:
**logic:** Variable assigned but never transformed - should be `alias.toLowerCase()`

```suggestion
        const aliasLower = alias.toLowerCase();
```

How can I resolve this? If you propose a fix, please make it concise.

This is a comment left during a code review.
Path: web/src/utils/dashboard/convertTableData.ts
Line: 117:117

Comment:
**logic:** Shallow copy breaks mutability assumptions - can cause unintended side effects

Removing the deep clone means the original `searchQueryData[0]` is now directly referenced and could be mutated by downstream code. If any code modifies `tableRows`, it will affect the original data structure.

How can I resolve this? If you propose a fix, please make it concise.