@pinepaper.studio/mcp-server 1.6.22 → 1.6.24

package/dist/tools/handlers.js

@@ -5,8 +5,10 @@
  * Supports i18n for localized error and success messages.
  * Supports browser execution via Puppeteer.
  */
+import { nestedIgnoredPaths } from './nested-ignored.js';
 import { CRAFT_FRAME_JS, generateDrawWeave, generateDrawKnots, generateDrawSashiko, generateDrawSubdivision, generateUiKit, uiKitCallProblems, } from './craft-tools.js';
 import { codeGenerator, generateQueryMutationsCode, SHEET_RUBRIC } from '../types/code-generator.js';
+import { expandBatchMacros, BatchMacroError } from './batch-macros.js';
 import { CreateItemInputSchema, ModifyItemInputSchema, DeleteItemInputSchema, AddRelationInputSchema, RemoveRelationInputSchema, QueryRelationsInputSchema, AnimateItemInputSchema, ImportMotionCaptureInputSchema, KeyframeAnimateInputSchema, ExecuteGeneratorInputSchema, ApplyEffectInputSchema, GetItemsInputSchema, PlayTimelineInputSchema, SetBackgroundColorInputSchema, SetCanvasSizeInputSchema, ImportSVGInputSchema, ImportMermaidInputSchema, AddFilterInputSchema, CreateGlossySphereInputSchema, CreateDiagonalStripesInputSchema, BatchCreateInputSchema, BatchModifyInputSchema, CreateGridInputSchema, GeometryInputSchema, EquationPathInputSchema, EventInputSchema, ConstructionSequenceInputSchema, ValidateSceneInputSchema, CaptureFramesInputSchema, InstantiateOntologyInputSchema, LintSceneInputSchema, MediaInputSchema, TextStyleInputSchema, TextEffectInputSchema, DesignMediumInputSchema, RelightInputSchema, ChoreographInputSchema, EmitterInputSchema, MorphSequenceInputSchema, OriginalCharacterInputSchema, LookInputSchema, RenderHookInputSchema, ShaderGraphInputSchema, ShatterImageInputSchema, ImportLayeredCharacterInputSchema, CharacterInputSchema, GameInputSchema, World3DInputSchema, BrandKitInputSchema, ComponentInputSchema, ArtboardInputSchema, CommentInputSchema, ProvenanceInputSchema, SceneDiffInputSchema, AudioBeatsInputSchema, TemplateParamsInputSchema, RenderBatchInputSchema, AccessibilityCheckInputSchema, QueryMutationsInputSchema, ComposeInputSchema, CropImageInputSchema, PathOpInputSchema, MotionInputSchema, SoundInputSchema, InterchangeInputSchema, StickInputSchema, DesignSystemInputSchema, StoryInputSchema, ChromaKeyInputSchema, RiggingInputSchema, GroupInputSchema, CameraDirectorInputSchema, DetectObjectsInputSchema, ExtractObjectInputSchema, ArrangeInputSchema, CreateSceneInputSchema, GetPerformanceMetricsInputSchema, DiagnosticReportInputSchema, SearchAssetsInputSchema, ImportAssetInputSchema, P5DrawInputSchema, 
 // Diagram schemas
 CreateDiagramShapeInputSchema, ConnectInputSchema, ConnectPortsInputSchema, AddPortsInputSchema, AutoLayoutInputSchema, GetDiagramShapesInputSchema, UpdateConnectorInputSchema, RemoveConnectorInputSchema, DiagramModeInputSchema, 
@@ -26,12 +28,14 @@ ImportImageInputSchema,
 // Tool guide schema
 // Ontology schemas
 // Scene management schemas
-ManageScenesInputSchema, ScenePlaybackInputSchema, SceneGraphInputSchema, SequenceInputSchema, StaggerInputSchema, FlipInputSchema, 
+ManageScenesInputSchema, ScenePlaybackInputSchema, SceneGraphInputSchema, SequenceInputSchema, StaggerInputSchema, PatternInputSchema, FlipInputSchema, 
 // New consolidated tool schemas
 SelectionInputSchema, TransformInputSchema, HistoryInputSchema, ImageFilterInputSchema, LassoInputSchema, CutoutStyleInputSchema, PrecompInputSchema, BackgroundInputSchema, QueryInputSchema, QueryCapabilitiesInputSchema, DeformInputSchema, HandDrawnInputSchema, PenFigureInputSchema, CreateCharacterInputSchema, CharacterActionInputSchema, CharacterPoseInputSchema, SpriteSheetInputSchema, InteractionInputSchema, ExportWidgetInputSchema, ExportWidgetHtmlInputSchema, CreateChartInputSchema, MagicInputSchema, PhysicsInputSchema, MeasurementInputSchema, PlaceOnSurfaceInputSchema, DrawWeaveInputSchema, DrawKnotsInputSchema, DrawSashikoInputSchema, DrawSubdivisionInputSchema, UiKitInputSchema, StyledSceneInputSchema, ErrorCodes, } from '../types/schemas.js';
 import { ZodError, z } from 'zod';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { effectClass } from './effect-class.js';
