@willwade/aac-processors 0.2.17 → 0.2.18

package/dist/browser/processors/snapProcessor.js

@@ -333,6 +333,9 @@ class SnapProcessor extends BaseProcessor {
                         buttonColumns.has('BackgroundColor') ? 'b.BackgroundColor' : 'NULL AS BackgroundColor',
                         buttonColumns.has('NavigatePageId') ? 'b.NavigatePageId' : 'NULL AS NavigatePageId',
                         buttonColumns.has('ContentType') ? 'b.ContentType' : 'NULL AS ContentType',
+                        buttonColumns.has('SerializedContentTypeHandler')
+                            ? 'b.SerializedContentTypeHandler'
+                            : 'NULL AS SerializedContentTypeHandler',
                     ];
                     if (this.loadAudio) {
                         selectFields.push(buttonColumns.has('MessageRecordingId')
@@ -548,22 +551,54 @@ class SnapProcessor extends BaseProcessor {
                             },
                         };
                     }
+                    let snapContentType;
+                    let snapContentSubType;
+                    let snapGrammarPos;
+                    let snapGrammarHandler;
+                    if (btnRow.ContentType === 1) {
+                        snapContentType = 'AutoContent';
+                        snapContentSubType = 'Prediction';
+                    }
+                    else if (btnRow.ContentType === 3 && btnRow.SerializedContentTypeHandler) {
+                        snapContentType = 'Inflector';
+                        snapGrammarHandler = String(btnRow.SerializedContentTypeHandler);
+                        const colonIdx = snapGrammarHandler.indexOf(':');
+                        if (colonIdx !== -1) {
+                            const subtype = snapGrammarHandler.substring(colonIdx + 1).split(',')[0];
+                            snapContentSubType = subtype;
+                            const { TDSnapLexiconParser, } = require('../utilities/analytics/morphology/tdsnapLexiconParser');
+                            snapGrammarPos = TDSnapLexiconParser.tagToPos(subtype);
+                        }
+                    }
                     const button = new AACButton({
                         id: String(btnRow.Id),
                         label: btnRow.Label || (btnRow.ContentType === 1 ? '[Prediction]' : ''),
                         message: btnRow.Message || (btnRow.ContentType === 1 ? '[Prediction]' : btnRow.Label || ''),
                         targetPageId: targetPageUniqueId,
                         semanticAction: semanticAction,
-                        contentType: btnRow.ContentType === 1 ? 'AutoContent' : undefined,
-                        contentSubType: btnRow.ContentType === 1 ? 'Prediction' : undefined,
+                        contentType: snapContentType,
+                        contentSubType: snapContentSubType,
                         audioRecording: audioRecording,
                         visibility: mapSnapVisibility(btnRow.Visible),
                         semantic_id: btnRow.LibrarySymbolId
                             ? `snap_symbol_${btnRow.LibrarySymbolId}`
-                            : undefined, // Extract semantic_id from LibrarySymbolId
+                            : undefined,
                         image: buttonImage,
                         resolvedImageEntry: buttonImage,
-                        parameters: Object.keys(buttonParameters).length > 0 ? buttonParameters : undefined,
+                        parameters: {
+                            ...(Object.keys(buttonParameters).length > 0 ? buttonParameters : {}),
+                            ...(snapGrammarHandler
+                                ? {
+                                    grammar: {
+                                        handler: snapGrammarHandler,
+                                        category: snapGrammarHandler.substring(0, snapGrammarHandler.indexOf(':') !== -1
+                                            ? snapGrammarHandler.indexOf(':')
+                                            : snapGrammarHandler.length),
+                                        subtype: snapContentSubType,
+                                    },
+                                }
+                                : {}),
+                        },
                         style: {
                             backgroundColor: btnRow.BackgroundColor
                                 ? `#${btnRow.BackgroundColor.toString(16)}`
@@ -576,6 +611,9 @@ class SnapProcessor extends BaseProcessor {
                             fontStyle: btnRow.FontStyle?.toString(),
                         },
                     });
+                    if (snapGrammarPos) {
+                        button.pos = snapGrammarPos;
+                    }
                     // Add to the intended parent page
                     const parentPage = tree.getPage(parentUniqueId);
                     if (parentPage) {

package/dist/browser/utilities/analytics/metrics/core.js

@@ -585,12 +585,20 @@ export class MetricsCalculator {
     /**
      * Quick check whether any button in the tree has a POS tag.
      * Used to auto-enable smart grammar without requiring explicit opt-in.
+     *
+     * IMPORTANT: Only counts POS from non-Inflector and non-Suffix buttons.
+     * TDSnap Inflector buttons and Grid3 Suffix buttons are grammar controls,
+     * not content words — they should NOT auto-enable morphology.
      */
     treeHasPosTags(tree) {
         for (const page of Object.values(tree.pages)) {
             for (const row of page.grid) {
                 for (const btn of row) {
-                    if (btn?.pos && btn.pos !== 'Unknown' && btn.pos !== 'Ignore') {
+                    if (btn?.pos &&
+                        btn.pos !== 'Unknown' &&
+                        btn.pos !== 'Ignore' &&
+                        btn.pos !== 'Suffix' &&
+                        btn.contentType !== 'Inflector') {
                         return true;
                     }
                 }
@@ -608,8 +616,44 @@ export class MetricsCalculator {
      */
     expandMorphologicalPredictions(tree, options) {
         const locale = options.morphologyLocale || 'en-gb';
-        const morph = new MorphologyEngine(locale);
-        // Words that should never be POS-inferred (function words, determiners, etc.)
+        let morph;
+        if (options.tdsnapLexiconPath) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { TDSnapLexiconParser } = require('../morphology/tdsnapLexiconParser');
+            const parser = new TDSnapLexiconParser();
+            const lexiconData = parser.parseDb(options.tdsnapLexiconPath, locale.replace('-', '_'));
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            morph = MorphologyEngine.fromTDSnapLexicon(lexiconData);
+            this.expandTDSnapPredictions(tree, morph);
+            return;
+        }
+        if (options.grid3VerbsPath) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { Grid3VerbsParser } = require('../morphology/grid3VerbsParser');
+            const parser = new Grid3VerbsParser();
+            const verbForms = parser.parseZip(options.grid3VerbsPath);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            morph = MorphologyEngine.fromGrid3Verbs(verbForms);
+            this.expandGrid3Predictions(tree, morph);
+            return;
+        }
+        morph = new MorphologyEngine(locale);
+        this.expandGrid3Predictions(tree, morph);
+    }
+    /**
+     * Expand morphological predictions for Grid3 pagesets.
+     *
+     * Grid3 uses suffix buttons (pos='Suffix') on the same page as content words.
+     * Different pages have different suffix buttons — e.g., topic pages may only
+     * have -s (plural), while the Magic Wand page has -s, -er, -est, -ly, -y, -'s.
+     *
+     * Rules:
+     * 1. Build a suffix→formSlot map (-s → plural, -er → comparative, etc.)
+     * 2. For each page, collect available suffix buttons
+     * 3. Only generate forms for slots that have matching suffix buttons on that page
+     * 4. POS inference is used for untagged content words (Grid3 grids often lack POS)
+     */
+    expandGrid3Predictions(tree, morph) {
         const skipInference = new Set([
             'a',
             'an',
@@ -692,30 +736,56 @@ export class MetricsCalculator {
             'wow',
             'sorry',
         ]);
+        // Map suffix button labels to the morphology slots they produce
+        const SUFFIX_TO_SLOT = {
+            '-s': ['plural'],
+            "-'s": ['possessive'],
+            '-er': ['comparative'],
+            '-est': ['superlative'],
+            '-ly': ['adverb'],
+            '-y': ['adjective'],
+        };
+        // POS → slots that POS can produce (for filtering)
+        const POS_TO_SUFFIX_SLOTS = {
+            Noun: new Set(['plural', 'possessive']),
+            Verb: new Set(['plural']),
+            Adjective: new Set(['comparative', 'superlative', 'adverb', 'adjective']),
+        };
         for (const page of Object.values(tree.pages)) {
+            // Collect suffix buttons on this page
+            const pageSuffixes = new Set();
+            const pageSuffixSlots = new Set();
+            for (const row of page.grid) {
+                for (const btn of row) {
+                    if (btn?.pos === 'Suffix' && btn.label) {
+                        pageSuffixes.add(btn.label);
+                        const slots = SUFFIX_TO_SLOT[btn.label];
+                        if (slots) {
+                            for (const s of slots)
+                                pageSuffixSlots.add(s);
+                        }
+                    }
+                }
+            }
+            // No suffix buttons on this page → no morphology
+            if (pageSuffixSlots.size === 0)
+                continue;
             for (const row of page.grid) {
                 for (const btn of row) {
                     if (!btn || !btn.label)
                         continue;
+                    if (btn.pos === 'Suffix')
+                        continue;
                     let pos = btn.pos;
-                    // If no POS tag (or Unknown/Ignore), attempt POS inference.
-                    // Many content words on topic pages lack POS tags even though
-                    // they are clearly nouns (e.g., "bird", "tree", "cloud").
-                    // Strategy: check irregular tables first for confident POS,
-                    // then fall back to Noun for single-word content labels.
                     if (!pos || pos === 'Unknown' || pos === 'Ignore') {
                         const lower = btn.label.toLowerCase();
-                        // Skip function words and multi-word labels
                         if (!skipInference.has(lower) && !lower.includes(' ') && lower.length > 1) {
-                            // Check irregular tables for confident POS assignment
                             const inferredPOS = morph.inferPOS(lower);
                             if (inferredPOS) {
                                 pos = inferredPOS;
                                 btn.pos = inferredPOS;
                             }
                             else {
-                                // Default to Noun for untagged content words.
-                                // This generates plurals (e.g., bird → birds, tree → trees).
                                 pos = 'Noun';
                                 btn.pos = 'Noun';
                             }
@@ -723,16 +793,90 @@ export class MetricsCalculator {
                     }
                     if (!pos || pos === 'Unknown' || pos === 'Ignore')
                         continue;
-                    const forms = morph.inflect(btn.label, pos);
-                    if (forms.length > 0) {
+                    // Check if this POS can produce forms matching the page's suffix slots
+                    const posSlots = POS_TO_SUFFIX_SLOTS[pos];
+                    if (!posSlots)
+                        continue;
+                    const hasRelevantSlot = [...posSlots].some((s) => pageSuffixSlots.has(s));
+                    if (!hasRelevantSlot)
+                        continue;
+                    const allForms = morph.inflect(btn.label, pos);
+                    if (allForms.length === 0)
+                        continue;
+                    // Filter forms: only include those producible by suffixes on this page
+                    // For the built-in engine, we can't easily map forms to slots, so
+                    // include all forms when any relevant suffix exists. The per-page
+                    // gate (suffix presence) is the main filter.
+                    const existing = btn.predictions || [];
+                    const merged = new Set([...existing, ...allForms]);
+                    btn.predictions = Array.from(merged);
+                }
+            }
+        }
+    }
+    /**
+     * Expand morphological predictions for TDSnap pagesets.
+     *
+     * TDSnap uses Inflector buttons (ContentType=3) on "Word Forms" pages to
+     * provide morphology. These pages are loaded dynamically by the runtime,
+     * NOT via navigation buttons, so they are unreachable in our tree model.
+     *
+     * Rules:
+     * 1. If the pageset has NO Inflector buttons → no morphology at all
+     * 2. Only generate forms whose grammar tag matches an available Inflector
+     *    (e.g., if there's no -ly Inflector, don't generate "happily")
+     * 3. No POS inference — only the lexicon determines which words get forms
+     */
+    expandTDSnapPredictions(tree, morph) {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { TDSnapLexiconParser } = require('../morphology/tdsnapLexiconParser');
+        // Step 1: Collect available grammar tags from Inflector buttons
+        const availableTags = new Set();
+        for (const page of Object.values(tree.pages)) {
+            for (const row of page.grid) {
+                for (const btn of row) {
+                    if (btn?.contentType === 'Inflector' && btn.parameters?.grammar?.handler) {
+                        const parsed = TDSnapLexiconParser.parseContentTypeHandler(btn.parameters.grammar.handler);
+                        if (parsed) {
+                            const key = `${parsed.category}:${parsed.subtype}`;
+                            const tag = TDSnapLexiconParser.HANDLER_TAG_MAP[key];
+                            if (tag)
+                                availableTags.add(tag);
+                        }
+                    }
+                }
+            }
+        }
+        if (availableTags.size === 0)
+            return;
+        // Step 2: For each button, look up lexicon forms filtered by available tags
+        for (const page of Object.values(tree.pages)) {
+            for (const row of page.grid) {
+                for (const btn of row) {
+                    if (!btn || !btn.label || btn.contentType === 'Inflector')
+                        continue;
+                    const filtered = this.filterFormsByAvailableTags(morph, btn.label, availableTags);
+                    if (filtered.length > 0) {
                         const existing = btn.predictions || [];
-                        const merged = new Set([...existing, ...forms]);
+                        const merged = new Set([...existing, ...filtered]);
                         btn.predictions = Array.from(merged);
                     }
                 }
             }
         }
     }
+    filterFormsByAvailableTags(morph, base, availableTags) {
+        const entry = morph.getLexiconEntry(base.toLowerCase());
+        if (!entry)
+            return [];
+        const forms = [];
+        for (const f of entry.forms) {
+            if (availableTags.has(f.tag) && f.form.toLowerCase() !== base.toLowerCase()) {
+                forms.push(f.form);
+            }
+        }
+        return forms;
+    }
     /**
      * Calculate metrics for word forms (smart grammar predictions)
      *
@@ -749,7 +893,7 @@ export class MetricsCalculator {
      * @param options - Metrics options
      * @returns Object containing word form metrics and labels that were replaced
      */
-    calculateWordFormMetrics(tree, buttons, _options = {}) {
+    calculateWordFormMetrics(tree, buttons, options = {}) {
         const wordFormMetrics = [];
         const replacedLabels = new Set();
         // Track buttons by label to compare efforts
@@ -811,23 +955,28 @@ export class MetricsCalculator {
                     // Calculate effort for each word form
                     btn.predictions.forEach((wordForm, index) => {
                         const wordFormLower = wordForm.toLowerCase();
-                        // Calculate effort based on position in predictions array
-                        // Assume predictions are displayed in a grid layout (e.g., 2 columns)
-                        const predictionsGridCols = 2; // Typical predictions layout
-                        const predictionRowIndex = Math.floor(index / predictionsGridCols);
-                        const predictionColIndex = index % predictionsGridCols;
-                        // Calculate visual scan effort to reach this word form position
-                        // Using similar logic to button scanning effort
-                        const predictionPriorItems = predictionRowIndex * predictionsGridCols + predictionColIndex;
-                        const predictionSelectionEffort = visualScanEffort(predictionPriorItems);
-                        // Add confirmation cost for Suggest Words outcomes only.
-                        // Suggest Words requires an explicit tap on the prediction bar,
-                        // while smart grammar morphology forms are auto-generated (no extra tap).
-                        const suggestWordsConfirmation = suggestWordsSet.has(wordFormLower)
-                            ? EFFORT_CONSTANTS.SUGGEST_WORDS_SELECTION_EFFORT
-                            : 0;
-                        // Word form effort = parent button's cumulative effort + selection effort + confirmation
-                        const wordFormEffort = parentMetrics.effort + predictionSelectionEffort + suggestWordsConfirmation;
+                        const isSuggestWords = suggestWordsSet.has(wordFormLower);
+                        let wordFormEffort;
+                        if (options.tdsnapLexiconPath && !isSuggestWords) {
+                            // TDSnap Inflector-based form: the grammar overlay appears
+                            // dynamically when a word is selected. The cost is a fixed
+                            // single selection to tap the Inflector button.
+                            wordFormEffort =
+                                parentMetrics.effort + EFFORT_CONSTANTS.TDSNAP_GRAMMAR_OVERLAY_EFFORT;
+                        }
+                        else {
+                            // Grid-based prediction layout (Suggest Words, or Grid3 morphology)
+                            const predictionsGridCols = 2;
+                            const predictionRowIndex = Math.floor(index / predictionsGridCols);
+                            const predictionColIndex = index % predictionsGridCols;
+                            const predictionPriorItems = predictionRowIndex * predictionsGridCols + predictionColIndex;
+                            const predictionSelectionEffort = visualScanEffort(predictionPriorItems);
+                            const suggestWordsConfirmation = isSuggestWords
+                                ? EFFORT_CONSTANTS.SUGGEST_WORDS_SELECTION_EFFORT
+                                : 0;
+                            wordFormEffort =
+                                parentMetrics.effort + predictionSelectionEffort + suggestWordsConfirmation;
+                        }
                         // Check if this word already exists as a regular button
                         const existingBtn = existingLabels.get(wordFormLower);
                         // If word exists and has lower or equal effort, skip the word form

package/dist/browser/utilities/analytics/metrics/effort.js

@@ -32,6 +32,7 @@ export const EFFORT_CONSTANTS = {
     DEFAULT_SCAN_ERROR_RATE: 0.1, // 10% chance of missing a selection
     SCAN_RETRY_PENALTY: 1.0, // Cost multiplier for a full loop retry
     SUGGEST_WORDS_SELECTION_EFFORT: 0.5, // Extra tap to confirm a Suggest Words prediction
+    TDSNAP_GRAMMAR_OVERLAY_EFFORT: 0.1, // Fixed cost: select an Inflector button from the dynamic grammar overlay
 };
 /**
  * Calculate button size effort based on grid dimensions

package/dist/browser/utilities/analytics/morphology/engine.js

@@ -1,4 +1,7 @@
 export class MorphologyEngine {
+    getLexiconEntry(word) {
+        return this.tdsnapLexicon?.words.get(word.toLowerCase());
+    }
     constructor(ruleSetOrLocale) {
         this.cache = new Map();
         if (typeof ruleSetOrLocale === 'string') {
@@ -18,6 +21,16 @@ export class MorphologyEngine {
         engine.grid3Verbs = verbForms.verbs;
         return engine;
     }
+    static fromTDSnapLexicon(lexiconData) {
+        const engine = new MorphologyEngine({
+            locale: lexiconData.locale,
+            version: 1,
+            irregular: {},
+            regular: {},
+        });
+        engine.tdsnapLexicon = lexiconData;
+        return engine;
+    }
     get locale() {
         return this.ruleSet.locale;
     }
@@ -26,9 +39,18 @@ export class MorphologyEngine {
         const cached = this.cache.get(key);
         if (cached)
             return cached;
+        if (this.tdsnapLexicon) {
+            const entry = this.tdsnapLexicon.words.get(base.toLowerCase());
+            if (entry) {
+                const forms = entry.forms.map((f) => f.form);
+                this.cache.set(key, forms);
+                return forms;
+            }
+        }
         if (this.grid3Verbs) {
-            const forms = this.grid3Verbs.get(base) || this.grid3Verbs.get(base.toLowerCase());
-            if (forms) {
+            const raw = this.grid3Verbs.get(base) || this.grid3Verbs.get(base.toLowerCase());
+            if (raw) {
+                const forms = raw.filter((f) => !f.includes('{'));
                 this.cache.set(key, forms);
                 return forms;
             }

package/dist/browser/utilities/analytics/morphology/index.js

@@ -1,2 +1,3 @@
 export { MorphologyEngine } from './engine';
 export { WordFormGenerator } from './wordFormGenerator';
+export { TDSnapLexiconParser } from './tdsnapLexiconParser';

package/dist/browser/utilities/analytics/morphology/tdsnapLexiconParser.js

@@ -0,0 +1,182 @@
+export class TDSnapLexiconParser {
+    parseDb(dbPath, locale) {
+        const detectedLocale = locale || this.inferLocale(dbPath);
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const Database = require('better-sqlite3');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const db = new Database(dbPath, { readonly: true });
+        try {
+            return this.extractAll(db, detectedLocale);
+        }
+        finally {
+            db.close();
+        }
+    }
+    inferLocale(dbPath) {
+        const match = dbPath.match(/lang_([a-z]{2}_[A-Z]{2})/i);
+        return match ? match[1] : 'unknown';
+    }
+    extractAll(db, locale) {
+        const words = new Map();
+        const subclassCache = new Map();
+        const getSubclass = (id) => {
+            let name = subclassCache.get(id);
+            if (name !== undefined)
+                return name;
+            const row = db.prepare('SELECT Name FROM PosSubclass WHERE Id = ?').get(id);
+            name = row?.Name;
+            if (name) {
+                subclassCache.set(id, name);
+                return name;
+            }
+            return undefined;
+        };
+        const allWords = db
+            .prepare(`SELECT w.Id as wordId, w.Text as text,
+                i.Id as inflectionId, i.LexemeId as lexemeId, i.PosSubclassId as posSubclassId
+         FROM Word w
+         JOIN Spelling s ON s.WordId = w.Id
+         JOIN Inflection i ON i.Id = s.InflectionId
+         WHERE i.PosSubclassId != 0
+         ORDER BY w.Text`)
+            .all();
+        const lexemeForms = new Map();
+        for (const row of allWords) {
+            const tag = getSubclass(row.posSubclassId);
+            if (!tag)
+                continue;
+            let formsByTag = lexemeForms.get(row.lexemeId);
+            if (!formsByTag) {
+                formsByTag = new Map();
+                lexemeForms.set(row.lexemeId, formsByTag);
+            }
+            const existing = formsByTag.get(tag);
+            if (existing) {
+                if (!existing.includes(row.text))
+                    existing.push(row.text);
+            }
+            else {
+                formsByTag.set(tag, [row.text]);
+            }
+        }
+        const wordToLexeme = new Map();
+        for (const row of allWords) {
+            if (!wordToLexeme.has(row.text.toLowerCase())) {
+                wordToLexeme.set(row.text.toLowerCase(), row.lexemeId);
+            }
+        }
+        for (const [text, lexemeId] of wordToLexeme) {
+            const formsByTag = lexemeForms.get(lexemeId);
+            if (!formsByTag || formsByTag.size === 0)
+                continue;
+            const forms = [];
+            for (const [tag, formTexts] of formsByTag) {
+                for (const formText of formTexts) {
+                    if (formText.toLowerCase() !== text) {
+                        forms.push({ tag, form: formText });
+                    }
+                }
+            }
+            if (forms.length > 0) {
+                words.set(text, { lexemeId, forms });
+            }
+        }
+        return { locale, words };
+    }
+    lookupWord(data, word) {
+        const entry = data.words.get(word.toLowerCase());
+        if (!entry)
+            return [];
+        return entry.forms.map((f) => f.form);
+    }
+    lookupWordByTag(data, word, tag) {
+        const entry = data.words.get(word.toLowerCase());
+        if (!entry)
+            return [];
+        return entry.forms.filter((f) => f.tag === tag).map((f) => f.form);
+    }
+    static parseContentTypeHandler(handler) {
+        if (!handler)
+            return null;
+        const colonIdx = handler.indexOf(':');
+        if (colonIdx === -1) {
+            const parts = handler.split(',');
+            return { category: parts[0], subtype: '', params: parts.slice(1) };
+        }
+        const category = handler.substring(0, colonIdx);
+        const rest = handler.substring(colonIdx + 1);
+        const commaIdx = rest.indexOf(',');
+        if (commaIdx === -1) {
+            return { category, subtype: rest, params: [] };
+        }
+        const subtype = rest.substring(0, commaIdx);
+        const paramsStr = rest.substring(commaIdx + 1);
+        const params = paramsStr.split(',').map((p) => p.trim());
+        return { category, subtype, params };
+    }
+    static tagToPos(tag) {
+        return TDSnapLexiconParser.TAG_TO_POS[tag] || 'Unknown';
+    }
+    static handlerToPos(handler) {
+        const parsed = TDSnapLexiconParser.parseContentTypeHandler(handler);
+        if (!parsed)
+            return 'Unknown';
+        if (parsed.category === 'RESET' || parsed.category === 'SPECIAL')
+            return 'Ignore';
+        const key = `${parsed.category}:${parsed.subtype}`;
+        const tag = TDSnapLexiconParser.HANDLER_TAG_MAP[key];
+        if (tag)
+            return TDSnapLexiconParser.TAG_TO_POS[tag] || 'Unknown';
+        return TDSnapLexiconParser.TAG_TO_POS[parsed.subtype] || 'Unknown';
+    }
+}
+TDSnapLexiconParser.TAG_TO_POS = {
+    V0: 'Verb',
+    VZ: 'Verb',
+    VG: 'Verb',
+    VD: 'Verb',
+    VN: 'Verb',
+    SNG: 'Noun',
+    PLU: 'Noun',
+    ADJ: 'Adjective',
+    ADJR: 'Adjective',
+    ADJT: 'Adjective',
+    ADV: 'Adjective',
+    SUB: 'Pronoun',
+    OBJ: 'Pronoun',
+    POS: 'Pronoun',
+    NPOS: 'Pronoun',
+    REF: 'Pronoun',
+    B0: 'Verb',
+    BZ: 'Verb',
+    BM: 'Verb',
+    BR: 'Verb',
+    BDZ: 'Verb',
+    BDR: 'Verb',
+    BG: 'Verb',
+    BN: 'Verb',
+};
+TDSnapLexiconParser.HANDLER_TAG_MAP = {
+    'NOUN:PLU': 'PLU',
+    'DESCRIBE:ADJR': 'ADJR',
+    'DESCRIBE:ADJT': 'ADJT',
+    'DESCRIBE:ADV': 'ADV',
+    'VERB:V0': 'V0',
+    'VERB:VZ': 'VZ',
+    'VERB:VG': 'VG',
+    'VERB:VD': 'VD',
+    'VERB:VN': 'VN',
+    'PRONOUN:SUB': 'SUB',
+    'PRONOUN:OBJ': 'OBJ',
+    'PRONOUN:POS': 'POS',
+    'PRONOUN:NPOS': 'NPOS',
+    'PRONOUN:REF': 'REF',
+    'BE:B0': 'B0',
+    'BE:BZ': 'BZ',
+    'BE:BM': 'BM',
+    'BE:BR': 'BR',
+    'BE:BDZ': 'BDZ',
+    'BE:BDR': 'BDR',
+    'BE:BG': 'BG',
+    'BE:BN': 'BN',
+};

package/dist/core/treeStructure.d.ts

@@ -121,7 +121,7 @@ export declare class AACButton {
         identifier?: string;
         metadata?: string;
     };
-    contentType?: 'Normal' | 'AutoContent' | 'Workspace' | 'LiveCell';
+    contentType?: 'Normal' | 'AutoContent' | 'Workspace' | 'LiveCell' | 'Inflector' | 'Prediction';
     contentSubType?: string;
     image?: string;
     resolvedImageEntry?: string;
@@ -169,7 +169,7 @@ export declare class AACButton {
             metadata?: string;
         };
         style?: AACStyle;
-        contentType?: 'Normal' | 'AutoContent' | 'Workspace' | 'LiveCell';
+        contentType?: 'Normal' | 'AutoContent' | 'Workspace' | 'LiveCell' | 'Inflector' | 'Prediction';
         contentSubType?: string;
         image?: string;
         resolvedImageEntry?: string;

package/dist/index.node.d.ts

@@ -13,6 +13,7 @@ export * as Analytics from './analytics';
 export * as Validation from './validation';
 export * as Metrics from './metrics';
 export { Grid3VerbsParser } from './utilities/analytics/morphology/grid3VerbsParser';
+export { TDSnapLexiconParser } from './utilities/analytics/morphology/tdsnapLexiconParser';
 export { WordFormGenerator } from './utilities/analytics/morphology/wordFormGenerator';
 export * as Gridset from './gridset';
 export * as Snap from './snap';

package/dist/index.node.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Translation = exports.AstericsGrid = exports.ApplePanels = exports.Opml = exports.Excel = exports.Dot = exports.TouchChat = exports.Obfset = exports.OBF = exports.Snap = exports.Gridset = exports.WordFormGenerator = exports.Grid3VerbsParser = exports.Metrics = exports.Validation = exports.Analytics = void 0;
+exports.Translation = exports.AstericsGrid = exports.ApplePanels = exports.Opml = exports.Excel = exports.Dot = exports.TouchChat = exports.Obfset = exports.OBF = exports.Snap = exports.Gridset = exports.WordFormGenerator = exports.TDSnapLexiconParser = exports.Grid3VerbsParser = exports.Metrics = exports.Validation = exports.Analytics = void 0;
 exports.getProcessor = getProcessor;
 exports.getSupportedExtensions = getSupportedExtensions;
 exports.isExtensionSupported = isExtensionSupported;
@@ -56,9 +56,11 @@ exports.Analytics = __importStar(require("./analytics"));
 exports.Validation = __importStar(require("./validation"));
 // Metrics namespace (pageset analytics)
 exports.Metrics = __importStar(require("./metrics"));
-// Node-only morphology utilities (Grid 3 verbs parser)
+// Node-only morphology utilities (Grid 3 verbs parser, TDSnap lexicon parser)
 var grid3VerbsParser_1 = require("./utilities/analytics/morphology/grid3VerbsParser");
 Object.defineProperty(exports, "Grid3VerbsParser", { enumerable: true, get: function () { return grid3VerbsParser_1.Grid3VerbsParser; } });
+var tdsnapLexiconParser_1 = require("./utilities/analytics/morphology/tdsnapLexiconParser");
+Object.defineProperty(exports, "TDSnapLexiconParser", { enumerable: true, get: function () { return tdsnapLexiconParser_1.TDSnapLexiconParser; } });
 var wordFormGenerator_1 = require("./utilities/analytics/morphology/wordFormGenerator");
 Object.defineProperty(exports, "WordFormGenerator", { enumerable: true, get: function () { return wordFormGenerator_1.WordFormGenerator; } });
 // Processor namespaces (platform-specific utilities)