@ifc-lite/viewer 1.17.4 → 1.18.0

package/src/lib/geo/effective-georef.test.ts

@@ -0,0 +1,73 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+import { inferMapUnitScale, mergeMapConversion, mergeProjectedCRS } from './effective-georef.js';
+import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
+
+describe('effective georeferencing', () => {
+  it('recomputes map unit scale when the edited MapUnit changes', () => {
+    const original: ProjectedCRS = {
+      id: 1,
+      name: 'EPSG:28992',
+      mapUnit: 'METRE',
+      mapUnitScale: 1,
+    };
+
+    const merged = mergeProjectedCRS(original, { mapUnit: 'US SURVEY FOOT' }, 1);
+
+    assert.strictEqual(merged?.mapUnit, 'US SURVEY FOOT');
+    assert.strictEqual(merged?.mapUnitScale, 0.3048006096);
+  });
+
+  it('preserves the extracted map unit scale when MapUnit was not edited', () => {
+    const original: ProjectedCRS = {
+      id: 1,
+      name: 'EPSG:1234',
+      mapUnit: 'CUSTOM',
+      mapUnitScale: 2.5,
+    };
+
+    const merged = mergeProjectedCRS(original, { description: 'Edited CRS' }, 1);
+
+    assert.strictEqual(merged?.description, 'Edited CRS');
+    assert.strictEqual(merged?.mapUnitScale, 2.5);
+  });
+
+  it('overlays edited IfcMapConversion fields without dropping original rotation and scale', () => {
+    const original: MapConversion = {
+      id: 2,
+      sourceCRS: 10,
+      targetCRS: 11,
+      eastings: 100,
+      northings: 200,
+      orthogonalHeight: 5,
+      xAxisAbscissa: 0,
+      xAxisOrdinate: 1,
+      scale: 0.9999,
+    };
+
+    const merged = mergeMapConversion(original, { eastings: 150, orthogonalHeight: 9 });
+
+    assert.deepStrictEqual(merged, {
+      id: 2,
+      sourceCRS: 10,
+      targetCRS: 11,
+      eastings: 150,
+      northings: 200,
+      orthogonalHeight: 9,
+      xAxisAbscissa: 0,
+      xAxisOrdinate: 1,
+      scale: 0.9999,
+    });
+  });
+
+  it('infers common IFC map unit names', () => {
+    assert.strictEqual(inferMapUnitScale('FOOT'), 0.3048);
+    assert.strictEqual(inferMapUnitScale('METRE'), 1);
+    assert.strictEqual(inferMapUnitScale('MILLIMETRE'), 0.001);
+  });
+});

package/src/lib/geo/effective-georef.ts

