@willwade/aac-processors 0.1.7 → 0.1.9

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

@@ -0,0 +1,138 @@
+/**
+ * Vocabulary Coverage Analysis
+ *
+ * Analyzes how well an AAC board set covers core vocabulary
+ * and identifies missing/extra words compared to reference lists.
+ */
+import { ReferenceLoader } from '../reference/index';
+import { spellingEffort } from './effort';
+export class VocabularyAnalyzer {
+    constructor(referenceLoader) {
+        this.referenceLoader = referenceLoader || new ReferenceLoader();
+    }
+    /**
+     * Analyze vocabulary coverage against core lists
+     */
+    analyze(metrics, options) {
+        // const locale = options?.locale || metrics.locale || 'en';
+        const highEffortThreshold = options?.highEffortThreshold || 5.0;
+        const lowEffortThreshold = options?.lowEffortThreshold || 2.0;
+        // Load reference data
+        const coreLists = this.referenceLoader.loadCoreLists();
+        // Create word to effort map (using lowercase keys for matching)
+        const wordEffortMap = new Map();
+        metrics.buttons.forEach((btn) => {
+            const word = btn.label.toLowerCase();
+            const existing = wordEffortMap.get(word);
+            if (!existing || btn.effort < existing) {
+                wordEffortMap.set(word, btn.effort);
+            }
+        });
+        // Analyze each core list
+        const core_coverage = {};
+        coreLists.forEach((list) => {
+            const analysis = this.analyzeCoreList(list, wordEffortMap);
+            core_coverage[list.id] = analysis;
+        });
+        // Find extra words (words not in any core list)
+        const allCoreWords = new Set();
+        coreLists.forEach((list) => {
+            list.words.forEach((word) => allCoreWords.add(word.toLowerCase()));
+        });
+        const extraWords = [];
+        wordEffortMap.forEach((effort, word) => {
+            if (!allCoreWords.has(word.toLowerCase())) {
+                extraWords.push(word);
+            }
+        });
+        extraWords.sort((a, b) => a.localeCompare(b));
+        // Find high/low effort words
+        const highEffortWords = [];
+        const lowEffortWords = [];
+        wordEffortMap.forEach((effort, word) => {
+            if (effort > highEffortThreshold) {
+                highEffortWords.push({ word, effort });
+            }
+            else if (effort < lowEffortThreshold) {
+                lowEffortWords.push({ word, effort });
+            }
+        });
+        highEffortWords.sort((a, b) => b.effort - a.effort);
+        lowEffortWords.sort((a, b) => a.effort - b.effort);
+        return {
+            core_coverage,
+            total_unique_words: wordEffortMap.size,
+            words_with_effort: wordEffortMap.size,
+            words_requiring_spelling: 0, // Calculated during sentence analysis
+            extra_words: extraWords,
+            high_effort_words: highEffortWords.slice(0, 50), // Top 50
+            low_effort_words: lowEffortWords.slice(0, 50), // Bottom 50
+        };
+    }
+    /**
+     * Analyze coverage for a single core list
+     */
+    analyzeCoreList(list, wordEffortMap) {
+        const covered = [];
+        const missing = [];
+        let totalEffort = 0;
+        list.words.forEach((word) => {
+            const lowerWord = word.toLowerCase();
+            const effort = wordEffortMap.get(lowerWord);
+            if (effort !== undefined) {
+                covered.push(word);
+                totalEffort += effort;
+            }
+            else {
+                missing.push(word);
+            }
+        });
+        const averageEffort = covered.length > 0 ? totalEffort / covered.length : 0;
+        return {
+            name: list.name,
+            total_words: list.words.length,
+            covered: covered.length,
+            missing: missing.length,
+            coverage_percent: (covered.length / list.words.length) * 100,
+            missing_words: missing,
+            average_effort: averageEffort,
+        };
+    }
+    /**
+     * Calculate coverage percentage for a specific word list
+     */
+    calculateCoverage(wordList, metrics) {
+        const wordSet = new Set(metrics.buttons.map((btn) => btn.label.toLowerCase()));
+        const covered = [];
+        const missing = [];
+        wordList.forEach((word) => {
+            if (wordSet.has(word.toLowerCase())) {
+                covered.push(word);
+            }
+            else {
+                missing.push(word);
+            }
+        });
+        return {
+            covered,
+            missing,
+            coverage_percent: (covered.length / wordList.length) * 100,
+        };
+    }
+    /**
+     * Get effort for a word, or calculate spelling effort if missing
+     */
+    getWordEffort(word, metrics) {
+        const btn = metrics.buttons.find((b) => b.label.toLowerCase() === word.toLowerCase());
+        if (btn) {
+            return btn.effort;
+        }
+        return spellingEffort(word, metrics.spelling_effort_base, metrics.spelling_effort_per_letter);
+    }
+    /**
+     * Check if a word is in the board set
+     */
+    hasWord(word, metrics) {
+        return metrics.buttons.some((b) => b.label.toLowerCase() === word.toLowerCase());
+    }
+}

