@ifc-lite/viewer 1.0.0 → 1.1.1

package/src/hooks/useIfc.ts

@@ -4,6 +4,7 @@
 
 /**
  * Hook for loading and processing IFC files
+ * Includes binary cache support for fast subsequent loads
  */
 
 import { useMemo, useCallback, useRef } from 'react';
@@ -13,6 +14,17 @@ import { GeometryProcessor, GeometryQuality, type MeshData } from '@ifc-lite/geo
 import { IfcQuery } from '@ifc-lite/query';
 import { BufferBuilder } from '@ifc-lite/geometry';
 import { buildSpatialIndex } from '@ifc-lite/spatial';
+import {
+  BinaryCacheWriter,
+  BinaryCacheReader,
+  xxhash64Hex,
+  type IfcDataStore as CacheDataStore,
+  type GeometryData,
+} from '@ifc-lite/cache';
+import { getCached, setCached } from '../services/ifc-cache.js';
+
+// Minimum file size to cache (10MB) - smaller files parse quickly anyway
+const CACHE_SIZE_THRESHOLD = 10 * 1024 * 1024;
 
 export function useIfc() {
   const {
@@ -33,19 +45,160 @@ export function useIfc() {
   // Track if we've already logged for this ifcDataStore
   const lastLoggedDataStoreRef = useRef<typeof ifcDataStore>(null);
 
+  /**
+   * Load from binary cache (INSTANT path)
+   * Key optimizations:
+   * 1. Single setGeometryResult call instead of batched appendGeometryBatch
+   * 2. Build spatial index in requestIdleCallback (non-blocking)
+   */
+  const loadFromCache = useCallback(async (
+    cacheBuffer: ArrayBuffer,
+    fileName: string
+  ): Promise<boolean> => {
+    try {
+      console.time('[useIfc] cache-load');
+      setProgress({ phase: 'Loading from cache', percent: 10 });
+
+      // IMPORTANT: Reset geometry first so Viewport detects this as a new file
+      // This ensures camera fitting and bounds are properly reset
+      setGeometryResult(null);
+
+      const reader = new BinaryCacheReader();
+      const result = await reader.read(cacheBuffer);
+
+      // Convert cache data store to viewer data store format
+      const dataStore = result.dataStore as any;
+
+      if (result.geometry) {
+        const { meshes, coordinateInfo, totalVertices, totalTriangles } = result.geometry;
+
+        // INSTANT: Set ALL geometry in ONE state update (no batching!)
+        setGeometryResult({
+          meshes,
+          totalVertices,
+          totalTriangles,
+          coordinateInfo,
+        });
+
+        // Set data store
+        setIfcDataStore(dataStore);
+
+        // Build spatial index in background (non-blocking)
+        if (meshes.length > 0) {
+          // Use requestIdleCallback for non-blocking BVH build
+          const buildIndex = () => {
+            console.time('[useIfc] spatial-index-background');
+            try {
+              const spatialIndex = buildSpatialIndex(meshes);
+              dataStore.spatialIndex = spatialIndex;
+              // Update store with spatial index (doesn't affect rendering)
+              setIfcDataStore({ ...dataStore });
+              console.timeEnd('[useIfc] spatial-index-background');
+            } catch (err) {
+              console.warn('[useIfc] Failed to build spatial index:', err);
+            }
+          };
+
+          // Schedule for idle time, or fallback to setTimeout
+          if ('requestIdleCallback' in window) {
+            (window as any).requestIdleCallback(buildIndex, { timeout: 1000 });
+          } else {
+            setTimeout(buildIndex, 100);
+          }
+        }
+      } else {
+        setIfcDataStore(dataStore);
+      }
+
+      setProgress({ phase: 'Complete (from cache)', percent: 100 });
+      console.timeEnd('[useIfc] cache-load');
+      console.log(`[useIfc] INSTANT load: ${fileName} from cache (${result.geometry?.meshes.length || 0} meshes)`);
+
+      return true;
+    } catch (err) {
+      console.error('[useIfc] Failed to load from cache:', err);
+      return false;
+    }
+  }, [setProgress, setIfcDataStore, setGeometryResult]);
+
+  /**
+   * Save to binary cache (background operation)
+   */
+  const saveToCache = useCallback(async (
+    cacheKey: string,
+    dataStore: any,
+    geometry: GeometryData,
+    sourceBuffer: ArrayBuffer,
+    fileName: string
+  ): Promise<void> => {
+    try {
+      console.time('[useIfc] cache-write');
+
+      const writer = new BinaryCacheWriter();
+
+      // Adapt dataStore to cache format
+      const cacheDataStore: CacheDataStore = {
+        schema: dataStore.schemaVersion === 'IFC4' ? 1 : dataStore.schemaVersion === 'IFC4X3' ? 2 : 0,
+        entityCount: dataStore.entityCount || dataStore.entities?.count || 0,
+        strings: dataStore.strings,
+        entities: dataStore.entities,
+        properties: dataStore.properties,
+        quantities: dataStore.quantities,
+        relationships: dataStore.relationships,
+        spatialHierarchy: dataStore.spatialHierarchy,
+      };
+
+      const cacheBuffer = await writer.write(
+        cacheDataStore,
+        geometry,
+        sourceBuffer,
+        { includeGeometry: true }
+      );
+
+      await setCached(cacheKey, cacheBuffer, fileName, sourceBuffer.byteLength);
+
+      console.timeEnd('[useIfc] cache-write');
+      console.log(`[useIfc] Cached ${fileName} (${(cacheBuffer.byteLength / 1024 / 1024).toFixed(2)}MB cache)`);
+    } catch (err) {
+      console.warn('[useIfc] Failed to cache model:', err);
+    }
+  }, []);
+
   const loadFile = useCallback(async (file: File) => {
     const { resetViewerState } = useViewerStore.getState();
-    
+
     try {
       // Reset all viewer state before loading new file
       resetViewerState();
-      
+
       setLoading(true);
       setError(null);
       setProgress({ phase: 'Loading file', percent: 0 });
 
       // Read file
       const buffer = await file.arrayBuffer();
+      const fileSizeMB = buffer.byteLength / (1024 * 1024);
+
+      // Compute cache key (hash of file content)
+      setProgress({ phase: 'Checking cache', percent: 5 });
+      const cacheKey = xxhash64Hex(buffer);
+      console.log(`[useIfc] File: ${file.name}, size: ${fileSizeMB.toFixed(2)}MB, hash: ${cacheKey}`);
+
+      // Try to load from cache first (only for files above threshold)
+      if (buffer.byteLength >= CACHE_SIZE_THRESHOLD) {
+        const cachedBuffer = await getCached(cacheKey);
+        if (cachedBuffer) {
+          const success = await loadFromCache(cachedBuffer, file.name);
+          if (success) {
+            setLoading(false);
+            return;
+          }
+          // Cache load failed, fall through to normal parsing
+          console.log('[useIfc] Cache load failed, falling back to parsing');
+        }
+      }
+
+      // Cache miss or small file - parse normally
       setProgress({ phase: 'Parsing IFC', percent: 10 });
 
       // Parse IFC using columnar parser
@@ -78,64 +231,126 @@ export function useIfc() {
         }
       }
 
-      // Use streaming processing for progressive rendering
-      const bufferBuilder = new BufferBuilder();
+      // Use adaptive processing: sync for small files, streaming for large files
       let estimatedTotal = 0;
       let totalMeshes = 0;
       const allMeshes: MeshData[] = []; // Collect all meshes for BVH building
+      let finalCoordinateInfo: any = null;
 
       // Clear existing geometry result
       setGeometryResult(null);
 
+      // Timing instrumentation
+      const processingStart = performance.now();
+      let batchCount = 0;
+      let lastBatchTime = processingStart;
+      let totalWaitTime = 0; // Time waiting for WASM to yield batches
+      let totalProcessTime = 0; // Time processing batches in JS
+
       try {
-        for await (const event of geometryProcessor.processStreaming(new Uint8Array(buffer), entityIndexMap, 100)) {
+        console.log(`[useIfc] Starting adaptive processing (file size: ${fileSizeMB.toFixed(2)}MB)...`);
+        console.time('[useIfc] total-processing');
+
+        for await (const event of geometryProcessor.processAdaptive(new Uint8Array(buffer), {
+          sizeThreshold: 2 * 1024 * 1024, // 2MB threshold
+          batchSize: 25,
+          entityIndex: entityIndexMap,
+        })) {
+          const eventReceived = performance.now();
+          const waitTime = eventReceived - lastBatchTime;
+
           switch (event.type) {
             case 'start':
               estimatedTotal = event.totalEstimate;
+              console.log(`[useIfc] Processing started, estimated: ${estimatedTotal}`);
               break;
             case 'model-open':
               setProgress({ phase: 'Processing geometry', percent: 50 });
+              console.log(`[useIfc] Model opened at ${(eventReceived - processingStart).toFixed(0)}ms`);
               break;
-            case 'batch':
+            case 'batch': {
+              batchCount++;
+              totalWaitTime += waitTime;
+
+              const processStart = performance.now();
+
               // Collect meshes for BVH building
               allMeshes.push(...event.meshes);
-              
-              // Convert MeshData[] to GPU-ready format and append
-              const gpuMeshes = bufferBuilder.processMeshes(event.meshes).meshes;
-              appendGeometryBatch(gpuMeshes, event.coordinateInfo);
+              finalCoordinateInfo = event.coordinateInfo;
+
+              // Append mesh batch to store (triggers React re-render)
+              appendGeometryBatch(event.meshes, event.coordinateInfo);
               totalMeshes = event.totalSoFar;
 
               // Update progress (50-95% for geometry processing)
-              const progressPercent = 50 + Math.min(45, (totalMeshes / Math.max(estimatedTotal, totalMeshes)) * 45);
+              const progressPercent = 50 + Math.min(45, (totalMeshes / Math.max(estimatedTotal / 10, totalMeshes)) * 45);
               setProgress({
                 phase: `Rendering geometry (${totalMeshes} meshes)`,
                 percent: progressPercent
               });
+
+              const processTime = performance.now() - processStart;
+              totalProcessTime += processTime;
+
+              // Log batch timing (first 5, then every 10th)
+              if (batchCount <= 5 || batchCount % 10 === 0) {
+                console.log(
+                  `[useIfc] Batch #${batchCount}: ${event.meshes.length} meshes, ` +
+                  `wait: ${waitTime.toFixed(0)}ms, process: ${processTime.toFixed(0)}ms, ` +
+                  `total: ${totalMeshes} meshes at ${(eventReceived - processingStart).toFixed(0)}ms`
+                );
+              }
               break;
+            }
             case 'complete':
+              console.log(
+                `[useIfc] Processing complete: ${batchCount} batches, ${event.totalMeshes} meshes\n` +
+                `  Total wait (WASM): ${totalWaitTime.toFixed(0)}ms\n` +
+                `  Total process (JS): ${totalProcessTime.toFixed(0)}ms\n` +
+                `  First batch at: ${batchCount > 0 ? '(see Batch #1 above)' : 'N/A'}`
+              );
+              console.timeEnd('[useIfc] total-processing');
+
+              finalCoordinateInfo = event.coordinateInfo;
+
               // Update geometry result with final coordinate info
               updateCoordinateInfo(event.coordinateInfo);
-              
-              // Build spatial index from all collected meshes
+
+              // Build spatial index from meshes
               if (allMeshes.length > 0) {
                 setProgress({ phase: 'Building spatial index', percent: 95 });
+                console.time('[useIfc] spatial-index');
                 try {
                   const spatialIndex = buildSpatialIndex(allMeshes);
-                  // Attach spatial index to dataStore
                   (dataStore as any).spatialIndex = spatialIndex;
-                  setIfcDataStore(dataStore); // Update store with spatial index
+                  setIfcDataStore(dataStore);
+                  console.timeEnd('[useIfc] spatial-index');
                 } catch (err) {
+                  console.timeEnd('[useIfc] spatial-index');
                   console.warn('[useIfc] Failed to build spatial index:', err);
-                  // Continue without spatial index - it's optional
                 }
               }
-              
+
               setProgress({ phase: 'Complete', percent: 100 });
+
+              // Cache the result in the background (for files above threshold)
+              if (buffer.byteLength >= CACHE_SIZE_THRESHOLD && allMeshes.length > 0 && finalCoordinateInfo) {
+                // Don't await - let it run in background
+                const geometryData: GeometryData = {
+                  meshes: allMeshes,
+                  totalVertices: allMeshes.reduce((sum, m) => sum + m.positions.length / 3, 0),
+                  totalTriangles: allMeshes.reduce((sum, m) => sum + m.indices.length / 3, 0),
+                  coordinateInfo: finalCoordinateInfo,
+                };
+                saveToCache(cacheKey, dataStore, geometryData, buffer, file.name);
+              }
               break;
           }
+
+          lastBatchTime = performance.now();
         }
       } catch (err) {
-        console.error('[useIfc] Error in streaming processing:', err);
+        console.error('[useIfc] Error in processing:', err);
         setError(err instanceof Error ? err.message : 'Unknown error during geometry processing');
       }
 
@@ -144,12 +359,12 @@ export function useIfc() {
       setError(err instanceof Error ? err.message : 'Unknown error');
       setLoading(false);
     }
-  }, [setLoading, setError, setProgress, setIfcDataStore, setGeometryResult, appendGeometryBatch, updateCoordinateInfo]);
+  }, [setLoading, setError, setProgress, setIfcDataStore, setGeometryResult, appendGeometryBatch, updateCoordinateInfo, loadFromCache, saveToCache]);
 
   // Memoize query to prevent recreation on every render
   const query = useMemo(() => {
     if (!ifcDataStore) return null;
-    
+
     // Only log once per ifcDataStore
     lastLoggedDataStoreRef.current = ifcDataStore;
 

package/src/services/ifc-cache.ts

@@ -0,0 +1,251 @@
+/* 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/. */
+
+/**
+ * IndexedDB cache service for IFC files
+ *
+ * Stores parsed IFC data and geometry in IndexedDB for fast subsequent loads.
+ * Uses xxhash64 of the source file as the cache key.
+ */
+
+const DB_NAME = 'ifc-lite-cache';
+const DB_VERSION = 1;
+const STORE_NAME = 'models';
+
+interface CacheEntry {
+  key: string;
+  buffer: ArrayBuffer;
+  fileName: string;
+  fileSize: number;
+  createdAt: number;
+}
+
+let dbPromise: Promise<IDBDatabase> | null = null;
+
+/**
+ * Open the IndexedDB database
+ */
+function openDatabase(): Promise<IDBDatabase> {
+  if (dbPromise) return dbPromise;
+
+  dbPromise = new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+    request.onerror = () => {
+      console.error('[IFC Cache] Failed to open database:', request.error);
+      dbPromise = null; // Reset so we can retry
+      reject(request.error);
+    };
+
+    request.onsuccess = () => {
+      const db = request.result;
+      
+      // Verify the object store exists (handles corrupted DB state)
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        console.warn('[IFC Cache] Object store missing, recreating database...');
+        db.close();
+        dbPromise = null;
+        
+        // Delete and recreate the database
+        const deleteRequest = indexedDB.deleteDatabase(DB_NAME);
+        deleteRequest.onsuccess = () => {
+          // Retry opening after deletion
+          openDatabase().then(resolve).catch(reject);
+        };
+        deleteRequest.onerror = () => {
+          reject(new Error('Failed to recreate database'));
+        };
+        return;
+      }
+      
+      resolve(db);
+    };
+
+    request.onupgradeneeded = (event) => {
+      const db = (event.target as IDBOpenDBRequest).result;
+
+      // Create object store for cached models
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, { keyPath: 'key' });
+        store.createIndex('createdAt', 'createdAt', { unique: false });
+        store.createIndex('fileName', 'fileName', { unique: false });
+      }
+    };
+  });
+
+  return dbPromise;
+}
+
+/**
+ * Get a cached model by hash key
+ */
+export async function getCached(key: string): Promise<ArrayBuffer | null> {
+  try {
+    const db = await openDatabase();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, 'readonly');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.get(key);
+
+      request.onsuccess = () => {
+        const entry = request.result as CacheEntry | undefined;
+        if (entry) {
+          console.log(`[IFC Cache] Cache hit for ${entry.fileName} (${(entry.fileSize / 1024 / 1024).toFixed(2)}MB)`);
+          resolve(entry.buffer);
+        } else {
+          resolve(null);
+        }
+      };
+
+      request.onerror = () => {
+        console.error('[IFC Cache] Failed to get cache entry:', request.error);
+        reject(request.error);
+      };
+    });
+  } catch (err) {
+    console.warn('[IFC Cache] Cache read failed:', err);
+    return null;
+  }
+}
+
+/**
+ * Store a model in the cache
+ */
+export async function setCached(
+  key: string,
+  buffer: ArrayBuffer,
+  fileName: string,
+  fileSize: number
+): Promise<void> {
+  try {
+    const db = await openDatabase();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, 'readwrite');
+      const store = tx.objectStore(STORE_NAME);
+
+      const entry: CacheEntry = {
+        key,
+        buffer,
+        fileName,
+        fileSize,
+        createdAt: Date.now(),
+      };
+
+      const request = store.put(entry);
+
+      request.onsuccess = () => {
+        console.log(`[IFC Cache] Cached ${fileName} (${(fileSize / 1024 / 1024).toFixed(2)}MB)`);
+        resolve();
+      };
+
+      request.onerror = () => {
+        console.error('[IFC Cache] Failed to cache entry:', request.error);
+        reject(request.error);
+      };
+    });
+  } catch (err) {
+    console.warn('[IFC Cache] Cache write failed:', err);
+  }
+}
+
+/**
+ * Check if a cache entry exists
+ */
+export async function hasCached(key: string): Promise<boolean> {
+  try {
+    const db = await openDatabase();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, 'readonly');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.count(IDBKeyRange.only(key));
+
+      request.onsuccess = () => {
+        resolve(request.result > 0);
+      };
+
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Delete a cache entry
+ */
+export async function deleteCached(key: string): Promise<void> {
+  try {
+    const db = await openDatabase();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, 'readwrite');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.delete(key);
+
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  } catch (err) {
+    console.warn('[IFC Cache] Failed to delete cache entry:', err);
+  }
+}
+
+/**
+ * Clear all cached models
+ */
+export async function clearCache(): Promise<void> {
+  try {
+    const db = await openDatabase();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, 'readwrite');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.clear();
+
+      request.onsuccess = () => {
+        console.log('[IFC Cache] Cache cleared');
+        resolve();
+      };
+
+      request.onerror = () => reject(request.error);
+    });
+  } catch (err) {
+    console.warn('[IFC Cache] Failed to clear cache:', err);
+  }
+}
+
+/**
+ * Get cache statistics
+ */
+export async function getCacheStats(): Promise<{
+  entryCount: number;
+  totalSize: number;
+  entries: Array<{ fileName: string; fileSize: number; createdAt: Date }>;
+}> {
+  try {
+    const db = await openDatabase();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, 'readonly');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.getAll();
+
+      request.onsuccess = () => {
+        const entries = request.result as CacheEntry[];
+        resolve({
+          entryCount: entries.length,
+          totalSize: entries.reduce((sum, e) => sum + e.buffer.byteLength, 0),
+          entries: entries.map((e) => ({
+            fileName: e.fileName,
+            fileSize: e.fileSize,
+            createdAt: new Date(e.createdAt),
+          })),
+        });
+      };
+
+      request.onerror = () => reject(request.error);
+    });
+  } catch {
+    return { entryCount: 0, totalSize: 0, entries: [] };
+  }
+}

