@willwade/aac-processors 0.2.20 → 0.3.1

package/dist/browser/processors/gotalkNowProcessor.js

@@ -0,0 +1,538 @@
+/**
+ * GoTalk NOW Processor
+ *
+ * Reads, translates, and converts Attainment Company's GoTalk NOW
+ * communication-board files (`.gtbz`).
+ *
+ * A `.gtbz` file is a ZIP archive containing Apple property lists:
+ *   - BookInfo.plist        – format version (GoTalkBookFormatVersion)
+ *   - PageData.plist        – pages dict keyed by page id (positive = content,
+ *                             negative = system/express-bar pages)
+ *   - PageOrder.plist       – ordered array of page ids
+ *   - PageHistory.plist     – navigation history (usually empty)
+ *   - SettingsWriteOut.plist– app-level settings (TTS, scanning, …)
+ *   - IconSource-<id>.png   – page icons
+ *   - Source-<page>-<btn>-<guid>-…png – button images
+ *   - <page>-<btn>.caf      – audio recordings (Core Audio Format)
+ *   - Backup-<n>.zip        – rolling backups
+ *   - REQUIRESREGEN         – marker file
+ *
+ * Colours and fonts in PageData are NSKeyedArchiver-encoded binary plists
+ * carried inside `<data>` tags. They are treated as opaque blobs and preserved
+ * verbatim so that only text fields are touched during translation.
+ */
+import { BaseProcessor, } from '../core/baseProcessor';
+import { AACTree, AACPage, AACButton, AACSemanticCategory, AACSemanticIntent, } from '../core/treeStructure';
+import plist from 'plist';
+import { ValidationFailureError, buildValidationResultFromMessage, } from '../validation/validationTypes';
+import { getBasename } from '../utils/io';
+import { decodeNsColor, decodeNsFont } from './gotalkNow/nsKeyed';
+// ---------------------------------------------------------------------------
+// GoTalk NOW button type → semantic-action mapping
+// ---------------------------------------------------------------------------
+function buildSemanticAction(rawButton, pageId, buttonIndex) {
+    const buttonType = rawButton.ButtonType || 'TTS';
+    const actionData = rawButton.ActionData || {};
+    const label = rawButton.ButtonText ?? '';
+    const ttsText = actionData.TTSText;
+    const spoken = ttsText && ttsText.length > 0 ? ttsText : label;
+    switch (buttonType) {
+        case 'Jump': {
+            const jumpTo = actionData.JumpTo;
+            const target = jumpTo !== undefined ? String(jumpTo) : undefined;
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.NAVIGATION,
+                    intent: AACSemanticIntent.NAVIGATE_TO,
+                    targetId: target,
+                    platformData: {
+                        gotalkNow: { buttonType: 'Jump', jumpTo, jumpBook: actionData.JumpBook },
+                    },
+                    fallback: { type: 'NAVIGATE', targetPageId: target },
+                },
+                message: '',
+                targetPageId: target,
+            };
+        }
+        case 'Audio':
+        case 'Recorded': {
+            // Recorded audio: plays a .caf file named <pageId>-<buttonIndex>.caf.
+            // Recorded buttons may also have TrimStart/TrimEnd for audio trimming.
+            const audioLocation = `${pageId}-${buttonIndex}.caf`;
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.MEDIA,
+                    intent: AACSemanticIntent.PLAY_SOUND,
+                    platformData: {
+                        gotalkNow: {
+                            buttonType,
+                            audioLocation,
+                            trimStart: actionData.TrimStart,
+                            trimEnd: actionData.TrimEnd,
+                        },
+                    },
+                    fallback: { type: 'ACTION' },
+                },
+                message: spoken,
+            };
+        }
+        case 'URL': {
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.SYSTEM_CONTROL,
+                    intent: AACSemanticIntent.WEB_NAVIGATE,
+                    text: actionData.URL,
+                    platformData: {
+                        gotalkNow: {
+                            buttonType: 'URL',
+                            url: actionData.URL,
+                            openInternally: actionData.OpenInternally,
+                        },
+                    },
+                    fallback: { type: 'ACTION' },
+                },
+                message: spoken,
+            };
+        }
+        case 'GoVisual': {
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.SYSTEM_CONTROL,
+                    intent: AACSemanticIntent.PLATFORM_SPECIFIC,
+                    platformData: {
+                        gotalkNow: {
+                            buttonType: 'GoVisual',
+                            goVisual: actionData.GoVisual,
+                            goVisualLink: actionData.GoVisualLink,
+                        },
+                    },
+                    fallback: { type: 'ACTION' },
+                },
+                message: spoken,
+            };
+        }
+        case 'Video': {
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.MEDIA,
+                    intent: AACSemanticIntent.PLAY_VIDEO,
+                    platformData: {
+                        gotalkNow: { buttonType: 'Video' },
+                    },
+                    fallback: { type: 'ACTION' },
+                },
+                message: spoken,
+            };
+        }
+        case 'Express':
+        case 'Bookmark': {
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.SYSTEM_CONTROL,
+                    intent: AACSemanticIntent.PLATFORM_SPECIFIC,
+                    platformData: {
+                        gotalkNow: { buttonType },
+                    },
+                    fallback: { type: 'ACTION' },
+                },
+                message: spoken,
+            };
+        }
+        case 'TTS':
+        default: {
+            // Empty/placeholder cells (no ButtonType or no label) get a SPEAK with empty text.
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.COMMUNICATION,
+                    intent: AACSemanticIntent.SPEAK_TEXT,
+                    text: spoken,
+                    platformData: {
+                        gotalkNow: { buttonType: buttonType === 'TTS' ? 'TTS' : 'Empty' },
+                    },
+                    fallback: { type: 'SPEAK', message: spoken },
+                },
+                message: spoken,
+            };
+        }
+    }
+}
+/**
+ * Derive a square-ish grid layout from the declared button count.
+ * GoTalk NOW uses fixed layouts (1, 4, 9, 16, 25, 36 …).
+ */
+function gridDimensionsFromButtonCount(count) {
+    const side = Math.max(1, Math.ceil(Math.sqrt(Math.max(count, 1))));
+    return { rows: side, cols: side };
+}
+// ---------------------------------------------------------------------------
+// Processor
+// ---------------------------------------------------------------------------
+class GotalkNowProcessor extends BaseProcessor {
+    constructor(options) {
+        super(options);
+        this.capabilities = {
+            wordList: 'none',
+            preservesAssetsOnSave: true,
+            newCellCreation: 'allowed',
+        };
+    }
+    // ---- Zip access ---------------------------------------------------------
+    async openZip(filePathOrBuffer) {
+        const zip = await this.options.zipAdapter(filePathOrBuffer, this.options.fileAdapter);
+        return zip;
+    }
+    async readPlistFromZip(zip, name, fallback) {
+        const files = zip.listFiles();
+        if (!files.includes(name)) {
+            if (fallback)
+                return fallback();
+            throw new Error(`GoTalk NOW archive is missing ${name}`);
+        }
+        const bytes = await zip.readFile(name);
+        const text = typeof Buffer !== 'undefined' && Buffer.isBuffer(bytes)
+            ? bytes.toString('utf8')
+            : new TextDecoder().decode(bytes);
+        return plist.parse(text);
+    }
+    // ---- extractTexts -------------------------------------------------------
+    async extractTexts(filePathOrBuffer) {
+        const tree = await this.loadIntoTree(filePathOrBuffer);
+        const texts = [];
+        for (const pageId in tree.pages) {
+            const page = tree.pages[pageId];
+            if (page.name)
+                texts.push(page.name);
+            page.buttons.forEach((btn) => {
+                if (btn.label)
+                    texts.push(btn.label);
+                if (btn.message && btn.message !== btn.label)
+                    texts.push(btn.message);
+            });
+        }
+        return texts;
+    }
+    // ---- loadIntoTree -------------------------------------------------------
+    async loadIntoTree(filePathOrBuffer) {
+        const { getFileSize, pathExists } = this.options.fileAdapter;
+        const filename = typeof filePathOrBuffer === 'string' ? getBasename(filePathOrBuffer) : 'upload.gtbz';
+        let zip;
+        let pageDataValue;
+        let pageOrderValue;
+        let bookInfoValue;
+        try {
+            zip = await this.openZip(filePathOrBuffer);
+            pageDataValue = await this.readPlistFromZip(zip, 'PageData.plist');
+            pageOrderValue = await this.readPlistFromZip(zip, 'PageOrder.plist', () => []);
+            bookInfoValue = await this.readPlistFromZip(zip, 'BookInfo.plist', () => ({}));
+        }
+        catch (err) {
+            if (err instanceof ValidationFailureError)
+                throw err;
+            const validation = buildValidationResultFromMessage({
+                filename,
+                filesize: typeof filePathOrBuffer === 'string'
+                    ? (await pathExists(filePathOrBuffer))
+                        ? await getFileSize(filePathOrBuffer)
+                        : 0
+                    : 0,
+                format: 'gotalknow',
+                message: err?.message || 'Failed to open GoTalk NOW archive',
+                type: 'structure',
+                description: 'gtbz archive',
+            });
+            throw new ValidationFailureError('Failed to load GoTalk NOW file', validation, err);
+        }
+        const pageData = pageDataValue || {};
+        const pageOrderRaw = Array.isArray(pageOrderValue) ? pageOrderValue : [];
+        const tree = new AACTree();
+        tree.metadata.format = 'gotalknow';
+        // Format version
+        const bookInfo = bookInfoValue || {};
+        if (bookInfo.GoTalkBookFormatVersion !== undefined) {
+            const version = bookInfo.GoTalkBookFormatVersion;
+            tree.metadata.version =
+                typeof version === 'number' || typeof version === 'string' ? String(version) : '1';
+        }
+        // Preserve the ordered list of page ids for round-trip fidelity.
+        const orderedPageIds = pageOrderRaw.map((id) => String(id));
+        tree.metadata.pageOrder = orderedPageIds;
+        // The first page in PageOrder (if any) is treated as the home page.
+        if (orderedPageIds.length > 0) {
+            tree.metadata.defaultHomePageId = orderedPageIds[0];
+        }
+        // Track available image files so we can resolve ButtonImages locations.
+        const zipFiles = new Set(zip.listFiles());
+        // Build pages. Use the union of PageData keys and PageOrder ids.
+        const allPageIds = new Set([...Object.keys(pageData), ...orderedPageIds]);
+        // Deterministic ordering: ordered pages first (in order), then any extras sorted numerically.
+        const sortedPageIds = [
+            ...orderedPageIds.filter((id) => allPageIds.has(id)),
+            ...[...allPageIds]
+                .filter((id) => !orderedPageIds.includes(id))
+                .sort((a, b) => Number(a) - Number(b)),
+        ];
+        if (sortedPageIds.length === 0) {
+            const validation = buildValidationResultFromMessage({
+                filename,
+                filesize: 0,
+                format: 'gotalknow',
+                message: 'No pages found in GoTalk NOW PageData.plist',
+                type: 'structure',
+                description: 'PageData.plist',
+            });
+            throw new ValidationFailureError('GoTalk NOW file has no pages', validation);
+        }
+        for (const pageId of sortedPageIds) {
+            const rawPage = pageData[pageId] || { Buttons: {} };
+            const pageTitle = typeof rawPage.PageTitle === 'string' && rawPage.PageTitle.trim().length > 0
+                ? rawPage.PageTitle
+                : `Page ${pageId}`;
+            const page = new AACPage({
+                id: pageId,
+                name: pageTitle,
+                grid: [],
+                buttons: [],
+                parentId: null,
+            });
+            // Page-level style: background colour and title font.
+            const pageBg = decodeNsColor(rawPage.BackgroundColor);
+            const pageFont = decodeNsFont(rawPage.TitleFont);
+            if (pageBg || pageFont.fontFamily) {
+                page.style = {
+                    ...(page.style || {}),
+                    ...(pageBg ? { backgroundColor: pageBg } : {}),
+                    ...(pageFont.fontFamily ? { fontFamily: pageFont.fontFamily } : {}),
+                };
+            }
+            if (rawPage.Enabled === false) {
+                // Disabled pages are retained but flagged for fidelity.
+                page.enabled = false;
+            }
+            const buttonsById = rawPage.Buttons || {};
+            // Numeric sort of button indices ("0","1",…,"10",…)
+            const buttonIndices = Object.keys(buttonsById).sort((a, b) => Number(a) - Number(b));
+            const buttonCount = rawPage.ButtonCount ?? buttonIndices.length;
+            const { rows, cols } = gridDimensionsFromButtonCount(buttonCount);
+            const gridLayout = Array.from({ length: rows }, () => Array.from({ length: cols }, () => null));
+            buttonIndices.forEach((btnIndex, i) => {
+                const rawButton = buttonsById[btnIndex];
+                if (!rawButton)
+                    return;
+                const { semanticAction, message, targetPageId } = buildSemanticAction(rawButton, pageId, btnIndex);
+                const button = new AACButton({
+                    id: `${pageId}_btn_${btnIndex}`,
+                    label: rawButton.ButtonText ?? '',
+                    message,
+                    targetPageId,
+                    semanticAction,
+                });
+                // Decode style from NSKeyedArchiver blobs.
+                const backgroundColor = decodeNsColor(rawButton.BackgroundColor);
+                const borderColor = decodeNsColor(rawButton.BorderColor);
+                const fontColor = decodeNsColor(rawButton.TextColor);
+                const font = decodeNsFont(rawButton.TextFont);
+                if (backgroundColor || borderColor || fontColor || font.fontFamily) {
+                    button.style = {
+                        ...(button.style || {}),
+                        ...(backgroundColor ? { backgroundColor } : {}),
+                        ...(borderColor ? { borderColor } : {}),
+                        ...(fontColor ? { fontColor } : {}),
+                        ...(font.fontFamily ? { fontFamily: font.fontFamily } : {}),
+                    };
+                }
+                // Resolve image metadata.
+                const images = rawButton.ButtonImages;
+                if (Array.isArray(images) && images.length > 0) {
+                    const first = images[0];
+                    if (first?.Location) {
+                        button.image = first.Location;
+                        if (zipFiles.has(first.Location)) {
+                            button.resolvedImageEntry = first.Location;
+                        }
+                    }
+                    if (first?.SourceLibrary)
+                        button.symbolLibrary = first.SourceLibrary;
+                    if (first?.SourceImageName)
+                        button.symbolPath = first.SourceImageName;
+                }
+                // Visibility: GoTalk buttons can be disabled via either field.
+                if (rawButton.Enabled === false || rawButton.Disabled === true) {
+                    button.visibility = 'Disabled';
+                }
+                // Auditory cue (played when scanning/highlighting).
+                if (rawButton.CueType && rawButton.CueType !== 'None') {
+                    const cueText = rawButton.CueData?.TTSText;
+                    if (cueText && cueText.length > 0) {
+                        button.audioDescription = cueText;
+                    }
+                }
+                // Recorded audio reference.
+                const btnType = rawButton.ButtonType;
+                if (btnType === 'Audio' || btnType === 'Recorded') {
+                    button.audioRecording = {
+                        identifier: `${pageId}-${btnIndex}.caf`,
+                    };
+                }
+                // AfterAction: motor-planning "speak and return" behaviour.
+                // AfterAction is an enum (0=stay, 2=..., 50=jump-back) and
+                // AfterActionData has the same shape as ActionData (e.g. {JumpTo: 0}).
+                const afterActionJumpTo = rawButton.AfterActionData?.JumpTo;
+                // Preserve raw style + extended data opaquely for round-trip styling.
+                button.parameters = {
+                    ...(button.parameters || {}),
+                    __gotalkNow: {
+                        buttonType: rawButton.ButtonType,
+                        textShadow: rawButton.TextShadow,
+                        textCenter: rawButton.TextCenter,
+                        cueType: rawButton.CueType,
+                        afterAction: rawButton.AfterAction,
+                        afterActionJumpTo: afterActionJumpTo !== undefined ? String(afterActionJumpTo) : undefined,
+                        jumpBook: rawButton.ActionData?.JumpBook,
+                    },
+                };
+                page._loadButton(button);
+                // Place into grid by index (row-major).
+                const row = Math.floor(i / cols);
+                const col = i % cols;
+                if (row < rows && col < cols) {
+                    gridLayout[row][col] = button;
+                }
+            });
+            page.grid = gridLayout;
+            tree.addPage(page);
+        }
+        return tree;
+    }
+    // ---- processTexts (asset-preserving round-trip) -------------------------
+    async processTexts(filePathOrBuffer, translations, outputPath) {
+        const { writeBinaryToPath } = this.options.fileAdapter;
+        const originalZip = await this.openZip(filePathOrBuffer);
+        // Parse PageData and apply translations in place.
+        const pageDataBytes = await originalZip.readFile('PageData.plist');
+        const pageDataText = typeof Buffer !== 'undefined' && Buffer.isBuffer(pageDataBytes)
+            ? pageDataBytes.toString('utf8')
+            : new TextDecoder().decode(pageDataBytes);
+        const pageData = plist.parse(pageDataText);
+        for (const pageId of Object.keys(pageData)) {
+            const rawPage = pageData[pageId];
+            if (!rawPage || !rawPage.Buttons)
+                continue;
+            for (const btnIndex of Object.keys(rawPage.Buttons)) {
+                const rawButton = rawPage.Buttons[btnIndex];
+                if (!rawButton)
+                    continue;
+                // Translate the visible label.
+                if (rawButton.ButtonText && translations.has(rawButton.ButtonText)) {
+                    rawButton.ButtonText = translations.get(rawButton.ButtonText);
+                }
+                // Translate the spoken text (only when explicitly set).
+                const actionData = rawButton.ActionData;
+                if (actionData && actionData.TTSText && translations.has(actionData.TTSText)) {
+                    actionData.TTSText = translations.get(actionData.TTSText);
+                }
+            }
+        }
+        const rebuiltPageData = plist.build(pageData);
+        // Repack: copy every original entry verbatim, replacing only PageData.plist.
+        const outputZip = await this.options.zipAdapter(undefined, this.options.fileAdapter);
+        const files = [];
+        for (const name of originalZip.listFiles()) {
+            if (name === 'PageData.plist')
+                continue;
+            files.push({ name, data: await originalZip.readFile(name) });
+        }
+        files.push({ name: 'PageData.plist', data: rebuiltPageData });
+        const outputBuffer = await outputZip.writeFiles(files);
+        await writeBinaryToPath(outputPath, outputBuffer);
+        return outputBuffer;
+    }
+    // ---- saveFromTree (build from tree) -------------------------------------
+    async saveFromTree(tree, outputPath) {
+        const { writeBinaryToPath } = this.options.fileAdapter;
+        const pageData = {};
+        const pageOrder = [];
+        const imageFiles = [];
+        const pageIds = Object.keys(tree.pages);
+        pageIds.forEach((pageId, pageIdx) => {
+            const page = tree.pages[pageId];
+            const numericId = Number(pageId);
+            if (!Number.isNaN(numericId))
+                pageOrder.push(numericId);
+            const buttons = {};
+            const buttonList = page.buttons;
+            buttonList.forEach((btn, i) => {
+                const btnIndex = String(i);
+                const buttonType = btn.parameters?.__gotalkNow?.buttonType ||
+                    (btn.targetPageId ? 'Jump' : 'TTS');
+                const actionData = {};
+                if (buttonType === 'Jump' && btn.targetPageId) {
+                    actionData.JumpTo = Number(btn.targetPageId);
+                    actionData.TTSText = '';
+                }
+                else if (buttonType === 'TTS') {
+                    // Only store TTSText when it differs from the label (matches GoTalk's convention).
+                    actionData.TTSText = btn.message && btn.message !== btn.label ? btn.message : '';
+                }
+                else {
+                    actionData.TTSText = btn.message || '';
+                }
+                const rawButton = {
+                    ActionData: actionData,
+                    ButtonType: buttonType,
+                    ButtonText: btn.label || '',
+                };
+                if (btn.resolvedImageEntry || btn.image) {
+                    rawButton.ButtonImages = [
+                        {
+                            Location: btn.resolvedImageEntry || btn.image,
+                            Type: 'Saved',
+                        },
+                    ];
+                }
+                buttons[btnIndex] = rawButton;
+            });
+            pageData[pageId] = {
+                ButtonCount: buttonList.length,
+                Buttons: buttons,
+            };
+            // Collect referenced images so we can include them in the archive.
+            buttonList.forEach((btn) => {
+                if (btn.resolvedImageEntry) {
+                    // Image bytes are not available from the tree alone; skip if absent.
+                }
+            });
+            void pageIdx;
+        });
+        const bookInfo = {
+            GoTalkBookFormatVersion: Number(tree.metadata.version) || 1,
+        };
+        const zip = await this.options.zipAdapter(undefined, this.options.fileAdapter);
+        const files = [
+            { name: 'BookInfo.plist', data: plist.build(bookInfo) },
+            { name: 'PageData.plist', data: plist.build(pageData) },
+            {
+                name: 'PageOrder.plist',
+                data: plist.build(pageOrder),
+            },
+            { name: 'PageHistory.plist', data: plist.build([]) },
+            ...imageFiles,
+        ];
+        const outputBuffer = await zip.writeFiles(files);
+        await writeBinaryToPath(outputPath, outputBuffer);
+    }
+    /**
+     * Extract strings with metadata for aac-tools-platform compatibility.
+     * Uses the generic implementation from BaseProcessor.
+     */
+    extractStringsWithMetadata(filePath) {
+        return this.extractStringsWithMetadataGeneric(filePath);
+    }
+    /**
+     * Generate translated download for aac-tools-platform compatibility.
+     * Uses the generic implementation from BaseProcessor.
+     */
+    generateTranslatedDownload(filePath, translatedStrings, sourceStrings) {
+        return this.generateTranslatedDownloadGeneric(filePath, translatedStrings, sourceStrings);
+    }
+}
+export { GotalkNowProcessor };