package/dist/browser/utilities/analytics/reference/browser.js

@@ -0,0 +1,67 @@
+/**
+ * Browser-friendly reference data loader using fetch.
+ */
+export class InMemoryReferenceLoader {
+    constructor(data) {
+        this.data = data;
+    }
+    loadCoreLists() {
+        return this.data.coreLists;
+    }
+    loadCommonWords() {
+        return this.data.commonWords;
+    }
+    loadSynonyms() {
+        return this.data.synonyms;
+    }
+    loadSentences() {
+        return this.data.sentences;
+    }
+    loadFringe() {
+        return this.data.fringe;
+    }
+    loadBaseWords() {
+        return this.data.baseWords;
+    }
+    loadCommonFringe() {
+        const commonWords = new Set(this.data.commonWords.words.map((w) => w.toLowerCase()));
+        const coreWords = new Set();
+        this.data.coreLists.forEach((list) => {
+            list.words.forEach((word) => coreWords.add(word.toLowerCase()));
+        });
+        return Array.from(commonWords).filter((word) => !coreWords.has(word));
+    }
+    loadAll() {
+        return this.data;
+    }
+}
+export async function loadReferenceDataFromUrl(baseUrl, locale = 'en') {
+    const root = baseUrl.replace(/\/$/, '');
+    const fetchJson = async (name) => {
+        const res = await fetch(`${root}/${name}.${locale}.json`);
+        if (!res.ok) {
+            throw new Error(`Failed to load ${name}.${locale}.json`);
+        }
+        return (await res.json());
+    };
+    const [coreLists, commonWords, synonyms, sentences, fringe, baseWords] = await Promise.all([
+        fetchJson('core_lists'),
+        fetchJson('common_words'),
+        fetchJson('synonyms'),
+        fetchJson('sentences'),
+        fetchJson('fringe'),
+        fetchJson('base_words'),
+    ]);
+    return {
+        coreLists,
+        commonWords,
+        synonyms,
+        sentences,
+        fringe,
+        baseWords,
+    };
+}
+export async function createBrowserReferenceLoader(baseUrl, locale = 'en') {
+    const data = await loadReferenceDataFromUrl(baseUrl, locale);
+    return new InMemoryReferenceLoader(data);
+}

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

