@qvac/harness 0.7.3 → 0.8.5

package/CHANGELOG.md

@@ -8,6 +8,90 @@ While the major version is `0`, a breaking change bumps the minor version.
 
 ## [Unreleased]
 
+## [0.8.5] - 2026-10-06
+
+### Added
+
+- Skill-gated `pptx`, `docx` and `xlsx` tools on the office engine. A call takes
+  an `attachmentId` (or `create` options), `ops` that name engine methods with
+  named arguments, and an `output` file name; with an `attachmentId` alone it
+  returns the file's contents. The first failing op saves nothing and returns
+  the engine's error. An edit is never saved under the attached file's own
+  name. Saving the same file again in one turn answers with the one already
+  attached, and a changed file under that name is refused. The one-line answer
+  comes back as `reply`. These are the tools the presentations, word and excel
+  skills in `@qvac/skills` 0.1.12 call. (#286)
+
+### Changed
+
+- **Breaking:** `@qvac/skills` is now 0.1.12, whose office and pdf skills run on
+  the `pptx`, `docx`, `xlsx` and `pdf` tools instead of Python. A host that
+  passes its own `skillsDir` needs 0.1.12 as well: older office skills import
+  Python libraries this release no longer ships. (#286)
+- `extractOfficeText` and `extractDocxText` read .docx, .xlsx and .pptx in
+  process on the engine instead of starting Pyodide, and read at most 1M cells
+  across a workbook. Extracted workbook booleans read `true`/`false` instead of
+  `True`/`False`. `closeOfficeWorker` and `closeDocxWorker` remain as no-ops.
+  (#286)
+- `exec` refuses Python that imports `pptx`, `docx` or `openpyxl`, or declares
+  their packages, before it runs, and names the tool (or the skill that grants
+  it) to use instead. (#287)
+- **Breaking:** Python run through `exec` asks for approval like any other
+  write, including a run that only builds a new PDF. (#289)
+
+### Removed
+
+- **Breaking:** the vendored Python wheels for python-pptx, python-docx,
+  openpyxl, fpdf2 and pypdf, and their dependencies. Only micropip is still
+  seeded; any other package installs from PyPI, which sandbox mode refuses.
+  Use the office and `pdf` tools. (#286, #289)
+- The `exec` guidance written for python-pptx, python-docx and fpdf2 code:
+  their error hints and source checks, and the shrink-to-fit pass on saved
+  decks. (#288, #289)
+
+## [0.8.0] - 2026-10-05
+
+### Added
+
+- A skill-gated `pdf` tool on `bare-pdfium` 1.6.0. With an `attachmentId` and
+  no `action` it reads a PDF: the page count, each page's text and the form
+  fields. With an `action` it saves a new file named `output` and attaches it:
+  `create` from Markdown (chat images placed with `![caption](attachmentId)`),
+  `merge`, `split`, `rotate`, `watermark`, `fill`, `encrypt`, `decrypt` and
+  `text`. Errors name what exists, a locked PDF takes its password on any
+  action, and the one-line answer comes back as `reply`. On Node it reports
+  that the device cannot open PDFs. The pdf skill in the next `@qvac/skills`
+  release uses it instead of Python. (#256)
+- An office engine in `lib/office/engine/` that reads, edits and creates `.pptx`,
+  `.docx` and `.xlsx` files in TypeScript on Bare and Node, so office editing no
+  longer needs Python and can run on mobile. It keeps untouched parts byte for
+  byte, fails with a `DocsError` whose code names the problem, and moves Excel
+  references when rows and columns change. It adds `@xmldom/xmldom`, makes
+  `bare-zlib` a direct dependency and maps `#zlib` to `bare-zlib` or `zlib`.
+
+### Fixed
+
+- Qwen3.5-family models: a tool call that ran goes back into the chat history
+  in the Qwen3.5 template's own format (`<tool_call>` wrapper, one line per tag,
+  string values as written) instead of a compact `<function=…>` line. A model
+  several calls into a turn copied the compact form, the tool grammar rejected
+  it, and the run ended in "This didn't finish". Models with another tool format
+  (e.g. MedPsy) still get a format that is not their own, until the SDK accepts
+  structured tool calls in history. (QVAC-23092, #146)
+- A skill loaded with a `file` it does not have, before its instructions were
+  loaded, now returns those instructions with a line naming the files it has,
+  so the skill counts as loaded and its skill-gated tools appear. Before, a
+  one-file skill answered that the model already had its instructions, and its
+  tools stayed hidden. (#257)
+- After a tool attaches a file, the loop tells the model the file is shown and
+  to answer, allows one more tool round, then writes the answer in a tool-less
+  round. Small models no longer keep calling tools on their own output until
+  the round cap. (#258)
+- `exec`: a `$` before a digit, a space or punctuation in a shell command is
+  escaped instead of rejected, so text like `$1,299` runs on the first try. Real
+  shell expansion is still refused, now with a hint to single-quote the text.
+  (#208)
+
 ## [0.7.3] - 2026-10-01
 
 ### Added
@@ -1065,7 +1149,9 @@ Tagged but never published to npm; these changes first shipped in 0.2.12.
 - GPU stats are read through `bare-gpu-info`, so every dependency installs from
   the public npm registry. (#12)
 
-[Unreleased]: https://github.com/tetherto/qvac-harness/compare/v0.7.3...HEAD
+[Unreleased]: https://github.com/tetherto/qvac-harness/compare/v0.8.5...HEAD
+[0.8.5]: https://github.com/tetherto/qvac-harness/compare/v0.8.0...v0.8.5
+[0.8.0]: https://github.com/tetherto/qvac-harness/compare/v0.7.3...v0.8.0
 [0.7.3]: https://github.com/tetherto/qvac-harness/compare/v0.7.2...v0.7.3
 [0.7.2]: https://github.com/tetherto/qvac-harness/compare/v0.7.1...v0.7.2
 [0.7.1]: https://github.com/tetherto/qvac-harness/compare/v0.7.0...v0.7.1

package/NOTICE.md

@@ -11,3 +11,19 @@ distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
+
+## Third-party components
+
+### @xmldom/xmldom
+
+XML parsing and serialization for the office engine. Copyright 2019 - present
+Christopher J. Brody and other contributors; Copyright 2012 - 2017 @jindw and
+other contributors. Licensed under the MIT License.
+<https://github.com/xmldom/xmldom>
+
+## Test data
+
+The files under `test/fixtures/office-corpus` are taken from the Apache POI test
+data. Copyright The Apache Software Foundation. Licensed under the Apache
+License, Version 2.0. <https://github.com/apache/poi>. They are used by the test
+suite only and are not part of the published package.

package/dist-lib/lib/capabilities/completion.d.ts

@@ -123,6 +123,7 @@ export interface RunBudget {
 export interface ToolExecuteContext {
     agentId?: string | null | undefined;
     skills?: readonly string[] | undefined;
+    skillsLoadedThisTurn?: readonly string[] | undefined;
     ctxSize?: number | undefined;
     image?: ImageSettings | undefined;
     settings?: Record<string, unknown> | undefined;

package/dist-lib/lib/capabilities/completion.js

@@ -29,7 +29,7 @@ import { resolveImplicitSkill, resolveSkillMention, skillPreloadMessage } from '
 import { NETWORK_TOOLSETS, permittedTools } from '../tools/toolsets.js';
 import { promptPrefixHash } from './prompt-prefix.js';
 import { logToolPrompt } from './tool-prompt-log.js';
-import { DIRECT_CALL_ID, loadedSkillFilesFrom, loadedSkillsFrom, TOOL_CONTINUATION_NUDGE, toolResultTurn, withoutSkillLoadTurns } from './tool-turns.js';
+import { DIRECT_CALL_ID, deliversFile, FILE_DELIVERED_NUDGE, loadedSkillFilesFrom, loadedSkillsFrom, TOOL_CONTINUATION_NUDGE, toolResultTurn, withoutSkillLoadTurns } from './tool-turns.js';
 export function imageSettingsFrom(agent) {
     if (!agent)
         return undefined;
@@ -153,7 +153,7 @@ function assistantToolTurn(contentText, calls) {
     if (!calls.length || contentText.includes('<function='))
         return contentText;
     const markup = toolCallMarkup(calls);
-    return contentText ? `${contentText}\n${markup}` : markup;
+    return contentText ? `${contentText}\n\n${markup}` : markup;
 }
 function preloadLastUser(messages, name, body) {
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -734,17 +734,18 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         let skillIcon = null;
         const skillEmoji = (name) => skillCatalog.find((entry) => entry.name === name)?.emoji ?? null;
         const nudgedSkills = new Set();
-        function recordSkillLoad(skillName, output, { mainRequested, askedFile }) {
+        function recordSkillLoad(skillName, output, { mainRequested, askedFile, executed }) {
             if (!output || typeof output !== 'object' || !('content' in output)) {
                 return;
             }
             loadedSkills.add(skillName);
-            if ('file' in output && typeof output.file === 'string') {
+            const loadedFile = 'file' in output && typeof output.file === 'string' ? output.file : null;
+            if (loadedFile !== null) {
                 const files = loadedSkillFiles.get(skillName) ?? new Set();
-                files.add(output.file);
+                files.add(loadedFile);
                 loadedSkillFiles.set(skillName, files);
             }
-            if (mainRequested) {
+            if (mainRequested || (executed && loadedFile === null)) {
                 loadedThisTurn.add(skillName);
             }
             else {
@@ -928,6 +929,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         for (; round < MAX_TOOL_ROUNDS; round++) {
             if (signal?.aborted)
                 throw new AbortedError();
+            let deliveredThisRound = false;
             if (Date.now() >= runBudget.deadlineMs) {
                 outcome = 'time-capped';
                 break;
@@ -1059,6 +1061,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     skills: [...loadedSkills].filter((name) => !skillsSelected ||
                         (agent?.enabledSkills ?? []).includes(name) ||
                         name === mention?.name),
+                    skillsLoadedThisTurn: [...loadedThisTurn],
                     settings: toolConfigs?.[call.name],
                     toolOps: grantedOps,
                     fsRoots,
@@ -1165,7 +1168,11 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     webSearches++;
                 }
                 if (call.name === SKILL_TOOL_NAME) {
-                    recordSkillLoad(skillName, output, { mainRequested, askedFile });
+                    recordSkillLoad(skillName, output, {
+                        mainRequested,
+                        askedFile,
+                        executed: execution.executed
+                    });
                 }
                 if (!activity &&
                     !silent &&
@@ -1196,6 +1203,9 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 if (isMutation && executionOutcome.kind === 'success') {
                     runOutcomes.confirmWrite(output);
                 }
+                if (executionOutcome.kind === 'success' && deliversFile(output)) {
+                    deliveredThisRound = true;
+                }
                 const turn = toolResultTurn(call.name, call.id, output);
                 sources.push({
                     origin: call.name === SKILL_TOOL_NAME ? 'skill' : 'tool-result',
@@ -1215,7 +1225,17 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 outcome = 'answered';
                 break;
             }
-            history.push({ role: 'user', content: TOOL_CONTINUATION_NUDGE });
+            history.push({
+                role: 'user',
+                content: deliveredThisRound ? FILE_DELIVERED_NUDGE : TOOL_CONTINUATION_NUDGE
+            });
+            if (runOutcomes.facts().delivered) {
+                outcome = 'delivered';
+                break;
+            }
+            if (deliveredThisRound) {
+                runOutcomes.confirmDelivery();
+            }
             if (blockedRepeats >= MAX_BLOCKED_REPEATS) {
                 break;
             }

package/dist-lib/lib/capabilities/tool-turns.d.ts

@@ -1,6 +1,9 @@
 import type { Message } from './completion.ts';
 export declare const DIRECT_CALL_ID = "call-direct";
 export declare const TOOL_CONTINUATION_NUDGE = "[Tool results above. Continue the user's request: call the next tool, or answer.]";
+export declare const FILE_DELIVERED_NUDGE = "[Tool results above. The file is attached to the chat and shown to the user. Answer now, unless the request still needs a file that is not made yet.]";
+export declare function isContinuationNudge(content: string): boolean;
+export declare function deliversFile(output: unknown): boolean;
 export declare function toolResultTurn(name: string, id: string, output: unknown): string;
 export declare function skillLoadedTurn(name: string): string;
 export declare function attachmentTurn(name: string, result: unknown): string | null;

package/dist-lib/lib/capabilities/tool-turns.js

@@ -2,6 +2,13 @@ import { isRecord } from '../guards.js';
 import { SKILL_TOOL_NAME } from './tool-names.js';
 export const DIRECT_CALL_ID = 'call-direct';
 export const TOOL_CONTINUATION_NUDGE = "[Tool results above. Continue the user's request: call the next tool, or answer.]";
+export const FILE_DELIVERED_NUDGE = '[Tool results above. The file is attached to the chat and shown to the user. Answer now, unless the request still needs a file that is not made yet.]';
+export function isContinuationNudge(content) {
+    return content === TOOL_CONTINUATION_NUDGE || content === FILE_DELIVERED_NUDGE;
+}
+export function deliversFile(output) {
+    return isRecord(output) && Array.isArray(output.attachments) && output.attachments.length > 0;
+}
 export function toolResultTurn(name, id, output) {
     return `[Tool: ${name} (${id})]\n${JSON.stringify(historyPayload(output))}`;
 }

package/dist-lib/lib/context-window.js

@@ -1,7 +1,7 @@
-import { TOOL_CONTINUATION_NUDGE } from './capabilities/tool-turns.js';
+import { isContinuationNudge } from './capabilities/tool-turns.js';
 export const TOOL_RESULT_TRUNCATION_MARKER = '\n[tool result truncated for context]\n';
 function isTurnBoundary(message) {
-    return message.role === 'user' && message.content !== TOOL_CONTINUATION_NUDGE;
+    return message.role === 'user' && !isContinuationNudge(message.content);
 }
 export function contextCandidates(history) {
     const { prefix, turns } = splitTurns(history);

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

@@ -1,5 +1,5 @@
 import type { AbortSignal } from 'bare-abort-controller';
-export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/active.ts';
+export declare function closeDocxWorker(): Promise<void>;
 export interface DocxExtractOptions {
     readonly signal?: AbortSignal;
 }

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

@@ -1,26 +1,18 @@
-import { extractWithPython } from '../office/python.js';
-export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/active.js';
-const PACKAGES = ['python-docx==1.2.0'];
-const EXTRACT = `from docx import Document
-from docx.text.paragraph import Paragraph
-from pathlib import Path
-
-def text(container):
-    for block in container.iter_inner_content():
-        if isinstance(block, Paragraph):
-            if block.text.strip():
-                yield block.text
-        else:
-            for row in block.rows:
-                yield " | ".join(" ".join(text(cell)) for cell in row.cells)
-
-Path("extracted.txt").write_text("\\n".join(text(Document("input.docx"))), encoding="utf-8")
-`;
+import { docx } from '../office/engine/index.js';
+import { cellText, extractWith } from '../office/extract.js';
+export async function closeDocxWorker() { }
+function documentText(bytes) {
+    const lines = [];
+    for (const block of docx.open(bytes).read().blocks) {
+        if (block.type === 'table') {
+            lines.push(...block.rows.map((row) => row.map(cellText).join(' | ')));
+        }
+        else if (block.type === 'paragraph' && block.text.trim()) {
+            lines.push(block.text);
+        }
+    }
+    return lines.join('\n');
+}
 export async function extractDocxText(bytes, fileName, options = {}) {
-    return extractWithPython(bytes, fileName, {
-        format: 'DOCX',
-        packages: PACKAGES,
-        source: EXTRACT,
-        signal: options.signal
-    });
+    return extractWith(bytes, { fileName, signal: options.signal, extract: documentText });
 }

package/dist-lib/lib/helpers/run-outcome.d.ts

@@ -1,13 +1,15 @@
 import type { ToolExecutionOutcome } from '../tool-call-display.ts';
-export type RunOutcome = 'answered' | 'mute' | 'exhausted' | 'search-capped' | 'time-capped';
+export type RunOutcome = 'answered' | 'mute' | 'exhausted' | 'search-capped' | 'time-capped' | 'delivered';
 export declare const DEGENERATE_ANSWER_FALLBACK = "I couldn't complete that step and don't have a useful result to share.";
 export declare const ROUND_CAP_ANSWER = "I ran out of steps before I could finish that. Ask me to continue and I'll pick up where I left off.";
 export declare const SEARCH_CAPPED_ANSWER = "I searched the web but couldn't find the answer in the results I got.";
+export declare const DELIVERED_ANSWER = "Your file is attached to the chat.";
 export declare const WRITE_RESULT_LEAD = "Here's what came back:";
 export declare const TIME_CAPPED_ANSWER = "I hit this run's time budget before I could finish that. Ask me to continue and I'll pick up where I left off.";
 export interface RunOutcomeFacts {
     readonly latestFailure: string | null;
     readonly confirmedWrites: ReadonlyArray<string>;
+    readonly delivered: boolean;
 }
 export interface HistoryTurn {
     readonly role: string;
@@ -19,6 +21,7 @@ export interface RunOutcomeTracker {
     record(result: unknown, outcome: ToolExecutionOutcome): void;
     finishRound(): void;
     confirmWrite(result: unknown): void;
+    confirmDelivery(): void;
     facts(): RunOutcomeFacts;
 }
 export declare function createRunOutcomeTracker(): RunOutcomeTracker;

package/dist-lib/lib/helpers/run-outcome.js

@@ -1,8 +1,9 @@
-import { TOOL_CONTINUATION_NUDGE } from '../capabilities/tool-turns.js';
+import { isContinuationNudge } from '../capabilities/tool-turns.js';
 import { isRecord } from '../guards.js';
 export const DEGENERATE_ANSWER_FALLBACK = "I couldn't complete that step and don't have a useful result to share.";
 export const ROUND_CAP_ANSWER = "I ran out of steps before I could finish that. Ask me to continue and I'll pick up where I left off.";
 export const SEARCH_CAPPED_ANSWER = "I searched the web but couldn't find the answer in the results I got.";
+export const DELIVERED_ANSWER = 'Your file is attached to the chat.';
 export const WRITE_RESULT_LEAD = "Here's what came back:";
 export const TIME_CAPPED_ANSWER = "I hit this run's time budget before I could finish that. Ask me to continue and I'll pick up where I left off.";
 const MAX_FAILURE_CHARS = 300;
@@ -18,6 +19,7 @@ export function createRunOutcomeTracker() {
     let roundFailure = null;
     let latestFailure = null;
     let hasRoundResult = false;
+    let delivered = false;
     return {
         confirmedWrites,
         beginRound() {
@@ -42,8 +44,11 @@ export function createRunOutcomeTracker() {
                 confirmedWrites.push(write);
             }
         },
+        confirmDelivery() {
+            delivered = true;
+        },
         facts() {
-            return { latestFailure, confirmedWrites };
+            return { latestFailure, confirmedWrites, delivered };
         }
     };
 }
@@ -64,11 +69,12 @@ export function failureFromToolExecution(result, outcome) {
 }
 export function degenerateAnswer(outcome, history, facts) {
     const rest = (facts ? facts.latestFailure : lastFailedToolAnswer(history)) ?? cappedAnswer(outcome, history);
-    const written = writeReport(facts?.confirmedWrites ?? []);
-    if (written) {
-        return rest ? `${written}\n\n${rest}` : written;
-    }
-    return rest ?? DEGENERATE_ANSWER_FALLBACK;
+    const lines = [
+        writeReport(facts?.confirmedWrites ?? []),
+        facts?.delivered ? DELIVERED_ANSWER : null,
+        rest
+    ].filter((line) => line !== null);
+    return lines.length ? lines.join('\n\n') : DEGENERATE_ANSWER_FALLBACK;
 }
 function cappedAnswer(outcome, history) {
     if (outcome === 'search-capped') {
@@ -108,7 +114,7 @@ function searchCappedAnswer(history) {
 export function lastFailedToolAnswer(history) {
     for (let i = history.length - 1; i >= 0; i--) {
         const turn = history[i];
-        if (turn?.role === 'user' && turn.content === TOOL_CONTINUATION_NUDGE) {
+        if (turn?.role === 'user' && isContinuationNudge(turn.content)) {
             continue;
         }
         if (turn?.role !== 'tool') {

package/dist-lib/lib/helpers/tool-call-markup.js

@@ -120,12 +120,12 @@ export function toolCallMarkup(calls) {
 }
 function markupForCall(call) {
     const params = Object.entries(call.arguments ?? {})
-        .map(([key, value]) => `<parameter=${key}>${encodeMarkupValue(value)}</parameter>`)
+        .map(([key, value]) => `<parameter=${key}>\n${markupValue(value)}\n</parameter>\n`)
         .join('');
-    return `<function=${call.name}>${params}</function>`;
+    return `<tool_call>\n<function=${call.name}>\n${params}</function>\n</tool_call>`;
 }
-function encodeMarkupValue(value) {
-    return JSON.stringify(value ?? null).replace(/</g, '\\u003c');
+function markupValue(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value ?? null);
 }
 const ARG_WRAPPER_KEYS = new Set(['parameters', 'arguments', 'args', 'input', 'params']);
 function isPlainObject(value) {

package/dist-lib/lib/hooks/built-in/arg-repair.js

@@ -1,6 +1,7 @@
 import { jsonrepair } from 'jsonrepair';
 import { isRecord } from '../../guards.js';
 import { hlog } from '../../log.js';
+import { escapeLiteralDollars } from '../../tools/exec/scope.js';
 const STRUCTURED_TYPES = new Set(['object', 'array']);
 export class ArgRepairHook {
     phase = 'preToolCall';
@@ -24,6 +25,12 @@ export class ArgRepairHook {
             }
             args = { ...args, [key]: parsed };
         }
+        if (ctx.toolName === 'exec' && args.language !== 'python' && typeof args.command === 'string') {
+            const command = escapeLiteralDollars(args.command);
+            if (command !== args.command) {
+                args = { ...args, command };
+            }
+        }
         if (args !== ctx.args) {
             return { args };
         }

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

@@ -0,0 +1,62 @@
+export declare const CODES: {
+    readonly INVALID_INPUT: 'the input is not a Uint8Array or Buffer';
+    readonly NOT_OOXML: 'the file is not a zip archive with [Content_Types].xml';
+    readonly NOT_PPTX: 'the file is not a PowerPoint presentation';
+    readonly NOT_DOCX: 'the file is not a Word document';
+    readonly NOT_XLSX: 'the file is not an Excel workbook';
+    readonly UNSUPPORTED_PPTX: 'the presentation uses Strict Open XML';
+    readonly UNSUPPORTED_DOCX: 'the document uses Strict Open XML';
+    readonly UNSUPPORTED_XLSX: 'the workbook uses Strict Open XML';
+    readonly BROKEN_PPTX: 'the presentation points at parts that do not exist';
+    readonly BROKEN_DOCX: 'the document is missing a required part';
+    readonly BROKEN_XLSX: 'the workbook points at parts that do not exist';
+    readonly TOO_LARGE: 'the file exceeds the entry, size or compression-ratio limits';
+    readonly UNSAFE_XML: 'an XML part declares a DOCTYPE or nests too deeply';
+    readonly INVALID_XML: 'an XML part is not well-formed';
+    readonly PART_EXISTS: 'a part with that name already exists';
+    readonly PART_MISSING: 'the part is not in the package';
+    readonly UNTOUCHED_EDIT: 'a part was changed without touch() (strict mode only)';
+    readonly INVALID_OPTIONS: 'an option is unknown or out of range';
+    readonly INVALID_TEXT: 'text or paragraphs are not in an accepted shape';
+    readonly INVALID_STYLE: 'a style or format value is unknown or out of range';
+    readonly INVALID_BOX: 'a position or size is not a valid whole number of EMU';
+    readonly INVALID_IMAGE: 'the image is empty, truncated or has no size';
+    readonly UNSUPPORTED_IMAGE: 'the image is not PNG, JPEG or GIF';
+    readonly INVALID_TABLE: 'table rows or cells are not in an accepted shape';
+    readonly INVALID_CHART: 'a chart option is not valid';
+    readonly INVALID_CHART_DATA: 'chart categories or series are not valid';
+    readonly UNSUPPORTED_CHART: 'that chart type cannot be created or edited';
+    readonly CHART_COMBO: 'a combo chart must keep its number of series';
+    readonly NOT_CHART: 'the target holds no chart';
+    readonly SLIDE_NOT_FOUND: 'no slide at that index';
+    readonly SHAPE_NOT_FOUND: 'no shape with that id or role on the slide';
+    readonly LAYOUT_NOT_FOUND: 'no layout with that name';
+    readonly PARAGRAPH_NOT_FOUND: 'no paragraph at that index';
+    readonly NOT_TEXT: 'the shape or block holds no text';
+    readonly NOT_PICTURE: 'the shape is not a picture';
+    readonly NOT_TABLE: 'the shape or block is not a table';
+    readonly CELL_NOT_FOUND: 'no table cell at that row and column';
+    readonly CELL_MERGED: 'the cell is covered by a merged cell';
+    readonly SLIDE_IS_LINKED: 'another slide links to the slide';
+    readonly TOO_MANY_SLIDES: 'the deck has run out of slide ids';
+    readonly BLOCK_NOT_FOUND: 'no block at that index';
+    readonly NOT_PARAGRAPH: 'the block is not a paragraph';
+    readonly NOT_HEADING: 'the block is not a heading';
+    readonly STYLE_NOT_FOUND: 'no style with that name';
+    readonly TRACKED_CHANGES: 'the paragraph has tracked changes that an edit would accept silently';
+    readonly ROW_NOT_FOUND: 'no table row at that index';
+    readonly ROW_MERGED: 'the row is part of a vertically merged cell';
+    readonly LAST_ROW: 'the table would be left without rows';
+    readonly SHEET_NOT_FOUND: 'no sheet with that name or index';
+    readonly NOT_WORKSHEET: 'the sheet is a chart sheet or dialog sheet';
+    readonly INVALID_NAME: 'the sheet name is not allowed';
+    readonly INVALID_CELL: 'not a valid cell, row or column reference';
+    readonly INVALID_RANGE: 'not a valid range or limit';
+    readonly INVALID_VALUE: 'a cell value, formula or date is not valid';
+    readonly INVALID_FORMULA: 'text starting with = does not parse as a formula';
+    readonly SHARED_FORMULA: 'the cell belongs to a shared or array formula range';
+    readonly SHEET_HAS_DEPENDENTS: 'the sheet has pivot tables, comments or other parts that rows or columns cannot move through yet';
+    readonly SHEET_IS_REFERENCED: 'other formulas, names or charts refer to the sheet';
+    readonly LAST_SHEET: 'a workbook needs at least one visible sheet';
+};
+export type DocsErrorCode = keyof typeof CODES;

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

@@ -0,0 +1,61 @@
+export const CODES = {
+    INVALID_INPUT: 'the input is not a Uint8Array or Buffer',
+    NOT_OOXML: 'the file is not a zip archive with [Content_Types].xml',
+    NOT_PPTX: 'the file is not a PowerPoint presentation',
+    NOT_DOCX: 'the file is not a Word document',
+    NOT_XLSX: 'the file is not an Excel workbook',
+    UNSUPPORTED_PPTX: 'the presentation uses Strict Open XML',
+    UNSUPPORTED_DOCX: 'the document uses Strict Open XML',
+    UNSUPPORTED_XLSX: 'the workbook uses Strict Open XML',
+    BROKEN_PPTX: 'the presentation points at parts that do not exist',
+    BROKEN_DOCX: 'the document is missing a required part',
+    BROKEN_XLSX: 'the workbook points at parts that do not exist',
+    TOO_LARGE: 'the file exceeds the entry, size or compression-ratio limits',
+    UNSAFE_XML: 'an XML part declares a DOCTYPE or nests too deeply',
+    INVALID_XML: 'an XML part is not well-formed',
+    PART_EXISTS: 'a part with that name already exists',
+    PART_MISSING: 'the part is not in the package',
+    UNTOUCHED_EDIT: 'a part was changed without touch() (strict mode only)',
+    INVALID_OPTIONS: 'an option is unknown or out of range',
+    INVALID_TEXT: 'text or paragraphs are not in an accepted shape',
+    INVALID_STYLE: 'a style or format value is unknown or out of range',
+    INVALID_BOX: 'a position or size is not a valid whole number of EMU',
+    INVALID_IMAGE: 'the image is empty, truncated or has no size',
+    UNSUPPORTED_IMAGE: 'the image is not PNG, JPEG or GIF',
+    INVALID_TABLE: 'table rows or cells are not in an accepted shape',
+    INVALID_CHART: 'a chart option is not valid',
+    INVALID_CHART_DATA: 'chart categories or series are not valid',
+    UNSUPPORTED_CHART: 'that chart type cannot be created or edited',
+    CHART_COMBO: 'a combo chart must keep its number of series',
+    NOT_CHART: 'the target holds no chart',
+    SLIDE_NOT_FOUND: 'no slide at that index',
+    SHAPE_NOT_FOUND: 'no shape with that id or role on the slide',
+    LAYOUT_NOT_FOUND: 'no layout with that name',
+    PARAGRAPH_NOT_FOUND: 'no paragraph at that index',
+    NOT_TEXT: 'the shape or block holds no text',
+    NOT_PICTURE: 'the shape is not a picture',
+    NOT_TABLE: 'the shape or block is not a table',
+    CELL_NOT_FOUND: 'no table cell at that row and column',
+    CELL_MERGED: 'the cell is covered by a merged cell',
+    SLIDE_IS_LINKED: 'another slide links to the slide',
+    TOO_MANY_SLIDES: 'the deck has run out of slide ids',
+    BLOCK_NOT_FOUND: 'no block at that index',
+    NOT_PARAGRAPH: 'the block is not a paragraph',
+    NOT_HEADING: 'the block is not a heading',
+    STYLE_NOT_FOUND: 'no style with that name',
+    TRACKED_CHANGES: 'the paragraph has tracked changes that an edit would accept silently',
+    ROW_NOT_FOUND: 'no table row at that index',
+    ROW_MERGED: 'the row is part of a vertically merged cell',
+    LAST_ROW: 'the table would be left without rows',
+    SHEET_NOT_FOUND: 'no sheet with that name or index',
+    NOT_WORKSHEET: 'the sheet is a chart sheet or dialog sheet',
+    INVALID_NAME: 'the sheet name is not allowed',
+    INVALID_CELL: 'not a valid cell, row or column reference',
+    INVALID_RANGE: 'not a valid range or limit',
+    INVALID_VALUE: 'a cell value, formula or date is not valid',
+    INVALID_FORMULA: 'text starting with = does not parse as a formula',
+    SHARED_FORMULA: 'the cell belongs to a shared or array formula range',
+    SHEET_HAS_DEPENDENTS: 'the sheet has pivot tables, comments or other parts that rows or columns cannot move through yet',
+    SHEET_IS_REFERENCED: 'other formulas, names or charts refer to the sheet',
+    LAST_SHEET: 'a workbook needs at least one visible sheet'
+};