@willwade/aac-processors 0.2.12 → 0.2.14

package/dist/core/treeStructure.d.ts

@@ -1,5 +1,5 @@
-import type { AACStyle, AACTreeMetadata, SnapMetadata, GridSetMetadata, AstericsGridMetadata, TouchChatMetadata, CellScanningOrder, ScanningSelectionMethod } from '../types/aac';
-export type { AACStyle, AACTreeMetadata, SnapMetadata, GridSetMetadata, AstericsGridMetadata, TouchChatMetadata, CellScanningOrder, ScanningSelectionMethod, };
+import type { AACStyle, AACTreeMetadata, SnapMetadata, GridSetMetadata, AstericsGridMetadata, TouchChatMetadata, CellScanningOrder, ScanningSelectionMethod, AACWordListItem, AACPageMutation, ProcessorCapabilities } from '../types/aac';
+export type { AACStyle, AACTreeMetadata, SnapMetadata, GridSetMetadata, AstericsGridMetadata, TouchChatMetadata, CellScanningOrder, ScanningSelectionMethod, AACWordListItem, AACPageMutation, ProcessorCapabilities, };
 export declare enum AACSemanticCategory {
     COMMUNICATION = "communication",// Speech, text output
     NAVIGATION = "navigation",// Page/grid navigation
@@ -227,6 +227,7 @@ export declare class AACPage {
     scanningConfig?: import('../types/aac').ScanningConfig;
     scanType?: AACScanType;
     scanBlocksConfig?: AACScanBlock[];
+    private _pendingMutations;
     constructor({ id, name, grid, buttons, parentId, style, locale, descriptionHtml, images, sounds, semantic_ids, clone_ids, scanningConfig, scanBlocksConfig, scanType, }: {
         id: string;
         name?: string;
@@ -248,6 +249,46 @@ export declare class AACPage {
         scanType?: AACScanType;
     });
     addButton(button: AACButton): void;
+    /**
+     * Internal load-path button push: adds a button to the page WITHOUT recording a mutation.
+     * Used by processors during loadIntoTree so the loaded baseline isn't treated as user changes.
+     * Not part of the public API — consumers should always use addButton.
+     */
+    _loadButton(button: AACButton): void;
+    /**
+     * Discard all recorded mutations on this page.
+     * Useful as an escape hatch after loadIntoTree if the consumer wants a clean baseline.
+     */
+    clearMutations(): void;
+    /**
+     * Get the list of pending mutations for this page (read-only)
+     */
+    get pendingMutations(): readonly AACPageMutation[];
+    /**
+     * Remove a button by ID
+     * @param buttonId - The ID of the button to remove
+     */
+    removeButton(buttonId: string): void;
+    /**
+     * Update a button by merging a patch
+     * @param buttonId - The ID of the button to update
+     * @param patch - Partial button object with fields to update
+     */
+    updateButton(buttonId: string, patch: Partial<AACButton>): void;
+    /**
+     * Add an item to the page's WordList (for formats with dynamic content cells)
+     * @param item - WordList item to add
+     */
+    addWordListItem(item: AACWordListItem): void;
+    /**
+     * Remove items from the page's WordList
+     * @param textOrPredicate - Text to match or predicate function to filter items
+     */
+    removeWordListItem(textOrPredicate: string | ((item: AACWordListItem) => boolean)): void;
+    /**
+     * Clear all items from the page's WordList
+     */
+    clearWordList(): void;
 }
 export declare class AACTree {
     pages: {

package/dist/core/treeStructure.js

@@ -172,6 +172,8 @@ class AACButton {
 exports.AACButton = AACButton;
 class AACPage {
     constructor({ id, name = '', grid = [], buttons = [], parentId = null, style, locale, descriptionHtml, images, sounds, semantic_ids, clone_ids, scanningConfig, scanBlocksConfig, scanType, }) {
+        // Mutation tracking
+        this._pendingMutations = [];
         this.id = id;
         this.name = name;
         if (Array.isArray(grid)) {
@@ -200,6 +202,64 @@ class AACPage {
     }
     addButton(button) {
         this.buttons.push(button);
+        // Record the mutation
+        this._pendingMutations.push({ type: 'addButton', button });
+    }
+    /**
+     * Internal load-path button push: adds a button to the page WITHOUT recording a mutation.
+     * Used by processors during loadIntoTree so the loaded baseline isn't treated as user changes.
+     * Not part of the public API — consumers should always use addButton.
+     */
+    _loadButton(button) {
+        this.buttons.push(button);
+    }
+    /**
+     * Discard all recorded mutations on this page.
+     * Useful as an escape hatch after loadIntoTree if the consumer wants a clean baseline.
+     */
+    clearMutations() {
+        this._pendingMutations = [];
+    }
+    /**
+     * Get the list of pending mutations for this page (read-only)
+     */
+    get pendingMutations() {
+        return Object.freeze([...this._pendingMutations]);
+    }
+    /**
+     * Remove a button by ID
+     * @param buttonId - The ID of the button to remove
+     */
+    removeButton(buttonId) {
+        this._pendingMutations.push({ type: 'removeButton', buttonId });
+    }
+    /**
+     * Update a button by merging a patch
+     * @param buttonId - The ID of the button to update
+     * @param patch - Partial button object with fields to update
+     */
+    updateButton(buttonId, patch) {
+        this._pendingMutations.push({ type: 'updateButton', buttonId, patch });
+    }
+    /**
+     * Add an item to the page's WordList (for formats with dynamic content cells)
+     * @param item - WordList item to add
+     */
+    addWordListItem(item) {
+        this._pendingMutations.push({ type: 'addWordListItem', item });
+    }
+    /**
+     * Remove items from the page's WordList
+     * @param textOrPredicate - Text to match or predicate function to filter items
+     */
+    removeWordListItem(textOrPredicate) {
+        this._pendingMutations.push({ type: 'removeWordListItem', match: textOrPredicate });
+    }
+    /**
+     * Clear all items from the page's WordList
+     */
+    clearWordList() {
+        this._pendingMutations.push({ type: 'clearWordList' });
     }
 }
 exports.AACPage = AACPage;

package/dist/processors/applePanelsProcessor.d.ts

@@ -2,6 +2,11 @@ import { BaseProcessor, ProcessorOptions, ExtractStringsResult, TranslatedString
 import { AACTree } from '../core/treeStructure';
 import { ProcessorInput } from '../utils/io';
 declare class ApplePanelsProcessor extends BaseProcessor {
+    readonly capabilities: {
+        wordList: "none";
+        preservesAssetsOnSave: boolean;
+        newCellCreation: "allowed";
+    };
     constructor(options?: ProcessorOptions);
     private parseRect;
     private pixelToGrid;

package/dist/processors/applePanelsProcessor.js

@@ -51,6 +51,11 @@ function normalizeActionParameters(input) {
 class ApplePanelsProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
+        this.capabilities = {
+            wordList: 'none',
+            preservesAssetsOnSave: false,
+            newCellCreation: 'allowed',
+        };
     }
     // Helper function to parse Apple Panels Rect format "{{x, y}, {width, height}}"
     parseRect(rectString) {
@@ -220,7 +225,8 @@ class ApplePanelsProcessor extends baseProcessor_1.BaseProcessor {
                             fontWeight: btn.DisplayImageWeight === 'bold' ? 'bold' : 'normal',
                         },
                     });
-                    page.addButton(button);
+                    // Load path: do not record as a user mutation
+                    page._loadButton(button);
                     if (btn.Rect) {
                         const rect = this.parseRect(btn.Rect);
                         if (rect) {

package/dist/processors/astericsGridProcessor.d.ts

@@ -17,6 +17,11 @@ export declare function calculateLuminance(hexColor: string): number;
  */
 export declare function getContrastingTextColor(backgroundColor: string): string;
 declare class AstericsGridProcessor extends BaseProcessor {
+    readonly capabilities: {
+        wordList: "none";
+        preservesAssetsOnSave: boolean;
+        newCellCreation: "allowed";
+    };
     private loadAudio;
     constructor(options?: ProcessorOptions & {
         loadAudio?: boolean;

package/dist/processors/astericsGridProcessor.js

@@ -552,6 +552,11 @@ function mapAstericsVisibility(hidden) {
 class AstericsGridProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options = {}) {
         super(options);
+        this.capabilities = {
+            wordList: 'none',
+            preservesAssetsOnSave: false,
+            newCellCreation: 'allowed',
+        };
         this.loadAudio = false;
         this.loadAudio = options.loadAudio || false;
     }
@@ -717,7 +722,8 @@ class AstericsGridProcessor extends baseProcessor_1.BaseProcessor {
                 }
                 grid.gridElements.forEach((element) => {
                     const button = this.createButtonFromElement(element, colorConfig, activeColorSchemeDefinition);
-                    page.addButton(button);
+                    // Load path: do not record as a user mutation
+                    page._loadButton(button);
                     const buttonX = element.x || 0;
                     const buttonY = element.y || 0;
                     const buttonWidth = element.width || 1;

package/dist/processors/dotProcessor.d.ts

@@ -2,6 +2,11 @@ import { BaseProcessor, ProcessorOptions, ExtractStringsResult, TranslatedString
 import { AACTree } from '../core/treeStructure';
 import { ProcessorInput } from '../utils/io';
 declare class DotProcessor extends BaseProcessor {
+    readonly capabilities: {
+        wordList: "none";
+        preservesAssetsOnSave: boolean;
+        newCellCreation: "allowed";
+    };
     constructor(options?: ProcessorOptions);
     private parseDotFile;
     extractTexts(filePathOrBuffer: ProcessorInput): Promise<string[]>;

package/dist/processors/dotProcessor.js

@@ -8,6 +8,11 @@ const io_1 = require("../utils/io");
 class DotProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
+        this.capabilities = {
+            wordList: 'none',
+            preservesAssetsOnSave: false,
+            newCellCreation: 'allowed',
+        };
     }
     parseDotFile(content) {
         const nodes = new Map();
@@ -115,7 +120,8 @@ class DotProcessor extends baseProcessor_1.BaseProcessor {
                 });
                 tree.addPage(page);
                 // Add a self button so single-node graphs yield one button
-                page.addButton(new treeStructure_1.AACButton({
+                // Load path: do not record as a user mutation
+                page._loadButton(new treeStructure_1.AACButton({
                     id: `${node.id}_self`,
                     label: node.label,
                     message: node.label,
@@ -136,7 +142,8 @@ class DotProcessor extends baseProcessor_1.BaseProcessor {
                         message: '',
                         targetPageId: edge.to,
                     });
-                    fromPage.addButton(button);
+                    // Load path: do not record as a user mutation
+                    fromPage._loadButton(button);
                 }
             }
             return tree;

package/dist/processors/excelProcessor.d.ts

@@ -7,6 +7,11 @@ import { AACTree } from '../core/treeStructure';
  * Supports visual styling, navigation links, and vocabulary analysis workflows
  */
 export declare class ExcelProcessor extends BaseProcessor {
+    readonly capabilities: {
+        wordList: "none";
+        preservesAssetsOnSave: boolean;
+        newCellCreation: "allowed";
+    };
     private static readonly NAVIGATION_BUTTONS;
     /**
      * Extract all text content from an Excel file

package/dist/processors/excelProcessor.js

@@ -33,6 +33,14 @@ const treeStructure_1 = require("../core/treeStructure");
  * Supports visual styling, navigation links, and vocabulary analysis workflows
  */
 class ExcelProcessor extends baseProcessor_1.BaseProcessor {
+    constructor() {
+        super(...arguments);
+        this.capabilities = {
+            wordList: 'none',
+            preservesAssetsOnSave: false,
+            newCellCreation: 'allowed',
+        };
+    }
     /**
      * Extract all text content from an Excel file
      * @param filePathOrBuffer - Path to Excel file or Buffer containing Excel data

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

@@ -0,0 +1,39 @@
+/**
+ * Gridset Save Mutations Module
+ *
+ * Handles saving AACTree mutations back to Gridset files.
+ * This module extracts the save logic from gridsetProcessor for better modularity.
+ */
+import { AACTree, AACPage } from '../../core/treeStructure';
+import type { AACButton } from '../../types/aac';
+export declare class GridsetSaveHandler {
+    private AdmZip;
+    private XMLParser;
+    private XMLBuilder;
+    constructor();
+    /**
+     * Show deprecation warning for legacy save path
+     */
+    static warnLegacySave(): void;
+    /**
+     * Save using mutation-based logic
+     * Fixes bugs A, B, C by processing explicit mutations
+     */
+    static saveWithMutations(tree: AACTree, originalZip: any, outputZip: any, parser: any, gridBuilder: any, createBasicGridXml: (page: AACPage) => string): void;
+    /**
+     * Apply button changes to a cell
+     */
+    static applyButtonToCell(cell: any, button: AACButton, patch?: Partial<AACButton>): void;
+    /**
+     * Add an item to the WordList with de-duplication (Bug A fix)
+     */
+    static addWordListItemToGrid(grid: any, item: {
+        text: string;
+        image?: string;
+        partOfSpeech?: string;
+    }): void;
+    /**
+     * Remove items from the WordList
+     */
+    static removeWordListItemFromGrid(grid: any, match: string | ((item: any) => boolean)): void;
+}

package/dist/processors/gridset/saveMutations.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Gridset Save Mutations Module
+ *
+ * Handles saving AACTree mutations back to Gridset files.
+ * This module extracts the save logic from gridsetProcessor for better modularity.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridsetSaveHandler = void 0;
+const xmlFormatter_1 = require("./xmlFormatter");
+class GridsetSaveHandler {
+    constructor() {
+        // Dynamic imports for browser compatibility
+    }
+    /**
+     * Show deprecation warning for legacy save path
+     */
+    static warnLegacySave() {
+        const key = 'gridset_legacy_save_warned';
+        if (!global[key]) {
+            console.warn('saveModifiedTree: detected button changes without recorded mutations. ' +
+                'This will continue to work in 0.x but is deprecated. ' +
+                'Use page.addButton / page.addWordListItem to make changes explicit.');
+            global[key] = true;
+        }
+    }
+    /**
+     * Save using mutation-based logic
+     * Fixes bugs A, B, C by processing explicit mutations
+     */
+    static saveWithMutations(tree, originalZip, outputZip, parser, gridBuilder, createBasicGridXml) {
+        for (const page of Object.values(tree.pages)) {
+            // Skip pages with no mutations
+            if (page.pendingMutations.length === 0) {
+                continue;
+            }
+            const gridPath = `Grids/${page.name}/grid.xml`;
+            // Load or create grid.xml
+            const originalEntry = originalZip.getEntry(gridPath);
+            let originalGrid;
+            if (originalEntry) {
+                const originalContent = originalEntry.getData().toString('utf-8');
+                originalGrid = parser.parse(originalContent);
+                if (!originalGrid.Grid) {
+                    originalGrid = null;
+                }
+            }
+            if (!originalGrid || !originalGrid.Grid) {
+                const basicGrid = createBasicGridXml(page);
+                const buffer = Buffer.from(basicGrid, 'utf8');
+                outputZip.addFile(gridPath, buffer);
+                continue;
+            }
+            // Index original cells by position
+            const cellsByPosition = new Map();
+            const cellArray = Array.isArray(originalGrid.Grid.Cells?.Cell)
+                ? originalGrid.Grid.Cells.Cell
+                : originalGrid.Grid.Cells?.Cell
+                    ? [originalGrid.Grid.Cells.Cell]
+                    : [];
+            for (const cell of cellArray) {
+                const x = cell['@_X'] !== undefined ? parseInt(String(cell['@_X']), 10) : undefined;
+                const y = parseInt(String(cell['@_Y'] || cell['@_Row'] || '0'), 10);
+                if (x !== undefined) {
+                    cellsByPosition.set(`${x},${y}`, cell);
+                }
+            }
+            // Process mutations in order
+            for (const mutation of page.pendingMutations) {
+                switch (mutation.type) {
+                    case 'addButton': {
+                        const button = mutation.button;
+                        const x = button.x ?? 0;
+                        const y = button.y ?? 0;
+                        const cell = cellsByPosition.get(`${x},${y}`);
+                        if (cell && cell.Content) {
+                            GridsetSaveHandler.applyButtonToCell(cell, button);
+                        }
+                        else {
+                            // Bug C fix: warn instead of silently dropping
+                            console.warn(`[Gridset] Cannot add button at (${x},${y}) - cell does not exist. ` +
+                                `Use addWordListItem for dynamic content.`);
+                        }
+                        break;
+                    }
+                    case 'removeButton': {
+                        const button = page.buttons.find((b) => b.id === mutation.buttonId);
+                        if (button) {
+                            const x = button.x ?? 0;
+                            const y = button.y ?? 0;
+                            const cell = cellsByPosition.get(`${x},${y}`);
+                            if (cell && cell.Content) {
+                                cell.Content.Visibility = 'Hidden';
+                            }
+                        }
+                        break;
+                    }
+                    case 'updateButton': {
+                        const button = page.buttons.find((b) => b.id === mutation.buttonId);
+                        if (button) {
+                            const x = button.x ?? 0;
+                            const y = button.y ?? 0;
+                            const cell = cellsByPosition.get(`${x},${y}`);
+                            if (cell && cell.Content) {
+                                GridsetSaveHandler.applyButtonToCell(cell, button, mutation.patch);
+                            }
+                        }
+                        break;
+                    }
+                    case 'addWordListItem': {
+                        GridsetSaveHandler.addWordListItemToGrid(originalGrid.Grid, mutation.item);
+                        break;
+                    }
+                    case 'removeWordListItem': {
+                        GridsetSaveHandler.removeWordListItemFromGrid(originalGrid.Grid, mutation.match);
+                        break;
+                    }
+                    case 'clearWordList': {
+                        if (originalGrid.Grid.WordList && originalGrid.Grid.WordList.Items) {
+                            originalGrid.Grid.WordList.Items.WordListItem = [];
+                        }
+                        break;
+                    }
+                }
+            }
+            // Build and write the updated grid XML
+            let builtXml = gridBuilder.build(originalGrid);
+            builtXml = (0, xmlFormatter_1.formatGrid3XmlComplete)(builtXml);
+            outputZip.addFile(gridPath, Buffer.from(builtXml, 'utf8'));
+        }
+    }
+    /**
+     * Apply button changes to a cell
+     */
+    static applyButtonToCell(cell, button, patch) {
+        const updates = patch ? { ...button, ...patch } : button;
+        const isPlaceholderLabel = !updates.label ||
+            updates.label.startsWith('Cell_') ||
+            updates.label.startsWith('AutoContent_') ||
+            updates.label.startsWith('Prediction ');
+        if (cell.Content.CaptionAndImage || cell.Content.captionAndImage) {
+            const captionAndImage = cell.Content.CaptionAndImage || cell.Content.captionAndImage;
+            if (!isPlaceholderLabel && updates.label) {
+                captionAndImage.Caption = updates.label;
+                if (captionAndImage['@_xsi:nil'] || captionAndImage['xsi:nil']) {
+                    delete captionAndImage['@_xsi:nil'];
+                    delete captionAndImage['xsi:nil'];
+                }
+            }
+            if (updates.image) {
+                captionAndImage.Image = updates.image;
+            }
+        }
+        const isPlaceholderMessage = !updates.message ||
+            updates.message.startsWith('Cell_') ||
+            updates.message.startsWith('AutoContent_') ||
+            updates.message.startsWith('Prediction ');
+        if (!isPlaceholderMessage &&
+            updates.message &&
+            updates.message !== updates.label &&
+            !cell.Content.Commands) {
+            cell.Content['#text'] = updates.message;
+        }
+    }
+    /**
+     * Add an item to the WordList with de-duplication (Bug A fix)
+     */
+    static addWordListItemToGrid(grid, item) {
+        if (!grid.WordList) {
+            grid.WordList = {};
+        }
+        if (!grid.WordList.Items) {
+            grid.WordList.Items = {};
+        }
+        const existingItems = grid.WordList.Items.WordListItem || grid.WordList.Items.wordlistitem || [];
+        const itemsArray = Array.isArray(existingItems) ? existingItems : [existingItems];
+        // De-duplicate by text
+        const existingTexts = new Set(itemsArray
+            .map((item) => {
+            if (typeof item.Text === 'string')
+                return item.Text;
+            return item.Text?.p?.s?.r || '';
+        })
+            .filter(Boolean));
+        if (!existingTexts.has(item.text)) {
+            itemsArray.push({
+                Text: { p: { s: { r: item.text } } },
+                Image: item.image || '',
+                PartOfSpeech: item.partOfSpeech || 'Unknown',
+            });
+            grid.WordList.Items.WordListItem = itemsArray;
+        }
+    }
+    /**
+     * Remove items from the WordList
+     */
+    static removeWordListItemFromGrid(grid, match) {
+        if (!grid.WordList || !grid.WordList.Items) {
+            return;
+        }
+        const existingItems = grid.WordList.Items.WordListItem || grid.WordList.Items.wordlistitem || [];
+        const itemsArray = Array.isArray(existingItems) ? existingItems : [existingItems];
+        let filteredItems;
+        if (typeof match === 'string') {
+            filteredItems = itemsArray.filter((item) => {
+                const text = item.Text?.p?.s?.r || item.Text || '';
+                return text !== match;
+            });
+        }
+        else {
+            filteredItems = itemsArray.filter(match);
+        }
+        grid.WordList.Items.WordListItem = filteredItems;
+    }
+}
+exports.GridsetSaveHandler = GridsetSaveHandler;

package/dist/processors/gridsetProcessor.d.ts

@@ -4,6 +4,11 @@ import { type ButtonForTranslation, type LLMLTranslationResult } from '../utilit
 import { ValidationResult } from '../validation/validationTypes';
 import { ProcessorInput } from '../utils/io';
 declare class GridsetProcessor extends BaseProcessor {
+    readonly capabilities: {
+        wordList: "native";
+        preservesAssetsOnSave: boolean;
+        newCellCreation: "restricted";
+    };
     constructor(options?: ProcessorOptions);
     private getGridsetPassword;
     private ensureAlphaChannel;

package/dist/processors/gridsetProcessor.js

@@ -32,6 +32,7 @@ const translationProcessor_1 = require("../utilities/translation/translationProc
 const password_1 = require("./gridset/password");
 const crypto_1 = require("./gridset/crypto");
 const xmlFormatter_1 = require("./gridset/xmlFormatter");
+const saveMutations_1 = require("./gridset/saveMutations");
 const gridCalculations_1 = require("./gridset/gridCalculations");
 const cellHelpers_1 = require("./gridset/cellHelpers");
 const gridsetValidator_1 = require("../validation/gridsetValidator");
@@ -46,6 +47,11 @@ const io_1 = require("../utils/io");
 class GridsetProcessor extends baseProcessor_1.BaseProcessor {
     constructor(options) {
         super(options);
+        this.capabilities = {
+            wordList: 'native',
+            preservesAssetsOnSave: true,
+            newCellCreation: 'restricted',
+        };
     }
     // Determine password to use when opening encrypted gridset archives (.gridsetx)
     getGridsetPassword(source) {
@@ -1591,8 +1597,8 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                                 ...(imageData ? { imageData, image_id: resolvedImageEntry } : {}),
                             },
                         });
-                        // Add button to page
-                        page.addButton(button);
+                        // Add button to page (load path: do not record as a user mutation)
+                        page._loadButton(button);
                         // Place button in grid layout (handle colspan/rowspan)
                         for (let r = cellY; r < cellY + rowSpan && r < maxRows; r++) {
                             for (let c = cellX; c < cellX + colSpan && c < maxCols; c++) {
@@ -2250,6 +2256,35 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
         const AdmZip = (await Promise.resolve().then(() => __importStar(require('adm-zip')))).default;
         const originalZip = new AdmZip(originalPath);
         const outputZip = new AdmZip();
+        // Check if any page has pending mutations
+        const hasPendingMutations = Object.values(tree.pages).some((page) => page.pendingMutations.length > 0);
+        if (hasPendingMutations) {
+            // NEW: Use mutation-based save path
+            const parser = new fast_xml_parser_1.XMLParser({
+                ignoreAttributes: false,
+                attributeNamePrefix: '@_',
+            });
+            const gridBuilder = new fast_xml_parser_1.XMLBuilder({
+                ignoreAttributes: false,
+                format: true,
+                indentBy: '  ',
+                suppressEmptyNode: true,
+                suppressBooleanAttributes: false,
+            });
+            saveMutations_1.GridsetSaveHandler.saveWithMutations(tree, originalZip, outputZip, parser, gridBuilder, (page) => this.createBasicGridXml(page));
+            // Copy remaining files
+            for (const entry of originalZip.getEntries()) {
+                if (entry.isDirectory)
+                    continue;
+                if (!outputZip.getEntry(entry.entryName)) {
+                    outputZip.addFile(entry.entryName, entry.getData());
+                }
+            }
+            const outputBuffer = outputZip.toBuffer();
+            await writeBinaryToPath(outputPath, outputBuffer);
+            return;
+        }
+        // LEGACY: Original position-based logic continues below...
         // Create a map of pages by name for easy lookup
         const pagesByName = new Map();
         for (const page of Object.values(tree.pages)) {
@@ -2443,43 +2478,6 @@ class GridsetProcessor extends baseProcessor_1.BaseProcessor {
                     originalGrid.Grid.WordList.Items.WordListItem = allItems;
                 }
             }
-            // Process WordList items attached to the page (from personalisation)
-            // These are tracked separately and shouldn't create new cells
-            // Use a known symbol key to check for WordList items
-            const WORDLIST_ITEMS_KEY = 'wordListItems';
-            const wordListItems = page[WORDLIST_ITEMS_KEY];
-            if (wordListItems && wordListItems.length > 0) {
-                // Ensure WordList structure exists
-                if (!originalGrid.Grid) {
-                    originalGrid.Grid = {};
-                }
-                if (!originalGrid.Grid.WordList) {
-                    originalGrid.Grid.WordList = {};
-                }
-                if (!originalGrid.Grid.WordList.Items) {
-                    originalGrid.Grid.WordList.Items = {};
-                }
-                const existingItems = originalGrid.Grid.WordList.Items.WordListItem ||
-                    originalGrid.Grid.WordList.Items.wordlistitem ||
-                    [];
-                const itemsArray = Array.isArray(existingItems) ? existingItems : [existingItems];
-                // Add new WordList items with proper Grid 3 format
-                for (const item of wordListItems) {
-                    itemsArray.push({
-                        Text: {
-                            p: {
-                                s: {
-                                    r: item.label,
-                                },
-                            },
-                        },
-                        Image: '',
-                        PartOfSpeech: 'Unknown',
-                    });
-                }
-                // Update the WordList
-                originalGrid.Grid.WordList.Items.WordListItem = itemsArray;
-            }
             // Build the updated grid XML and format for Grid 3 compatibility
             let builtXml = gridBuilder.build(originalGrid);
             builtXml = (0, xmlFormatter_1.formatGrid3XmlComplete)(builtXml);