@@ -0,0 +1,129 @@
+/**
+ * Reference Data Loader
+ *
+ * Loads reference vocabulary lists, core lists, and sentences
+ * for AAC metrics analysis.
+ */
+import { getFs, getPath } from '../../../utils/io';
+export class ReferenceLoader {
+    constructor(dataDir, locale = 'en') {
+        this.locale = locale;
+        if (dataDir) {
+            this.dataDir = dataDir;
+        }
+        else {
+            // Resolve the data directory relative to this file's location
+            // Use __dirname which works correctly after compilation
+            this.dataDir = getPath().join(__dirname, 'data');
+        }
+    }
+    /**
+     * Load core vocabulary lists
+     */
+    loadCoreLists() {
+        const filePath = getPath().join(this.dataDir, `core_lists.${this.locale}.json`);
+        const content = getFs().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
+    }
+    /**
+     * Load common words with baseline effort scores
+     */
+    loadCommonWords() {
+        const filePath = getPath().join(this.dataDir, `common_words.${this.locale}.json`);
+        const content = getFs().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
+    }
+    /**
+     * Load synonym mappings
+     */
+    loadSynonyms() {
+        const filePath = getPath().join(this.dataDir, `synonyms.${this.locale}.json`);
+        const content = getFs().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
+    }
+    /**
+     * Load test sentences
+     */
+    loadSentences() {
+        const filePath = getPath().join(this.dataDir, `sentences.${this.locale}.json`);
+        const content = getFs().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
+    }
+    /**
+     * Load fringe vocabulary
+     */
+    loadFringe() {
+        const filePath = getPath().join(this.dataDir, `fringe.${this.locale}.json`);
+        const content = getFs().readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(String(content));
+        // Flatten nested category words if needed
+        if (Array.isArray(data) && data.length > 0 && data[0].categories) {
+            const flattened = [];
+            data.forEach((list) => {
+                list.categories.forEach((cat) => {
+                    flattened.push(...cat.words);
+                });
+            });
+            return flattened;
+        }
+        return data;
+    }
+    /**
+     * Load base words hash map
+     */
+    loadBaseWords() {
+        const filePath = getPath().join(this.dataDir, `base_words.${this.locale}.json`);
+        const content = getFs().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
+    }
+    /**
+     * Load common fringe vocabulary
+     * Common words that are NOT in core vocabulary lists
+     * (matching Ruby loader.rb:413-420)
+     */
+    loadCommonFringe() {
+        const commonWordsData = this.loadCommonWords();
+        const commonWords = new Set(commonWordsData.words.map((w) => w.toLowerCase()));
+        const coreLists = this.loadCoreLists();
+        const coreWords = new Set();
+        coreLists.forEach((list) => {
+            list.words.forEach((word) => coreWords.add(word.toLowerCase()));
+        });
+        // Common fringe = common words - core words
+        const commonFringe = Array.from(commonWords).filter((word) => !coreWords.has(word));
+        return commonFringe;
+    }
+    /**
+     * Get all reference data at once
+     */
+    loadAll() {
+        return {
+            coreLists: this.loadCoreLists(),
+            commonWords: this.loadCommonWords(),
+            synonyms: this.loadSynonyms(),
+            sentences: this.loadSentences(),
+            fringe: this.loadFringe(),
+            baseWords: this.loadBaseWords(),
+        };
+    }
+}
+/**
+ * Get the default reference data path
+ */
+export function getReferenceDataPath() {
+    return String(getPath().join(__dirname, 'data'));
+}
+/**
+ * Check if reference data files exist
+ */
+export function hasReferenceData() {
+    const dataPath = getReferenceDataPath();
+    const requiredFiles = [
+        'core_lists.en.json',
+        'common_words.en.json',
+        'sentences.en.json',
+        'synonyms.en.json',
+        'fringe.en.json',
+    ];
+    return requiredFiles.every((file) => getFs().existsSync(getPath().join(dataPath, file)));
+}

package/dist/browser/utils/dotnetTicks.js

@@ -0,0 +1,17 @@
+/**
+ * Number of ticks (.NET 100ns units) between 0001-01-01 and Unix epoch.
+ */
+export const DOTNET_EPOCH_TICKS = 621355968000000000n;
+/**
+ * Number of ticks per millisecond.
+ */
+export const TICKS_PER_MILLISECOND = 10000n;
+/**
+ * Convert .NET ticks (100ns since 0001-01-01) to a JavaScript Date.
+ * Accepts bigint or number and rounds down to millisecond precision.
+ */
+export function dotNetTicksToDate(ticks) {
+    const tickValue = BigInt(ticks);
+    const ms = Number((tickValue - DOTNET_EPOCH_TICKS) / TICKS_PER_MILLISECOND);
+    return new Date(ms);
+}

package/dist/index.browser.d.ts

@@ -22,6 +22,7 @@ export { SnapProcessor } from './processors/snapProcessor';
 export { TouchChatProcessor } from './processors/touchchatProcessor';
 export { ApplePanelsProcessor } from './processors/applePanelsProcessor';
 export { AstericsGridProcessor } from './processors/astericsGridProcessor';