package/src/store.ts

@@ -307,13 +307,25 @@ export const useViewerStore = create<ViewerState>((set, get) => ({
 
   // Visibility actions
   hideEntity: (id) => set((state) => {
+    // Toggle hide: if already hidden, show it; otherwise hide it
     const newHidden = new Set(state.hiddenEntities);
-    newHidden.add(id);
+    if (newHidden.has(id)) {
+      newHidden.delete(id);
+    } else {
+      newHidden.add(id);
+    }
     return { hiddenEntities: newHidden };
   }),
   hideEntities: (ids) => set((state) => {
+    // Toggle hide for each entity: if already hidden, show it; otherwise hide it
     const newHidden = new Set(state.hiddenEntities);
-    ids.forEach(id => newHidden.add(id));
+    ids.forEach(id => {
+      if (newHidden.has(id)) {
+        newHidden.delete(id);
+      } else {
+        newHidden.add(id);
+      }
+    });
     return { hiddenEntities: newHidden };
   }),
   showEntity: (id) => set((state) => {
@@ -335,8 +347,47 @@ export const useViewerStore = create<ViewerState>((set, get) => ({
     }
     return { hiddenEntities: newHidden };
   }),
-  isolateEntity: (id) => set({ isolatedEntities: new Set([id]) }),
-  isolateEntities: (ids) => set({ isolatedEntities: new Set(ids) }),
+  isolateEntity: (id) => set((state) => {
+    // Toggle isolate: if this entity is already the only isolated one, clear isolation
+    // Otherwise, isolate it (and unhide it for good UX)
+    const isAlreadyIsolated = state.isolatedEntities !== null && 
+      state.isolatedEntities.size === 1 && 
+      state.isolatedEntities.has(id);
+    
+    if (isAlreadyIsolated) {
+      // Toggle off: clear isolation
+      return { isolatedEntities: null };
+    } else {
+      // Toggle on: isolate this entity (and unhide it)
+      const newHidden = new Set(state.hiddenEntities);
+      newHidden.delete(id);
+      return { 
+        isolatedEntities: new Set([id]),
+        hiddenEntities: newHidden,
+      };
+    }
+  }),
+  isolateEntities: (ids) => set((state) => {
+    // Toggle isolate: if these exact entities are already isolated, clear isolation
+    // Otherwise, isolate them (and unhide them for good UX)
+    const idsSet = new Set(ids);
+    const isAlreadyIsolated = state.isolatedEntities !== null &&
+      state.isolatedEntities.size === idsSet.size &&
+      ids.every(id => state.isolatedEntities!.has(id));
+    
+    if (isAlreadyIsolated) {
+      // Toggle off: clear isolation
+      return { isolatedEntities: null };
+    } else {
+      // Toggle on: isolate these entities (and unhide them)
+      const newHidden = new Set(state.hiddenEntities);
+      ids.forEach(id => newHidden.delete(id));
+      return { 
+        isolatedEntities: idsSet,
+        hiddenEntities: newHidden,
+      };
+    }
+  }),
   clearIsolation: () => set({ isolatedEntities: null }),
   showAll: () => set({ hiddenEntities: new Set(), isolatedEntities: null }),
   isEntityVisible: (id) => {

package/tsconfig.json

@@ -9,7 +9,11 @@
       "@ifc-lite/parser": ["../../packages/parser/src"],
       "@ifc-lite/geometry": ["../../packages/geometry/src"],
       "@ifc-lite/renderer": ["../../packages/renderer/src"],
-      "@ifc-lite/query": ["../../packages/query/src"]
+      "@ifc-lite/query": ["../../packages/query/src"],
+      "@ifc-lite/spatial": ["../../packages/spatial/src"],
+      "@ifc-lite/data": ["../../packages/data/src"],
+      "@ifc-lite/export": ["../../packages/export/src"],
+      "@ifc-lite/cache": ["../../packages/cache/src"]
     }
   },
   "include": ["src/**/*", "../../packages/renderer/src/webgpu-types.d.ts"]