+import { exportFileReceipt } from './export-file-receipt.js';
+import { ExportStepError, errorText, verifySavedFile, writeStep, bytesForSave } from './export-file-check.js';
 import { EFFECT_BEFORE_JS, effectAfterJs, namedItemIds, idMayBeGone, NO_CHANGE_NOTE } from './effect-check.js';
 import { writeFile, mkdir, appendFile, unlink, readFile, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -44,6 +48,7 @@ import { formatErrorContext, captureCanvasState } from '../execution/index.js';
 import { FILTER_PARAM_RANGES } from './engine-lists.js';
 import { getSessionManager } from '../agent/session-manager.js';
 import { vocabularyHintForPath, validateBatchVocabulary, detectBatchPropertyTypos } from '../ontology/hints.js';
+import { compileBatchTimelines } from './timeline.js';
 import { cameraHandlers } from './handlers/camera.js';
 import { fontHandlers } from './handlers/font.js';
 import { toolGuideHandlers } from './handlers/tool-guide.js';
@@ -372,12 +377,15 @@ async function saveAdExport(r, input, platform) {
         const html = buildHtml5Ad(r.adPage, opts);
         const zip = buildZip([{ name: 'index.html', data: html }]);
         files.zip = join(exportDir, `${stamp}.zip`);
-        await writeFile(files.zip, zip);
+        await writeStep(files.zip, () => writeFile(files.zip, zip));
+        await verifySavedFile(files.zip, zip.length);
         uploadBytes = zip.length;
         // The backup image is uploaded BESIDE the zip, not inside it.
         if (r.backupImage && r.backupImage.startsWith('data:')) {
             files.backupImage = join(exportDir, `${stamp}_backup.png`);
-            await writeFile(files.backupImage, Buffer.from(r.backupImage.split(',')[1], 'base64'));
+            const backup = bytesForSave(r.backupImage, 'the backup image');
+            await writeStep(files.backupImage, () => writeFile(files.backupImage, backup));
+            await verifySavedFile(files.backupImage, backup.length);
         }
         else {
             warnings.push({ code: 'no_backup_image', message: 'no backup image was made (the studio could not capture a frame); display networks require one — export format "png" at the same size.' });
@@ -386,8 +394,9 @@ async function saveAdExport(r, input, platform) {
     else {
         const html = buildPlayable(r.adPage, opts);
         files.html = join(exportDir, `${stamp}.html`);
-        await writeFile(files.html, html, 'utf-8');
+        await writeStep(files.html, () => writeFile(files.html, html, 'utf-8'));
         uploadBytes = Buffer.byteLength(html, 'utf-8');
+        await verifySavedFile(files.html, uploadBytes);
     }
     // 150 KB is Google Ads' display HTML5 figure; some uploads allow 600 KB, and
     // playable networks set their own — so it is a default, not a rule.
@@ -416,22 +425,26 @@ async function saveAdExport(r, input, platform) {
 }
 async function saveExportToFile(data, format, platform) {
     const exportDir = getExportDir();
-    await mkdir(exportDir, { recursive: true });
+    await writeStep(exportDir, () => mkdir(exportDir, { recursive: true }));
     const ext = getFileExtension(format);
     const timestamp = Date.now();
     const fileName = `pinepaper_${platform}_${timestamp}.${ext}`;
     const filePath = join(exportDir, fileName);
-    if (data.startsWith('data:')) {
-        const base64Data = data.split(',')[1];
-        const buffer = Buffer.from(base64Data, 'base64');
-        await writeFile(filePath, buffer);
-        return { filePath, fileSize: buffer.length };
+    // A data URL is decoded (base64 or percent-encoded); plain text (SVG, captions) is written as UTF-8. Nothing to
+    // write is the `export` or `save` step's failure, named — it used to write a 0-byte file and report it saved.
+    let buffer;
+    try {
+        buffer = bytesForSave(data, `the ${format} export`);
     }
-    else {
-        // Plain text (SVG)
-        await writeFile(filePath, data, 'utf-8');
-        return { filePath, fileSize: Buffer.byteLength(data, 'utf-8') };
+    catch (e) {
+        if (e instanceof ExportStepError)
+            throw new ExportStepError(e.step, filePath, e.reason);
+        throw e;
     }
+    await writeStep(filePath, () => writeFile(filePath, buffer));
+    // Read back: success is a file that exists and holds what was written.
+    await verifySavedFile(filePath, buffer.length);
+    return { filePath, fileSize: buffer.length };
 }
 /**
  * Page a RETAINED export out of the studio's export store into a local file.
@@ -459,15 +472,16 @@ async function streamRetainedExportToFile(controller, retained, platform) {
     let offset = 0;
     let chunks = 0;
     // Start from empty: appendFile would otherwise extend a same-millisecond file.
-    await writeFile(filePath, Buffer.alloc(0));
+    await writeStep(filePath, () => writeFile(filePath, Buffer.alloc(0)));
     // Returns the error rather than throwing it, so `throw await abandon(...)`
     // reads as a throw to the type checker and narrows what follows.
-    const abandon = async (why) => {
+    // Paging the bytes out is the `save` step; a refusal from the file system is the `write` step.
+    const abandon = async (why, step = 'save') => {
         try {
             await unlink(filePath);
         }
         catch { /* nothing written yet */ }
-        return new Error(
+        return new ExportStepError(step, filePath, 
         // The promise now names the call that keeps it. It was true before and
         // unreachable: reading a held export mutates nothing, so "it can be paged
         // again" was always correct and there was no door to page it through.
@@ -546,7 +560,12 @@ async function streamRetainedExportToFile(controller, retained, platform) {
         const buf = Buffer.from(chunk.data || '', 'base64');
         if (buf.length === 0 && chunk.eof !== true)
             throw await abandon('the studio returned an empty chunk before the end of the file');
-        await appendFile(filePath, buf);
+        try {
+            await appendFile(filePath, buf);
+        }
+        catch (writeError) {
+            throw await abandon(`appending ${buf.length} bytes at offset ${offset} failed: ${errorText(writeError, 'the file system gave no reason')}`, 'write');
+        }
         offset += buf.length;
         chunks++;
         if (chunk.eof === true)
@@ -557,6 +576,16 @@ async function streamRetainedExportToFile(controller, retained, platform) {
     if (offset !== retained.size) {
         throw await abandon(`reassembled ${offset} bytes but the studio reported ${retained.size}`);
     }
+    // An empty export is not a saved file, and neither is one the disk does not hold: read it back BEFORE the
+    // studio's copy is released, so a failure here still leaves the bytes recoverable.
+    if (offset === 0)
+        throw await abandon('the studio held an empty export (0 bytes): there is nothing to save');
+    try {
+        await verifySavedFile(filePath, offset);
+    }
+    catch (verifyError) {
+        throw await abandon(errorText(verifyError instanceof ExportStepError ? verifyError.reason : verifyError, 'the written file could not be read back'), 'write');
+    }
     // Only now is it safe to drop the studio's copy.
     try {
         await controller.executeCode(codeGenerator.generateReleaseExport(retained.exportId), false);
@@ -685,10 +714,40 @@ function withSessionNote(out, r) {
     }
     return out;
 }
+export const RECEIPTS_META_KEY = 'pinepaper.studio/receipts';
+/** The engine run's receipts (report.receipts: { calls, byDoor, notes }), when any call has something to say. */
+export function engineReceipts(report) {
+    const r = report && typeof report === 'object' ? report.receipts : undefined;
+    if (!r || !Array.isArray(r.notes) || r.notes.length === 0)
+        return null;
+    return { calls: Number(r.calls) || 0, byDoor: r.byDoor ?? {}, notes: r.notes };
+}
+/**
+ * agent_export answered from the export's own result and never read the run's report (AR-1 R2): an export's engine
+ * warnings and receipts are now on the reply like every other tool's — a text line an agent reads, and _meta.
+ */
+export function withEngineReport(result, report) {
+    if (!report || result.isError)
+        return result;
+    const receipts = engineReceipts(report);
+    const engineWarnings = Array.isArray(report.engineWarnings) ? report.engineWarnings.filter((w) => w && typeof w === 'object') : [];
+    if (!receipts && !engineWarnings.length)
+        return result;
+    const body = { ...(receipts ? { receipts } : {}), ...(engineWarnings.length ? { engineWarnings } : {}) };
+    return {
+        ...result,
+        content: [...(result.content ?? []), { type: 'text', text: `ENGINE RECEIPTS: ${JSON.stringify(body)}` }],
+        _meta: { ...(result._meta ?? {}), [RECEIPTS_META_KEY]: body },
+    };
+}
 function executedResult(code, result, screenshot, description, report) {
     const resultObj = { success: true, result };
     if (description)
         resultObj.description = description;
+    // The scene lint after the code ran, when there is something to say.
+    const lint = report && Array.isArray(report.lintWarnings) ? report.lintWarnings : [];
+    if (lint.length)
+        resultObj.lintWarnings = lint;
     // Surface the governor's model-actionable feedback (app.runGenerated report):
     // warnings (e.g. "500 items created one-by-one — prefer a pattern"), item count,
     // and guard trips. Omitted entirely on pre-governor FxTool builds (no report).
@@ -711,6 +770,11 @@ function executedResult(code, result, screenshot, description, report) {
             governor.loopGuardTripped = true;
         if (Object.keys(governor).length)
             resultObj.governor = governor;
+        // AR-1 R2: what each engine call did with what it was given (FxTool js/core/Receipt.js) — only when a call
+        // renamed, fell back, dropped or warned; a run whose calls all applied as asked adds nothing.
+        const receipts = engineReceipts(report);
+        if (receipts)
+            resultObj.receipts = receipts;
     }
     // THE CODE ECHO WAS 90% OF THE RESPONSE, AND THE AGENT WROTE THE REQUEST.
     //
@@ -777,6 +841,44 @@ function redactGeneratedCode(details) {
         },
     };
 }
+/**
+ * The studio's scene-lint warnings on an export (FxTool lintScene), one line each, so a centred title that runs
+ * out of the frame ("IGNAL" for "SIGNAL") is read on the success path rather than left in the JSON. Empty when none.
+ */
+export function lintLines(exportResult) {
+    const w = exportResult?.lintWarnings;
+    if (!Array.isArray(w) || !w.length)
+        return '';
+    return w.map((x) => `LINT: ${String(x?.message ?? x?.code ?? 'scene lint warning')}\n`).join('');
+}
+/**
+ * The file as ffprobe read it, when it disagrees with what the studio encoded: one line per field. A summary
+ * line when they agree; nothing when there is no summary.
+ */
+export function probeLines(receipt) {
+    const p = receipt.probe;
+    if (!p)
+        return '';
+    const head = `Probe: ${p.container} ${p.codec} ${p.width}x${p.height}${p.fps ? ` @ ${p.fps} fps` : ''}, ${p.durationS} s, ${p.frames} frame${p.frames === 1 ? '' : 's'}`;
+    const c = receipt.probeCheck;
+    if (!c)
+        return `${head}\n`;
+    if (c.tool === null)
+        return `${head} (not read back: ${c.reason})\n`;
+    if (c.ok)
+        return `${head} (ffprobe agrees)\n`;
+    if (!c.mismatches?.length)
+        return `${head}\nPROBE: ${c.reason ?? 'ffprobe could not confirm the file'}\n`;
+    return `${head}\n` + c.mismatches.map((m) => `PROBE MISMATCH: ${m.field} — the studio encoded ${JSON.stringify(m.studio)}, ffprobe reads ${JSON.stringify(m.file)}\n`).join('');
+}
+/**
+ * An export that failed at a step, as an error result: `{ step, path, reason }` in the data and in the words.
+ * A non-ExportStepError is named at `fallbackStep` with its own message, never "undefined".
+ */
+function exportStepErrorResult(e, fallbackStep, extra = {}, toolName = 'pinepaper_agent_export') {
+    const err = e instanceof ExportStepError ? e : new ExportStepError(fallbackStep, null, errorText(e, `the ${fallbackStep} step failed with no reason given`));
+    return errorResult(ErrorCodes.EXECUTION_ERROR, err.message, { ...err.toData(), ...extra }, { toolName });
+}
 export function errorResult(code, message, rawDetails, context) {
     // THE GENERATED SCRIPT IS NOT THE ERROR.
     //
@@ -811,15 +913,19 @@ export function errorResult(code, message, rawDetails, context) {
         isError: true,
     };
 }
-function handleValidationError(error, i18n) {
+function handleValidationError(error, i18n, args) {
     const message = i18n
         ? i18n.getError('validationError', { message: 'Invalid input parameters' })
         : 'Invalid input parameters';
-    const details = error.errors.map((e) => {
+    const details = error.issues.map((e) => {
         const path = e.path.join('.');
         const detail = { path, message: e.message };
-        if (e.code === 'invalid_enum_value') {
-            const received = e.received;
+        // zod 4 names a value outside an enum `invalid_value` and no longer carries what was sent; it is read back from the
+        // call's own arguments along the issue's path, so the vocabulary hint ("did you mean …") still has a word to match.
+        if (e.code === 'invalid_value') {
+            let received = args;
+            for (const k of e.path)
+                received = received && typeof received === 'object' ? received[k] : undefined;
             const hint = vocabularyHintForPath(path, received);
             if (hint)
                 detail.vocabulary = hint;
@@ -1062,23 +1168,34 @@ async function writeResultDataToFile(out, ext) {
         return out;
     }
     const r = obj.result;
-    if (!r || r.data === undefined || r.data === null)
+    if (!r || r.success === false)
         return out;
-    let bytes;
-    if (typeof r.data === 'string' && r.data.startsWith('data:'))
-        bytes = Buffer.from(r.data.slice(r.data.indexOf(',') + 1), 'base64');
-    else if (typeof r.data === 'string')
-        bytes = Buffer.from(r.data, 'utf-8');
-    else
-        bytes = Buffer.from(JSON.stringify(r.data), 'utf-8');
+    if (r.data === undefined || r.data === null) {
+        // A result that says in fields that it wrote no file (png-sequence frames left in the page: `file: null` and
+        // `why`) claims no file: it passes as it is. Any other success with nothing to write is the exit-0-without-file
+        // case, named.
+        if (r.file === null && typeof r.why === 'string' && r.why.trim())
+            return out;
+        const err = new ExportStepError('export', null, `the ${ext} export reported success but returned no file data`);
+        return errorResult(ErrorCodes.EXECUTION_ERROR, err.message, { ...err.toData(), result: r });
+    }
     const dir = getExportDir();
-    await mkdir(dir, { recursive: true });
     const filePath = join(dir, `pinepaper_${String(r.format ?? 'export').replace(/[^a-z0-9-]/gi, '')}_${Date.now()}.${ext}`);
-    await writeFile(filePath, bytes);
-    const { data: _d, ...rest } = r;
-    void _d;
-    obj.result = { ...rest, filePath, bytes: bytes.length };
-    return { ...out, content: [{ type: 'text', text: JSON.stringify(obj, null, 2) }, ...out.content.slice(1)] };
+    // No success without a file that exists and is not empty: each failure names its step, path and reason.
+    try {
+        const bytes = typeof r.data === 'string' ? bytesForSave(r.data, `the ${ext} export`) : Buffer.from(JSON.stringify(r.data), 'utf-8');
+        await writeStep(filePath, async () => { await mkdir(dir, { recursive: true }); await writeFile(filePath, bytes); });
+        await verifySavedFile(filePath, bytes.length);
+        const { data: _d, ...rest } = r;
+        void _d;
+        obj.result = { ...rest, filePath, bytes: bytes.length };
+        return { ...out, content: [{ type: 'text', text: JSON.stringify(obj, null, 2) }, ...out.content.slice(1)] };
+    }
+    catch (e) {
+        const err = e instanceof ExportStepError ? new ExportStepError(e.step, e.path ?? filePath, e.reason)
+            : new ExportStepError('write', filePath, errorText(e, 'the file could not be written'));
+        return errorResult(ErrorCodes.EXECUTION_ERROR, err.message, err.toData());
+    }
 }
 /**
  * pinepaper_capture_frames with `sheet`: one tiled image of the film, saved
@@ -1282,8 +1399,9 @@ ${code}
         tracker.startTimer(`${timerId}_screenshot`);
     }
     // Agent-written code is rolled back when it fails part-way; a tool's own
-    // emitter is not (its verdict already describes what it left behind).
-    const rollbackOnFailure = toolName === 'pinepaper_execute_custom_code'
+    // emitter is not (its verdict already describes what it left behind), except
+    // an atomic batch, whose contract is that a refused call changed nothing.
+    const rollbackOnFailure = (toolName === 'pinepaper_execute_custom_code' || options.rollbackCreatedOnFailure === true)
         && await markItemsBeforeRun(controller);
     const governorTimeoutMs = LONG_GOVERNOR_BUDGET_MS[toolName];
     // NO SILENT SUCCESS (effect-class.ts / effect-check.ts): fingerprint a
@@ -1308,6 +1426,10 @@ ${code}
         ...(governorTimeoutMs ? { governorTimeoutMs } : {}),
     });
     const browserDuration = tracker.endTimer(`${timerId}_browser_execution`);
+    // THE SCENE LINT RIDES OUT OF BAND: an emitter that ran app.lintScene() returns it under __ppLint, and
+    // execute_custom_code returns its own value under __ppValue. Both are unwrapped HERE, before any verdict reads the
+    // result, so the code's own value is what is judged and returned, and the lint sits beside it.
+    const lintWarnings = unwrapLint(result);
     // THE METRIC RECORDS THE CALL'S VERDICT, NOT THE TRANSPORT'S (gate H2,
     // 1.6.19). result.success only says the code RAN; an emitter that ran and
     // returned { success: false } is a failed call, and get_performance_metrics
@@ -1352,6 +1474,8 @@ ${code}
         // PP_LOOP_BUDGET, PP_TIMEOUT) so the model can correct on the next turn.
         {
             code, errorCode: result.errorCode, governorReport: result.report,
+            failures: stepFailures(toolName, result.result, result.error || 'Failed to execute code in browser'),
+            ...(lintWarnings.length ? { lintWarnings } : {}),
             ...(rollbackOnFailure ? await customCodeRollback(controller, result.error) : {}),
         }, {
             toolName,
@@ -1383,6 +1507,8 @@ ${code}
             .slice(0, 3);
         return withTiming(errorResult(ErrorCodes.EXECUTION_ERROR, said.length ? `${inner} The studio said: ${said.join(' | ')}` : inner, {
             code, result: result.result, governorReport: result.report,
+            failures: stepFailures(toolName, result.result, inner),
+            ...(lintWarnings.length ? { lintWarnings } : {}),
             ...(rollbackOnFailure ? await customCodeRollback(controller, inner) : {}),
         }, { toolName, canvasState: canvasState || undefined }), timing);
     }
@@ -1434,6 +1560,46 @@ ${code}
  * string with no `success: true` beside it is a failure too — it is what the
  * emitters' catch blocks return.
  */
+/**
+ * Move an emitter's out-of-band scene lint (`__ppLint`) off its result, and unwrap execute_custom_code's own value
+ * (`__ppValue`). The lint is also put on `run.report.lintWarnings`, where executedResult reads it. Returns the lint.
+ */
+export function unwrapLint(run) {
+    const r = run.result;
+    if (!r || typeof r !== 'object' || Array.isArray(r) || !('__ppLint' in r))
+        return [];
+    const lint = Array.isArray(r.__ppLint) ? r.__ppLint : [];
+    if ('__ppValue' in r)
+        run.result = r.__ppValue;
+    else {
+        const { __ppLint: _l, ...rest } = r;
+        void _l;
+        run.result = rest;
+    }
+    if (lint.length)
+        run.report = { ...(run.report ?? {}), lintWarnings: lint };
+    return lint;
+}
+/**
+ * Every failed step of a call as `{ step, itemId, reason }`, never a bare message: a batch's own `failures`, a
+ * result that names its step, or the call itself with the item it named.
+ */
+export function stepFailures(toolName, value, message) {
+    const v = value;
+    const reasonOf = (x) => (typeof x === 'string' && x.trim() ? x : '');
+    if (v && typeof v === 'object' && Array.isArray(v.failures) && v.failures.length) {
+        return v.failures.map((f) => ({
+            step: reasonOf(f.step) || toolName,
+            itemId: typeof f.itemId === 'string' ? f.itemId : null,
+            reason: reasonOf(f.reason) || reasonOf(f.error) || message,
+        }));
+    }
+    return [{
+            step: (v && typeof v === 'object' && reasonOf(v.step)) || toolName,
+            itemId: v && typeof v === 'object' && typeof v.itemId === 'string' ? v.itemId : null,
+            reason: (v && typeof v === 'object' && (reasonOf(v.reason) || reasonOf(v.error))) || reasonOf(message) || `${toolName} failed with no reason given`,
+        }];
+}
 export function innerFailure(value) {
     if (!value || typeof value !== 'object')
         return null;
@@ -1561,15 +1727,23 @@ function measureResponseBytes(result) {
     return bytes;
 }
 /**
- * TOP-LEVEL ARGUMENTS A TOOL DROPPED, SAID OUT LOUD.
+ * TOP-LEVEL ARGUMENTS A TOOL DROPPED, SAID OUT LOUD — FOR EVERY TOOL.
  *
  * z.object() strips unknown keys, so agent_export {loop: true, seamless: true}
  * answered success and exported exactly what it would have without them — the
- * caller believed they had a loop setting. create_item / modify_item report
- * unread PROPERTIES; this is the same idea one level up, for tools listed
- * here. Keyed to the zod schema the handler parses with, so a key the handler
- * accepts is never reported, and extended one tool at a time rather than
- * guessed for all 150.
+ * caller believed they had a loop setting. keyframe_animate {mode: 'merge'}
+ * (issue #14) was the same: stripped, success, the track replaced.
+ *
+ * A key is known when the tool's published JSON schema lists it, when the zod
+ * schema in IGNORED_ARGUMENT_SCHEMAS has it, or when HIDDEN_ARGUMENTS names it.
+ * Anything else had no effect, and the reply says so. The published schema is
+ * the contract the caller reads, so it is the right default; the two lists
+ * cover what a handler accepts without advertising.
+ *
+ * ignored-arguments-coverage.test.ts pairs every tool with the zod schemas its
+ * handler parses and the args.x it reads, and fails when a key the handler
+ * accepts is neither published nor in HIDDEN_ARGUMENTS — so a working key is
+ * never reported as ignored — and when an entry here is no longer needed.
  */
 const IGNORED_ARGUMENT_SCHEMAS = {
     pinepaper_agent_export: AgentExportInputSchema,
@@ -1580,6 +1754,34 @@ const IGNORED_ARGUMENT_SCHEMAS = {
     // Its options live in `options` / `spec`; a key beside them was dropped.
     pinepaper_sound: SoundInputSchema,
 };
+/**
+ * Keys a handler accepts that its published schema does not list. Shrink-only:
+ * publishing one (or dropping it from the handler) means deleting it here.
+ */
+export const HIDDEN_ARGUMENTS = {
+    pinepaper_agent_end_job: ['takeScreenshot'],
+    pinepaper_agent_export: ['includeRecommendations'],
+    pinepaper_agent_reset: ['preserveCanvasSize'],
+    pinepaper_agent_start_job: ['headless', 'canvasSize', 'backgroundColor'],
+    pinepaper_font: ['fontFamily'],
+    pinepaper_import_svg: ['source'],
+    // load takes its options flat as well as under `options`.
+    pinepaper_map: ['quality', 'fillColor', 'strokeColor', 'strokeWidth', 'scale', 'rotate', 'enableHover', 'enableClick', 'hoverFill', 'hoverStroke', 'animate', 'geoJson'],
+    pinepaper_map_regions: ['pulse', 'shape'],
+    pinepaper_query_capabilities: ['query'],
+    pinepaper_text_effect: ['startAt', 'hideAfter'],
+};
+/**
+ * Nested keys (paths with [] for any array index) a handler accepts that its published schema closes over without
+ * listing. Shrink-only, held exact by nested-ignored-coverage.test.ts; publishing one means deleting it here.
+ */
+export const NESTED_HIDDEN = {
+    pinepaper_create_item: ['keyframes[].hold', 'keyframes[].interpolation'],
+    pinepaper_create_scene: ['animations[].startTime'],
+    pinepaper_keyframe_animate: ['keyframes[].hold', 'keyframes[].interpolation'],
+};
+/** Tools whose schema passes every key through: nothing is dropped. */
+export const PASSTHROUGH_ARGUMENT_TOOLS = new Set(['pinepaper_equation_path', 'pinepaper_ui_kit']);
 const IGNORED_ARGUMENT_HINTS = {
     pinepaper_create_item: Object.fromEntries(['width', 'height', 'radius', 'color', 'fillColor', 'strokeColor', 'strokeWidth', 'content', 'fontSize', 'fontFamily', 'opacity', 'rotation', 'x', 'y']
         .map((k) => [k, 'Shape properties go INSIDE properties: {…}; only itemType, position, anchor, properties, animation*, keyframes and data are top-level.'])),
@@ -1590,29 +1792,73 @@ const IGNORED_ARGUMENT_HINTS = {
         seamless: 'A seamless loop is keyed, not a switch: key the animation to the SAME state at t = 0 and at t = duration and export exactly that duration (the export stops one frame before duration, so nothing is doubled at the wrap). A GIF\'s play count is the loop parameter.',
     },
 };
-export function ignoredArgumentsNote(toolName, args) {
+let PUBLISHED_ARGUMENTS = null;
+/** Each tool's published top-level keys; null when its schema allows any key. */
+export async function publishedArguments(toolName) {
+    if (!PUBLISHED_ARGUMENTS) {
+        const { PINEPAPER_TOOLS } = await import('./definitions.js');
+        PUBLISHED_ARGUMENTS = new Map(PINEPAPER_TOOLS.map((t) => {
+            const js = t.inputSchema;
+            return [t.name, js.additionalProperties === true ? null : new Set(Object.keys(js.properties ?? {}))];
+        }));
+    }
+    return PUBLISHED_ARGUMENTS.get(toolName);
+}
+/** The top-level keys of `args` the tool does not read. */
+export function ignoredArgumentKeys(toolName, args, published) {
+    if (!args || typeof args !== 'object' || PASSTHROUGH_ARGUMENT_TOOLS.has(toolName) || published === null)
+        return [];
+    const known = new Set([...(published ?? []), ...(HIDDEN_ARGUMENTS[toolName] ?? [])]);
     let schema = IGNORED_ARGUMENT_SCHEMAS[toolName];
-    if (!schema || !args || typeof args !== 'object')
-        return null;
-    while (schema instanceof z.ZodEffects)
-        schema = schema._def.schema;
-    if (!(schema instanceof z.ZodObject))
-        return null;
-    const known = new Set(Object.keys(schema.shape));
-    const ignored = Object.keys(args).filter((k) => !known.has(k));
+    // zod 4: a preprocess or transform is a ZodPipe (preprocess: transform → object; .transform: object → transform).
+    while (schema instanceof z.ZodPipe)
+        schema = (schema._def.in instanceof z.ZodObject || !(schema._def.out instanceof z.ZodObject) ? schema._def.in : schema._def.out);
+    if (schema instanceof z.ZodObject)
+        Object.keys(schema.shape).forEach((k) => known.add(k));
+    else if (published === undefined)
+        return []; // neither a schema nor a published contract to judge by
+    return Object.keys(args).filter((k) => !known.has(k));
+}
+export function ignoredArgumentsNote(toolName, args, published) {
+    const ignored = ignoredArgumentKeys(toolName, args, published);
     if (ignored.length === 0)
         return null;
     const hints = ignored.map((k) => IGNORED_ARGUMENT_HINTS[toolName]?.[k]).filter(Boolean);
     return `IGNORED ARGUMENTS: ${ignored.join(', ')} ${ignored.length > 1 ? 'are' : 'is'} not a parameter of ${toolName}, so ${ignored.length > 1 ? 'they had' : 'it had'} no effect.`
         + (hints.length ? ` ${[...new Set(hints)].join(' ')}` : '');
 }
+/** The same check, against the tool's published schema, and below the top level (AR-1 R2: nested-ignored.ts). */
+export async function ignoredArgumentsNoteFor(toolName, args) {
+    const published = await publishedArguments(toolName);
+    const top = ignoredArgumentKeys(toolName, args, published);
+    const nested = PASSTHROUGH_ARGUMENT_TOOLS.has(toolName) || published === null ? [] : await nestedIgnoredFor(toolName, args);
+    const ignored = [...top, ...nested];
+    if (!ignored.length)
+        return null;
+    const topNote = top.length ? ignoredArgumentsNote(toolName, args, published) : '';
+    const nestedNote = nested.length
+        ? `IGNORED ARGUMENTS: ${nested.join(', ')} ${nested.length > 1 ? 'are' : 'is'} not a parameter of ${toolName}, so ${nested.length > 1 ? 'they had' : 'it had'} no effect.`
+        : '';
+    return { note: [topNote, nestedNote].filter(Boolean).join(' '), ignored };
+}
+async function nestedIgnoredFor(toolName, args) {
+    const { PINEPAPER_TOOLS } = await import('./definitions.js');
+    const tool = PINEPAPER_TOOLS.find((t) => t.name === toolName);
+    if (!tool)
+        return [];
+    const hidden = new Set(NESTED_HIDDEN[toolName] ?? []);
+    return nestedIgnoredPaths(tool.inputSchema, args).filter((p) => !hidden.has(p.replace(/\[\d+\]/g, '[]')));
+}
+export const IGNORED_ARGUMENTS_META_KEY = 'pinepaper.studio/ignoredArguments';
 export async function handleToolCall(toolName, args, options = {}) {
     const tracker = getPerformanceTracker();
     const baseTimerId = `${toolName}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
     const result = await callContext.run({ toolName, action: typeof args.action === 'string' ? args.action : undefined }, () => handleToolCallInner(toolName, args, options, tracker, baseTimerId));
-    const ignoredNote = ignoredArgumentsNote(toolName, args);
-    if (ignoredNote)
-        result.content = [...(result.content ?? []), { type: 'text', text: ignoredNote }];
+    const ignored = await ignoredArgumentsNoteFor(toolName, args);
+    if (ignored) {
+        result.content = [...(result.content ?? []), { type: 'text', text: ignored.note }];
+        result._meta = { ...(result._meta ?? {}), [IGNORED_ARGUMENTS_META_KEY]: ignored.ignored };
+    }
     // Record response payload size for token estimation
     const responseBytes = measureResponseBytes(result);
     tracker.recordMetric({
@@ -1742,6 +1988,11 @@ async function handleToolCallInner(toolName, args, options, tracker, baseTimerId
                 const code = codeGenerator.generateStagger(input);
                 return executeOrGenerate(code, `Stagger: ${input.action}`, options, 'pinepaper_stagger');
             }
+            case 'pinepaper_pattern': {
+                const input = PatternInputSchema.parse(args);
+                const code = codeGenerator.generatePattern(input);
+                return executeOrGenerate(code, `Pattern: ${input.action}${input.id ? ' ' + input.id : ''}`, options, 'pinepaper_pattern');
+            }
             case 'pinepaper_flip': {
                 const input = FlipInputSchema.parse(args);
                 const code = codeGenerator.generateFlip(input);
@@ -3555,8 +3806,26 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
                         })));
                     }
                 }
+                let expanded;
+                try {
+                    expanded = expandBatchMacros(input.operations);
+                }
+                catch (e) {
+                    if (e instanceof BatchMacroError)
+                        return errorResult(ErrorCodes.VALIDATION_ERROR, e.message, {}, { toolName: 'pinepaper_agent_batch_execute' });
+                    throw e;
+                }
+                // A timeline op compiles on the server: a tween it cannot honour is refused by name here, before the canvas is
+                // touched (skipValidation does not bypass it — there is nothing to send for a tween that did not compile).
+                if (expanded.some((op) => op.type === 'timeline')) {
+                    const tl = compileBatchTimelines(expanded);
+                    if (tl.errors.length > 0) {
+                        return errorResult(ErrorCodes.VALIDATION_ERROR, `The timeline was refused (${tl.errors.length} problem${tl.errors.length > 1 ? 's' : ''}); nothing was run. Fix ${tl.errors.length > 1 ? 'each' : 'it'} and send the batch again.`, tl.errors.map((e) => ({ path: e.path, reason: e.message })));
+                    }
+                }
                 const code = codeGenerator.generateAgentBatchExecute(input);
-                const description = `Batch executed ${input.operations.length} operations${input.atomic !== false ? ' (atomic)' : ''}`;
+                const description = `Batch executed ${input.operations.length} operations${input.atomic !== false ? ' (atomic)' : ''}`
+                    + (expanded.length !== input.operations.length ? ` (${expanded.length} after expanding ring / grid / orbit / stagger)` : '');
                 // Check for out-of-bounds items before execution
                 let boundsWarning = '';
                 const sizeOp = input.operations.find((op) => op.type === 'set_canvas_size');
@@ -3564,7 +3833,7 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
                     const cw = sizeOp.width || 1920;
                     const ch = sizeOp.height || 1080;
                     const oobItems = [];
-                    input.operations.forEach((op, idx) => {
+                    expanded.forEach((op, idx) => {
                         if (op.type === 'create' && op.position) {
                             const { x, y } = op.position;
                             if (x < 0 || y < 0 || x > cw || y > ch) {
@@ -3576,7 +3845,7 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
                         boundsWarning = `\n\nWARNING: ${oobItems.length} item(s) positioned outside canvas bounds (${cw}x${ch}): ${oobItems.join(', ')}. Items may be clipped or invisible.`;
                     }
                 }
-                const batchResult = await executeOrGenerate(code, description, options, 'pinepaper_agent_batch_execute');
+                const batchResult = await executeOrGenerate(code, description, input.atomic !== false ? { ...options, rollbackCreatedOnFailure: true } : options, 'pinepaper_agent_batch_execute');
                 // Append bounds warning if any
                 if (boundsWarning && batchResult.content && batchResult.content.length > 0) {
                     const firstContent = batchResult.content[0];
@@ -3748,13 +4017,14 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
                             format,
                             chunkBytes: Number(exportResult.chunkBytes) || undefined,
                         }, input.platform || 'auto');
-                        const cleanResult = { ...exportResult, data: undefined, filePath, fileSize, chunks };
-                        return {
+                        const receipt = await exportFileReceipt(filePath, exportResult);
+                        const cleanResult = { ...exportResult, data: undefined, filePath, fileSize, chunks, file: receipt };
+                        return withEngineReport({
                             content: [{
                                     type: 'text',
-                                    text: `Export saved to file:\n\nFile: ${filePath}\nFormat: ${format}\nSize: ${(fileSize / 1024).toFixed(1)} KB\nPlatform: ${input.platform}\nPaged out of the studio's export store in ${chunks} chunk${chunks === 1 ? '' : 's'}\n\nResult: ${JSON.stringify(cleanResult, null, 2)}`,
+                                    text: `Export saved to file:\n\nFile: ${filePath}\nFormat: ${format}\nSize: ${(fileSize / 1024).toFixed(1)} KB\nPlatform: ${input.platform}\nPaged out of the studio's export store in ${chunks} chunk${chunks === 1 ? '' : 's'}\n${probeLines(receipt)}${lintLines(exportResult)}\nResult: ${JSON.stringify(cleanResult, null, 2)}`,
                                 }],
-                        };
+                        }, exportBrowserResult.report);
                     }
                     catch (streamError) {
                         // The export is still held — the message says so and names the id,
@@ -3768,7 +4038,14 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
                 // SCC (CEA-608, 8.37): the studio sent the cues; encoded here.
                 if (format === 'scc' && Array.isArray(exportResult?.sccCues)) {
                     const scc = buildScc(exportResult.sccCues);
-                    const { filePath, fileSize } = await saveExportToFile(scc.text, 'scc', input.platform || 'auto');
+                    let saved;
+                    try {
+                        saved = await saveExportToFile(scc.text, 'scc', input.platform || 'auto');
+                    }
+                    catch (saveError) {
+                        return exportStepErrorResult(saveError, 'save', { format: 'scc' });
+                    }
+                    const { filePath, fileSize } = saved;
                     const warnings = [];
                     if (scc.truncated)
                         warnings.push({ code: 'caption_truncated', message: `${scc.truncated} caption(s) did not fit two rows of 32 characters and were cut. Split long captions into more cues.` });
@@ -3779,10 +4056,22 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
                     const { sccCues: _c, ...rest } = exportResult;
                     void _c;
                     const cleanResult = { ...rest, filePath, fileSize, frameRate: '29.97 drop-frame', fidelity: { warnings } };
-                    return { content: [{ type: 'text', text: `Export saved to file:\n\nFile: ${filePath}\nFormat: scc (CEA-608, CC1, pop-on)\nSize: ${fileSize} bytes\n\nResult: ${JSON.stringify(cleanResult, null, 2)}` }] };
+                    return withEngineReport({ content: [{ type: 'text', text: `Export saved to file:\n\nFile: ${filePath}\nFormat: scc (CEA-608, CC1, pop-on)\nSize: ${fileSize} bytes\n\nResult: ${JSON.stringify(cleanResult, null, 2)}` }] }, exportBrowserResult.report);
                 }
                 if ((format === 'html5-ad' || format === 'playable') && typeof exportResult?.adPage === 'string') {
-                    return saveAdExport(exportResult, input, input.platform || 'auto');
+                    try {
+                        return withEngineReport(await saveAdExport(exportResult, input, input.platform || 'auto'), exportBrowserResult.report);
+                    }
+                    catch (saveError) {
+                        return exportStepErrorResult(saveError, 'save', { format });
+                    }
+                }
+                // NO SUCCESS WITHOUT BYTES. Every delivering branch above returned; what is left must carry the file's
+                // data. A success with none (no data field, an empty string) used to fall through to the inline return and
+                // report success with nothing in it. An estimate is the one answer that is not a file.
+                if (!exportResult?.estimateOnly && !(typeof data === 'string' && data.length > 0)) {
+                    const err = new ExportStepError('export', null, `the studio reported a successful ${format} export but returned no file data (${data === undefined ? 'no data field' : typeof data === 'string' ? 'an empty string' : `a ${data === null ? 'null' : typeof data}`})`);
+                    return errorResult(ErrorCodes.EXECUTION_ERROR, err.message, { ...err.toData(), format, result: exportResult }, { toolName: 'pinepaper_agent_export' });
                 }
                 const shouldSaveToFile = data && typeof data === 'string' && (options.saveToFile ||
                     ALWAYS_SAVE_FORMATS.has(format) ||
@@ -3790,29 +4079,32 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
                 if (shouldSaveToFile) {
                     try {
                         const { filePath, fileSize } = await saveExportToFile(data, format, input.platform || 'auto');
-                        const cleanResult = { ...exportResult, data: undefined, filePath, fileSize };
+                        const receipt = await exportFileReceipt(filePath, exportResult);
+                        const cleanResult = { ...exportResult, data: undefined, filePath, fileSize, file: receipt };
                         // A mix that dropped sounds wrote a perfectly good file that is
                         // missing tracks. It rides the SUCCESS path, which is exactly why
                         // it has to be said out loud here rather than left in the JSON.
                         const dropNote = exportResult.incomplete;
-                        return {
+                        return withEngineReport({
                             content: [{
                                     type: 'text',
                                     text: `Export saved to file:\n\nFile: ${filePath}\nFormat: ${format}\nSize: ${(fileSize / 1024).toFixed(1)} KB\nPlatform: ${input.platform}\n`
                                         + (dropNote ? `DROPPED: ${dropNote}\n` : '')
+                                        + probeLines(receipt)
+                                        + lintLines(exportResult)
                                         + `\nResult: ${JSON.stringify(cleanResult, null, 2)}`,
                                 }],
-                        };
+                        }, exportBrowserResult.report);
                     }
                     catch (saveError) {
+                        // A failed save is a failed export, never a success with a note inside it: the step, the path and
+                        // the reason, and the data stripped so the error is not the size of the video.
                         console.error('[PinePaper] Failed to save export to file:', saveError);
-                        // Strip the massive data to prevent oversized response
-                        const strippedResult = { ...exportResult, data: `[${format} export data — file save failed: ${saveError instanceof Error ? saveError.message : 'unknown error'}]` };
-                        return executedResult(code, strippedResult, exportBrowserResult.screenshot, description);
+                        return exportStepErrorResult(saveError, 'save', { format, bytes: typeof data === 'string' ? data.length : 0 });
                     }
                 }
-                // Small export — return inline (existing behavior)
-                return executedResult(code, exportResult, exportBrowserResult.screenshot, description);
+                // Small export — return inline (existing behavior). The bytes are in the result, checked non-empty above.
+                return executedResult(code, exportResult, exportBrowserResult.screenshot, description, exportBrowserResult.report);
             }
             case 'pinepaper_design_styles':
                 return dataResult({ styles: designSystems.listStyles() });
@@ -3884,10 +4176,24 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
                         const sizeWarning = sizeIgnored
                             ? `"${scene.style}" lays out at its own size, ${scene.width}x${scene.height}; the requested ${input.width ?? '?'}x${input.height ?? '?'} was not used`
                             : undefined;
+                        // BAUHAUS-SUBTITLE: at a size the style was not laid out for, its
+                        // proportions can put text across a shape (bauhaus at 1920x1080
+                        // runs the subtitle over the red circle). The layout is vendored;
+                        // the result names each collision rather than drawing it as intended.
+                        const collisions = designSystems.scalingCollisions(input.style, {
+                            title: input.title, subtitle: input.subtitle, body: input.body,
+                            width: input.width, height: input.height, variant: input.variant,
+                        }, scene);
+                        const layoutWarning = collisions.length
+                            ? `at ${scene.width}x${scene.height} the "${scene.style}" layout runs text onto a shape it does not touch at its own default size: `
+                                + collisions.map((c) => `${c.text} over ${c.shape}`).join(', ')
+                                + '. Compose without width/height (its default size) for the layout as designed, or move the text afterwards with pinepaper_modify_item.'
+                            : undefined;
+                        const collisionReport = collisions.length ? { layoutCollisions: collisions, layoutWarning } : {};
                         if (input.draw === false) {
-                            return dataResult({ scene, ops, drawn: false, ...(sizeWarning ? { warning: sizeWarning } : {}) });
+                            return dataResult({ scene, ops, drawn: false, ...(sizeWarning ? { warning: sizeWarning } : {}), ...collisionReport });
                         }
-                        const code = codeGenerator.generateDesignCompose(scene, ops, scene.style, sizeWarning);
+                        const code = codeGenerator.generateDesignCompose(scene, ops, scene.style, sizeWarning, collisionReport);
                         return executeOrGenerate(code, `Composed a ${scene.style} scene (${ops.length} items)`, options, 'pinepaper_design_system');
                     }
                 }
@@ -3969,11 +4275,8 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
                         };
                     }
                     catch (saveError) {
-                        const stripped = {
-                            ...soundtrack,
-                            wavBase64: `[${soundtrack.byteLength} bytes of WAV — file save failed: ${saveError instanceof Error ? saveError.message : 'unknown error'}]`,
-                        };
-                        return executedResult(code, stripped, wavResult.screenshot, soundDescription);
+                        // The soundtrack rendered; writing it did not. That is a failed export, said as one.
+                        return exportStepErrorResult(saveError, 'save', { format: 'wav', byteLength: soundtrack.byteLength }, 'pinepaper_sound');
                     }
                 }
                 return executeOrGenerate(code, soundDescription, options, 'pinepaper_sound');
@@ -4222,7 +4525,7 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
     }
     catch (error) {
         if (error instanceof ZodError) {
-            return handleValidationError(error, i18n);
+            return handleValidationError(error, i18n, args);
         }
         // Try to capture canvas state for error context (if browser is connected)
         let canvasState = null;
@@ -4235,6 +4538,10 @@ You can now start creating new items on a clean canvas.${sizeNote}`,
         catch (_stateError) {
             // Ignore errors from canvas state capture
         }
+        // An export that failed at a named step keeps its step, path and reason as fields.
+        if (error instanceof ExportStepError) {
+            return errorResult(ErrorCodes.EXECUTION_ERROR, error.message, error.toData(), { toolName, canvasState: canvasState || undefined });
+        }
         if (error instanceof Error) {
             const message = i18n
                 ? i18n.getError('executionError', { message: error.message })