+export * as Metrics from './metrics';
 import { BaseProcessor } from './core/baseProcessor';
 export { configureSqlJs } from './utils/sqlite';
 /**

package/dist/index.browser.js

@@ -23,11 +23,23 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configureSqlJs = exports.AstericsGridProcessor = exports.ApplePanelsProcessor = exports.TouchChatProcessor = exports.SnapProcessor = exports.GridsetProcessor = exports.ObfProcessor = exports.OpmlProcessor = exports.DotProcessor = void 0;
+exports.configureSqlJs = exports.Metrics = exports.AstericsGridProcessor = exports.ApplePanelsProcessor = exports.TouchChatProcessor = exports.SnapProcessor = exports.GridsetProcessor = exports.ObfProcessor = exports.OpmlProcessor = exports.DotProcessor = void 0;
 exports.getProcessor = getProcessor;
 exports.getSupportedExtensions = getSupportedExtensions;
 exports.isExtensionSupported = isExtensionSupported;
@@ -56,6 +68,11 @@ var applePanelsProcessor_1 = require("./processors/applePanelsProcessor");
 Object.defineProperty(exports, "ApplePanelsProcessor", { enumerable: true, get: function () { return applePanelsProcessor_1.ApplePanelsProcessor; } });
 var astericsGridProcessor_1 = require("./processors/astericsGridProcessor");
 Object.defineProperty(exports, "AstericsGridProcessor", { enumerable: true, get: function () { return astericsGridProcessor_1.AstericsGridProcessor; } });
+// ===================================================================
+// UTILITY FUNCTIONS
+// ===================================================================
+// Metrics namespace (pageset analytics)
+exports.Metrics = __importStar(require("./metrics"));
 const dotProcessor_2 = require("./processors/dotProcessor");
 const opmlProcessor_2 = require("./processors/opmlProcessor");
 const obfProcessor_2 = require("./processors/obfProcessor");

package/dist/index.node.d.ts

@@ -9,9 +9,9 @@ export * from './core/treeStructure';
 export * from './core/baseProcessor';
 export * from './core/stringCasing';
 export * from './processors';
-export * as Analytics from './utilities/analytics';
-export * from './utilities/analytics';
+export * as Analytics from './analytics';
 export * as Validation from './validation';
+export * as Metrics from './metrics';
 export * as Gridset from './gridset';
 export * as Snap from './snap';
 export * as OBF from './obf';

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.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.Metrics = exports.Validation = exports.Analytics = void 0;
 exports.getProcessor = getProcessor;
 exports.getSupportedExtensions = getSupportedExtensions;
 exports.isExtensionSupported = isExtensionSupported;
@@ -50,12 +50,12 @@ __exportStar(require("./processors"), exports);
 // ===================================================================
 // NAMESPACES
 // ===================================================================
-// Analytics namespace
-exports.Analytics = __importStar(require("./utilities/analytics"));
-// Also export analytics classes directly for convenience
-__exportStar(require("./utilities/analytics"), exports);
+// Analytics namespace (usage/history)
+exports.Analytics = __importStar(require("./analytics"));
 // Validation namespace
 exports.Validation = __importStar(require("./validation"));
+// Metrics namespace (pageset analytics)
+exports.Metrics = __importStar(require("./metrics"));
 // Processor namespaces (platform-specific utilities)
 exports.Gridset = __importStar(require("./gridset"));
 exports.Snap = __importStar(require("./snap"));

package/dist/metrics.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Metrics Namespace
+ *
+ * Pageset-focused metrics and analytics (board structure, effort, vocabulary).
+ * Use this for analyzing AAC trees, not end-user usage logs.
+ */
+export * from './utilities/analytics/metrics/types';
+export * from './utilities/analytics/metrics/effort';
+export * from './utilities/analytics/metrics/obl-types';
+export { OblUtil, OblAnonymizer } from './utilities/analytics/metrics/obl';
+export { MetricsCalculator } from './utilities/analytics/metrics/core';
+export { VocabularyAnalyzer } from './utilities/analytics/metrics/vocabulary';
+export { SentenceAnalyzer } from './utilities/analytics/metrics/sentence';
+export { ComparisonAnalyzer } from './utilities/analytics/metrics/comparison';
+export { ReferenceLoader } from './utilities/analytics/reference';
+export { InMemoryReferenceLoader, createBrowserReferenceLoader, loadReferenceDataFromUrl, type ReferenceData, } from './utilities/analytics/reference/browser';
+export * from './utilities/analytics/utils/idGenerator';

