@willwade/aac-processors 0.2.16 → 0.2.18

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

@@ -588,12 +588,20 @@ 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;
                     }
                 }
@@ -611,8 +619,44 @@ class MetricsCalculator {
      */
     expandMorphologicalPredictions(tree, options) {
         const locale = options.morphologyLocale || 'en-gb';
-        const morph = new morphology_1.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 = morphology_1.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 = morphology_1.MorphologyEngine.fromGrid3Verbs(verbForms);
+            this.expandGrid3Predictions(tree, morph);
+            return;
+        }
+        morph = new morphology_1.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',
@@ -695,30 +739,56 @@ 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';
                             }
@@ -726,16 +796,90 @@ 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)
      *
@@ -752,7 +896,7 @@ 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
@@ -814,23 +958,28 @@ 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 = (0, effort_1.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_1.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_1.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 = (0, effort_1.visualScanEffort)(predictionPriorItems);
+                            const suggestWordsConfirmation = isSuggestWords
+                                ? effort_1.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/utilities/analytics/metrics/effort.d.ts

@@ -32,6 +32,7 @@ export declare const EFFORT_CONSTANTS: {
     readonly DEFAULT_SCAN_ERROR_RATE: 0.1;
     readonly SCAN_RETRY_PENALTY: 1;
     readonly SUGGEST_WORDS_SELECTION_EFFORT: 0.5;
+    readonly TDSNAP_GRAMMAR_OVERLAY_EFFORT: 0.1;
 };
 /**
  * Calculate button size effort based on grid dimensions

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

@@ -48,6 +48,7 @@ exports.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/utilities/analytics/metrics/types.d.ts

@@ -147,6 +147,32 @@ export interface MetricsOptions {
      * Only used when useSmartGrammar is true.
      */
     morphologyLocale?: string;
+    /**
+     * Path to a TDSnap Lexicon.db3 for word form lookups
+     *
+     * When provided, the MorphologyEngine will use the TDSnap lexicon database
+     * to look up inflected forms (e.g., "happy" → "happily", "run" → "ran")
+     * instead of (or before falling back to) rule-based morphology.
+     *
+     * The Lexicon.db3 is found in the TDSnap installation at:
+     *   Data/LanguageModels/lang_en_US/Lexicon.db3
+     *
+     * Only used when useSmartGrammar is true.
+     */
+    tdsnapLexiconPath?: string;
+    /**
+     * Path to a Grid 3 verbs.zip for verb conjugation lookups
+     *
+     * When provided, the MorphologyEngine will use the Grid 3 verbs database
+     * to look up conjugated forms (e.g., "go" → "goes", "went", "gone", "going")
+     * instead of (or before falling back to) rule-based morphology.
+     *
+     * The verbs.zip is found in the Grid 3 installation at:
+     *   Locale/en-GB/verbs/verbs.zip
+     *
+     * Only used when useSmartGrammar is true.
+     */
+    grid3VerbsPath?: string;
 }
 /**
  * Comparison result between two board sets

package/dist/utilities/analytics/morphology/engine.d.ts

@@ -1,11 +1,15 @@
 import { MorphRuleSet } from './types';
 import type { Grid3VerbForms } from './grid3VerbsParser';
+import type { TDSnapLexiconData, TDSnapLexiconEntry } from './tdsnapLexiconParser';
 export declare class MorphologyEngine {
     private ruleSet;
     private grid3Verbs?;
+    private tdsnapLexicon?;
     private cache;
+    getLexiconEntry(word: string): TDSnapLexiconEntry | undefined;
     constructor(ruleSetOrLocale: string | MorphRuleSet);
     static fromGrid3Verbs(verbForms: Grid3VerbForms): MorphologyEngine;
+    static fromTDSnapLexicon(lexiconData: TDSnapLexiconData): MorphologyEngine;
     get locale(): string;
     inflect(base: string, pos: string): string[];
     isFormOf(word: string, base: string, pos: string): boolean;

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

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MorphologyEngine = void 0;
 class MorphologyEngine {
+    getLexiconEntry(word) {
+        return this.tdsnapLexicon?.words.get(word.toLowerCase());
+    }
     constructor(ruleSetOrLocale) {
         this.cache = new Map();
         if (typeof ruleSetOrLocale === 'string') {
@@ -21,6 +24,16 @@ 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;
     }
@@ -29,9 +42,18 @@ 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/utilities/analytics/morphology/index.d.ts

@@ -1,4 +1,6 @@
 export { MorphologyEngine } from './engine';
 export { WordFormGenerator } from './wordFormGenerator';
+export { TDSnapLexiconParser } from './tdsnapLexiconParser';
 export type { MorphRuleSet, MorphRule, MorphWordForms, AstericsWordForm, VerbFormWithConditions, Grid3VerbFormsDetailed, } from './types';
 export type { Grid3VerbForms } from './grid3VerbsParser';
+export type { TDSnapLexiconData, TDSnapLexiconEntry, TDSnapLexiconForm, } from './tdsnapLexiconParser';

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

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WordFormGenerator = exports.MorphologyEngine = void 0;
+exports.TDSnapLexiconParser = exports.WordFormGenerator = exports.MorphologyEngine = void 0;
 var engine_1 = require("./engine");
 Object.defineProperty(exports, "MorphologyEngine", { enumerable: true, get: function () { return engine_1.MorphologyEngine; } });
 var wordFormGenerator_1 = require("./wordFormGenerator");
 Object.defineProperty(exports, "WordFormGenerator", { enumerable: true, get: function () { return wordFormGenerator_1.WordFormGenerator; } });
+var tdsnapLexiconParser_1 = require("./tdsnapLexiconParser");
+Object.defineProperty(exports, "TDSnapLexiconParser", { enumerable: true, get: function () { return tdsnapLexiconParser_1.TDSnapLexiconParser; } });

package/dist/utilities/analytics/morphology/tdsnapLexiconParser.d.ts

@@ -0,0 +1,28 @@
+export interface TDSnapLexiconForm {
+    tag: string;
+    form: string;
+}
+export interface TDSnapLexiconEntry {
+    lexemeId: number;
+    forms: TDSnapLexiconForm[];
+}
+export interface TDSnapLexiconData {
+    locale: string;
+    words: Map<string, TDSnapLexiconEntry>;
+}
+export declare class TDSnapLexiconParser {
+    parseDb(dbPath: string, locale?: string): TDSnapLexiconData;
+    private inferLocale;
+    private extractAll;
+    lookupWord(data: TDSnapLexiconData, word: string): string[];
+    lookupWordByTag(data: TDSnapLexiconData, word: string, tag: string): string[];
+    static readonly TAG_TO_POS: Record<string, string>;
+    static readonly HANDLER_TAG_MAP: Record<string, string>;
+    static parseContentTypeHandler(handler: string): {
+        category: string;
+        subtype: string;
+        params: string[];
+    } | null;
+    static tagToPos(tag: string): string;
+    static handlerToPos(handler: string): string;
+}

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TDSnapLexiconParser = void 0;
+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';
+    }
+}
+exports.TDSnapLexiconParser = TDSnapLexiconParser;
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willwade/aac-processors",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "A comprehensive TypeScript library for processing AAC (Augmentative and Alternative Communication) file formats with translation support",
   "main": "dist/index.js",
   "browser": "dist/browser/index.browser.js",
@@ -131,7 +131,7 @@
   ],
   "author": {
     "name": "Will Wade",
-    "email": "wwade@acecentre.org.uk",
+    "email": "will@aactools.co.uk",
     "url": "https://github.com/willwade"
   },
   "license": "MIT",
@@ -140,12 +140,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/willwade/AACProcessors-nodejs.git"
+    "url": "https://github.com/AACTools/AACProcessors-nodejs.git"
   },
   "bugs": {
-    "url": "https://github.com/willwade/AACProcessors-nodejs/issues"
+    "url": "https://github.com/AACTools/AACProcessors-nodejs/issues"
   },
-  "homepage": "https://github.com/willwade/AACProcessors-nodejs#readme",
+  "homepage": "https://github.com/AACTools/AACProcessors-nodejs#readme",
   "engines": {
     "node": ">=20.0.0",
     "npm": ">=9.0.0"