tide-commander 1.199.6 → 1.201.0

package/dist/src/packages/server/routes/files.js

@@ -14,7 +14,8 @@ import { loadAreas } from '../data/index.js';
 import { detectRunnerType, mightBeTestFile, mightBeVitestFile, mightBePhpTestFile } from '../services/test-runner-service.js';
 import { DEFAULT_FILE_SEARCH_EXCLUDE_DIRS, parseExcludeDirNames } from '../../shared/file-search.js';
 import { detectArchiveFormat, listArchive } from '../services/archive-listing.js';
-import { readSpreadsheet, detectSpreadsheetKind, UnsupportedSpreadsheetError, SPREADSHEET_DEFAULT_MAX_ROWS, SPREADSHEET_DEFAULT_MAX_COLS, SPREADSHEET_HARD_MAX_ROWS, SPREADSHEET_HARD_MAX_COLS } from '../services/spreadsheet-parse.js';
+import { readSpreadsheet, detectSpreadsheetKind, UnsupportedSpreadsheetError, SPREADSHEET_DEFAULT_MAX_ROWS, SPREADSHEET_DEFAULT_MAX_COLS, SPREADSHEET_HARD_MAX_ROWS, SPREADSHEET_HARD_MAX_COLS, zipSourceFromFd } from '../services/spreadsheet-parse.js';
+import { readDocument, detectDocumentKind, UnsupportedDocumentError, DOCUMENT_DEFAULT_MAX_BLOCKS, DOCUMENT_HARD_MAX_BLOCKS } from '../services/document-parse.js';
 import { searchFilesGlobal, searchFileContentsGlobal, FILE_SEARCH_MIN_QUERY, FILE_CONTENT_SEARCH_MIN_QUERY, } from '../services/global-file-search.js';
 const log = logger.files;
 // Get or create temp directory for tide-commander uploads. Exported so other
@@ -971,6 +972,136 @@ router.get('/spreadsheet', async (req, res) => {
         res.status(422).json({ error: err.message });
     }
 });