package/dist/metrics.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Metrics Namespace
+ *
+ * Pageset-focused metrics and analytics (board structure, effort, vocabulary).
+ * Use this for analyzing AAC trees, not end-user usage logs.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadReferenceDataFromUrl = exports.createBrowserReferenceLoader = exports.InMemoryReferenceLoader = exports.ReferenceLoader = exports.ComparisonAnalyzer = exports.SentenceAnalyzer = exports.VocabularyAnalyzer = exports.MetricsCalculator = exports.OblAnonymizer = exports.OblUtil = void 0;
+__exportStar(require("./utilities/analytics/metrics/types"), exports);
+__exportStar(require("./utilities/analytics/metrics/effort"), exports);
+__exportStar(require("./utilities/analytics/metrics/obl-types"), exports);
+var obl_1 = require("./utilities/analytics/metrics/obl");
+Object.defineProperty(exports, "OblUtil", { enumerable: true, get: function () { return obl_1.OblUtil; } });
+Object.defineProperty(exports, "OblAnonymizer", { enumerable: true, get: function () { return obl_1.OblAnonymizer; } });
+var core_1 = require("./utilities/analytics/metrics/core");
+Object.defineProperty(exports, "MetricsCalculator", { enumerable: true, get: function () { return core_1.MetricsCalculator; } });
+var vocabulary_1 = require("./utilities/analytics/metrics/vocabulary");
+Object.defineProperty(exports, "VocabularyAnalyzer", { enumerable: true, get: function () { return vocabulary_1.VocabularyAnalyzer; } });
+var sentence_1 = require("./utilities/analytics/metrics/sentence");
+Object.defineProperty(exports, "SentenceAnalyzer", { enumerable: true, get: function () { return sentence_1.SentenceAnalyzer; } });
+var comparison_1 = require("./utilities/analytics/metrics/comparison");
+Object.defineProperty(exports, "ComparisonAnalyzer", { enumerable: true, get: function () { return comparison_1.ComparisonAnalyzer; } });
+var reference_1 = require("./utilities/analytics/reference");
+Object.defineProperty(exports, "ReferenceLoader", { enumerable: true, get: function () { return reference_1.ReferenceLoader; } });
+var browser_1 = require("./utilities/analytics/reference/browser");
+Object.defineProperty(exports, "InMemoryReferenceLoader", { enumerable: true, get: function () { return browser_1.InMemoryReferenceLoader; } });
+Object.defineProperty(exports, "createBrowserReferenceLoader", { enumerable: true, get: function () { return browser_1.createBrowserReferenceLoader; } });
+Object.defineProperty(exports, "loadReferenceDataFromUrl", { enumerable: true, get: function () { return browser_1.loadReferenceDataFromUrl; } });
+__exportStar(require("./utilities/analytics/utils/idGenerator"), exports);

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