package/dist/browser/processors/gridsetProcessor.js

@@ -2960,8 +2960,8 @@ class GridsetProcessor extends BaseProcessor {
                                         cellContent.CaptionAndImage = captionAndImage;
                                     }
                                     const cellData = {
-                                        '@_X': position.x + 1, // Grid3 uses 1-based X coordinates
-                                        '@_Y': position.y + yOffset + 1, // Grid3 uses 1-based Y coordinates with workspace offset
+                                        '@_X': position.x, // Grid 3 coordinates are 0-based (matching loader)
+                                        '@_Y': position.y + yOffset,
                                         '@_ColumnSpan': position.columnSpan,
                                         '@_RowSpan': position.rowSpan,
                                         Content: cellContent,

package/dist/browser/processors/obfProcessor.js

@@ -144,14 +144,21 @@ class ObfProcessor extends BaseProcessor {
         const pageId = boardData?.id ? String(boardData.id) : _boardPath?.split(/[/\\]/).pop() || '';
         const images = boardData.images;
         const buttons = await Promise.all(sourceButtons.map(async (btn) => {
+            // Resolve load_board.path to a board ID (strip .obf suffix if present).
+            // The OBF spec says load_board.path is a file path, but internally we
+            // store the board ID as targetPageId.
+            const rawPath = btn.load_board?.path;
+            const boardRef = rawPath
+                ? rawPath.replace(/\.obf$/i, '').replace(/\.obz$/i, '')
+                : undefined;
             const semanticAction = btn.load_board
                 ? {
                     category: AACSemanticCategory.NAVIGATION,
                     intent: AACSemanticIntent.NAVIGATE_TO,
-                    targetId: btn.load_board.path,
+                    targetId: boardRef,
                     fallback: {
                         type: 'NAVIGATE',
-                        targetPageId: btn.load_board.path,
+                        targetPageId: boardRef,
                     },
                 }
                 : {
@@ -199,7 +206,7 @@ class ObfProcessor extends BaseProcessor {
                 resolvedImageEntry: resolvedImage,
                 parameters: Object.keys(buttonParameters).length > 0 ? buttonParameters : undefined,
                 semanticAction,
-                targetPageId: btn.load_board?.path,
+                targetPageId: boardRef,
                 semantic_id: btn.semantic_id, // Extract semantic_id if present
             });
         }));
@@ -618,7 +625,7 @@ class ObfProcessor extends BaseProcessor {
                     vocalization: button.message || button.label,
                     load_board: button.semanticAction?.intent === AACSemanticIntent.NAVIGATE_TO && button.targetPageId
                         ? {
-                            path: button.targetPageId,
+                            path: this.getPageFilename(button.targetPageId, metadata),
                         }
                         : undefined,
                     background_color: button.style?.backgroundColor,
@@ -688,7 +695,9 @@ class ObfProcessor extends BaseProcessor {
             });
             const manifest = {
                 format: OBF_FORMAT_VERSION,
-                root: tree.metadata.defaultHomePageId,
+                root: tree.metadata.defaultHomePageId
+                    ? this.getPageFilename(tree.metadata.defaultHomePageId, tree.metadata)
+                    : undefined,
                 paths: {
                     boards: Object.fromEntries(Object.entries(tree.pages).map(([id, page]) => [
                         id,
@@ -755,7 +764,9 @@ class ObfProcessor extends BaseProcessor {
         if (Object.keys(tree.pages).length > 0) {
             const manifest = {
                 format: OBF_FORMAT_VERSION,
-                root: tree.metadata.defaultHomePageId,
+                root: tree.metadata.defaultHomePageId
+                    ? this.getPageFilename(tree.metadata.defaultHomePageId, tree.metadata)
+                    : undefined,
                 paths: {
                     boards: Object.fromEntries(Object.entries(tree.pages).map(([id, page]) => [
                         id,