@willwade/aac-processors 0.0.12 → 0.0.13

package/dist/optional/analytics/metrics/obl.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OblAnonymizer = exports.OblUtil = void 0;
+const treeStructure_1 = require("../../../core/treeStructure");
+/**
+ * .obl (Open Board Logging) Utility
+ *
+ * Provides parsing and generation support for the .obl format.
+ */
+class OblUtil {
+    /**
+     * Parse an OBL JSON string.
+     * Handles the optional /* notice * / at the start of the file.
+     */
+    static parse(json) {
+        // Remove potential comment at the start
+        let cleanJson = json.trim();
+        if (cleanJson.startsWith('/*')) {
+            const endComment = cleanJson.indexOf('*/');
+            if (endComment !== -1) {
+                cleanJson = cleanJson.substring(endComment + 2).trim();
+            }
+        }
+        return JSON.parse(cleanJson);
+    }
+    /**
+     * Stringify an OBL file object.
+     * Optionally adds the recommended notice comment.
+     */
+    static stringify(obl, includeNotice = true) {
+        const json = JSON.stringify(obl, null, 2);
+        if (includeNotice) {
+            return `/* NOTICE: The following information represents an individual's communication and should be treated respectfully and securely. */\n${json}`;
+        }
+        return json;
+    }
+    /**
+     * Convert an OBL file to internal HistoryEntry format.
+     */
+    static toHistoryEntries(obl) {
+        const entries = [];
+        const source = obl.source || 'OBL';
+        // OBL is session-based and event-based.
+        // HistoryEntry is content-based with occurrences.
+        // We'll group events by content (label/text) to match HistoryEntry structure.
+        const contentMap = new Map();
+        for (const session of obl.sessions) {
+            for (const event of session.events) {
+                let content = '';
+                const evtAny = event;
+                const occurrence = {
+                    timestamp: new Date(event.timestamp),
+                    modeling: event.modeling,
+                    pageId: evtAny.board_id || null,
+                    latitude: event.geo?.[0] || null,
+                    longitude: event.geo?.[1] || null,
+                    type: event.type,
+                    // Store all other OBL fields in the occurrence
+                    buttonId: evtAny.button_id || null,
+                    boardId: evtAny.board_id || null,
+                    spoken: evtAny.spoken,
+                    vocalization: evtAny.vocalization,
+                    imageUrl: evtAny.image_url,
+                    actions: evtAny.actions,
+                };
+                if (event.type === 'button') {
+                    const btn = event;
+                    content = btn.vocalization || btn.label;
+                }
+                else if (event.type === 'utterance') {
+                    const utt = event;
+                    content = utt.text;
+                }
+                else if (event.type === 'action') {
+                    const act = event;
+                    content = act.action;
+                }
+                else if (event.type === 'note') {
+                    const note = event;
+                    content = note.text;
+                }
+                else {
+                    const evtAny = event;
+                    content = evtAny.label || evtAny.text || evtAny.action || 'unknown';
+                }
+                const occurrences = contentMap.get(content) || [];
+                occurrences.push(occurrence);
+                contentMap.set(content, occurrences);
+            }
+        }
+        contentMap.forEach((occurrences, content) => {
+            entries.push({
+                id: `obl:${content}`,
+                source: source,
+                content: content,
+                occurrences: occurrences.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime()),
+            });
+        });
+        return entries;
+    }
+    /**
+     * Convert HistoryEntries to an OBL file object.
+     */
+    static fromHistoryEntries(entries, userId, source) {
+        const events = [];
+        for (const entry of entries) {
+            for (const occ of entry.occurrences) {
+                const timestamp = occ.timestamp.toISOString();
+                const intent = occ.intent;
+                let oblType = occ.type || 'button';
+                let actionStr = undefined;
+                // Smart mapping based on AACSemanticIntent
+                if (intent === treeStructure_1.AACSemanticIntent.CLEAR_TEXT) {
+                    oblType = 'action';
+                    actionStr = ':clear';
+                }
+                else if (intent === treeStructure_1.AACSemanticIntent.GO_HOME) {
+                    oblType = 'action';
+                    actionStr = ':home';
+                }
+                else if (intent === treeStructure_1.AACSemanticIntent.NAVIGATE_TO) {
+                    oblType = 'action';
+                    actionStr = ':open_board';
+                }
+                else if (intent === treeStructure_1.AACSemanticIntent.GO_BACK) {
+                    oblType = 'action';
+                    actionStr = ':back';
+                }
+                else if (intent === treeStructure_1.AACSemanticIntent.DELETE_CHARACTER) {
+                    oblType = 'action';
+                    actionStr = ':backspace';
+                }
+                else if (intent === treeStructure_1.AACSemanticIntent.SPEAK_IMMEDIATE ||
+                    intent === treeStructure_1.AACSemanticIntent.SPEAK_TEXT) {
+                    // Speak could be a button or an utterance or an action
+                    if (oblType !== 'utterance' && oblType !== 'button') {
+                        oblType = 'action';
+                        actionStr = ':speak';
+                    }
+                }
+                const common = {
+                    id: Math.random().toString(36).substring(2, 11),
+                    timestamp,
+                    modeling: occ.modeling,
+                    type: oblType,
+                };
+                if (occ.latitude !== null &&
+                    occ.latitude !== undefined &&
+                    occ.longitude !== null &&
+                    occ.longitude !== undefined) {
+                    common.geo = [occ.latitude, occ.longitude];
+                }
+                if (oblType === 'utterance') {
+                    events.push({
+                        ...common,
+                        text: entry.content,
+                    });
+                }
+                else if (oblType === 'action') {
+                    events.push({
+                        ...common,
+                        action: actionStr || entry.content,
+                        destination_board_id: occ.boardId || undefined,
+                        text: intent === treeStructure_1.AACSemanticIntent.SPEAK_TEXT ? entry.content : undefined,
+                    });
+                }
+                else if (oblType === 'note') {
+                    events.push({
+                        ...common,
+                        text: entry.content,
+                    });
+                }
+                else {
+                    // Default to button
+                    events.push({
+                        ...common,
+                        type: 'button',
+                        label: occ.vocalization ? entry.content : entry.content,
+                        spoken: occ.spoken ??
+                            occ.category === treeStructure_1.AACSemanticCategory.COMMUNICATION,
+                        button_id: occ.buttonId || undefined,
+                        board_id: occ.boardId || occ.pageId || undefined,
+                        vocalization: occ.vocalization || undefined,
+                        image_url: occ.imageUrl || undefined,
+                        actions: occ.actions || undefined,
+                    });
+                }
+            }
+        }
+        // Sort events by timestamp
+        events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        const started = events.length > 0 ? events[0].timestamp : new Date().toISOString();
+        const ended = events.length > 0 ? events[events.length - 1].timestamp : new Date().toISOString();
+        const session = {
+            id: 'session-1',
+            type: 'log',
+            started,
+            ended,
+            events,
+        };
+        return {
+            format: 'open-board-log-0.1',
+            user_id: userId,
+            source: source || 'aac-processors',
+            sessions: [session],
+        };
+    }
+}
+exports.OblUtil = OblUtil;
+/**
+ * .obl Anonymization Utility
+ */
+class OblAnonymizer {
+    /**
+     * Apply anonymization to an OBL file.
+     */
+    static anonymize(obl, types) {
+        const newObl = JSON.parse(JSON.stringify(obl));
+        newObl.anonymized = true;
+        for (const session of newObl.sessions) {
+            session.anonymizations = session.anonymizations || [];
+            if (types.includes('timestamp_shift')) {
+                this.applyTimestampShift(session);
+                if (!session.anonymizations.includes('timestamp_shift'))
+                    session.anonymizations.push('timestamp_shift');
+            }
+            if (types.includes('geolocation_masking')) {
+                this.applyGeolocationMasking(session);
+                if (!session.anonymizations.includes('geolocation_masking'))
+                    session.anonymizations.push('geolocation_masking');
+            }
+            if (types.includes('url_stripping')) {
+                this.applyUrlStripping(session);
+                if (!session.anonymizations.includes('url_stripping'))
+                    session.anonymizations.push('url_stripping');
+            }
+            if (types.includes('name_masking')) {
+                this.applyNameMasking(newObl, session);
+                if (!session.anonymizations.includes('name_masking'))
+                    session.anonymizations.push('name_masking');
+            }
+        }
+        return newObl;
+    }
+    static applyTimestampShift(session) {
+        if (session.events.length === 0)
+            return;
+        const firstEventTime = session.events.length > 0 ? new Date(session.events[0].timestamp).getTime() : Infinity;
+        const sessionStartTime = session.started ? new Date(session.started).getTime() : Infinity;
+        const firstTimestamp = Math.min(firstEventTime, sessionStartTime);
+        if (firstTimestamp === Infinity)
+            return;
+        const targetStart = new Date('2000-01-01T00:00:00.000Z').getTime();
+        const offset = targetStart - firstTimestamp;
+        session.started = new Date(new Date(session.started).getTime() + offset).toISOString();
+        session.ended = new Date(new Date(session.ended).getTime() + offset).toISOString();
+        for (const event of session.events) {
+            event.timestamp = new Date(new Date(event.timestamp).getTime() + offset).toISOString();
+        }
+    }
+    static applyGeolocationMasking(session) {
+        for (const event of session.events) {
+            delete event.geo;
+            delete event.location_id;
+        }
+    }
+    static applyUrlStripping(session) {
+        for (const event of session.events) {
+            if (event.type === 'button') {
+                delete event.image_url;
+            }
+            if (event.type === 'note') {
+                delete event.author_url;
+                delete event.author_email;
+            }
+        }
+    }
+    static applyNameMasking(obl, session) {
+        delete obl.user_name;
+        for (const event of session.events) {
+            if (event.type === 'note') {
+                delete event.author_name;
+            }
+        }
+    }
+}
+exports.OblAnonymizer = OblAnonymizer;

