@qvac/harness 0.7.3 → 0.8.5

package/dist-lib/lib/office/engine/xlsx/write.d.ts

@@ -0,0 +1,2 @@
+export type EmbeddedValue = string | number | null | undefined;
+export declare function writeWorkbook(rows: EmbeddedValue[][], sheet?: string): Uint8Array;

package/dist-lib/lib/office/engine/xlsx/write.js

@@ -0,0 +1,42 @@
+import { Package } from '../opc/package.js';
+import * as xml from '../xml.js';
+import { cell } from './refs.js';
+const SML = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+const REL_BASE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/';
+const TYPES = {
+    workbook: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml',
+    worksheet: 'application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml',
+    styles: 'application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'
+};
+const STYLES = `<styleSheet xmlns="${SML}"><fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts><fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills><borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders><cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs><cellXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/></cellXfs><cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles></styleSheet>`;
+function escape(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function cellXml(value, ref) {
+    if (value === null || value === undefined || value === '')
+        return '';
+    if (typeof value === 'number')
+        return `<c r="${ref}"><v>${value}</v></c>`;
+    return `<c r="${ref}" t="inlineStr"><is><t xml:space="preserve">${escape(value)}</t></is></c>`;
+}
+function sheetXml(rows) {
+    const data = rows
+        .map((row, r) => `<row r="${r + 1}">${row.map((value, c) => cellXml(value, cell(r, c))).join('')}</row>`)
+        .join('');
+    return `<worksheet xmlns="${SML}"><sheetData>${data}</sheetData></worksheet>`;
+}
+export function writeWorkbook(rows, sheet = 'Sheet1') {
+    const pkg = Package.create();
+    const workbook = `<workbook xmlns="${SML}" xmlns:r="${xml.ns.r}"><sheets><sheet name="${escape(sheet)}" sheetId="1" r:id="rId1"/></sheets></workbook>`;
+    pkg.add('/xl/workbook.xml', xml.parse(workbook), TYPES.workbook);
+    pkg.add('/xl/worksheets/sheet1.xml', xml.parse(sheetXml(rows)), TYPES.worksheet);
+    pkg.add('/xl/styles.xml', xml.parse(STYLES), TYPES.styles);
+    pkg.rels('/').add(REL_BASE + 'officeDocument', '/xl/workbook.xml');
+    pkg.rels('/xl/workbook.xml').add(REL_BASE + 'worksheet', '/xl/worksheets/sheet1.xml');
+    pkg.rels('/xl/workbook.xml').add(REL_BASE + 'styles', '/xl/styles.xml');
+    return pkg.save();
+}

package/dist-lib/lib/office/engine/xml.d.ts

@@ -0,0 +1,45 @@
+import { Element, type Document, type Node } from '@xmldom/xmldom';
+export type { Document, Element, Node };
+export declare const ns: {
+    readonly a: 'http://schemas.openxmlformats.org/drawingml/2006/main';
+    readonly p: 'http://schemas.openxmlformats.org/presentationml/2006/main';
+    readonly r: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+    readonly w: 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+    readonly p14: 'http://schemas.microsoft.com/office/powerpoint/2010/main';
+    readonly wp: 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing';
+    readonly pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture';
+    readonly c: 'http://schemas.openxmlformats.org/drawingml/2006/chart';
+    readonly xdr: 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing';
+    readonly x: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+    readonly rels: 'http://schemas.openxmlformats.org/package/2006/relationships';
+    readonly ct: 'http://schemas.openxmlformats.org/package/2006/content-types';
+};
+export type Attributes = Record<string, string | number | undefined | null>;
+export type Build = (local: string, attributes?: Attributes) => Element;
+export declare function decode(bytes: Uint8Array): string;
+export declare function parse(input: Uint8Array | string, name?: string): Document;
+export declare function toString(doc: Document): string;
+export declare function serialize(doc: Document): Uint8Array;
+export declare function root(doc: Document): Element;
+export declare function owner(node: Node): Document;
+export declare function isElement(node: Node | null, namespace?: string, local?: string): node is Element;
+export declare function children(el: Node, namespace?: string, local?: string): Element[];
+export declare function child(el: Node, namespace?: string, local?: string): Element | null;
+export declare function descendants(el: Element | Document, namespace: string, local: string): Element[];
+export declare function text(node: Node | null): string;
+export declare function clean(value: string): string;
+export declare function setText(el: Element, value: string): void;
+export declare function attr(el: Element, name: string): string;
+export declare function setAttributes(el: Element, attributes?: Attributes): Element;
+export declare function named(doc: Document, qualifiedName: string, namespace: string): Element;
+export declare function qualify(doc: Document, namespace: string, local: string): string;
+export declare function builder(doc: Document, namespace: string): Build;
+export interface QualifiedName {
+    namespace: string;
+    local: string;
+}
+export declare function setNsAttribute(el: Element, name: QualifiedName, value: string): void;
+export declare function insertOrdered(parent: Element, el: Element, order: readonly string[]): Element;
+export declare function remove(node: Node): void;
+export declare function append(parent: Node, node: Element): Element;
+export declare function clone(el: Element): Element;

package/dist-lib/lib/office/engine/xml.js

@@ -0,0 +1,258 @@
+import { DOMParser, XMLSerializer, Element } from '@xmldom/xmldom';
+import { DocsError } from './errors.js';
+import { errorMessage } from '../../guards.js';
+import * as utf8 from './utf8.js';
+export const ns = {
+    a: 'http://schemas.openxmlformats.org/drawingml/2006/main',
+    p: 'http://schemas.openxmlformats.org/presentationml/2006/main',
+    r: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+    w: 'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+    p14: 'http://schemas.microsoft.com/office/powerpoint/2010/main',
+    wp: 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing',
+    pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture',
+    c: 'http://schemas.openxmlformats.org/drawingml/2006/chart',
+    xdr: 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing',
+    x: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+    rels: 'http://schemas.openxmlformats.org/package/2006/relationships',
+    ct: 'http://schemas.openxmlformats.org/package/2006/content-types'
+};
+const MAX_DEPTH = 256;
+const NOT_XML = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+const DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+const UNPREFIXED = [ns.rels, ns.ct, ns.x];
+const PREFIXES = new Map(Object.entries(ns)
+    .filter(([, uri]) => !UNPREFIXED.includes(uri))
+    .map(([prefix, uri]) => [uri, prefix]));
+const SKIPPED = [
+    ['<!--', '-->'],
+    ['<![CDATA[', ']]>'],
+    ['<?', '?>'],
+    ['<!', '>']
+];
+function skipped(text, at) {
+    for (const [open, close] of SKIPPED) {
+        if (text.startsWith(open, at)) {
+            const end = text.indexOf(close, at + open.length);
+            return end === -1 ? -1 : end + close.length;
+        }
+    }
+    return null;
+}
+function tagEnd(text, at) {
+    let quote = '';
+    for (let i = at; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            quote = c === quote ? '' : quote;
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+        }
+        else if (c === '>') {
+            return i;
+        }
+    }
+    return -1;
+}
+function checkDepth(text, name) {
+    let depth = 0;
+    for (let i = text.indexOf('<'); i !== -1; i = text.indexOf('<', i)) {
+        const after = skipped(text, i);
+        if (after === -1) {
+            return;
+        }
+        if (after !== null) {
+            i = after;
+            continue;
+        }
+        const end = tagEnd(text, i + 1);
+        if (end === -1) {
+            return;
+        }
+        if (text[i + 1] === '/') {
+            depth--;
+        }
+        else if (text[end - 1] !== '/') {
+            depth++;
+        }
+        if (depth > MAX_DEPTH) {
+            throw new DocsError('UNSAFE_XML', `${name} nests elements more than ${MAX_DEPTH} levels deep`);
+        }
+        i = end + 1;
+    }
+}
+function decodeUtf16(bytes, endian) {
+    const littleEndian = endian === 'le';
+    let out = '';
+    for (let i = 2; i + 1 < bytes.length; i += 2) {
+        const code = littleEndian ? bytes[i] | (bytes[i + 1] << 8) : (bytes[i] << 8) | bytes[i + 1];
+        out += String.fromCharCode(code);
+    }
+    return out;
+}
+export function decode(bytes) {
+    if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        return utf8.decode(bytes.subarray(3));
+    }
+    if (bytes[0] === 0xff && bytes[1] === 0xfe) {
+        return decodeUtf16(bytes, 'le');
+    }
+    if (bytes[0] === 0xfe && bytes[1] === 0xff) {
+        return decodeUtf16(bytes, 'be');
+    }
+    return utf8.decode(bytes);
+}
+function causeOf(err) {
+    return err instanceof Error ? err.cause : undefined;
+}
+export function parse(input, name = 'part') {
+    const text = (typeof input === 'string' ? input : decode(input)).replace(/^/, '');
+    if (/<!DOCTYPE/i.test(text)) {
+        throw new DocsError('UNSAFE_XML', `${name} declares a DOCTYPE, which Office files never do`);
+    }
+    checkDepth(text, name);
+    const invalid = (message) => new DocsError('INVALID_XML', `${name} is not well-formed XML: ${message}`);
+    const parser = new DOMParser({
+        onError(level, message) {
+            if (level !== 'warning') {
+                throw invalid(message);
+            }
+        }
+    });
+    let doc;
+    try {
+        doc = parser.parseFromString(text, 'application/xml');
+    }
+    catch (err) {
+        if (err instanceof DocsError) {
+            throw err;
+        }
+        const cause = causeOf(err);
+        if (cause instanceof DocsError) {
+            throw cause;
+        }
+        throw invalid(errorMessage(err));
+    }
+    if (!doc.documentElement) {
+        throw new DocsError('INVALID_XML', `${name} has no root element`);
+    }
+    return doc;
+}
+export function toString(doc) {
+    return new XMLSerializer().serializeToString(doc);
+}
+export function serialize(doc) {
+    const text = toString(doc);
+    if (!text.startsWith('<?xml')) {
+        return utf8.encode(DECLARATION + text);
+    }
+    return utf8.encode(text.replace(/^(<\?xml[^?]*?encoding=)(["'])[^"']*\2/i, '$1$2UTF-8$2'));
+}
+export function root(doc) {
+    const el = doc.documentElement;
+    if (!el) {
+        throw new DocsError('INVALID_XML', 'the part has no root element');
+    }
+    return el;
+}
+export function owner(node) {
+    const doc = node.ownerDocument;
+    if (!doc) {
+        throw new DocsError('INVALID_XML', 'the element belongs to no document');
+    }
+    return doc;
+}
+export function isElement(node, namespace, local) {
+    return (node instanceof Element &&
+        (namespace === undefined || node.namespaceURI === namespace) &&
+        (local === undefined || node.localName === local));
+}
+export function children(el, namespace, local) {
+    const out = [];
+    for (let n = el.firstChild; n; n = n.nextSibling) {
+        if (isElement(n, namespace, local)) {
+            out.push(n);
+        }
+    }
+    return out;
+}
+export function child(el, namespace, local) {
+    for (let n = el.firstChild; n; n = n.nextSibling) {
+        if (isElement(n, namespace, local))
+            return n;
+    }
+    return null;
+}
+export function descendants(el, namespace, local) {
+    return Array.from(el.getElementsByTagNameNS(namespace, local));
+}
+export function text(node) {
+    return node?.textContent ?? '';
+}
+export function clean(value) {
+    return value.replace(NOT_XML, '');
+}
+export function setText(el, value) {
+    while (el.firstChild) {
+        el.removeChild(el.firstChild);
+    }
+    el.appendChild(owner(el).createTextNode(clean(value)));
+}
+export function attr(el, name) {
+    return el.getAttribute(name) ?? '';
+}
+export function setAttributes(el, attributes = {}) {
+    for (const [key, value] of Object.entries(attributes)) {
+        if (value !== undefined && value !== null) {
+            el.setAttribute(key, String(value));
+        }
+    }
+    return el;
+}
+export function named(doc, qualifiedName, namespace) {
+    return doc.createElementNS(namespace, qualifiedName);
+}
+export function qualify(doc, namespace, local) {
+    const top = root(doc);
+    if (top.namespaceURI === namespace && !top.prefix) {
+        return local;
+    }
+    const prefix = top.lookupPrefix(namespace) ?? PREFIXES.get(namespace);
+    return prefix ? `${prefix}:${local}` : local;
+}
+export function builder(doc, namespace) {
+    return (local, attributes) => setAttributes(named(doc, qualify(doc, namespace, local), namespace), attributes);
+}
+export function setNsAttribute(el, name, value) {
+    const doc = owner(el);
+    const prefix = root(doc).lookupPrefix(name.namespace) ?? PREFIXES.get(name.namespace) ?? name.local;
+    el.setAttributeNS(name.namespace, `${prefix}:${name.local}`, value);
+}
+export function insertOrdered(parent, el, order) {
+    const rank = order.indexOf(el.localName ?? '');
+    for (let n = parent.firstChild; n; n = n.nextSibling) {
+        if (!(n instanceof Element))
+            continue;
+        const other = order.indexOf(n.localName ?? '');
+        if (other > rank || other === -1) {
+            parent.insertBefore(el, n);
+            return el;
+        }
+    }
+    parent.appendChild(el);
+    return el;
+}
+export function remove(node) {
+    node.parentNode?.removeChild(node);
+}
+export function append(parent, node) {
+    parent.appendChild(node);
+    return node;
+}
+export function clone(el) {
+    const copy = el.cloneNode(true);
+    if (!(copy instanceof Element)) {
+        throw new DocsError('INVALID_XML', 'cloning an element produced no element');
+    }
+    return copy;
+}

package/dist-lib/lib/office/extract.d.ts

@@ -0,0 +1,9 @@
+import type { AbortSignal } from 'bare-abort-controller';
+export type Extract = (bytes: Uint8Array) => string;
+export interface ExtractJob {
+    readonly fileName: string;
+    readonly signal: AbortSignal | undefined;
+    readonly extract: Extract;
+}
+export declare function extractWith(bytes: Uint8Array, { fileName, signal, extract }: ExtractJob): string;
+export declare function cellText(value: unknown): string;

package/dist-lib/lib/office/extract.js

@@ -0,0 +1,19 @@
+import { errorMessage } from '../guards.js';
+const MAX_OFFICE_BYTES = 20 * 1024 * 1024;
+export function extractWith(bytes, { fileName, signal, extract }) {
+    if (bytes.byteLength > MAX_OFFICE_BYTES) {
+        throw new Error(`document is too large to extract: ${bytes.byteLength} bytes, limit ${MAX_OFFICE_BYTES}`);
+    }
+    if (signal?.aborted) {
+        throw new Error(`${fileName}: extraction aborted`);
+    }
+    try {
+        return extract(bytes);
+    }
+    catch (err) {
+        throw new Error(`${fileName}: ${errorMessage(err)}`);
+    }
+}
+export function cellText(value) {
+    return value === null || value === undefined ? '' : String(value).replaceAll('\n', ' ');
+}

package/dist-lib/lib/office/index.d.ts

@@ -1,5 +1,5 @@
 import type { AbortSignal } from 'bare-abort-controller';
-export { closePythonWorker as closeOfficeWorker } from '../tools/exec/adapters/python/worker/active.ts';
+export { closeDocxWorker as closeOfficeWorker } from '../docx/index.ts';
 export interface OfficeExtractOptions {
     readonly signal?: AbortSignal | undefined;
     readonly mimeType?: string | undefined;

package/dist-lib/lib/office/index.js

@@ -1,14 +1,81 @@
 import path from 'path';
 import { extractDocxText } from '../docx/index.js';
-import { extractWithPython } from './python.js';
-import { XLSX_EXTRACT } from './xlsx.js';
-import { PPTX_EXTRACT } from './pptx.js';
-export { closePythonWorker as closeOfficeWorker } from '../tools/exec/adapters/python/worker/active.js';
+import { pptx, xlsx } from './engine/index.js';
+import { cellText, extractWith } from './extract.js';
+export { closeDocxWorker as closeOfficeWorker } from '../docx/index.js';
 const OFFICE_MIME_EXTENSIONS = {
     'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
     'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
     'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx'
 };
+const EXTRACT_CELL_LIMIT = 1_000_000;
+function columnIndex(letters) {
+    let index = 0;
+    for (const char of letters) {
+        index = index * 26 + char.charCodeAt(0) - 64;
+    }
+    return index;
+}
+function columnName(index) {
+    let name = '';
+    for (let n = index; n > 0; n = Math.floor((n - 1) / 26)) {
+        name = String.fromCharCode(65 + ((n - 1) % 26)) + name;
+    }
+    return name;
+}
+function trimmedRow(values) {
+    const row = [...values];
+    while (row.length && !cellText(row.at(-1)).trim()) {
+        row.pop();
+    }
+    return row;
+}
+function workbookText(bytes) {
+    const book = xlsx.open(bytes);
+    let output = '';
+    let budget = EXTRACT_CELL_LIMIT;
+    for (const sheet of book.sheets()) {
+        if (sheet.kind !== 'worksheet' || budget <= 0)
+            continue;
+        const { range, rows, formulas } = book.read(sheet.index, { limit: budget });
+        budget -= rows.length * (rows[0]?.length ?? 0);
+        const [, letters = 'A', digits = '1'] = /^([A-Z]+)(\d+)/.exec(range ?? 'A1') ?? [];
+        const firstColumn = columnIndex(letters);
+        const firstRow = Number(digits);
+        const lines = rows
+            .map((row, r) => trimmedRow(row.map((value, c) => value ?? formulas[`${columnName(firstColumn + c)}${firstRow + r}`] ?? null)))
+            .filter((row) => row.length)
+            .map((row) => row.map(cellText).join(' | '));
+        if (lines.length) {
+            output += `Sheet: ${sheet.name}\n${lines.join('\n')}\n`;
+        }
+    }
+    return output;
+}
+function shapeBlocks(shape) {
+    if (shape.paragraphs) {
+        const text = shape.paragraphs.map((paragraph) => paragraph.text).join('\n');
+        return text.trim() ? [text] : [];
+    }
+    return (shape.rows ?? [])
+        .map((row) => row.map(cellText))
+        .filter((cells) => cells.some((cell) => cell.trim()))
+        .map((cells) => cells.join(' | '));
+}
+function deckText(bytes) {
+    let output = '';
+    for (const slide of pptx.open(bytes).read()) {
+        const blocks = slide.shapes.flatMap(shapeBlocks);
+        if (blocks.length) {
+            output += `Slide ${slide.index + 1}\n${blocks.join('\n')}\n`;
+        }
+    }
+    return output;
+}
+const EXTRACTORS = new Map([
+    ['.xlsx', workbookText],
+    ['.pptx', deckText]
+]);
 export async function extractOfficeText(bytes, fileName, options = {}) {
     const mimeType = options.mimeType?.split(';')[0]?.trim().toLowerCase();
     const suffix = path.extname(fileName).toLowerCase();
@@ -18,21 +85,9 @@ export async function extractOfficeText(bytes, fileName, options = {}) {
     if (extension === '.docx') {
         return extractDocxText(bytes, fileName, options);
     }
-    if (extension === '.xlsx') {
-        return extractWithPython(bytes, fileName, {
-            format: 'XLSX',
-            packages: ['openpyxl==3.1.5'],
-            source: XLSX_EXTRACT,
-            signal: options.signal
-        });
-    }
-    if (extension === '.pptx') {
-        return extractWithPython(bytes, fileName, {
-            format: 'PPTX',
-            packages: ['python-pptx==1.0.2'],
-            source: PPTX_EXTRACT,
-            signal: options.signal
-        });
+    const extract = EXTRACTORS.get(extension ?? '');
+    if (extract) {
+        return extractWith(bytes, { fileName, signal: options.signal, extract });
     }
     throw new Error(`Unsupported Office document: ${fileName}`);
 }

package/dist-lib/lib/tools/exec/adapters/python/module-distributions.js

@@ -20,12 +20,10 @@ export const MODULE_DISTRIBUTIONS = {
     cvxpy: 'cvxpy-base',
     dateutil: 'python-dateutil',
     dns: 'dnspython',
-    docx: 'python-docx',
     erfa: 'pyerfa',
     fitz: 'PyMuPDF',
     flint: 'python-flint',
     flirt: 'python-flirt',
-    fpdf: 'fpdf2',
     google: 'protobuf',
     gridfs: 'pymongo',
     isympy: 'sympy',
@@ -33,7 +31,6 @@ export const MODULE_DISTRIBUTIONS = {
     mpl_toolkits: 'matplotlib',
     mypyc: 'mypy',
     nacl: 'pynacl',
-    pptx: 'python-pptx',
     pygame: 'pygame-ce',
     pylab: 'matplotlib',
     pysat: 'python-sat',

package/dist-lib/lib/tools/exec/adapters/python/python-adapter.d.ts

@@ -1,8 +1,7 @@
-import type { ExecAttachment } from '../../runner.ts';
 import type { ExecutionAdapter } from '../adapter.ts';
 import { type ExecInput } from './attachments.ts';
 import { type ExecError } from './output-policy.ts';
-import { type LoadPyodideFn, type PythonRunResult } from './pyodide.ts';
+import { type LoadPyodideFn } from './pyodide.ts';
 export declare function isPythonLanguage(language: unknown): boolean;
 export declare function runsThroughPyodide(language: unknown, disablePyodide: boolean): boolean;
 export declare function unwrapPythonSource(command: string): string | null;
@@ -20,70 +19,28 @@ export interface PipFromSourceHintOptions {
 export declare function pipFromSourceHint(stderr: string, source: string, { packages, sandbox }?: PipFromSourceHintOptions): string | null;
 export declare function stringLiteralProgramHint(source: string): string | null;
 export declare function checkCollapsedCompound(source: string): string | null;
-export declare function mangledPptxApiHint(source: string): string | null;
-export declare function wrongRgbColorHint(source: string): string | null;
-export declare function fpdfSizeKeywordHint(source: string): string | null;
-export declare function fpdfKeywordErrorHint(stderr: string): string | null;
-export declare function normalizeFpdfSource(source: string): string;
-export declare function fpdfTextCallHint(source: string): string | null;
-export declare function fpdfTextErrorHint(stderr: string): string | null;
-export declare function fpdfNonLatin1Hint(source: string): string | null;
-export declare function fpdfUnicodeErrorHint(stderr: string): string | null;
-export declare function fpdfHorizontalSpaceHint(stderr: string): string | null;
-export declare function rgbColorImportHint(stderr: string): string | null;
 export declare function checkPythonSource(command: string): string | null;
 export declare function syntaxErrorHint(stderr: string, source: string): string | null;
-export declare function checkPptxBuildSource(source: string, outputs: readonly string[] | undefined, packages?: readonly string[] | undefined): string | null;
-export declare function tripleQuoteAt(source: string, index: number): string | null;
-export declare function isEscaped(source: string, index: number): boolean;
-export declare function checkBareLengthArgs(source: string, packages?: readonly string[] | undefined): string | null;
-export declare function checkPdfBuildSource(source: string, outputs: readonly string[] | undefined, packages?: readonly string[] | undefined): string | null;
-export declare function stripCommentsAndDocstrings(source: string): string;
-export declare const PDF_READ: RegExp;
-export declare const OFFICE_READ: RegExp;
-export declare function checkUnstagedRead(source: string, inputs: readonly Pick<ExecInput, 'path'>[] | undefined): string | null;
 export declare function missingFileHint(stderr: string): string | null;
 export declare function parsePackages(value: unknown): string[] | ExecError | undefined;
 export declare function parseInputs(value: unknown): ExecInput[] | ExecError | undefined;
 export declare function parseOutputs(value: unknown): string[] | ExecError | undefined;
 export declare function parseWorkdir(value: unknown): string | ExecError | undefined;
+export interface OfficeImportContext {
+    readonly packages: readonly string[] | undefined;
+    readonly toolNames: readonly string[] | undefined;
+}
+export declare function officeModuleHint(stderr: string, toolNames: readonly string[] | undefined): string | null;
+export declare function officeImportError(source: string, { packages, toolNames }: OfficeImportContext): string | null;
 export interface MissingModuleHintOptions {
     readonly packages?: readonly string[] | undefined;
     readonly sandbox?: boolean;
     readonly network?: boolean;
 }
 export declare function missingModuleHint(stderr: string, { packages, sandbox, network }?: MissingModuleHintOptions): string | null;
-export declare function nonePlaceholderHint(stderr: string): string | null;
-export declare function slideShapesHint(stderr: string): string | null;
-export declare function shapeFontHint(stderr: string): string | null;
-export declare function shapesBackgroundHint(stderr: string): string | null;
-export declare function paragraphFillHint(stderr: string): string | null;
-export declare function readOnlyPropertyHint(stderr: string): string | null;
-export declare function paragraphIndexHint(stderr: string, outputs: readonly string[]): string | null;
 export declare function shellNameHint(stderr: string): string | null;
 export declare function noProcessHint(stderr: string, sandbox?: boolean): string | null;
 export declare function noNetworkHint(stderr: string, tools?: readonly string[], network?: boolean): string | null;
 export declare function nativeWheelHint(stderr: string): string | null;
 export declare function packageFetchFailedHint(stderr: string): string | null;
-export declare const IMAGE_INPUT: RegExp;
-export declare function pptxHasEmbeddedMedia(bytes: Uint8Array): boolean;
-export declare function softFailedDeckHint(stdout: string, exitCode: number, source: string): string | null;
-export interface DeckImagesOptions {
-    readonly inputs: readonly {
-        path: string;
-    }[] | undefined;
-    readonly outputs: readonly string[] | undefined;
-    readonly source: string;
-}
-export declare function stagedImagesMissingFromDeck(result: Pick<PythonRunResult, 'exitCode' | 'files'>, { inputs, outputs, source }: DeckImagesOptions): string | null;
-export declare function checkStagedImagesUsed(source: string, inputs: readonly Pick<ExecInput, 'path'>[] | undefined, outputs: readonly string[] | undefined): string | null;
-export interface TurnImagesStagedOptions {
-    readonly inputs: readonly ExecInput[] | undefined;
-    readonly outputs: readonly string[] | undefined;
-    readonly turnImages: readonly {
-        path: string;
-    }[] | undefined;
-}
-export declare function checkTurnImagesStaged(source: string, { inputs, outputs, turnImages }: TurnImagesStagedOptions): string | null;
-export declare function deckDeliveredStop(attachments: readonly Pick<ExecAttachment, 'fileName'>[] | undefined, exitCode: number, source?: string): string | null;
 export declare function createPythonAdapter(disabled: boolean, loadPyodide?: LoadPyodideFn, network?: boolean): ExecutionAdapter;