@@ -0,0 +1,111 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import {
+  extractGeoreferencingOnDemand,
+  extractLengthUnitScale,
+  type GeoreferenceInfo,
+  type IfcDataStore,
+  type MapConversion,
+  type ProjectedCRS,
+} from '@ifc-lite/parser';
+import type { CoordinateInfo } from '@ifc-lite/geometry';
+
+export interface GeorefMutationDataLike {
+  projectedCRS?: Partial<ProjectedCRS>;
+  mapConversion?: Partial<MapConversion>;
+}
+
+export interface EffectiveGeoreference extends GeoreferenceInfo {
+  hasGeoreference: true;
+  coordinateInfo?: CoordinateInfo;
+  lengthUnitScale: number;
+}
+
+export function inferMapUnitScale(mapUnit: string | undefined, fallback?: number): number | undefined {
+  if (!mapUnit) return fallback;
+  const normalized = mapUnit.toUpperCase();
+  if (normalized.includes('US') && (normalized.includes('SURVEY') || normalized.includes('FTUS'))) {
+    return 0.3048006096;
+  }
+  if (normalized.includes('FOOT') || normalized.includes('FEET')) return 0.3048;
+  if (normalized.includes('MILLI')) return 0.001;
+  if (normalized.includes('CENTI')) return 0.01;
+  if (normalized.includes('DECI')) return 0.1;
+  if (normalized.includes('KILO')) return 1000;
+  if (normalized.includes('METRE') || normalized.includes('METER')) return 1;
+  return fallback;
+}
+
+export function getIfcLengthUnitScale(dataStore: IfcDataStore | null | undefined): number {
+  if (!dataStore?.source?.length || !dataStore.entityIndex) return 1;
+  return extractLengthUnitScale(dataStore.source, dataStore.entityIndex);
+}
+
+export function mergeProjectedCRS(
+  original: ProjectedCRS | undefined,
+  mutations: Partial<ProjectedCRS> | undefined,
+  lengthUnitScale: number,
+): ProjectedCRS | undefined {
+  if (!original && !mutations) return undefined;
+  const mapUnit = mutations?.mapUnit ?? original?.mapUnit;
+  const mapUnitScale = mutations?.mapUnit !== undefined
+    ? inferMapUnitScale(mapUnit, lengthUnitScale)
+    : original?.mapUnitScale ?? inferMapUnitScale(mapUnit, undefined);
+  return {
+    id: original?.id ?? 0,
+    name: (mutations?.name ?? original?.name ?? '') as string,
+    description: mutations?.description ?? original?.description,
+    geodeticDatum: mutations?.geodeticDatum ?? original?.geodeticDatum,
+    verticalDatum: mutations?.verticalDatum ?? original?.verticalDatum,
+    mapProjection: mutations?.mapProjection ?? original?.mapProjection,
+    mapZone: mutations?.mapZone ?? original?.mapZone,
+    mapUnit,
+    mapUnitScale,
+  };
+}
+
+export function mergeMapConversion(
+  original: MapConversion | undefined,
+  mutations: Partial<MapConversion> | undefined,
+): MapConversion | undefined {
+  if (!original && !mutations) return undefined;
+  return {
+    id: original?.id ?? 0,
+    sourceCRS: original?.sourceCRS ?? 0,
+    targetCRS: original?.targetCRS ?? 0,
+    eastings: (mutations?.eastings ?? original?.eastings ?? 0) as number,
+    northings: (mutations?.northings ?? original?.northings ?? 0) as number,
+    orthogonalHeight: (mutations?.orthogonalHeight ?? original?.orthogonalHeight ?? 0) as number,
+    xAxisAbscissa: mutations?.xAxisAbscissa ?? original?.xAxisAbscissa,
+    xAxisOrdinate: mutations?.xAxisOrdinate ?? original?.xAxisOrdinate,
+    scale: mutations?.scale ?? original?.scale,
+  };
+}
+
+export function getEffectiveGeoreference(
+  dataStore: IfcDataStore | null | undefined,
+  coordinateInfo?: CoordinateInfo,
+  mutations?: GeorefMutationDataLike,
+): EffectiveGeoreference | null {
+  if (!dataStore) return null;
+  const original = extractGeoreferencingOnDemand(dataStore);
+  const lengthUnitScale = getIfcLengthUnitScale(dataStore);
+  const projectedCRS = mergeProjectedCRS(
+    original?.projectedCRS,
+    mutations?.projectedCRS,
+    lengthUnitScale,
+  );
+  const mapConversion = mergeMapConversion(original?.mapConversion, mutations?.mapConversion);
+
+  if (!projectedCRS && !mapConversion) return null;
+  return {
+    hasGeoreference: true,
+    projectedCRS,
+    mapConversion,
+    coordinateInfo,
+    lengthUnitScale,
+    transformMatrix: original?.transformMatrix,
+  };
+}

package/src/lib/geo/reproject.ts

@@ -36,6 +36,29 @@ function extractEpsgCode(crs: ProjectedCRS): string | null {
   return match ? match[1] : null;
 }
 
+/**
+ * Well-known CRS names that IFC authoring tools set without an EPSG: prefix.
+ * Maps normalised name → EPSG code.
+ */
+const WELL_KNOWN_CRS: Record<string, string> = {
+  'wgs 84': '4326',
+  'wgs84': '4326',
+  'wgs-84': '4326',
+  'nad83': '4269',
+  'nad27': '4267',
+  'etrs89': '4258',
+  'gcs_wgs_1984': '4326',        // ArcGIS / Revit export alias
+  'gcs_north_american_1983': '4269',
+};
+
+/**
+ * Check if a proj4 definition is a geographic (longlat) CRS rather than a projected one.
+ * Geographic CRS coordinates are in degrees, not metres.
+ */
+function isGeographicProj4(def: string): boolean {
+  return /\+proj=longlat\b/.test(def);
+}
+
 /**
  * Build a proj4 definition string for a UTM zone.
  */
