@ifc-lite/viewer 1.17.3 → 1.17.6

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,40 +231,19 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
 function computeProjectedCenter(
   conversion: MapConversion,
   coordinateInfo?: CoordinateInfo,
+  lengthUnitScale = 1,
 ): { easting: number; northing: number } {
-  let ifcX = 0;
-  let ifcY = 0;
-
-  if (coordinateInfo) {
-    const bounds = coordinateInfo.originalBounds;
-    const shift = coordinateInfo.originShift;
-    const rtc = coordinateInfo.wasmRtcOffset;
-
-    // Convert WASM RTC offset from IFC Z-up to viewer Y-up
-    const rtcYup = rtc
-      ? { x: rtc.x, y: rtc.z, z: -rtc.y }
-      : { x: 0, y: 0, z: 0 };
-
-    // Bounds center in viewer Y-up (scene-local)
-    const cx = (bounds.min.x + bounds.max.x) / 2;
-    const cz = (bounds.min.z + bounds.max.z) / 2;
-
-    // World Y-up = scene_local + originShift + wasmRtcOffset_yup
-    const worldYupX = cx + shift.x + rtcYup.x;
-    const worldYupZ = cz + shift.z + rtcYup.z;
-
-    // Convert Y-up to IFC Z-up: ifc_x = viewer_x, ifc_y = -viewer_z
-    ifcX = worldYupX;
-    ifcY = -worldYupZ;
-  }
+  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 };
 }
@@ -219,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]);
@@ -242,3 +292,165 @@ export async function reprojectToLatLon(
     return null;
   }
 }
+
+/**
+ * Compute the model's local IFC center offset (ifcX, ifcY) from coordinate info.
+ * This is the geometry center in IFC Z-up coordinates, before MapConversion is applied.
+ */
+function computeLocalIfcCenter(coordinateInfo?: CoordinateInfo): { ifcX: number; ifcY: number } {
+  if (!coordinateInfo) return { ifcX: 0, ifcY: 0 };
+
+  const bounds = coordinateInfo.originalBounds;
+  const shift = coordinateInfo.originShift;
+  const rtc = coordinateInfo.wasmRtcOffset;
+
+  const rtcYup = rtc
+    ? { x: rtc.x, y: rtc.z, z: -rtc.y }
+    : { x: 0, y: 0, z: 0 };
+
+  const cx = (bounds.min.x + bounds.max.x) / 2;
+  const cz = (bounds.min.z + bounds.max.z) / 2;
+
+  const worldYupX = cx + shift.x + rtcYup.x;
+  const worldYupZ = cz + shift.z + rtcYup.z;
+
+  return { ifcX: worldYupX, ifcY: -worldYupZ };
+}
+
+/**
+ * Reverse-project a WGS84 lat/lon into the IfcMapConversion eastings/northings
+ * values that would place the model center at the given location.
+ *
+ * This accounts for the model's local geometry offset, rotation, and scale:
+ *   projected = eastings + scale * (cos*ifcX - sin*ifcY)
+ *   ⟹ eastings = projected - scale * (cos*ifcX - sin*ifcY)
+ */
+export async function reprojectFromLatLon(
+  latLon: LatLon,
+  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;
+
+    // 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;
+
+    // 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 {
+    return null;
+  }
+}
+
+/**
+ * Compute a building footprint rectangle from the model's bounding box and
+ * reproject each corner to WGS84 for display as a GeoJSON polygon on a web map.
+ *
+ * Uses the shiftedBounds (scene-local after RTC) from CoordinateInfo, transforms
+ * each corner through the MapConversion pipeline (rotation + scale + offset),
+ * 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) {
+    console.warn('[footprint] failed to resolve projection for CRS:', crs.name);
+    return null;
+  }
+
+  const scale = conversion.scale ?? 1.0;
+  const abscissa = conversion.xAxisAbscissa ?? 1.0;
+  const ordinate = conversion.xAxisOrdinate ?? 0.0;
+
+  const shift = coordinateInfo.originShift;
+  const rtc = coordinateInfo.wasmRtcOffset;
+  const rtcYup = rtc
+    ? { x: rtc.x, z: -rtc.y }
+    : { x: 0, z: 0 };
+
+  const bounds = coordinateInfo.shiftedBounds;
+
+  // Four corners of the bounding box on the XZ plane (viewer Y-up)
+  const corners = [
+    { x: bounds.min.x, z: bounds.min.z },
+    { x: bounds.max.x, z: bounds.min.z },
+    { x: bounds.max.x, z: bounds.max.z },
+    { x: bounds.min.x, z: bounds.max.z },
+  ];
+
+  const ring: [number, number][] = [];
+
+  for (const c of corners) {
+    // Scene-local → world Y-up
+    const worldX = c.x + shift.x + rtcYup.x;
+    const worldZ = c.z + shift.z + rtcYup.z;
+
+    // Y-up → IFC Z-up: ifcX = worldX, ifcY = -worldZ
+    const ifcX = worldX;
+    const ifcY = -worldZ;
+
+    // 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 {
+      const [lon, lat] = proj4(projDef, 'WGS84', [easting, northing]);
+      if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+      ring.push([lon, lat]);
+    } catch {
+      return null;
+    }
+  }
+
+  // Close the ring (GeoJSON requirement)
+  ring.push(ring[0]);
+  return ring;
+}
+
+/**
+ * Query terrain elevation at a given lat/lon using the Open-Meteo elevation API.
+ * Returns height in metres above sea level, or null on failure.
+ */
+export async function queryTerrainElevation(latLon: LatLon): Promise<number | null> {
+  try {
+    const url = `https://api.open-meteo.com/v1/elevation?latitude=${latLon.lat}&longitude=${latLon.lon}`;
+    const resp = await fetch(url);
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const elev = data?.elevation?.[0];
+    return typeof elev === 'number' && Number.isFinite(elev) ? elev : null;
+  } catch {
+    return null;
+  }
+}

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';