@willwade/aac-processors 0.2.20 → 0.3.0

package/README.md

@@ -65,6 +65,7 @@ const tree = await processor.loadIntoTree(gridsetUint8Array);
 - DOT (Graphviz)
 - Apple Panels (macOS plist)
 - Asterics Grid
+- GoTalk NOW (.gtbz)
 - Excel export
 
 ## Wrangle strings workflow

package/dist/browser/index.browser.js

@@ -28,6 +28,7 @@ export { SnapProcessor } from './processors/snapProcessor';
 export { TouchChatProcessor } from './processors/touchchatProcessor';
 export { ApplePanelsProcessor } from './processors/applePanelsProcessor';
 export { AstericsGridProcessor } from './processors/astericsGridProcessor';
+export { GotalkNowProcessor } from './processors/gotalkNowProcessor';
 // ===================================================================
 // UTILITY FUNCTIONS
 // ===================================================================
@@ -41,6 +42,7 @@ import { SnapProcessor } from './processors/snapProcessor';
 import { TouchChatProcessor } from './processors/touchchatProcessor';
 import { ApplePanelsProcessor } from './processors/applePanelsProcessor';
 import { AstericsGridProcessor } from './processors/astericsGridProcessor';
+import { GotalkNowProcessor } from './processors/gotalkNowProcessor';
 export { configureSqlJs } from './utils/sqlite';
 /**
  * Factory function to get the appropriate processor for a file extension
@@ -71,6 +73,8 @@ export function getProcessor(filePathOrExtension, options) {
             return new ApplePanelsProcessor(options);
         case '.grd':
             return new AstericsGridProcessor(options);
+        case '.gtbz':
+            return new GotalkNowProcessor(options);
         default:
             throw new Error(`Unsupported file extension: ${extension}`);
     }
@@ -80,7 +84,19 @@ export function getProcessor(filePathOrExtension, options) {
  * @returns Array of supported file extensions
  */
 export function getSupportedExtensions() {
-    return ['.dot', '.opml', '.obf', '.obz', '.gridset', '.spb', '.sps', '.ce', '.plist', '.grd'];
+    return [
+        '.dot',
+        '.opml',
+        '.obf',
+        '.obz',
+        '.gridset',
+        '.spb',
+        '.sps',
+        '.ce',
+        '.plist',
+        '.grd',
+        '.gtbz',
+    ];
 }
 /**
  * Check if a file extension is supported

package/dist/browser/processors/gotalkNow/nsKeyed.js

@@ -0,0 +1,101 @@
+/**
+ * Helpers for decoding GoTalk NOW's NSKeyedArchiver-encoded values.
+ *
+ * GoTalk NOW stores UIColor and UIFont objects inside `<data>` tags as
+ * binary property lists (NSKeyedArchiver). Rather than pulling in a full
+ * bplist parser, we exploit the fact that the archived objects embed
+ * human-readable ASCII representations of the component values, e.g. an
+ * NSRGB colour appears as "0.908 0.355 0.522" and a font name appears as
+ * "Futura-Medium".
+ */
+function bufferToLatinString(buffer) {
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(buffer)) {
+        return buffer.toString('latin1');
+    }
+    let out = '';
+    for (let i = 0; i < buffer.length; i++)
+        out += String.fromCharCode(buffer[i]);
+    return out;
+}
+function clampUnit(v) {
+    if (Number.isNaN(v))
+        return 0;
+    return Math.max(0, Math.min(1, v));
+}
+function toHexChannel(v) {
+    return Math.round(clampUnit(v) * 255)
+        .toString(16)
+        .padStart(2, '0');
+}
+/** Convert a 0-1 float triple to an #rrggbb hex string. */
+function rgbToHex(r, g, b) {
+    return `#${toHexChannel(r)}${toHexChannel(g)}${toHexChannel(b)}`;
+}
+/**
+ * Decode an NSKeyedArchiver-encoded UIColor into a #rrggbb hex string.
+ *
+ * NSRGB / NSCalibratedRGB colours store a human-readable "R G B [A]" string
+ * (e.g. "0.908 0.355 0.522") inside the archive — this is the only encoding we
+ * can reliably read without a full binary-plist parser. NSWhite and
+ * UISystemColor values store their components as raw IEEE-754 floats, so we
+ * return undefined for those rather than risk an incorrect colour.
+ */
+export function decodeNsColor(buffer) {
+    if (!buffer)
+        return undefined;
+    const s = bufferToLatinString(buffer);
+    // Require decimal points to avoid matching bplist header bytes (e.g. "00").
+    // Accept 3 or 4 components (RGB or RGBA).
+    const rgbMatch = s.match(/(\d+\.\d+)\s+(\d+\.\d+)\s+(\d+\.\d+)(?:\s+(\d+\.\d+))?/);
+    if (rgbMatch) {
+        const [, r, g, b] = rgbMatch;
+        return rgbToHex(parseFloat(r), parseFloat(g), parseFloat(b));
+    }
+    return undefined;
+}
+const FONT_KEYWORDS = new Set([
+    'UIFont',
+    'UIFontName',
+    'UIFontPointSize',
+    'UIFontDescriptor',
+    'UIFontTraits',
+    'UIFontSystemFont',
+    'UIFontDescriptorAttributes',
+    'UIFontSystemFontName',
+    'NSFont',
+    'NSFontNameAttribute',
+    'NSFontSizeAttribute',
+    'NSName',
+    'NSSize',
+    'NSMutableDictionary',
+    'NSDictionary',
+    'NSObject',
+    'NSKeyedArchiver',
+    'NSColor',
+    'NSColorSpace',
+    'VUIFont',
+    'XNSObject',
+    'classname',
+    'classhints',
+    'classes',
+    'objects',
+    'version',
+    'archiver',
+    'root',
+]);
+/**
+ * Decode an NSKeyedArchiver-encoded UIFont into its family name.
+ * Font size is encoded as a raw IEEE-754 float and is not extracted.
+ */
+export function decodeNsFont(buffer) {
+    if (!buffer)
+        return {};
+    const s = bufferToLatinString(buffer);
+    const tokens = s.match(/[A-Za-z][A-Za-z0-9-]{2,}/g) || [];
+    const fontFamily = tokens.find((t) => !FONT_KEYWORDS.has(t) &&
+        !t.startsWith('UI') &&
+        !t.startsWith('NS') &&
+        !t.startsWith('CF') &&
+        !t.startsWith('GT'));
+    return fontFamily ? { fontFamily } : {};
+}

