@pinepaper.studio/mcp-server 1.6.8 → 1.6.9

package/dist/tools/engine-methods.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine-methods.d.ts","sourceRoot":"","sources":["../../src/tools/engine-methods.ts"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAsMpD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAcpD,CAAC"}
+{"version":3,"file":"engine-methods.d.ts","sourceRoot":"","sources":["../../src/tools/engine-methods.ts"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAwMpD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAcpD,CAAC"}

package/dist/tools/engine-methods.js

@@ -70,10 +70,12 @@ export const REQUIRED_ENGINE_METHODS = [
     'diffHistoryStates',
     'distillArticle',
     'dollyWorldCamera',
+    'ensureHeavyModules',
     'estimateExportSize',
     'exportBVH',
     'exportDotLottie',
     'exportEngine.exportToStore',
+    'exportEngine.listExports',
     'exportEngine.readExport',
     'exportEngine.releaseExport',
     'exportEngine.sceneHasAudio',

package/dist/tools/engine-methods.js.map

@@ -1 +1 @@
-{"version":3,"file":"engine-methods.js","sourceRoot":"","sources":["../../src/tools/engine-methods.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"engine-methods.js","sourceRoot":"","sources":["../../src/tools/engine-methods.ts"],"names":[],"mappings":"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"}

package/dist/tools/handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/tools/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAA6B,MAAM,oCAAoC,CAAC;AA8I/F,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,0BAA0B,EAG3B,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EAAE,YAAY,EAA0C,MAAM,uBAAuB,CAAC;AAgC7F;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE/D;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAOlD;AAaD,eAAO,MAAM,mBAAmB,aAAgD,CAAC;AAGjF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGvD;AAiHD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,MAAM,CAAC;AAEjD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,CAOhD;AAMD,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,0BAA0B,CAAC;IAC/C,oEAAoE;IACpE,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,sEAAsE;IACtE,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAuFD,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,OAAO,EACjB,OAAO,CAAC,EAAE,YAAY,GACrB,cAAc,CAwBhB;AAyBD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CAqMzB;AAMD,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GACtC,MAAM,CASR;AAkFD,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,cAAc,CAAC,CAkBzB"}
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/tools/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAA6B,MAAM,oCAAoC,CAAC;AA+I/F,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,0BAA0B,EAG3B,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EAAE,YAAY,EAA0C,MAAM,uBAAuB,CAAC;AAgC7F;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE/D;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAOlD;AAaD,eAAO,MAAM,mBAAmB,aAAgD,CAAC;AAkCjF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGvD;AAsLD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,MAAM,CAAC;AAEjD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,CAOhD;AAMD,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,0BAA0B,CAAC;IAC/C,oEAAoE;IACpE,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,sEAAsE;IACtE,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAuFD,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,OAAO,EACjB,OAAO,CAAC,EAAE,YAAY,GACrB,cAAc,CAwBhB;AAyBD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CAqMzB;AAMD,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GACtC,MAAM,CASR;AAkFD,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,cAAc,CAAC,CAkBzB"}

package/dist/tools/handlers.js

@@ -10,7 +10,7 @@ import { CreateItemInputSchema, ModifyItemInputSchema, DeleteItemInputSchema, Ad
 // Diagram schemas
 CreateDiagramShapeInputSchema, ConnectInputSchema, ConnectPortsInputSchema, AddPortsInputSchema, AutoLayoutInputSchema, GetDiagramShapesInputSchema, UpdateConnectorInputSchema, RemoveConnectorInputSchema, DiagramModeInputSchema, 
 // Agent flow mode schemas
-AgentStartJobInputSchema, AgentEndJobInputSchema, AgentResetInputSchema, AgentBatchExecuteInputSchema, AgentExportInputSchema, AgentAnalyzeInputSchema, 
+AgentStartJobInputSchema, AgentEndJobInputSchema, AgentResetInputSchema, AgentBatchExecuteInputSchema, AgentExportInputSchema, ExportStoreInputSchema, AgentAnalyzeInputSchema, 
 // Letter collage schemas
 CreateLetterCollageInputSchema, AnimateLetterCollageInputSchema, 
 // Map schemas
@@ -84,6 +84,34 @@ function getExportDir() {
 // pasted into a response.
 export const ALWAYS_SAVE_FORMATS = new Set(['mp4', 'webm', 'gif', 'pdf', 'wav']);
 const SAVE_THRESHOLD_BYTES = 500_000; // ~500KB base64 ≈ 375KB decoded
+/**
+ * Governor budget for the export run itself.
+ *
+ * FxTool's runGenerated defaults to a 10s async-tail timeout — right for a
+ * scene-building script that has no business running longer, and fatal for an
+ * export, which renders frame by frame and is capped at 600s of footage. The
+ * export died at ten seconds with a PP_TIMEOUT that read like a bug in the
+ * scene. This raises the budget rather than bypassing the governor, so the
+ * report, the item budget and the seeded PRNG all survive.
+ *
+ * PINEPAPER_EXPORT_TIMEOUT overrides it. The default matches the floor put on
+ * CDP's own per-call timeout (MIN_PROTOCOL_TIMEOUT_MS in
+ * puppeteer-controller.ts), so raising this past the default without also
+ * raising PINEPAPER_TIMEOUT just moves the execution to a protocol error —
+ * which is why that case says so out loud rather than failing obscurely later.
+ */
+const EXPORT_GOVERNOR_DEFAULT_MS = 300_000;
+function exportGovernorTimeoutMs() {
+    const raw = Number(process.env.PINEPAPER_EXPORT_TIMEOUT);
+    if (!Number.isFinite(raw) || raw <= 0)
+        return EXPORT_GOVERNOR_DEFAULT_MS;
+    const protocolFloor = Math.max(Number(process.env.PINEPAPER_TIMEOUT) || 0, EXPORT_GOVERNOR_DEFAULT_MS);
+    if (raw > protocolFloor) {
+        console.error(`[PinePaper] PINEPAPER_EXPORT_TIMEOUT=${raw}ms is above the browser's protocol timeout (${protocolFloor}ms) — ` +
+            'raise PINEPAPER_TIMEOUT to match, or an export past that point fails as a protocol error rather than a governor timeout.');
+    }
+    return raw;
+}
 export function getFileExtension(format) {
     const extMap = { mp4: 'mp4', webm: 'webm', gif: 'gif', pdf: 'pdf', png: 'png', svg: 'svg', wav: 'wav' };
     return extMap[format] || format;
@@ -122,6 +150,8 @@ async function saveExportToFile(data, format, platform) {
  * recoverable. `releaseExport` runs only once the whole file is written.
  */
 async function streamRetainedExportToFile(controller, retained, platform) {
+    // Reassigned once if the store corrects the size below.
+    let corrected = false;
     const exportDir = getExportDir();
     await mkdir(exportDir, { recursive: true });
     const ext = getFileExtension(retained.format);
@@ -139,18 +169,78 @@ async function streamRetainedExportToFile(controller, retained, platform) {
             await unlink(filePath);
         }
         catch { /* nothing written yet */ }
-        return new Error(`${why} (export "${retained.exportId}" is still held in the studio, ${offset} of ${retained.size} bytes read; ` +
-            `it can be paged again, and is released only once a whole file is written)`);
+        return new Error(
+        // 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.
+        `${why} (export "${retained.exportId}" is still held in the studio, ${offset} of ${retained.size} bytes read; ` +
+            `page it out with pinepaper_export_store action 'save', exportId "${retained.exportId}" — reading is idempotent, ` +
+            'so retrying costs nothing and the export is released only once a whole file is written. Do it BEFORE the next ' +
+            'export: a new one evicts the oldest held bytes to make room)');
     };
+    // A READ THAT FAILS ON SIZE IS NOT A READ THAT FAILS.
+    //
+    // A 17 MB memphis chunk died on its FOURTH 4 MB read — three had already
+    // landed — with "Failed to write data to data pipe". That is CDP refusing to
+    // carry one oversized value across the bridge, not the store refusing to
+    // serve it: the render had succeeded and the bytes were sitting right there.
+    // The loop abandoned the whole export anyway, and the caller was left with an
+    // error that explained the bytes were still held and no way to go get them.
+    //
+    // So a transport failure halves the request and asks again, down to a floor,
+    // before giving up. The offset does not move, so a retry costs one re-read,
+    // never a corrupt file. A refusal from the STORE (evicted, out of range) is
+    // NOT retried — that answer will not change with a smaller window, and
+    // retrying it would only spend the caller's time to reach the same place.
+    const MIN_CHUNK_BYTES = 256 * 1024;
+    let window = chunkBytes;
     for (;;) {
-        const code = codeGenerator.generateReadExportChunk(retained.exportId, offset, Math.min(chunkBytes, retained.size - offset));
+        const want = Math.min(window, retained.size - offset);
+        const code = codeGenerator.generateReadExportChunk(retained.exportId, offset, want);
+        // Deliberately governed at the default budget: a chunk read is a slice of a
+        // string already in memory. If one of these ever needs ten seconds, the
+        // store is wedged and a timeout is the correct answer, not a longer wait.
         const run = await controller.executeCode(code, false);
-        if (!run.success)
-            throw await abandon(`reading the export failed: ${run.error || 'unknown error'}`);
+        if (!run.success) {
+            if (want > MIN_CHUNK_BYTES) {
+                window = Math.max(MIN_CHUNK_BYTES, Math.floor(want / 2));
+                console.error(`[PinePaper] a ${want}-byte read of "${retained.exportId}" failed (${run.error || 'unknown error'}); `
+                    + `retrying the same offset at ${window} bytes`);
+                continue;
+            }
+            throw await abandon(`reading the export failed even at the ${MIN_CHUNK_BYTES}-byte floor: ${run.error || 'unknown error'}`);
+        }
         const chunk = run.result;
         if (!chunk || chunk.ok !== true) {
+            // A RANGE REFUSAL IS A CORRECTION, and it carries the real size.
+            //
+            // readExport refuses an out-of-range read by name rather than clamping —
+            // deliberately, so a miscounting caller is told instead of handed a short
+            // chunk it treats as the tail, which surfaces later as a truncated video
+            // with nothing pointing back at the cause. The size this loop is working
+            // from came from the export result, and `save` works from a listing; when
+            // either disagrees with the file, the refusal is the authority. Take it
+            // ONCE — a second disagreement is not a miscount, it is a moving target.
+            // Only when it DISAGREES. Every range refusal quotes the real size,
+            // including the ones that are refusing for some other reason — so
+            // matching the number alone treated an eviction as a miscount, spent the
+            // one correction on a no-op re-read, and hid the actual reason for an
+            // iteration.
+            const stated = /\(size (\d+)\)/.exec(chunk?.reason ?? '');
+            if (stated && !corrected && Number(stated[1]) !== retained.size) {
+                corrected = true;
+                const was = retained.size;
+                retained = { ...retained, size: Number(stated[1]) };
+                console.error(`[PinePaper] the store reports "${retained.exportId}" as ${retained.size} bytes, not ${was}; `
+                    + "taking the store's number and continuing");
+                continue;
+            }
             // An evicted id is its own failure: a later export reclaimed the space.
-            // Re-exporting is the caller's decision, never this loop's.
+            // Re-exporting is the caller's decision, never this loop's. The engine
+            // records an eviction in browser storage so it survives a reload, but
+            // that storage is best-effort — a private window, cleared site data or
+            // storage switched off all fall back to memory-only. So `evicted` being
+            // ABSENT means unknown, never that the export was not there.
             throw await abandon(chunk?.evicted
                 ? `the export was evicted mid-read: ${chunk.reason}`
                 : `the studio refused the read: ${chunk?.reason || 'no reason given'}`);
@@ -2021,6 +2111,74 @@ You can now start creating new items on a clean canvas.`,
                 }
                 return batchResult;
             }
+            case 'pinepaper_export_store': {
+                const input = ExportStoreInputSchema.parse(args);
+                const controller = options.browserController || getBrowserController();
+                if (!controller.connected) {
+                    try {
+                        await controller.connect();
+                    }
+                    catch (connectError) {
+                        return errorResult(ErrorCodes.EXECUTION_ERROR, `the export store lives in the studio, and connecting to it failed: ${connectError instanceof Error ? connectError.message : 'unknown error'}`, {}, { toolName: 'pinepaper_export_store' });
+                    }
+                }
+                const held = await controller.executeCode(codeGenerator.generateListExports(), false);
+                if (!held.success) {
+                    return errorResult(ErrorCodes.EXECUTION_ERROR, `listing the export store failed: ${held.error || 'unknown error'}`, {}, { toolName: 'pinepaper_export_store' });
+                }
+                const listing = held.result;
+                if (!listing || listing.ok !== true) {
+                    return errorResult(ErrorCodes.EXECUTION_ERROR, listing?.reason || 'the studio did not answer with a listing', {}, { toolName: 'pinepaper_export_store' });
+                }
+                const exports = listing.exports ?? [];
+                if (input.action === 'list') {
+                    return dataResult({
+                        exports,
+                        held: exports.length,
+                        heldBytes: exports.reduce((n, e) => n + (e.size || 0), 0),
+                        note: exports.length > 1
+                            ? 'A later export evicts the OLDEST held ones to make room. Save or release each before starting the next.'
+                            : undefined,
+                    });
+                }
+                // Both remaining actions name an id, and an id the store does not have
+                // is the one thing worth saying carefully. The engine records an
+                // eviction durably enough to survive a reload, so a read of that id
+                // will usually say "evicted" — but the record is best-effort browser
+                // storage and a listing cannot consult it at all. Absence of the id
+                // here is therefore "gone, cause unknown", and stating one cause as
+                // fact would be inventing the more interesting half of the answer.
+                const entry = exports.find((e) => e.id === input.exportId);
+                if (!entry) {
+                    return errorResult(ErrorCodes.INVALID_PARAMS, `the studio is not holding "${input.exportId}". It was released, evicted to make room for a later export, `
+                        + `or never existed here — a listing cannot tell which. `
+                        + `${exports.length ? `Held right now: ${exports.map((e) => e.id).join(', ')}.` : 'The store is empty.'}`, { exportId: input.exportId, held: exports.map((e) => e.id) }, { toolName: 'pinepaper_export_store' });
+                }
+                if (input.action === 'release') {
+                    const dropped = await controller.executeCode(codeGenerator.generateReleaseExport(entry.id), false);
+                    const outcome = dropped.result;
+                    if (!dropped.success || outcome?.ok !== true) {
+                        return errorResult(ErrorCodes.EXECUTION_ERROR, `releasing "${entry.id}" failed: ${dropped.error || outcome?.reason || 'unknown error'}`, { exportId: entry.id }, { toolName: 'pinepaper_export_store' });
+                    }
+                    return dataResult({ released: entry.id, freedBytes: entry.size });
+                }
+                // save: the same pager agent_export uses, pointed at an id instead of a
+                // fresh render. Reading is idempotent, so a save that failed halfway
+                // can simply be run again — there is no partial state to clean up here.
+                try {
+                    const { filePath, fileSize, chunks } = await streamRetainedExportToFile(controller, { exportId: entry.id, size: entry.size, format: entry.format }, input.platform || 'recovered');
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Export recovered from the studio's store:\n\nFile: ${filePath}\nFormat: ${entry.format}\n`
+                                    + `Size: ${(fileSize / 1024).toFixed(1)} KB\nPaged out in ${chunks} chunk${chunks === 1 ? '' : 's'}, then released\n`,
+                            }],
+                    };
+                }
+                catch (streamError) {
+                    return errorResult(ErrorCodes.EXECUTION_ERROR, streamError instanceof Error ? streamError.message : 'paging the export out of the store failed', { exportId: entry.id, size: entry.size }, { toolName: 'pinepaper_export_store' });
+                }
+            }
             case 'pinepaper_agent_export': {
                 const input = AgentExportInputSchema.parse(args);
                 const code = codeGenerator.generateAgentExport(input);
@@ -2048,12 +2206,46 @@ You can now start creating new items on a clean canvas.`,
                 if (!exportSessionManager.hasActiveJob()) {
                     exportSessionManager.startJob({ name: 'auto_session', screenshotPolicy: 'on_complete' });
                 }
-                const exportBrowserResult = await controller.executeCode(code, false);
+                const exportBrowserResult = await controller.executeCode(code, false, {
+                    governorTimeoutMs: exportGovernorTimeoutMs(),
+                });
                 if (!exportBrowserResult.success) {
                     const canvasState = await captureCanvasState(controller);
                     return errorResult(ErrorCodes.EXECUTION_ERROR, exportBrowserResult.error || 'Export failed', { code }, { toolName: 'pinepaper_agent_export', canvasState: canvasState || undefined });
                 }
                 const exportResult = exportBrowserResult.result;
+                // TWO VERDICTS, and only one of them was being read.
+                //
+                // `exportBrowserResult.success` says the CODE RAN. The export's own
+                // verdict is `exportResult.success`, and every emitted branch that
+                // cannot deliver returns `{ success: false, error }` — a studio without
+                // the renderer, an encoder that died, a blob past the inline ceiling.
+                // None of that was checked: the value fell through to the inline return
+                // below, which reports a success and hands back a result object nobody
+                // reads past the first line.
+                //
+                // Measured cost: a five-chunk video where two chunks came back
+                // `success: false, error: "export failed: Failed to write data to data
+                // pipe"` under an outer `"success": true`. The caller shipped a
+                // three-chunk video believing it had five. A silent success is the one
+                // failure mode this surface can never afford, because nothing
+                // downstream has any reason to look again.
+                if (exportResult && exportResult.success === false) {
+                    const canvasState = await captureCanvasState(controller);
+                    // A "data pipe" failure is the BROWSER TRANSPORT refusing to carry
+                    // the result back, not the encoder refusing to make it — the string
+                    // exists nowhere in the engine. So the render may well have finished
+                    // and the bytes may be sitting in the export store right now. Saying
+                    // so is the difference between recovering an export and re-rendering
+                    // one, and re-rendering is what evicts an earlier chunk's bytes.
+                    const looksLikeTransport = /data pipe/i.test(String(exportResult.error ?? ''));
+                    return errorResult(ErrorCodes.EXECUTION_ERROR, `export failed: ${exportResult.error || 'the studio reported failure without naming a reason'}`
+                        + (looksLikeTransport
+                            ? ' — that is the browser transport failing to carry the result back, not necessarily the render failing.'
+                                + " Call pinepaper_export_store action 'list' BEFORE re-rendering: the bytes may already be held, and a"
+                                + ' fresh export can evict an earlier one to make room.'
+                            : ''), { code, format: exportResult.format ?? input.format, result: exportResult }, { toolName: 'pinepaper_agent_export', canvasState: canvasState || undefined });
+                }
                 const format = exportResult?.format || input.format || 'png';
                 const data = exportResult?.data;
                 // RETAINED: the studio held the encoded file in its export store rather
@@ -2145,6 +2337,18 @@ You can now start creating new items on a clean canvas.`,
                         }
                         return dataResult(sys);
                     }
+                    case 'list_motion': {
+                        // Curves and durations together, because a motion token is a shape
+                        // AND a length. The curves were published and the durations beside
+                        // them in the same store were not, so a caller could match a
+                        // system's easing and had to invent its timing.
+                        const easings = designSystems.listEasings(input.authoredOnly);
+                        const durations = designSystems.listDurations(input.authoredOnly);
+                        return dataResult({
+                            easings, durations,
+                            note: 'These are the licensed SYSTEMS\' motion scales. An aesthetic style (bauhaus_geometric, memphis_group) carries no upstream motion data — pair one of these with a style rather than expecting the style to name its own.',
+                        });
+                    }
                     case 'list_easings':
                         return dataResult({ easings: designSystems.listEasings(input.authoredOnly) });
                     case 'list_styles':