@@ -101,11 +124,12 @@ async function fetchProj4Def(epsgCode: string): Promise<string | null> {
  * Resolution order:
  *   1. Cache hit
  *   2. Bundled EPSG index (7000+ codes with proj4 strings)
- *   3. UTM zone heuristic (from CRS metadata)
- *   4. Fetch from epsg.io (network fallback)
+ *   3. Well-known CRS name lookup (e.g. "WGS 84" → EPSG:4326)
+ *   4. UTM zone heuristic (from CRS metadata — mapZone, name, description, mapProjection)
+ *   5. Fetch from epsg.io (network fallback)
  */
 export async function resolveProjection(crs: ProjectedCRS): Promise<string | null> {
-  const code = extractEpsgCode(crs);
+  let code = extractEpsgCode(crs);
 
   // 1. Check cache
   if (code && projDefCache.has(code)) {
@@ -126,7 +150,31 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
     }
   }
 
-  // 3. UTM zone heuristic
+  // 3. Well-known CRS name → EPSG code (handles "WGS 84", "NAD83", etc.)
+  if (!code) {
+    const normalised = crs.name?.trim().toLowerCase() ?? '';
+    const wellKnownCode = WELL_KNOWN_CRS[normalised];
+    if (wellKnownCode) {
+      code = wellKnownCode;
+      if (projDefCache.has(code)) {
+        return projDefCache.get(code) ?? null;
+      }
+      try {
+        const bundled = await lookupProj4(code);
+        if (bundled) {
+          const sanitized = sanitizeProj4(bundled);
+          projDefCache.set(code, sanitized);
+          // For geographic CRS (longlat), check if we can infer a projected CRS
+          // from the UTM zone metadata — a projected CRS is much more useful.
+          // If we can't, fall through and return the geographic def below.
+        }
+      } catch {
+        // continue
+      }
+    }
+  }
+
+  // 4. UTM zone heuristic — check mapZone, name, description, AND mapProjection
   if (crs.mapZone) {
     const def = utmProj4String(crs.mapZone);
     if (def) {
@@ -136,7 +184,8 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
   }
   const name = crs.name?.toUpperCase() ?? '';
   const utmMatch = name.match(/UTM\s+ZONE\s+(\d{1,2}[NS])/i)
-    ?? crs.description?.match(/UTM\s+zone\s+(\d{1,2}[NS])/i);
+    ?? crs.description?.match(/UTM\s+zone\s+(\d{1,2}[NS])/i)
+    ?? crs.mapProjection?.match(/UTM\s+zone\s+(\d{1,2}[NS])/i);
   if (utmMatch) {
     const def = utmProj4String(utmMatch[1]);
     if (def) {
@@ -145,7 +194,14 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
     }
   }
 
-  // 4. Network fallback — fetch from epsg.io
+  // If step 3 resolved a geographic CRS (e.g. EPSG:4326) and we couldn't
+  // upgrade it to a projected CRS via the UTM heuristic, still return it —
+  // reprojectToLatLon will handle the longlat identity case.
+  if (code && projDefCache.has(code)) {
+    return projDefCache.get(code) ?? null;
+  }
+
+  // 5. Network fallback — fetch from epsg.io
   if (code) {
     const raw = await fetchProj4Def(code);
     const fetched = raw ? sanitizeProj4(raw) : null;
@@ -175,16 +231,19 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
 function computeProjectedCenter(
   conversion: MapConversion,
   coordinateInfo?: CoordinateInfo,
+  lengthUnitScale = 1,
 ): { easting: number; northing: number } {
   const { ifcX, ifcY } = computeLocalIfcCenter(coordinateInfo);
 
-  // Apply MapConversion rotation + scale + offset
+  // Geometry coordinates (ifcX, ifcY) are already in metres — the geometry engine
+  // converts from the IFC file's native unit during extraction. Only MapConversion
+  // values (eastings, northings) are in the file's native unit and need scaling.
   const scale = conversion.scale ?? 1.0;
   const abscissa = conversion.xAxisAbscissa ?? 1.0;
   const ordinate = conversion.xAxisOrdinate ?? 0.0;
 
-  const easting = conversion.eastings + scale * (abscissa * ifcX - ordinate * ifcY);
-  const northing = conversion.northings + scale * (ordinate * ifcX + abscissa * ifcY);
+  const easting = conversion.eastings * lengthUnitScale + scale * (abscissa * ifcX - ordinate * ifcY);
+  const northing = conversion.northings * lengthUnitScale + scale * (ordinate * ifcX + abscissa * ifcY);
 
   return { easting, northing };
 }
@@ -195,19 +254,34 @@ function computeProjectedCenter(
  * Uses the model's actual geometry bounds + RTC offset to determine where
  * the model sits in the projected coordinate system, then reprojects to WGS84.
  *
- * @param conversion  IfcMapConversion (offset, rotation, scale)
- * @param crs         IfcProjectedCRS (EPSG code)
+ * @param conversion      IfcMapConversion (offset, rotation, scale)
+ * @param crs             IfcProjectedCRS (EPSG code, mapUnitScale)
  * @param coordinateInfo  Geometry coordinate info with bounds and RTC offset
+ * @param lengthUnitScale IFC project length unit → metres (fallback when crs.mapUnitScale is absent)
  */
 export async function reprojectToLatLon(
   conversion: MapConversion,
   crs: ProjectedCRS,
   coordinateInfo?: CoordinateInfo,
+  lengthUnitScale = 1,
 ): Promise<LatLon | null> {
   const projDef = await resolveProjection(crs);
   if (!projDef) return null;
 
-  const { easting, northing } = computeProjectedCenter(conversion, coordinateInfo);
+  // Geographic CRS (e.g. EPSG:4326) — eastings/northings are already lon/lat.
+  // Don't add the model's geometry center (in meters) to degree-based coordinates.
+  if (isGeographicProj4(projDef)) {
+    const lon = conversion.eastings;
+    const lat = conversion.northings;
+    if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+    if (lat < -90 || lat > 90 || lon < -180 || lon > 180) return null;
+    return { lat, lon };
+  }
+
+  // MapConversion values use the unit from IfcProjectedCRS.MapUnit. If MapUnit
+  // is not specified, the IFC spec defaults to the project's length unit.
+  const mapScale = crs.mapUnitScale ?? lengthUnitScale;
+  const { easting, northing } = computeProjectedCenter(conversion, coordinateInfo, mapScale);
 
   try {
     const [lon, lat] = proj4(projDef, 'WGS84', [easting, northing]);
@@ -256,23 +330,32 @@ export async function reprojectFromLatLon(
   crs: ProjectedCRS,
   conversion?: MapConversion,
   coordinateInfo?: CoordinateInfo,
+  lengthUnitScale = 1,
 ): Promise<{ easting: number; northing: number } | null> {
   const projDef = await resolveProjection(crs);
   if (!projDef) return null;
 
+  // Geographic CRS — coordinates are lon/lat in degrees, no projection needed.
+  if (isGeographicProj4(projDef)) {
+    return { easting: latLon.lon, northing: latLon.lat };
+  }
+
   try {
     const [projE, projN] = proj4('WGS84', projDef, [latLon.lon, latLon.lat]);
     if (!Number.isFinite(projE) || !Number.isFinite(projN)) return null;
 
-    // Subtract the rotated/scaled local geometry offset so that
-    // the resulting eastings/northings place the model center at this position
+    // Convert projected metres back to MapConversion's unit.
+    // Geometry offsets (ifcX/Y) are already in metres.
+    const mapScale = crs.mapUnitScale ?? lengthUnitScale;
+    const invScale = mapScale !== 0 ? 1 / mapScale : 1;
     const { ifcX, ifcY } = computeLocalIfcCenter(coordinateInfo);
     const scale = conversion?.scale ?? 1.0;
     const abscissa = conversion?.xAxisAbscissa ?? 1.0;
     const ordinate = conversion?.xAxisOrdinate ?? 0.0;
 
-    const easting = projE - scale * (abscissa * ifcX - ordinate * ifcY);
-    const northing = projN - scale * (ordinate * ifcX + abscissa * ifcY);
+    // Result is in IFC native units (the reverse of: E_native * LUS + geom_offset = E_metres)
+    const easting = (projE - scale * (abscissa * ifcX - ordinate * ifcY)) * invScale;
+    const northing = (projN - scale * (ordinate * ifcX + abscissa * ifcY)) * invScale;
 
     return { easting, northing };
   } catch {
@@ -289,12 +372,14 @@ export async function reprojectFromLatLon(
  * then reprojects to lat/lon. The result is a rotated rectangle matching the
  * model's XZ extent on the map.
  *
+ * @param lengthUnitScale IFC project length unit → metres (fallback when crs.mapUnitScale is absent)
  * @returns A single GeoJSON-compatible polygon: closed ring of [lon, lat] pairs
  */
 export async function computeFootprintGeoJSON(
   conversion: MapConversion,
   crs: ProjectedCRS,
   coordinateInfo: CoordinateInfo,
+  lengthUnitScale = 1,
 ): Promise<[number, number][] | null> {
   const projDef = await resolveProjection(crs);
   if (!projDef) {
@@ -333,9 +418,10 @@ export async function computeFootprintGeoJSON(
     const ifcX = worldX;
     const ifcY = -worldZ;
 
-    // MapConversion: local IFC → projected CRS
-    const easting = conversion.eastings + scale * (abscissa * ifcX - ordinate * ifcY);
-    const northing = conversion.northings + scale * (ordinate * ifcX + abscissa * ifcY);
+    // Geometry coords (ifcX/Y) are already in metres; only MapConversion needs scaling
+    const mapScale = crs.mapUnitScale ?? lengthUnitScale;
+    const easting = conversion.eastings * mapScale + scale * (abscissa * ifcX - ordinate * ifcY);
+    const northing = conversion.northings * mapScale + scale * (ordinate * ifcX + abscissa * ifcY);
 
     // Projected CRS → WGS84
     try {

package/src/lib/llm/byok-guard.test.ts

@@ -0,0 +1,77 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveStreamRoute } from './byok-guard.js';
+import { DEFAULT_BYOK_MODEL, BYOK_MODELS } from './models.js';
+
+const ANTHROPIC_MODEL = BYOK_MODELS.find((m) => m.source === 'anthropic')!;
+const OPENAI_MODEL = BYOK_MODELS.find((m) => m.source === 'openai')!;
+
+test('resolveStreamRoute returns proxy route for free models', () => {
+  const route = resolveStreamRoute('openai/gpt-free', { anthropicKey: '', openaiKey: '' });
+  assert.equal(route.kind, 'proxy');
+  if (route.kind === 'proxy') {
+    assert.equal(route.model, 'openai/gpt-free');
+  }
+});
+
+test('resolveStreamRoute returns proxy route for unknown model ids', () => {
+  const route = resolveStreamRoute('made-up-model', { anthropicKey: 'sk-ant-...', openaiKey: '' });
+  assert.equal(route.kind, 'proxy');
+});
+
+test('resolveStreamRoute returns anthropic route when key present', () => {
+  const route = resolveStreamRoute(ANTHROPIC_MODEL.id, {
+    anthropicKey: 'sk-ant-abc',
+    openaiKey: '',
+  });
+  assert.equal(route.kind, 'anthropic');
+  if (route.kind === 'anthropic') {
+    assert.equal(route.apiKey, 'sk-ant-abc');
+    assert.equal(route.model, ANTHROPIC_MODEL.id);
+  }
+});
+
+test('resolveStreamRoute returns missing-key when anthropic model selected without key', () => {
+  const route = resolveStreamRoute(ANTHROPIC_MODEL.id, {
+    anthropicKey: '',
+    openaiKey: 'sk-openai-xyz',
+  });
+  assert.equal(route.kind, 'missing-key');
+  if (route.kind === 'missing-key') {
+    assert.equal(route.provider, 'anthropic');
+  }
+});
+
+test('resolveStreamRoute returns openai route when key present', () => {
+  const route = resolveStreamRoute(OPENAI_MODEL.id, {
+    anthropicKey: '',
+    openaiKey: 'sk-openai-xyz',
+  });
+  assert.equal(route.kind, 'openai');
+  if (route.kind === 'openai') {
+    assert.equal(route.apiKey, 'sk-openai-xyz');
+  }
+});
+
+test('resolveStreamRoute returns missing-key when openai model selected without key', () => {
+  const route = resolveStreamRoute(OPENAI_MODEL.id, {
+    anthropicKey: 'sk-ant-abc',
+    openaiKey: '',
+  });
+  assert.equal(route.kind, 'missing-key');
+  if (route.kind === 'missing-key') {
+    assert.equal(route.provider, 'openai');
+  }
+});
+
+test('resolveStreamRoute treats whitespace-only keys as missing', () => {
+  const route = resolveStreamRoute(DEFAULT_BYOK_MODEL.id, {
+    anthropicKey: '   ',
+    openaiKey: '   ',
+  });
+  assert.equal(route.kind, 'missing-key');
+});

package/src/lib/llm/byok-guard.ts

@@ -0,0 +1,39 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Pure routing guard for chat streams.
+ *
+ * Given a model id and the current BYOK key bag, decide whether the send
+ * should go through the proxy, direct to a provider, or be blocked because
+ * a required key is missing. Pulled out of ChatPanel so we can unit-test
+ * the guard without spinning up React — and so the "missing key" check
+ * happens BEFORE the user message is appended to the chat history.
+ */
+
+import { getModelById } from './models.js';
+import type { ApiKeyConfig } from '../../services/api-keys.js';
+
+export type StreamRoute =
+  | { kind: 'proxy'; model: string }
+  | { kind: 'anthropic'; model: string; apiKey: string }
+  | { kind: 'openai'; model: string; apiKey: string }
+  | { kind: 'missing-key'; provider: 'anthropic' | 'openai' };
+
+export function resolveStreamRoute(modelId: string, keys: ApiKeyConfig): StreamRoute {
+  const model = getModelById(modelId);
+  const source = model?.source ?? 'proxy';
+
+  if (source === 'anthropic') {
+    const apiKey = keys.anthropicKey.trim();
+    if (!apiKey) return { kind: 'missing-key', provider: 'anthropic' };
+    return { kind: 'anthropic', model: modelId, apiKey };
+  }
+  if (source === 'openai') {
+    const apiKey = keys.openaiKey.trim();
+    if (!apiKey) return { kind: 'missing-key', provider: 'openai' };
+    return { kind: 'openai', model: modelId, apiKey };
+  }
+  return { kind: 'proxy', model: modelId };
+}

package/src/lib/llm/free-models.test.ts

@@ -47,9 +47,6 @@ test('registry free models match configured env list', async (t) => {
   }
 
   process.env.VITE_LLM_FREE_MODELS = configuredFreeModels.join(',');
-  process.env.VITE_LLM_PRO_MODELS_LOW = '';
-  process.env.VITE_LLM_PRO_MODELS_MEDIUM = '';
-  process.env.VITE_LLM_PRO_MODELS_HIGH = '';
   process.env.VITE_LLM_IMAGE_MODELS = '';
   process.env.VITE_LLM_FILE_ATTACHMENT_MODELS = '';
 
@@ -63,9 +60,6 @@ test('registry free models match configured env list', async (t) => {
 
 test('model capabilities follow override env lists', async () => {
   process.env.VITE_LLM_FREE_MODELS = 'qwen/qwen3-coder,mistralai/devstral-2512';
-  process.env.VITE_LLM_PRO_MODELS_LOW = '';
-  process.env.VITE_LLM_PRO_MODELS_MEDIUM = '';
-  process.env.VITE_LLM_PRO_MODELS_HIGH = '';
   process.env.VITE_LLM_IMAGE_MODELS = 'mistralai/devstral-2512';
   process.env.VITE_LLM_FILE_ATTACHMENT_MODELS = 'qwen/qwen3-coder';