package/dist/browser/processors/gotalkNowProcessor.js

@@ -0,0 +1,463 @@
+/**
+ * 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;
+    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 },
+                    },
+                    fallback: { type: 'NAVIGATE', targetPageId: target },
+                },
+                message: '',
+                targetPageId: target,
+            };
+        }
+        case 'Audio': {
+            // Audio buttons play a recorded .caf file named <pageId>-<buttonIndex>.caf
+            const audioLocation = `${pageId}-${buttonIndex}.caf`;
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.MEDIA,
+                    intent: AACSemanticIntent.PLAY_SOUND,
+                    platformData: {
+                        gotalkNow: { buttonType: 'Audio', audioLocation },
+                    },
+                    fallback: { type: 'ACTION' },
+                },
+                message: label,
+            };
+        }
+        case 'Express':
+        case 'Bookmark':
+        case 'URL':
+        case 'Video': {
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.SYSTEM_CONTROL,
+                    intent: AACSemanticIntent.PLATFORM_SPECIFIC,
+                    platformData: {
+                        gotalkNow: { buttonType },
+                    },
+                    fallback: { type: 'ACTION' },
+                },
+                message: ttsText && ttsText.length > 0 ? ttsText : label,
+            };
+        }
+        case 'TTS':
+        default: {
+            // When TTSText is empty the visible ButtonText is spoken.
+            const spoken = ttsText && ttsText.length > 0 ? ttsText : label;
+            return {
+                semanticAction: {
+                    category: AACSemanticCategory.COMMUNICATION,
+                    intent: AACSemanticIntent.SPEAK_TEXT,
+                    text: spoken,
+                    platformData: {
+                        gotalkNow: { buttonType: 'TTS' },
+                    },
+                    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.
+                if (rawButton.Enabled === false) {
+                    button.visibility = 'Disabled';
+                }
+                // Preserve raw style data opaquely for round-trip styling.
+                button.parameters = {
+                    ...(button.parameters || {}),
+                    __gotalkNow: {
+                        buttonType: rawButton.ButtonType,
+                        textShadow: rawButton.TextShadow,
+                        textCenter: rawButton.TextCenter,
+                    },
+                };
+                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/obfProcessor.js

@@ -688,7 +688,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 +757,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,