@@ -79,6 +79,7 @@ export declare const AUTOCONTENT_TYPES: {
     readonly PREDICTION: "Prediction";
     readonly GRAMMAR: "Grammar";
     readonly CONTEXTUAL: "Contextual";
+    readonly WORDLIST: "WordList";
 };
 /**
  * Human-readable names for cell types

package/dist/processors/gridset/pluginTypes.js

@@ -78,6 +78,7 @@ exports.AUTOCONTENT_TYPES = {
     PREDICTION: 'Prediction',
     GRAMMAR: 'Grammar',
     CONTEXTUAL: 'Contextual',
+    WORDLIST: 'WordList',
 };
 /**
  * Human-readable names for cell types

package/dist/processors/gridsetProcessor.js

@@ -651,6 +651,27 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             });
                         });
                     }
+                    const pageWordListItems = [];
+                    if (grid.WordList && grid.WordList.Items) {
+                        const items = grid.WordList.Items.WordListItem || grid.WordList.Items.wordlistitem || [];
+                        const itemArr = Array.isArray(items) ? items : items ? [items] : [];
+                        for (const item of itemArr) {
+                            const text = item.Text || item.text;
+                            if (text) {
+                                const val = this.textOf(text);
+                                if (val) {
+                                    pageWordListItems.push({
+                                        text: val,
+                                        image: item.Image || item.image || undefined,
+                                        partOfSpeech: item.PartOfSpeech || item.partOfSpeech || undefined,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    // Track WordList AutoContent cells and their positions for "more" button placement
+                    const wordListAutoContentCells = [];
+                    let wordListCellIndex = 0;
                     cellArr.forEach((cell, idx) => {
                         if (!cell || !cell.Content)
                             return;
@@ -718,7 +739,7 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                                 return; // Skip cells without labels AND without images/symbols
                             }
                         }
-                        const message = label; // Use caption as message
+                        let message = label; // Use caption as message
                         // Detect plugin cell type (Workspace, LiveCell, AutoContent)
                         const pluginMetadata = (0, pluginTypes_1.detectPluginCellType)(content);
                         // Friendly labels for workspace/prediction cells when captions are missing
@@ -737,6 +758,45 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                             // Always surface a friendly label for predictions even if a placeholder exists
                             label = `Prediction ${predictionCellCounter}`;
                         }
+                        // Handle WordList AutoContent cells - populate from page-level WordList
+                        let isMoreButton = false;
+                        if (pluginMetadata.cellType === pluginTypes_1.Grid3CellType.AutoContent &&
+                            pluginMetadata.autoContentType === 'WordList' &&
+                            pageWordListItems.length > 0) {
+                            // Track this cell for potential "more" button
+                            wordListAutoContentCells.push({
+                                cell,
+                                idx,
+                                x: cellX,
+                                y: cellY,
+                            });
+                            // Check if we have more WordList items than available cells
+                            // The "more" button replaces the last WordList cell
+                            const cellsNeededForWordList = pageWordListItems.length;
+                            const availableWordListCells = wordListAutoContentCells.length;
+                            const isLastWordListCell = availableWordListCells === cellsNeededForWordList + 1; // +1 for "more" button
+                            if (isLastWordListCell) {
+                                // This cell becomes the "more" button
+                                label = 'more...';
+                                message = 'more...';
+                                isMoreButton = true;
+                            }
+                            else if (wordListCellIndex < pageWordListItems.length) {
+                                // Populate this cell with the next WordList item
+                                const wordListItem = pageWordListItems[wordListCellIndex];
+                                label = wordListItem.text;
+                                message = wordListItem.text;
+                                // Use the WordList item's image if available
+                                if (wordListItem.image && !label) {
+                                    label = wordListItem.image; // Fallback to image path if no text
+                                }
+                                wordListCellIndex++;
+                            }
+                            else {
+                                // No more WordList items - skip this cell
+                                return;
+                            }
+                        }
                         // Parse all command types from Grid3 and create semantic actions
                         let semanticAction;
                         let legacyAction = null;
@@ -1311,6 +1371,13 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                                     : undefined,
                                 // Store page name for Grid3 image lookup
                                 gridPageName: gridName,
+                                // Store WordList "more" button flag
+                                isMoreButton: isMoreButton || undefined,
+                                wordListItemIndex: pluginMetadata.cellType === pluginTypes_1.Grid3CellType.AutoContent &&
+                                    pluginMetadata.autoContentType === 'WordList' &&
+                                    !isMoreButton
+                                    ? wordListCellIndex - 1
+                                    : undefined,
                             },
                         });
                         // Add button to page

package/dist/processors/obfProcessor.js

@@ -517,19 +517,27 @@ class ObfProcessor extends baseProcessor_1.BaseProcessor {
                 columns,
                 order,
             },
-            buttons: page.buttons.map((button) => ({
-                id: button.id,
-                label: button.label,
-                vocalization: button.message || button.label,
-                load_board: button.semanticAction?.intent === treeStructure_1.AACSemanticIntent.NAVIGATE_TO && button.targetPageId
-                    ? {
-                        path: button.targetPageId,
-                    }
-                    : undefined,
-                background_color: button.style?.backgroundColor,
-                border_color: button.style?.borderColor,
-                box_id: buttonPositions.get(String(button.id ?? '')),
-            })),
+            buttons: page.buttons.map((button) => {
+                const extraButtonInfo = button;
+                const imageId = button.parameters?.image_id ||
+                    button.parameters?.imageId ||
+                    extraButtonInfo.image_id ||
+                    extraButtonInfo.imageId;
+                return {
+                    id: button.id,
+                    label: button.label,
+                    vocalization: button.message || button.label,
+                    load_board: button.semanticAction?.intent === treeStructure_1.AACSemanticIntent.NAVIGATE_TO && button.targetPageId
+                        ? {
+                            path: button.targetPageId,
+                        }
+                        : undefined,
+                    background_color: button.style?.backgroundColor,
+                    border_color: button.style?.borderColor,
+                    box_id: buttonPositions.get(String(button.id ?? '')),
+                    image_id: imageId,
+                };
+            }),
             images: Array.isArray(page.images) ? page.images : [],
             sounds: Array.isArray(page.sounds) ? page.sounds : [],
         };