package/dist/optional/analytics/metrics/vocabulary.js

@@ -22,12 +22,13 @@ class VocabularyAnalyzer {
         const lowEffortThreshold = options?.lowEffortThreshold || 2.0;
         // Load reference data
         const coreLists = this.referenceLoader.loadCoreLists();
-        // Create word to effort map
+        // Create word to effort map (using lowercase keys for matching)
         const wordEffortMap = new Map();
         metrics.buttons.forEach((btn) => {
-            const existing = wordEffortMap.get(btn.label);
+            const word = btn.label.toLowerCase();
+            const existing = wordEffortMap.get(word);
             if (!existing || btn.effort < existing) {
-                wordEffortMap.set(btn.label, btn.effort);
+                wordEffortMap.set(word, btn.effort);
             }
         });
         // Analyze each core list
@@ -79,7 +80,8 @@ class VocabularyAnalyzer {
         const missing = [];
         let totalEffort = 0;
         list.words.forEach((word) => {
-            const effort = wordEffortMap.get(word);
+            const lowerWord = word.toLowerCase();
+            const effort = wordEffortMap.get(lowerWord);
             if (effort !== undefined) {
                 covered.push(word);
                 totalEffort += effort;

package/dist/optional/symbolTools.js

@@ -7,7 +7,7 @@ exports.TouchChatSymbolResolver = exports.TouchChatSymbolExtractor = exports.Gri
 exports.resolveSymbol = resolveSymbol;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const password_1 = require("../processors/gridset/password");
+const symbols_1 = require("../processors/gridset/symbols");
 // --- Base Classes ---
 class SymbolExtractor {
 }
@@ -61,10 +61,13 @@ exports.SnapSymbolResolver = SnapSymbolResolver;
 let AdmZip = null;
 let XMLParser = null;
 try {
+    // Dynamic requires for optional dependencies
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    AdmZip = require('adm-zip');
+    const admZipModule = require('adm-zip');
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    XMLParser = require('fast-xml-parser').XMLParser;
+    const fxpModule = require('fast-xml-parser');
+    AdmZip = admZipModule;
+    XMLParser = fxpModule.XMLParser;
 }
 catch {
     AdmZip = null;
@@ -74,19 +77,13 @@ class Grid3SymbolExtractor extends SymbolExtractor {
     getSymbolReferences(filePath) {
         if (!AdmZip || !XMLParser)
             throw new Error('adm-zip or fast-xml-parser not installed');
-        const zip = new AdmZip(filePath);
-        const parser = new XMLParser();
-        const refs = new Set();
-        const entries = (0, password_1.getZipEntriesWithPassword)(zip, (0, password_1.resolveGridsetPasswordFromEnv)());
-        entries.forEach((entry) => {
-            if (entry.entryName.endsWith('.gridset') || entry.entryName.endsWith('.gridsetx')) {
-                const xmlBuffer = entry.getData();
-                // Parse to validate XML structure (future: extract refs)
-                parser.parse(xmlBuffer.toString('utf8'));
-                // TODO: Extract symbol references from Grid 3 XML structure when needed
-            }
-        });
-        return Array.from(refs);
+        // Import GridsetProcessor dynamically to avoid circular dependencies
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { GridsetProcessor } = require('../processors/gridsetProcessor');
+        const proc = new GridsetProcessor();
+        const tree = proc.loadIntoTree(filePath);
+        // Use the existing extractSymbolReferences function from gridset/symbols.ts
+        return (0, symbols_1.extractSymbolReferences)(tree);
     }
 }
 exports.Grid3SymbolExtractor = Grid3SymbolExtractor;

package/dist/processors/astericsGridProcessor.d.ts

@@ -1,5 +1,20 @@
 import { BaseProcessor, ProcessorOptions, ExtractStringsResult, TranslatedString, SourceString } from '../core/baseProcessor';
 import { AACTree } from '../core/treeStructure';
+export declare function normalizeHexColor(hexColor: string): string | null;
+export declare function adjustHexColor(hexColor: string, amount: number): string;
+export declare function getHighContrastNeutralColor(backgroundColor: string): string;
+/**
+ * Calculate relative luminance of a color using WCAG formula
+ * @param hexColor - Hex color string (e.g., "#1d90ff")
+ * @returns Relative luminance value between 0 and 1
+ */
+export declare function calculateLuminance(hexColor: string): number;
+/**
+ * Choose white or black text color based on background luminance for optimal contrast
+ * @param backgroundColor - Background color hex string
+ * @returns "#FFFFFF" for dark backgrounds, "#000000" for light backgrounds
+ */
+export declare function getContrastingTextColor(backgroundColor: string): string;
 declare class AstericsGridProcessor extends BaseProcessor {
     private loadAudio;
     constructor(options?: ProcessorOptions & {

package/dist/processors/astericsGridProcessor.js

@@ -4,6 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstericsGridProcessor = void 0;
+exports.normalizeHexColor = normalizeHexColor;
+exports.adjustHexColor = adjustHexColor;
+exports.getHighContrastNeutralColor = getHighContrastNeutralColor;
+exports.calculateLuminance = calculateLuminance;
+exports.getContrastingTextColor = getContrastingTextColor;
 const baseProcessor_1 = require("../core/baseProcessor");
 const treeStructure_1 = require("../core/treeStructure");
 const fs_1 = __importDefault(require("fs"));
@@ -535,6 +540,17 @@ function getContrastingTextColor(backgroundColor) {
     // WCAG threshold: use white text if luminance < 0.5, black otherwise
     return luminance < 0.5 ? '#FFFFFF' : '#000000';
 }
+/**
+ * Map Asterics Grid hidden value to AAC standard visibility
+ * Asterics Grid: true = hidden, false = visible
+ * Maps to: 'Hidden' | 'Visible' | undefined
+ */
+function mapAstericsVisibility(hidden) {
+    if (hidden === undefined) {
+        return undefined; // Default to visible
+    }
+    return hidden ? 'Hidden' : 'Visible';
+}
 class AstericsGridProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options = {}) {
         super(options);
@@ -979,6 +995,7 @@ class AstericsGridProcessor extends baseProcessor_1.BaseProcessor {
             targetPageId: targetPageId || undefined,
             semanticAction: semanticAction,
             audioRecording: audioRecording,
+            visibility: mapAstericsVisibility(element.hidden),
             image: imageName, // Store image filename/reference
             parameters: imageData
                 ? {

package/dist/processors/gridset/helpers.d.ts

@@ -1,4 +1,4 @@
-import { AACTree } from '../../core/treeStructure';
+import { AACTree, AACSemanticCategory, AACSemanticIntent } from '../../core/treeStructure';
 /**
  * Build a map of button IDs to resolved image entry paths for a specific page.
  * Helpful when rewriting zip entry names or validating images referenced in a grid.
@@ -66,6 +66,9 @@ export interface Grid3HistoryEntry {
         timestamp: Date;
         latitude?: number | null;
         longitude?: number | null;
+        type?: 'button' | 'action' | 'utterance' | 'note' | 'other';
+        intent?: AACSemanticIntent | string;
+        category?: AACSemanticCategory;
     }>;
     rawXml?: string;
 }

package/dist/processors/gridset/helpers.js

@@ -44,6 +44,7 @@ exports.readGrid3HistoryForUser = readGrid3HistoryForUser;
 exports.readAllGrid3History = readAllGrid3History;
 const adm_zip_1 = __importDefault(require("adm-zip"));
 const fast_xml_parser_1 = require("fast-xml-parser");
+const treeStructure_1 = require("../../core/treeStructure");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
@@ -394,6 +395,9 @@ function readGrid3History(historyDbPath) {
             timestamp: (0, dotnetTicks_1.dotNetTicksToDate)(BigInt(row.TickValue ?? 0)),
             latitude: row.Latitude ?? null,
             longitude: row.Longitude ?? null,
+            type: 'utterance',
+            intent: treeStructure_1.AACSemanticIntent.SPEAK_TEXT,
+            category: treeStructure_1.AACSemanticCategory.COMMUNICATION,
         });
         events.set(phraseId, entry);
     }

package/dist/processors/gridset/pluginTypes.js

@@ -106,10 +106,10 @@ function detectPluginCellType(content) {
     if (!content) {
         return { cellType: Grid3CellType.Regular };
     }
-    const contentType = content.ContentType || content.contenttype || content.ContentType;
-    const contentSubType = content.ContentSubType || content.contentsubtype || content.ContentSubType;
+    const contentType = content.ContentType || content.contenttype;
+    const contentSubType = content.ContentSubType || content.contentsubtype;
     // Workspace cells - full editing workspaces
-    if (contentType === 'Workspace') {
+    if (contentType === 'Workspace' || content.Style?.BasedOnStyle === 'Workspace') {
         return {
             cellType: Grid3CellType.Workspace,
             subType: contentSubType || undefined,
@@ -118,7 +118,7 @@ function detectPluginCellType(content) {
         };
     }
     // LiveCell detection - dynamic content displays
-    if (contentType === 'LiveCell') {
+    if (contentType === 'LiveCell' || content.Style?.BasedOnStyle === 'LiveCell') {
         return {
             cellType: Grid3CellType.LiveCell,
             liveCellType: contentSubType || undefined,
@@ -127,7 +127,7 @@ function detectPluginCellType(content) {
         };
     }
     // AutoContent detection - dynamic word/content suggestions
-    if (contentType === 'AutoContent') {
+    if (contentType === 'AutoContent' || content.Style?.BasedOnStyle === 'AutoContent') {
         const autoContentType = extractAutoContentType(content);
         return {
             cellType: Grid3CellType.AutoContent,
@@ -172,38 +172,38 @@ function inferWorkspacePlugin(subType) {
         return undefined;
     const normalized = subType.toLowerCase();
     if (normalized.includes('chat'))
-        return 'chat';
+        return 'Grid3.Chat';
     if (normalized.includes('email') || normalized.includes('mail'))
-        return 'email';
-    if (normalized.includes('word') || normalized.includes('processor'))
-        return 'wordprocessor';
+        return 'Grid3.Email';
+    if (normalized.includes('word') || normalized.includes('doc'))
+        return 'Grid3.WordProcessor';
     if (normalized.includes('phone'))
-        return 'phone';
+        return 'Grid3.Phone';
     if (normalized.includes('sms') || normalized.includes('text'))
-        return 'sms';
-    if (normalized.includes('web') || normalized.includes('browser'))
-        return 'webbrowser';
-    if (normalized.includes('computer') || normalized.includes('control'))
-        return 'computercontrol';
-    if (normalized.includes('calculator') || normalized.includes('calc'))
-        return 'calculator';
-    if (normalized.includes('timer') || normalized.includes('stopwatch'))
-        return 'timer';
+        return 'Grid3.Sms';
+    if (normalized.includes('browser') || normalized.includes('web'))
+        return 'Grid3.WebBrowser';
+    if (normalized.includes('computer'))
+        return 'Grid3.ComputerControl';
+    if (normalized.includes('calc'))
+        return 'Grid3.Calculator';
+    if (normalized.includes('timer'))
+        return 'Grid3.Timer';
     if (normalized.includes('music') || normalized.includes('video'))
-        return 'musicvideo';
+        return 'Grid3.MusicVideo';
     if (normalized.includes('photo') || normalized.includes('image'))
-        return 'photos';
+        return 'Grid3.Photos';
     if (normalized.includes('contact'))
-        return 'contacts';
+        return 'Grid3.Contacts';
     if (normalized.includes('learning'))
-        return 'interactivelearning';
-    if (normalized.includes('message') && normalized.includes('bank'))
-        return 'messagebanking';
-    if (normalized.includes('env') || normalized.includes('ir'))
-        return 'environmentcontrol';
-    if (normalized.includes('setting'))
-        return 'settings';
-    return undefined;
+        return 'Grid3.InteractiveLearning';
+    if (normalized.includes('message') && normalized.includes('banking'))
+        return 'Grid3.MessageBanking';
+    if (normalized.includes('control'))
+        return 'Grid3.EnvironmentControl';
+    if (normalized.includes('settings'))
+        return 'Grid3.Settings';
+    return `Grid3.${subType}`;
 }
 /**
  * Infer plugin ID from live cell type
@@ -212,24 +212,25 @@ function inferLiveCellPlugin(liveCellType) {
     if (!liveCellType)
         return undefined;
     const normalized = liveCellType.toLowerCase();
-    if (normalized.includes('clock') || normalized.includes('time') || normalized.includes('date')) {
-        return 'clock';
-    }
+    if (normalized.includes('clock'))
+        return 'Grid3.Clock';
+    if (normalized.includes('date'))
+        return 'Grid3.Clock';
     if (normalized.includes('volume'))
-        return 'speech';
+        return 'Grid3.Volume';
     if (normalized.includes('speed'))
-        return 'speech';
+        return 'Grid3.Speed';
     if (normalized.includes('voice'))
-        return 'speech';
+        return 'Grid3.Speech';
     if (normalized.includes('message'))
-        return 'chat';
+        return 'Grid3.Chat';
     if (normalized.includes('battery'))
-        return 'settings';
-    if (normalized.includes('wifi') || normalized.includes('network'))
-        return 'settings';
+        return 'Grid3.Battery';
+    if (normalized.includes('wifi'))
+        return 'Grid3.Wifi';
     if (normalized.includes('bluetooth'))
-        return 'settings';
-    return undefined;
+        return 'Grid3.Bluetooth';
+    return `Grid3.${liveCellType}`;
 }
 /**
  * Infer plugin ID from auto content type
@@ -239,24 +240,24 @@ function inferAutoContentPlugin(autoContentType) {
         return undefined;
     const normalized = autoContentType.toLowerCase();
     if (normalized.includes('voice') || normalized.includes('speed'))
-        return 'speech';
+        return 'Grid3.Speech';
     if (normalized.includes('email') || normalized.includes('mail'))
-        return 'email';
+        return 'Grid3.Email';
     if (normalized.includes('phone'))
-        return 'phone';
+        return 'Grid3.Phone';
     if (normalized.includes('sms') || normalized.includes('text'))
-        return 'sms';
+        return 'Grid3.Sms';
     if (normalized.includes('web') ||
         normalized.includes('favorite') ||
         normalized.includes('history')) {
-        return 'webbrowser';
+        return 'Grid3.WebBrowser';
     }
     if (normalized.includes('prediction'))
-        return 'prediction';
+        return 'Grid3.Prediction';
     if (normalized.includes('grammar'))
-        return 'grammar';
+        return 'Grid3.Grammar';
     if (normalized.includes('context'))
-        return 'autocontent';
+        return 'Grid3.AutoContent';
     return undefined;
 }
 /**

package/dist/processors/gridset/symbolExtractor.js

@@ -154,10 +154,11 @@ function extractSymbolLibraryImage(reference, options = {}) {
         };
     }
     // Successfully extracted!
-    const format = detectImageFormat(resolved.data);
+    const data = resolved.data;
+    const format = data ? detectImageFormat(data) : 'unknown';
     return {
         found: true,
-        data: resolved.data,
+        data,
         format,
         source: 'symbol-library',
         reference: reference,

package/dist/processors/gridset/symbolSearch.js

@@ -126,13 +126,15 @@ function searchSymbols(searchTerm, options = {}) {
         // Exact match first
         if (index.searchTerms.has(lowerSearchTerm)) {
             const symbolFilename = index.searchTerms.get(lowerSearchTerm);
-            results.push({
-                searchTerm: lowerSearchTerm,
-                symbolFilename,
-                displayName: index.filenames.get(symbolFilename) || lowerSearchTerm,
-                library: libraryName,
-                exactMatch: true,
-            });
+            if (symbolFilename) {
+                results.push({
+                    searchTerm: lowerSearchTerm,
+                    symbolFilename,
+                    displayName: index.filenames.get(symbolFilename) || lowerSearchTerm,
+                    library: libraryName,
+                    exactMatch: true,
+                });
+            }
         }
         // Fuzzy match if enabled
         if (options.fuzzyMatch !== false) {