fontastic 1.2.0 → 1.3.0

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.2.0"
+  ".": "1.3.0"
 }

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [1.3.0](https://github.com/tomshaw/fontastic/compare/fontastic-v1.2.0...fontastic-v1.3.0) (2026-03-15)
+
+
+### 🎉 Features
+
+* add smart collection preview functionality and enhance rule builder component ([436b162](https://github.com/tomshaw/fontastic/commit/436b16242ddae4eaaff3279d749b70dc79c9098c))
+* enhance application with secure storage and scan progress features ([7a2576b](https://github.com/tomshaw/fontastic/commit/7a2576b5484ce3d8ce1c06171f60608b43c3e42b))
+
+
+### 🛠️ Fixes
+
+* add height class to footer layout for improved display ([10da788](https://github.com/tomshaw/fontastic/commit/10da78803ba3ccec3cf9f76646a896a013a8935f))
+* adjust collection order handling in createParent and createChild methods ([3c9a0c4](https://github.com/tomshaw/fontastic/commit/3c9a0c4e2062a3c8a36b32f71193b01ddc57073e))
+* refactor footer component layout and enhance version handling ([dc0475e](https://github.com/tomshaw/fontastic/commit/dc0475ed4c67a326a7710894d9145731a7909b5d))
+* update collection order handling in createParent and createChild methods ([ce855d0](https://github.com/tomshaw/fontastic/commit/ce855d0664ab391fd15fed0bbffd16568a019699))
+* update footer layout to use grid for improved structure and responsiveness ([b2a4dac](https://github.com/tomshaw/fontastic/commit/b2a4dac434f9ea732180f32477854905c0fa80fb))
+
+
+### 🏗️ Refactor
+
+* standardize string quotes and improve code readability ([f352ddb](https://github.com/tomshaw/fontastic/commit/f352ddb248e6c7dc1e566917ebf57ebabdde3531))
+
 ## [1.2.0](https://github.com/tomshaw/fontastic/compare/fontastic-v1.1.0...fontastic-v1.2.0) (2026-03-14)
 
 

package/README.md

@@ -23,6 +23,12 @@ Fontastic is an Electron-based font management and cataloging application built
 - Glyph inspector — browse and examine individual characters and Unicode points
 - Waterfall preview — compare text rendering across multiple sizes at a glance
 - Font table viewer — read raw OpenType and TrueType metadata tables
+- System theme sync — automatically matches OS light/dark mode via `nativeTheme`
+- Encrypted storage — API keys secured at rest using OS keychain via `safeStorage`
+- Scan progress — real-time font import progress streamed over `MessageChannelMain`
+- Power aware — pauses activity on system sleep and resumes on wake via `powerMonitor`
+- Session hardening — CSP headers, permission deny-list, and cache management via `session`
+- Accessibility — respects OS reduced motion and accent color via `systemPreferences`
 - Cross-platform — builds for Windows, macOS, and Linux
 
 ## Getting Started

package/app/Application.js

@@ -26,12 +26,12 @@ class Application {
             const systemManager = new SystemManager_1.default(this.machineId, this.isProduction);
             const configManager = new ConfigManager_1.default(systemManager);
             configManager.initialize();
+            const menuBuilder = new MenuBuilder_1.default(this.mainWindow, this.isProduction);
             const connectionManager = new ConnectionManager_1.default(configManager);
-            yield connectionManager.initialize();
+            // Initialize menu and database connection in parallel — menu doesn't depend on DB
+            yield Promise.all([connectionManager.initialize(), Promise.resolve(menuBuilder.initialize())]);
             const fontManager = new FontManager_1.default(systemManager, configManager, connectionManager);
-            const menuBuilder = new MenuBuilder_1.default(this.mainWindow, this.isProduction);
-            menuBuilder.initialize();
-            const messageHandler = new MessageHandler_1.default(systemManager, configManager, connectionManager, fontManager);
+            const messageHandler = new MessageHandler_1.default(systemManager, configManager, connectionManager, fontManager, this.mainWindow);
             messageHandler.initialize();
         });
     }

package/app/Application.ts

@@ -1,13 +1,12 @@
-import SystemManager from "./core/SystemManager";
-import ConfigManager from "./core/ConfigManager";
-import ConnectionManager from "./core/ConnectionManager";
-import FontManager from "./core/FontManager";
-import MessageHandler from "./core/MessageHandler";
-import MenuBuilder from "./core/menu/MenuBuilder";
-import { BrowserWindow } from "electron";
+import SystemManager from './core/SystemManager';
+import ConfigManager from './core/ConfigManager';
+import ConnectionManager from './core/ConnectionManager';
+import FontManager from './core/FontManager';
+import MessageHandler from './core/MessageHandler';
+import MenuBuilder from './core/menu/MenuBuilder';
+import { BrowserWindow } from 'electron';
 
 export default class Application {
-
   machineId: string;
   isProduction: boolean;
   mainWindow: BrowserWindow;
@@ -24,15 +23,16 @@ export default class Application {
     const configManager = new ConfigManager(systemManager);
     configManager.initialize();
 
+    const menuBuilder = new MenuBuilder(this.mainWindow, this.isProduction);
+
     const connectionManager = new ConnectionManager(configManager);
-    await connectionManager.initialize()
 
-    const fontManager = new FontManager(systemManager, configManager, connectionManager);
+    // Initialize menu and database connection in parallel — menu doesn't depend on DB
+    await Promise.all([connectionManager.initialize(), Promise.resolve(menuBuilder.initialize())]);
 
-    const menuBuilder = new MenuBuilder(this.mainWindow, this.isProduction);
-    menuBuilder.initialize();
+    const fontManager = new FontManager(systemManager, configManager, connectionManager);
 
-    const messageHandler = new MessageHandler(systemManager, configManager, connectionManager, fontManager);
+    const messageHandler = new MessageHandler(systemManager, configManager, connectionManager, fontManager, this.mainWindow);
     messageHandler.initialize();
   }
 }

package/app/config/database.js

@@ -146,7 +146,7 @@ exports.dbColumns = [
         searchable: true,
     },
     {
-        name: 'manufacturer',
+        name: 'manufacturer_url',
         searchable: true,
     },
     {

package/app/config/database.ts

@@ -145,7 +145,7 @@ export const dbColumns = [
     searchable: true,
   },
   {
-    name: 'manufacturer',
+    name: 'manufacturer_url',
     searchable: true,
   },
   {

package/app/config/mimes.js

@@ -3,41 +3,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.installable = exports.mimeTypes = exports.fontMimeTypes = void 0;
 exports.fontMimeTypes = [
     {
-        type: "font/ttf",
-        name: "TrueType",
+        type: 'font/ttf',
+        name: 'TrueType',
         description: "TrueType is an outline font standard developed by Apple in the late 1980s as a competitor to Adobe's Type 1 fonts used in PostScript. It has become the most common format for fonts on the classic Mac OS, macOS, and Microsoft Windows operating systems.",
-        installable: true
+        installable: true,
     },
     {
-        type: "font/otf",
-        name: "OpenType",
+        type: 'font/otf',
+        name: 'OpenType',
         description: "OpenType is a format for scalable computer fonts. It was built on its predecessor TrueType, retaining TrueType's basic structure and adding many intricate data structures for prescribing typographic behavior. OpenType is a registered trademark of Microsoft Corporation.",
-        installable: true
+        installable: true,
     },
     {
-        type: "font/woff",
-        name: "Web Open Font Format",
-        description: "The Web Open Font Format is a font format for use in web pages. WOFF files are OpenType or TrueType fonts, with format-specific compression applied and additional XML metadata added.",
-        installable: false
+        type: 'font/woff',
+        name: 'Web Open Font Format',
+        description: 'The Web Open Font Format is a font format for use in web pages. WOFF files are OpenType or TrueType fonts, with format-specific compression applied and additional XML metadata added.',
+        installable: false,
     },
     {
-        type: "font/woff2",
-        name: "Web Open Font Format 2",
-        description: "A WOFF2 file is a web font file created in the WOFF (Web Open Font Format) 2.0 format, an open format used to deliver webpage fonts on the fly. It is saved as a compressed container that supports TrueType (. TTF) and OpenType (. OTF) fonts. WOFF2 files also support font licensing metadata.",
-        installable: false
+        type: 'font/woff2',
+        name: 'Web Open Font Format 2',
+        description: 'A WOFF2 file is a web font file created in the WOFF (Web Open Font Format) 2.0 format, an open format used to deliver webpage fonts on the fly. It is saved as a compressed container that supports TrueType (. TTF) and OpenType (. OTF) fonts. WOFF2 files also support font licensing metadata.',
+        installable: false,
     },
     {
-        type: "font/ttc",
-        name: "TrueType Collection",
-        description: "TrueType Collection (TTC) is an extension of TrueType format that allows combining multiple fonts into a single file, creating substantial space savings for a collection of fonts with many glyphs in common.",
-        installable: false
+        type: 'font/ttc',
+        name: 'TrueType Collection',
+        description: 'TrueType Collection (TTC) is an extension of TrueType format that allows combining multiple fonts into a single file, creating substantial space savings for a collection of fonts with many glyphs in common.',
+        installable: false,
     },
     {
-        type: "font/dfont",
-        name: "Datafork TrueType",
-        description: "Datafork TrueType is a font wrapper used on Apple Macintosh computers running Mac OS X. It is a TrueType suitcase with the resource map in the data fork, rather than the resource fork as had been the case in Mac OS 9.",
-        installable: false
-    }
+        type: 'font/dfont',
+        name: 'Datafork TrueType',
+        description: 'Datafork TrueType is a font wrapper used on Apple Macintosh computers running Mac OS X. It is a TrueType suitcase with the resource map in the data fork, rather than the resource fork as had been the case in Mac OS 9.',
+        installable: false,
+    },
 ];
 exports.mimeTypes = exports.fontMimeTypes.map((item) => item.type);
 exports.installable = exports.fontMimeTypes.reduce((prev, curr) => {

package/app/config/mimes.ts

@@ -1,54 +1,60 @@
 interface Mime {
   type: string;
   name: string;
-  description: string,
-  installable: boolean
+  description: string;
+  installable: boolean;
 }
 
 export const fontMimeTypes: Mime[] = [
   {
-    type: "font/ttf",
-    name: "TrueType",
-    description: "TrueType is an outline font standard developed by Apple in the late 1980s as a competitor to Adobe's Type 1 fonts used in PostScript. It has become the most common format for fonts on the classic Mac OS, macOS, and Microsoft Windows operating systems.",
-    installable: true
+    type: 'font/ttf',
+    name: 'TrueType',
+    description:
+      "TrueType is an outline font standard developed by Apple in the late 1980s as a competitor to Adobe's Type 1 fonts used in PostScript. It has become the most common format for fonts on the classic Mac OS, macOS, and Microsoft Windows operating systems.",
+    installable: true,
   },
   {
-    type: "font/otf",
-    name: "OpenType",
-    description: "OpenType is a format for scalable computer fonts. It was built on its predecessor TrueType, retaining TrueType's basic structure and adding many intricate data structures for prescribing typographic behavior. OpenType is a registered trademark of Microsoft Corporation.",
-    installable: true
+    type: 'font/otf',
+    name: 'OpenType',
+    description:
+      "OpenType is a format for scalable computer fonts. It was built on its predecessor TrueType, retaining TrueType's basic structure and adding many intricate data structures for prescribing typographic behavior. OpenType is a registered trademark of Microsoft Corporation.",
+    installable: true,
   },
   {
-    type: "font/woff",
-    name: "Web Open Font Format",
-    description: "The Web Open Font Format is a font format for use in web pages. WOFF files are OpenType or TrueType fonts, with format-specific compression applied and additional XML metadata added.",
-    installable: false
+    type: 'font/woff',
+    name: 'Web Open Font Format',
+    description:
+      'The Web Open Font Format is a font format for use in web pages. WOFF files are OpenType or TrueType fonts, with format-specific compression applied and additional XML metadata added.',
+    installable: false,
   },
   {
-    type: "font/woff2",
-    name: "Web Open Font Format 2",
-    description: "A WOFF2 file is a web font file created in the WOFF (Web Open Font Format) 2.0 format, an open format used to deliver webpage fonts on the fly. It is saved as a compressed container that supports TrueType (. TTF) and OpenType (. OTF) fonts. WOFF2 files also support font licensing metadata.",
-    installable: false
+    type: 'font/woff2',
+    name: 'Web Open Font Format 2',
+    description:
+      'A WOFF2 file is a web font file created in the WOFF (Web Open Font Format) 2.0 format, an open format used to deliver webpage fonts on the fly. It is saved as a compressed container that supports TrueType (. TTF) and OpenType (. OTF) fonts. WOFF2 files also support font licensing metadata.',
+    installable: false,
   },
   {
-    type: "font/ttc",
-    name: "TrueType Collection",
-    description: "TrueType Collection (TTC) is an extension of TrueType format that allows combining multiple fonts into a single file, creating substantial space savings for a collection of fonts with many glyphs in common.",
-    installable: false
+    type: 'font/ttc',
+    name: 'TrueType Collection',
+    description:
+      'TrueType Collection (TTC) is an extension of TrueType format that allows combining multiple fonts into a single file, creating substantial space savings for a collection of fonts with many glyphs in common.',
+    installable: false,
   },
   {
-    type: "font/dfont",
-    name: "Datafork TrueType",
-    description: "Datafork TrueType is a font wrapper used on Apple Macintosh computers running Mac OS X. It is a TrueType suitcase with the resource map in the data fork, rather than the resource fork as had been the case in Mac OS 9.",
-    installable: false
-  }
+    type: 'font/dfont',
+    name: 'Datafork TrueType',
+    description:
+      'Datafork TrueType is a font wrapper used on Apple Macintosh computers running Mac OS X. It is a TrueType suitcase with the resource map in the data fork, rather than the resource fork as had been the case in Mac OS 9.',
+    installable: false,
+  },
 ];
 
 export const mimeTypes: string[] = fontMimeTypes.map((item) => item.type);
 
-export const installable: Mime[] = fontMimeTypes.reduce((prev, curr) => {
+export const installable: string[] = fontMimeTypes.reduce((prev: string[], curr) => {
   if (curr.installable) {
     prev.push(curr.type);
   }
   return prev;
-}, []);
+}, []);

package/app/core/ConfigManager.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
 const database_1 = require("../config/database");
 const StorageType_1 = require("../enums/StorageType");
 const Store = require('electron-store');
@@ -26,6 +27,32 @@ class ConfigManager {
     clear() {
         return store.clear();
     }
+    // --- Safe Storage (OS keychain encryption) ---
+    setSecure(key, value) {
+        if (electron_1.safeStorage.isEncryptionAvailable()) {
+            const encrypted = electron_1.safeStorage.encryptString(value);
+            store.set(key, encrypted.toString('base64'));
+        }
+        else {
+            store.set(key, value);
+        }
+    }
+    getSecure(key) {
+        const raw = store.get(key);
+        if (!raw)
+            return null;
+        if (electron_1.safeStorage.isEncryptionAvailable() && typeof raw === 'string') {
+            try {
+                const buffer = Buffer.from(raw, 'base64');
+                return electron_1.safeStorage.decryptString(buffer);
+            }
+            catch (_a) {
+                // Fallback: value may have been stored before encryption was enabled
+                return raw;
+            }
+        }
+        return typeof raw === 'string' ? raw : null;
+    }
     toArray() {
         return store.store;
     }

package/app/core/ConfigManager.ts

@@ -1,3 +1,4 @@
+import { safeStorage } from 'electron';
 import SystemManager from './SystemManager';
 import { database } from '../config/database';
 import { StorageType } from '../enums/StorageType';
@@ -35,6 +36,33 @@ export default class ConfigManager {
     return store.clear();
   }
 
+  // --- Safe Storage (OS keychain encryption) ---
+
+  setSecure(key: string, value: string): void {
+    if (safeStorage.isEncryptionAvailable()) {
+      const encrypted = safeStorage.encryptString(value);
+      store.set(key, encrypted.toString('base64'));
+    } else {
+      store.set(key, value);
+    }
+  }
+
+  getSecure(key: string): string | null {
+    const raw = store.get(key);
+    if (!raw) return null;
+
+    if (safeStorage.isEncryptionAvailable() && typeof raw === 'string') {
+      try {
+        const buffer = Buffer.from(raw, 'base64');
+        return safeStorage.decryptString(buffer);
+      } catch {
+        // Fallback: value may have been stored before encryption was enabled
+        return raw;
+      }
+    }
+    return typeof raw === 'string' ? raw : null;
+  }
+
   toArray(): any {
     return store.store;
   }

package/app/core/FontFinder.js

@@ -13,58 +13,109 @@ const FontObject_1 = require("./FontObject");
 const fs = require("fs/promises");
 const path = require("path");
 const mimes_1 = require("../config/mimes");
-const prettyBytes = require("pretty-bytes");
-const mime = require("mime");
+const prettyBytes = require('pretty-bytes');
+const mime = require('mime');
+const SCAN_CONCURRENCY = 10;
 class FontFinder {
-    constructor(connectionManager) {
+    constructor(connectionManager, onProgress) {
         this.errors = [];
         this.counter = 0;
+        this.onProgress = null;
         this.connectionManager = connectionManager;
+        this.onProgress = onProgress !== null && onProgress !== void 0 ? onProgress : null;
     }
-    isFontFile(filePath) {
+    getFontMimeType(filePath) {
         const fileType = mime.getType(filePath);
-        return fileType && mimes_1.mimeTypes.includes(fileType);
+        return fileType && mimes_1.mimeTypes.includes(fileType) ? fileType : null;
     }
     scanFiles(files, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.errors = [];
+            this.counter = 0;
+            const fontFiles = [];
             for (const fp of files) {
-                if (this.isFontFile(fp)) {
-                    const stat = yield fs.stat(fp);
-                    yield this.processFont(fp, stat, options);
+                const fileType = this.getFontMimeType(fp);
+                if (fileType) {
+                    fontFiles.push({ fp, fileType });
                 }
             }
+            yield this.processInBatches(fontFiles, options);
         });
     }
     scanFolder(dir, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.errors = [];
+            this.counter = 0;
+            const fontFiles = yield this.collectFontFiles(dir);
+            yield this.processInBatches(fontFiles, options);
+        });
+    }
+    collectFontFiles(dir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
             const entries = yield fs.readdir(dir, { withFileTypes: true });
+            const subdirPromises = [];
             for (const entry of entries) {
                 const fp = path.join(dir, entry.name);
                 if (entry.isDirectory()) {
-                    yield this.scanFolder(fp, options);
+                    subdirPromises.push(this.collectFontFiles(fp));
+                }
+                else {
+                    const fileType = this.getFontMimeType(fp);
+                    if (fileType) {
+                        results.push({ fp, fileType });
+                    }
                 }
-                else if (this.isFontFile(fp)) {
-                    const stat = yield fs.stat(fp);
-                    yield this.processFont(fp, stat, options);
+            }
+            if (subdirPromises.length > 0) {
+                const subdirResults = yield Promise.all(subdirPromises);
+                for (const subResults of subdirResults) {
+                    results.push(...subResults);
                 }
             }
+            return results;
         });
     }
-    processFont(fp, stat, options) {
+    processInBatches(fontFiles, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const total = fontFiles.length;
+            for (let i = 0; i < fontFiles.length; i += SCAN_CONCURRENCY) {
+                const batch = fontFiles.slice(i, i + SCAN_CONCURRENCY);
+                yield Promise.all(batch.map(({ fp, fileType }) => this.processFont(fp, fileType, options)));
+                if (this.onProgress) {
+                    const lastFile = batch[batch.length - 1];
+                    this.onProgress({
+                        processed: Math.min(i + SCAN_CONCURRENCY, total),
+                        total,
+                        currentFile: path.basename(lastFile.fp),
+                        errors: this.errors.length,
+                    });
+                }
+            }
+        });
+    }
+    processFont(fp, fileType, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const font = new FontObject_1.default(fp);
             if (font.hasError()) {
                 this.errors.push(font.getError());
                 return;
             }
-            const fileType = mime.getType(fp);
+            let stat;
+            try {
+                stat = yield fs.stat(fp);
+            }
+            catch (err) {
+                this.errors.push({ file: fp, message: err.message });
+                return;
+            }
             const data = Object.assign(Object.assign({ file_path: fp, file_name: path.basename(fp), file_size: stat.size, file_size_pretty: prettyBytes(stat.size), file_type: fileType, installable: mimes_1.installable.includes(fileType) }, options), font.getNamesTable());
             try {
                 yield this.connectionManager.getStoreRepository().create(data);
                 this.counter++;
             }
             catch (err) {
-                this.errors.push(err.message);
+                this.errors.push({ file: fp, message: err.message });
             }
         });
     }

package/app/core/FontFinder.ts

@@ -1,50 +1,103 @@
-import ConnectionManager from "./ConnectionManager";
-import FontObject from "./FontObject";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { mimeTypes, installable } from "../config/mimes";
+import ConnectionManager from './ConnectionManager';
+import FontObject from './FontObject';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { mimeTypes, installable } from '../config/mimes';
+import type { ScanProgress } from '../types';
 
-const prettyBytes = require("pretty-bytes");
-const mime = require("mime");
+const prettyBytes = require('pretty-bytes');
+const mime = require('mime');
 
-export default class FontFinder {
+const SCAN_CONCURRENCY = 10;
+
+export type ProgressCallback = (progress: ScanProgress) => void;
 
+export default class FontFinder {
   connectionManager: ConnectionManager;
   errors: any[] = [];
   counter: number = 0;
+  private onProgress: ProgressCallback | null = null;
 
-  constructor(connectionManager: ConnectionManager) {
+  constructor(connectionManager: ConnectionManager, onProgress?: ProgressCallback) {
     this.connectionManager = connectionManager;
+    this.onProgress = onProgress ?? null;
   }
 
-  private isFontFile(filePath: string): boolean {
+  private getFontMimeType(filePath: string): string | null {
     const fileType = mime.getType(filePath);
-    return fileType && mimeTypes.includes(fileType);
+    return fileType && mimeTypes.includes(fileType) ? fileType : null;
   }
 
   async scanFiles(files: string[], options: any) {
+    this.errors = [];
+    this.counter = 0;
+
+    const fontFiles: { fp: string; fileType: string }[] = [];
     for (const fp of files) {
-      if (this.isFontFile(fp)) {
-        const stat = await fs.stat(fp);
-        await this.processFont(fp, stat, options);
+      const fileType = this.getFontMimeType(fp);
+      if (fileType) {
+        fontFiles.push({ fp, fileType });
       }
     }
+
+    await this.processInBatches(fontFiles, options);
   }
 
   async scanFolder(dir: string, options: any) {
+    this.errors = [];
+    this.counter = 0;
+
+    const fontFiles = await this.collectFontFiles(dir);
+    await this.processInBatches(fontFiles, options);
+  }
+
+  private async collectFontFiles(dir: string): Promise<{ fp: string; fileType: string }[]> {
+    const results: { fp: string; fileType: string }[] = [];
     const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    const subdirPromises: Promise<{ fp: string; fileType: string }[]>[] = [];
+
     for (const entry of entries) {
       const fp = path.join(dir, entry.name);
       if (entry.isDirectory()) {
-        await this.scanFolder(fp, options);
-      } else if (this.isFontFile(fp)) {
-        const stat = await fs.stat(fp);
-        await this.processFont(fp, stat, options);
+        subdirPromises.push(this.collectFontFiles(fp));
+      } else {
+        const fileType = this.getFontMimeType(fp);
+        if (fileType) {
+          results.push({ fp, fileType });
+        }
+      }
+    }
+
+    if (subdirPromises.length > 0) {
+      const subdirResults = await Promise.all(subdirPromises);
+      for (const subResults of subdirResults) {
+        results.push(...subResults);
       }
     }
+
+    return results;
   }
 
-  private async processFont(fp: string, stat: any, options: any) {
+  private async processInBatches(fontFiles: { fp: string; fileType: string }[], options: any) {
+    const total = fontFiles.length;
+    for (let i = 0; i < fontFiles.length; i += SCAN_CONCURRENCY) {
+      const batch = fontFiles.slice(i, i + SCAN_CONCURRENCY);
+      await Promise.all(batch.map(({ fp, fileType }) => this.processFont(fp, fileType, options)));
+
+      if (this.onProgress) {
+        const lastFile = batch[batch.length - 1];
+        this.onProgress({
+          processed: Math.min(i + SCAN_CONCURRENCY, total),
+          total,
+          currentFile: path.basename(lastFile.fp),
+          errors: this.errors.length,
+        });
+      }
+    }
+  }
+
+  private async processFont(fp: string, fileType: string, options: any) {
     const font = new FontObject(fp);
 
     if (font.hasError()) {
@@ -52,7 +105,13 @@ export default class FontFinder {
       return;
     }
 
-    const fileType = mime.getType(fp);
+    let stat;
+    try {
+      stat = await fs.stat(fp);
+    } catch (err: any) {
+      this.errors.push({ file: fp, message: err.message });
+      return;
+    }
 
     const data = {
       file_path: fp,
@@ -68,8 +127,8 @@ export default class FontFinder {
     try {
       await this.connectionManager.getStoreRepository().create(data);
       this.counter++;
-    } catch (err) {
-      this.errors.push(err.message);
+    } catch (err: any) {
+      this.errors.push({ file: fp, message: err.message });
     }
   }
 }