+/** Parsed documents, most-recently-used last (Map preserves order). */
+const documentCache = new Map();
+const DOCUMENT_CACHE_ENTRIES = 12;
+// GET /api/files/document - Parse a word-processing document (docx/docm/odt/
+// doc/rtf — see document-parse.ts) into renderable blocks for the file
+// viewers. `blocks` caps the payload; the response says how many exist.
+router.get('/document', async (req, res) => {
+    try {
+        const resolution = findFileWithFallbacks(req.query.path, req.query.baseDir);
+        if (!resolution.ok) {
+            const body = { error: resolution.error };
+            if (resolution.requested)
+                body.path = resolution.requested;
+            if (resolution.tried)
+                body.triedRoots = resolution.tried;
+            res.status(resolution.status).json(body);
+            return;
+        }
+        const filePath = resolution.path;
+        const stats = fs.statSync(filePath);
+        if (stats.isDirectory()) {
+            res.status(400).json({ error: 'Path is a directory', path: filePath });
+            return;
+        }
+        const filename = path.basename(filePath);
+        if (!detectDocumentKind(filename)) {
+            res.status(415).json({ error: 'Not a supported document type', path: filePath });
+            return;
+        }
+        const rawBlocks = typeof req.query.blocks === 'string' ? parseInt(req.query.blocks, 10) : NaN;
+        const maxBlocks = Number.isFinite(rawBlocks) && rawBlocks > 0
+            ? Math.min(rawBlocks, DOCUMENT_HARD_MAX_BLOCKS)
+            : DOCUMENT_DEFAULT_MAX_BLOCKS;
+        const cacheKey = `${filePath}|${stats.mtimeMs}|${stats.size}|${maxBlocks}`;
+        const cached = documentCache.get(cacheKey);
+        if (cached) {
+            documentCache.delete(cacheKey);
+            documentCache.set(cacheKey, cached);
+            res.json(cached);
+            return;
+        }
+        const parsed = await readDocument(filePath, { maxBlocks });
+        const body = {
+            path: filePath,
+            filename,
+            extension: path.extname(filePath).toLowerCase(),
+            size: stats.size,
+            modified: stats.mtime,
+            format: parsed.format,
+            title: parsed.title,
+            author: parsed.author,
+            blocks: parsed.blocks,
+            footnotes: parsed.footnotes,
+            header: parsed.header,
+            footer: parsed.footer,
+            wordCount: parsed.wordCount,
+            blockCount: parsed.blockCount,
+            truncated: parsed.truncated,
+            plainTextOnly: parsed.plainTextOnly,
+            maxBlocks,
+        };
+        documentCache.set(cacheKey, body);
+        while (documentCache.size > DOCUMENT_CACHE_ENTRIES) {
+            const oldest = documentCache.keys().next().value;
+            if (oldest === undefined)
+                break;
+            documentCache.delete(oldest);
+        }
+        res.json(body);
+    }
+    catch (err) {
+        if (err instanceof UnsupportedDocumentError) {
+            res.status(415).json({ error: err.message, extension: err.extension, unsupported: true });
+            return;
+        }
+        log.error(' Failed to parse document:', err);
+        res.status(422).json({ error: err.message });
+    }
+});
+/** Image types that may be served out of a document container. */
+const DOCUMENT_MEDIA_TYPES = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
+    '.bmp': 'image/bmp', '.webp': 'image/webp', '.svg': 'image/svg+xml', '.tif': 'image/tiff',
+    '.tiff': 'image/tiff', '.emf': 'image/emf', '.wmf': 'image/wmf', '.ico': 'image/x-icon',
+};
+// GET /api/files/document-media - Serve ONE embedded image out of a document
+// container (docx/odt zip entry), so the viewer can render pictures inline
+// without ever extracting the archive to disk.
+router.get('/document-media', async (req, res) => {
+    let fd;
+    try {
+        const entry = typeof req.query.entry === 'string' ? req.query.entry : '';
+        // Only media entries of the container — never an arbitrary zip member.
+        if (!/^(?:word\/media\/|media\/|Pictures\/)[^/]+$/i.test(entry)) {
+            res.status(400).json({ error: 'Invalid media entry' });
+            return;
+        }
+        const resolution = findFileWithFallbacks(req.query.path, req.query.baseDir);
+        if (!resolution.ok) {
+            res.status(resolution.status).json({ error: resolution.error });
+            return;
+        }
+        const filePath = resolution.path;
+        const stats = fs.statSync(filePath);
+        if (stats.isDirectory() || !detectDocumentKind(path.basename(filePath))) {
+            res.status(415).json({ error: 'Not a supported document type' });
+            return;
+        }
+        fd = await fs.promises.open(filePath, 'r');
+        const src = await zipSourceFromFd(fd, stats.size);
+        const data = await src.readMember(entry);
+        if (!data) {
+            res.status(404).json({ error: 'Media entry not found in document' });
+            return;
+        }
+        const ext = path.extname(entry).toLowerCase();
+        res.setHeader('Content-Type', DOCUMENT_MEDIA_TYPES[ext] ?? 'application/octet-stream');
+        res.setHeader('Cache-Control', 'private, max-age=3600');
+        res.setHeader('Content-Length', String(data.length));
+        res.end(data);
+    }
+    catch (err) {
+        log.error(' Failed to read document media:', err);
+        if (!res.headersSent)
+            res.status(422).json({ error: err.message });
+    }
+    finally {
+        await fd?.close();
+    }
+});
 // GET /api/files/binary - Read binary file (for images, PDFs, downloads)
 router.get('/binary', async (req, res) => {
     try {

package/dist/src/packages/server/services/cfb-reader.js

@@ -0,0 +1,153 @@
+/**
+ * OLE2 / Compound File Binary (CFB) container reader — dependency-free.
+ *
+ * The envelope of every legacy Office binary: `.xls` keeps its BIFF records in
+ * a "Workbook" stream, `.doc` keeps text and tables in "WordDocument" +
+ * "0Table"/"1Table", `.ppt` in "PowerPoint Document". This module exposes the
+ * directory and the streams; the format-specific readers live next to it
+ * (spreadsheet-biff.ts, document-doc.ts).
+ */
+const CFB_MAGIC = Buffer.from([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]);
+const ENDOFCHAIN = 0xfffffffe;
+const FREESECT = 0xffffffff;
+const MAX_STREAM_BYTES = 256 * 1024 * 1024;
+export function isCfbBuffer(buf) {
+    return buf.length >= 8 && buf.subarray(0, 8).equals(CFB_MAGIC);
+}
+export function readCfb(buf) {
+    if (!isCfbBuffer(buf))
+        throw new Error('not an OLE2 compound file');
+    const sectorShift = buf.readUInt16LE(0x1e);
+    const miniShift = buf.readUInt16LE(0x20);
+    const sectorSize = 1 << sectorShift;
+    const miniSectorSize = 1 << miniShift;
+    const numFatSectors = buf.readUInt32LE(0x2c);
+    const firstDirSector = buf.readUInt32LE(0x30);
+    const miniCutoff = buf.readUInt32LE(0x38);
+    const firstMiniFatSector = buf.readUInt32LE(0x3c);
+    const numMiniFatSectors = buf.readUInt32LE(0x40);
+    const firstDifatSector = buf.readUInt32LE(0x44);
+    const numDifatSectors = buf.readUInt32LE(0x48);
+    const entriesPerSector = sectorSize / 4;
+    const sectorOffset = (n) => (n + 1) * sectorSize;
+    const readSector = (n) => {
+        const off = sectorOffset(n);
+        if (off + sectorSize > buf.length) {
+            // Truncated files: pad the last sector instead of failing outright.
+            const out = Buffer.alloc(sectorSize);
+            if (off < buf.length)
+                buf.copy(out, 0, off);
+            return out;
+        }
+        return buf.subarray(off, off + sectorSize);
+    };
+    // DIFAT → list of FAT sectors.
+    const fatSectors = [];
+    for (let i = 0; i < 109 && fatSectors.length < numFatSectors; i++) {
+        const s = buf.readUInt32LE(0x4c + i * 4);
+        if (s === FREESECT || s === ENDOFCHAIN)
+            break;
+        fatSectors.push(s);
+    }
+    let difat = firstDifatSector;
+    let guard = 0;
+    while (difat !== ENDOFCHAIN && difat !== FREESECT && guard++ < numDifatSectors + 1) {
+        const sec = readSector(difat);
+        for (let i = 0; i < entriesPerSector - 1 && fatSectors.length < numFatSectors; i++) {
+            const s = sec.readUInt32LE(i * 4);
+            if (s === FREESECT || s === ENDOFCHAIN)
+                break;
+            fatSectors.push(s);
+        }
+        difat = sec.readUInt32LE((entriesPerSector - 1) * 4);
+    }
+    const fat = new Uint32Array(fatSectors.length * entriesPerSector);
+    fatSectors.forEach((s, i) => {
+        const sec = readSector(s);
+        for (let j = 0; j < entriesPerSector; j++)
+            fat[i * entriesPerSector + j] = sec.readUInt32LE(j * 4);
+    });
+    const readChain = (start, sizeHint) => {
+        const parts = [];
+        let s = start;
+        let total = 0;
+        let steps = 0;
+        const maxSteps = fat.length + 2;
+        while (s !== ENDOFCHAIN && s !== FREESECT && s < 0xfffffffa && steps++ < maxSteps) {
+            parts.push(readSector(s));
+            total += sectorSize;
+            if (total > MAX_STREAM_BYTES)
+                throw new Error('compound file stream too large');
+            if (sizeHint !== undefined && total >= sizeHint)
+                break;
+            s = s < fat.length ? fat[s] : ENDOFCHAIN;
+        }
+        const joined = Buffer.concat(parts);
+        return sizeHint !== undefined ? joined.subarray(0, Math.min(sizeHint, joined.length)) : joined;
+    };
+    // Directory entries.
+    const dir = readChain(firstDirSector);
+    const entries = [];
+    for (let off = 0; off + 128 <= dir.length; off += 128) {
+        const nameLen = dir.readUInt16LE(off + 0x40);
+        const type = dir[off + 0x42];
+        if (type === 0 && nameLen === 0)
+            continue;
+        const name = dir.subarray(off, off + Math.max(0, Math.min(64, nameLen) - 2)).toString('utf16le');
+        const startSector = dir.readUInt32LE(off + 0x74);
+        // 64-bit size field; anything beyond 2^32 is nonsense for our purposes.
+        const size = dir.readUInt32LE(off + 0x78);
+        entries.push({ name, type, startSector, size });
+    }
+    const root = entries.find((e) => e.type === 5) ?? entries[0];
+    // Mini FAT + mini stream (root entry's chain).
+    let miniFat = new Uint32Array(0);
+    let miniStream = Buffer.alloc(0);
+    if (root && numMiniFatSectors > 0 && firstMiniFatSector !== ENDOFCHAIN) {
+        const mf = readChain(firstMiniFatSector);
+        miniFat = new Uint32Array(Math.floor(mf.length / 4));
+        for (let i = 0; i < miniFat.length; i++)
+            miniFat[i] = mf.readUInt32LE(i * 4);
+        miniStream = readChain(root.startSector, root.size);
+    }
+    return { sectorSize, miniSectorSize, fat, miniFat, miniStream, miniCutoff, entries };
+}
+export function readCfbStream(cfb, entry, buf) {
+    if (entry.size < cfb.miniCutoff) {
+        const parts = [];
+        let s = entry.startSector;
+        let total = 0;
+        let steps = 0;
+        while (s !== ENDOFCHAIN && s !== FREESECT && s < 0xfffffffa && steps++ < cfb.miniFat.length + 2 && total < entry.size) {
+            const off = s * cfb.miniSectorSize;
+            parts.push(cfb.miniStream.subarray(off, off + cfb.miniSectorSize));
+            total += cfb.miniSectorSize;
+            s = s < cfb.miniFat.length ? cfb.miniFat[s] : ENDOFCHAIN;
+        }
+        return Buffer.concat(parts).subarray(0, entry.size);
+    }
+    const parts = [];
+    let s = entry.startSector;
+    let total = 0;
+    let steps = 0;
+    while (s !== ENDOFCHAIN && s !== FREESECT && s < 0xfffffffa && steps++ < cfb.fat.length + 2 && total < entry.size) {
+        const off = (s + 1) * cfb.sectorSize;
+        const sec = off + cfb.sectorSize <= buf.length ? buf.subarray(off, off + cfb.sectorSize) : Buffer.concat([buf.subarray(off), Buffer.alloc(Math.max(0, off + cfb.sectorSize - buf.length))]);
+        parts.push(sec);
+        total += cfb.sectorSize;
+        if (total > MAX_STREAM_BYTES)
+            throw new Error('compound file stream too large');
+        s = s < cfb.fat.length ? cfb.fat[s] : ENDOFCHAIN;
+    }
+    return Buffer.concat(parts).subarray(0, entry.size);
+}
+/** Read a stream by (case-insensitive) name; null when absent. */
+export function readCfbStreamByName(buf, cfb, name) {
+    const target = name.toLowerCase();
+    const entry = cfb.entries.find((e) => e.type === 2 && e.name.toLowerCase() === target);
+    return entry ? readCfbStream(cfb, entry, buf) : null;
+}
+/** Names of the streams in the container (for diagnostics / sniffing). */
+export function cfbStreamNames(cfb) {
+    return cfb.entries.filter((e) => e.type === 2).map((e) => e.name);
+}

package/dist/src/packages/server/services/document-doc.js

@@ -0,0 +1,235 @@
+/**
+ * Legacy Word (.doc, Word 97-2003) reader — dependency-free, text + structure.
+ *
+ * A .doc is an OLE2 compound file (see cfb-reader.ts). The "WordDocument"
+ * stream starts with the FIB (File Information Block), whose `fcClx` /`lcbClx`
+ * point into the table stream ("1Table" or "0Table", chosen by the FIB's
+ * `fWhichTblStm` flag). The Clx ends with a Pcdt: a PlcPcd — an array of
+ * character positions followed by 8-byte piece descriptors. Each piece says
+ * where its text lives in WordDocument and whether it is UTF-16 or CP1252
+ * (bit 30 of the fc field, with the offset halved when set).
+ *
+ * What we recover: the document text split into paragraphs (Word separates
+ * them with CR = 0x0D), with the field/footnote/header sentinels and the
+ * cell/row marks turned into readable structure. Formatting (bold, styles)
+ * lives in the CHPX/PAPX binary tables and is deliberately NOT parsed — the
+ * viewer marks these documents `plainTextOnly` and suggests converting to
+ * .docx for full fidelity.
+ */
+import { cfbStreamNames, isCfbBuffer, readCfb, readCfbStreamByName } from './cfb-reader.js';
+const FIB_MAGIC_WORD = 0xa5ec; // wIdent for Word 97+ (0xA5DC/0xA5DB are Word 6/95)
+/** Parse the PlcPcd (piece table) out of the Clx blob. */
+export function parsePieceTable(clx) {
+    // Clx = Prc* Pcdt. Skip Prc entries (0x01 + 2-byte cbGrpprl + data).
+    let pos = 0;
+    while (pos < clx.length && clx[pos] === 0x01) {
+        if (pos + 3 > clx.length)
+            return [];
+        const cb = clx.readUInt16LE(pos + 1);
+        pos += 3 + cb;
+    }
+    if (pos >= clx.length || clx[pos] !== 0x02)
+        return [];
+    if (pos + 5 > clx.length)
+        return [];
+    const lcb = clx.readUInt32LE(pos + 1);
+    const plc = clx.subarray(pos + 5, pos + 5 + lcb);
+    // PlcPcd: (n+1) CPs (4 bytes each) then n PCDs (8 bytes each).
+    const n = Math.floor((plc.length - 4) / 12);
+    if (n <= 0)
+        return [];
+    const pieces = [];
+    for (let i = 0; i < n; i++) {
+        const cpStart = plc.readUInt32LE(i * 4);
+        const cpEnd = plc.readUInt32LE((i + 1) * 4);
+        const pcdOff = (n + 1) * 4 + i * 8;
+        if (pcdOff + 8 > plc.length)
+            break;
+        const fcValue = plc.readUInt32LE(pcdOff + 2);
+        const compressed = (fcValue & 0x40000000) !== 0;
+        const fc = compressed ? (fcValue & 0x3fffffff) / 2 : (fcValue & 0x3fffffff);
+        pieces.push({ cpStart, cpEnd, fc: Math.floor(fc), compressed });
+    }
+    return pieces;
+}
+/** CP1252 high range (0x80-0x9F) — the rest of latin1 maps 1:1. */
+const CP1252_HIGH = '€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ';
+function decodeCp1252(bytes) {
+    let out = '';
+    for (const b of bytes)
+        out += b >= 0x80 && b <= 0x9f ? CP1252_HIGH[b - 0x80] : String.fromCharCode(b);
+    return out;
+}
+/** Concatenate the text of every piece, in CP order. */
+export function readPieceText(wordDocument, pieces) {
+    const parts = [];
+    for (const p of pieces) {
+        const chars = Math.max(0, p.cpEnd - p.cpStart);
+        if (chars === 0)
+            continue;
+        const bytes = p.compressed ? chars : chars * 2;
+        if (p.fc < 0 || p.fc >= wordDocument.length)
+            continue;
+        const slice = wordDocument.subarray(p.fc, Math.min(wordDocument.length, p.fc + bytes));
+        parts.push(p.compressed ? decodeCp1252(slice) : slice.toString('utf16le'));
+    }
+    return parts.join('');
+}
+/**
+ * Word control characters that must not reach the reader:
+ *  0x01 picture placeholder · 0x02 footnote/annotation ref · 0x05 comment
+ *  0x08 drawn object · 0x13/0x14/0x15 field begin/separator/end · 0x0C page
+ *  break · 0x0E column break · 0x1E non-breaking hyphen · 0x1F optional hyphen.
+ * Field instructions (between 0x13 and 0x14) are metadata (HYPERLINK "…",
+ * PAGE, TOC) — dropped; the field RESULT (0x14…0x15) is kept.
+ */
+export function docTextToParagraphs(text, maxBlocks) {
+    const blocks = [];
+    let blockCount = 0;
+    let truncated = false;
+    let current = '';
+    let inFieldInstruction = false;
+    let cellFlush = false;
+    const push = () => {
+        const cleaned = current.replace(/[\u0000-\u0008\u000e-\u001f]/g, '').replace(/\u00a0/g, ' ').trimEnd();
+        current = '';
+        if (cleaned.trim() === '')
+            return;
+        blockCount++;
+        if (blocks.length >= maxBlocks) {
+            truncated = true;
+            return;
+        }
+        const para = { type: 'paragraph', runs: [{ text: cleaned }] };
+        blocks.push(para);
+    };
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        switch (code) {
+            case 0x13:
+                inFieldInstruction = true;
+                continue; // field begin
+            case 0x14:
+                inFieldInstruction = false;
+                continue; // field separator
+            case 0x15: continue; // field end
+            case 0x0d:
+            case 0x0a: // paragraph end
+                push();
+                continue;
+            case 0x07:
+                // Every cell ends with 0x07; the ROW ends with one more right after
+                // the last cell's — so two in a row mean "end of line", one means
+                // "next cell" (rendered as a tab, like the .doc → text convention).
+                if (cellFlush) {
+                    push();
+                    cellFlush = false;
+                }
+                else {
+                    current += '\t';
+                    cellFlush = true;
+                }
+                continue;
+            case 0x0b:
+                current += '\n';
+                continue; // line break
+            case 0x0c:
+                push();
+                continue; // page break
+            case 0x1e:
+                current += '-';
+                continue; // non-breaking hyphen
+            case 0x1f: continue; // optional hyphen
+            default:
+                if (inFieldInstruction)
+                    continue;
+                if (code < 0x20 && code !== 0x09)
+                    continue;
+                current += text[i];
+        }
+        // Only a SECOND consecutive 0x07 is a row mark, so the flag survives only
+        // until the next character.
+        cellFlush = false;
+    }
+    push();
+    return { blocks, blockCount, truncated };
+}
+/** Parse a Word 97-2003 .doc buffer into plain paragraphs. */
+export function parseDocBuffer(buf, maxBlocks) {
+    if (!isCfbBuffer(buf))
+        throw new Error('not an OLE2 compound file');
+    const cfb = readCfb(buf);
+    const wordDocument = readCfbStreamByName(buf, cfb, 'WordDocument');
+    if (!wordDocument) {
+        const names = cfbStreamNames(cfb).slice(0, 8).join(', ');
+        throw new Error(`OLE2 file without a WordDocument stream (streams: ${names || 'none'}) — not a Word document`);
+    }
+    if (wordDocument.length < 0x0200)
+        throw new Error('WordDocument stream is too small to hold a FIB');
+    const wIdent = wordDocument.readUInt16LE(0);
+    if (wIdent !== FIB_MAGIC_WORD) {
+        throw new Error(wIdent === 0xa5db || wIdent === 0xa5dc
+            ? 'This is a Word 6/95 document — too old for the built-in viewer; open it in LibreOffice and save as .docx.'
+            : `unrecognized Word file header (0x${wIdent.toString(16)})`);
+    }
+    // FIB base: flags at 0x0A, fWhichTblStm is bit 9 (0x0200).
+    const flags = wordDocument.readUInt16LE(0x0a);
+    const tableName = (flags & 0x0200) ? '1Table' : '0Table';
+    const table = readCfbStreamByName(buf, cfb, tableName) ?? readCfbStreamByName(buf, cfb, tableName === '1Table' ? '0Table' : '1Table');
+    if (!table)
+        throw new Error('Word document without a table stream (0Table/1Table)');
+    // The FibRgFcLcb array starts after the FIB base (0x0020) + csw (2 + 2*csw)
+    // + cslw (2 + 4*cslw) + cbRgFcLcb (2). Its entries are (fc, lcb) u32 pairs;
+    // fcClx/lcbClx is entry 33 of FibRgFcLcb97 (unchanged in the 2000-2007
+    // extensions, which only append).
+    let pos = 0x0020;
+    const csw = wordDocument.readUInt16LE(pos);
+    pos += 2 + csw * 2;
+    const cslw = wordDocument.readUInt16LE(pos);
+    pos += 2 + cslw * 4;
+    const cbRgFcLcb = wordDocument.readUInt16LE(pos);
+    pos += 2;
+    const rgFcLcb = wordDocument.subarray(pos, pos + cbRgFcLcb * 8);
+    const CLX_INDEX = 33;
+    if (rgFcLcb.length < (CLX_INDEX + 1) * 8)
+        throw new Error('Word FIB is truncated (no Clx pointer)');
+    let fcClx = rgFcLcb.readUInt32LE(CLX_INDEX * 8);
+    let lcbClx = rgFcLcb.readUInt32LE(CLX_INDEX * 8 + 4);
+    let pieces = lcbClx > 0 && fcClx + lcbClx <= table.length
+        ? parsePieceTable(table.subarray(fcClx, fcClx + lcbClx))
+        : [];
+    if (pieces.length === 0) {
+        // Writers that lay the FIB out differently (or files repaired by other
+        // tools) still keep a Clx in the table stream: find the entry that points
+        // at one and yields a usable piece table.
+        for (let i = 0; i < cbRgFcLcb && pieces.length === 0; i++) {
+            const fc = rgFcLcb.readUInt32LE(i * 8);
+            const lcb = rgFcLcb.readUInt32LE(i * 8 + 4);
+            if (lcb <= 8 || fc + lcb > table.length)
+                continue;
+            if (table[fc] !== 0x01 && table[fc] !== 0x02)
+                continue;
+            const candidate = parsePieceTable(table.subarray(fc, fc + lcb));
+            if (candidate.length > 0) {
+                pieces = candidate;
+                fcClx = fc;
+                lcbClx = lcb;
+            }
+        }
+    }
+    if (pieces.length === 0)
+        throw new Error('Word document has no readable piece table');
+    const text = readPieceText(wordDocument, pieces);
+    const { blocks, blockCount, truncated } = docTextToParagraphs(text, maxBlocks);
+    let wordCount = 0;
+    for (const b of blocks) {
+        if (b.type !== 'paragraph')
+            continue;
+        for (const r of b.runs) {
+            const t = r.text.trim();
+            if (t)
+                wordCount += t.split(/\s+/).length;
+        }
+    }
+    return { format: 'doc', blocks, wordCount, blockCount, truncated, plainTextOnly: true };
+}