@pinepaper.studio/mcp-server 1.6.7 → 1.6.9

package/README.de.md

@@ -14,7 +14,7 @@
 
 Der PinePaper MCP-Server lässt KI-Assistenten über das Model Context Protocol Grafiken in [PinePaper Studio](https://pinepaper.studio) erstellen und animieren. Funktioniert mit jeder KI, die MCP-Tool-Aufrufe unterstützt (Claude, GPT, Gemini, lokale Modelle usw.).
 
-Der Server bietet **144 Tools**: Zeichnen, Animation, Diagramme, Karten, Typografie, Physik, Bildbearbeitung, Datenvisualisierung und Export:
+Der Server bietet **152 Tools**: Zeichnen, Animation, Diagramme, Karten, Typografie, Physik, Bildbearbeitung, Datenvisualisierung und Export:
 
 - Text, Formen, Geometrie und komplexe Grafiken erstellen
 - Mit deklarativen **Relationen** animieren statt mit Keyframes
@@ -78,10 +78,14 @@ gesperrten Arbeitsrechner eher nicht.
 Server für Sie** — gleiche Tools, gleiche Version, über HTTP, ohne Installation
 und ohne Browser auf Ihrem Rechner.
 
-Hosting kostet Geld, daher ist es kostenpflichtig: **Starter 4,99 $/Monat**
-(500 Anfragen/Tag) und **Pro 14,99 $/Monat** (5.000/Tag, plus die
-Animationsvorlagen). Wenn Sie lokal laufen lassen können, tun Sie das — Sie
-verlieren dadurch nichts.
+Hosting kostet Geld, daher ist es kostenpflichtig — es läuft über Credits.
+Aktuelle Preise finden Sie unter [cloud.pinepaper.studio](https://cloud.pinepaper.studio).
+Lassen Sie es lokal laufen, wenn Sie können — identisch ist es aber nicht: Der
+gehostete Dienst nutzt einen getesteten Satz an LLMs und repariert generierten
+Code, bevor er die Leinwand erreicht. Das kann ein lokaler Server nicht selbst. Welchem Modell Sie trauen, können
+Sie selbst prüfen: Ein Benchmark führt ein Prompt über mehrere Modelle aus und
+stellt die Ergebnisse nebeneinander, jeder Lauf teilbar. Derzeit in einer Beta
+nur mit Einladung.
 
 ## Mehr
 

package/README.es.md

@@ -14,7 +14,7 @@
 
 El servidor MCP de PinePaper permite a los asistentes de IA crear y animar gráficos en [PinePaper Studio](https://pinepaper.studio) a través del Model Context Protocol. Funciona con cualquier IA que soporte llamadas a herramientas MCP (Claude, GPT, Gemini, modelos locales, etc.).
 
-Expone **144 herramientas**: dibujo, animación, diagramas, mapas, tipografía, física, edición de imágenes, visualización de datos y exportación:
+Expone **152 herramientas**: dibujo, animación, diagramas, mapas, tipografía, física, edición de imágenes, visualización de datos y exportación:
 
 - Crear texto, formas, geometría y gráficos complejos
 - Animar con **relaciones** declarativas en lugar de fotogramas clave
@@ -78,10 +78,14 @@ restringido, sí.
 servidor por usted** — mismas herramientas, misma versión, por HTTP, sin
 instalación y sin navegador en su máquina.
 
-El alojamiento cuesta dinero, así que es de pago: **Starter 4,99 $/mes**
-(500 peticiones/día) y **Pro 14,99 $/mes** (5.000/día, más la biblioteca de
-plantillas de animación). Si puede ejecutarlo localmente, hágalo — no pierde
-nada.
+El alojamiento cuesta dinero, así que es de pago — funciona con créditos.
+Los precios actuales están en [cloud.pinepaper.studio](https://cloud.pinepaper.studio). Ejecútelo
+en local si puede, pero no es idéntico: el servicio alojado usa un conjunto de
+LLM probados y repara el código generado antes de que llegue al lienzo, algo
+que un servidor local no puede hacer por sí mismo. En qué modelo confiar es
+algo que puede comprobar usted mismo: un benchmark ejecuta un prompt en varios
+modelos y muestra los resultados en paralelo, y cualquier ejecución se puede
+compartir. Está en beta solo por invitación.
 
 ## Más
 

package/README.fr.md

@@ -14,7 +14,7 @@
 
 Le serveur MCP PinePaper permet aux assistants IA de créer et d'animer des graphiques dans [PinePaper Studio](https://pinepaper.studio) via le Model Context Protocol. Compatible avec toute IA gérant les appels d'outils MCP (Claude, GPT, Gemini, modèles locaux, etc.).
 
-Il expose **144 outils** : dessin, animation, diagrammes, cartes, typographie, physique, retouche d'image, visualisation de données et export :
+Il expose **152 outils** : dessin, animation, diagrammes, cartes, typographie, physique, retouche d'image, visualisation de données et export :
 
 - Créer du texte, des formes, de la géométrie et des graphiques complexes
 - Animer avec des **relations** déclaratives plutôt que des images clés
@@ -78,10 +78,14 @@ de travail verrouillée, moins.
 serveur à votre place** — mêmes outils, même version, en HTTP, sans
 installation ni navigateur sur votre machine.
 
-L'hébergement a un coût, il est donc payant : **Starter 4,99 $/mois**
-(500 requêtes/jour) et **Pro 14,99 $/mois** (5 000/jour, plus la bibliothèque
-de modèles d'animation). Si vous pouvez l'exécuter en local, faites-le — vous
-n'y perdez rien.
+L'hébergement a un coût, il est donc payant — il fonctionne avec des crédits.
+Les tarifs actuels sont sur [cloud.pinepaper.studio](https://cloud.pinepaper.studio). Exécutez-le
+en local si vous le pouvez, mais ce n'est pas identique : le service hébergé
+utilise un ensemble de LLM testés et répare le code généré avant qu'il
+n'atteigne le canevas, ce qu'un serveur local ne peut pas faire lui-même. Quel modèle privilégier est
+une question que vous pouvez trancher vous-même : un banc d'essai exécute un
+prompt sur plusieurs modèles et affiche les résultats côte à côte, chaque
+exécution étant partageable. Actuellement en bêta sur invitation.
 
 ## Aller plus loin
 

package/README.hi.md

@@ -14,7 +14,7 @@
 
 PinePaper MCP सर्वर AI असिस्टेंट्स को Model Context Protocol के ज़रिए [PinePaper Studio](https://pinepaper.studio) में ग्राफ़िक्स बनाने और एनिमेट करने देता है। MCP टूल कॉलिंग वाले किसी भी AI (Claude, GPT, Gemini, लोकल मॉडल आदि) के साथ काम करता है।
 
-सर्वर **144 टूल** देता है — ड्रॉइंग, एनिमेशन, डायग्राम, नक्शे, टाइपोग्राफ़ी, फिज़िक्स, इमेज एडिटिंग, डेटा विज़ुअलाइज़ेशन और एक्सपोर्ट:
+सर्वर **152 टूल** देता है — ड्रॉइंग, एनिमेशन, डायग्राम, नक्शे, टाइपोग्राफ़ी, फिज़िक्स, इमेज एडिटिंग, डेटा विज़ुअलाइज़ेशन और एक्सपोर्ट:
 
 - टेक्स्ट, आकृतियाँ, ज्यामिति और जटिल ग्राफ़िक्स बनाना
 - कीफ़्रेम की जगह व्यवहार बताने वाले **रिलेशन** से एनिमेशन
@@ -76,10 +76,13 @@ npm install -g @pinepaper.studio/mcp-server
 **[cloud.pinepaper.studio](https://cloud.pinepaper.studio) वही सर्वर आपके लिए
 चलाता है** — वही टूल, वही वर्ज़न, HTTP पर, बिना इंस्टॉल और बिना ब्राउज़र के।
 
-होस्टिंग पर खर्च होता है, इसलिए यह सशुल्क है: **Starter $4.99/माह**
-(500 अनुरोध/दिन) और **Pro $14.99/माह** (5,000/दिन, साथ में एनिमेशन टेम्पलेट
-लाइब्रेरी)। अगर आप इसे लोकल चला सकते हैं, तो लोकल ही चलाएँ — इससे कुछ नहीं
-खोता।
+होस्टिंग पर खर्च होता है, इसलिए यह सशुल्क है — यह क्रेडिट पर चलता है। मौजूदा
+मूल्य के लिए [cloud.pinepaper.studio](https://cloud.pinepaper.studio) देखें। हो सके तो
+लोकल चलाएँ, लेकिन यह एक जैसा नहीं है: होस्टेड सेवा परखे हुए LLM चलाती है और
+जनरेट किए गए कोड को कैनवास तक पहुँचने से पहले ठीक करती है — यह लोकल सर्वर
+अपने आप नहीं कर सकता। कौन-सा मॉडल बेहतर है, यह आप खुद जाँच सकते हैं: एक बेंचमार्क एक ही प्रॉम्प्ट
+कई मॉडलों पर चलाकर नतीजे साथ-साथ दिखाता है, और कोई भी रन साझा किया जा सकता है।
+यह फ़िलहाल केवल आमंत्रण-आधारित बीटा में है।
 
 ## और जानें
 

package/README.ja.md

@@ -14,7 +14,7 @@
 
 PinePaper MCP サーバーは、MCP 経由で AI アシスタントが [PinePaper Studio](https://pinepaper.studio) 上にグラフィックを作成・アニメーションさせるためのサーバーです。MCP ツールコールに対応した AI（Claude、GPT、Gemini、ローカルモデルなど）で動作します。
 
-**144 個のツール**を提供 — 描画・アニメーション・図・地図・タイポグラフィ・物理・画像編集・データ可視化・エクスポート：
+**152 個のツール**を提供 — 描画・アニメーション・図・地図・タイポグラフィ・物理・画像編集・データ可視化・エクスポート：
 
 - テキスト、図形、ジオメトリ、複雑なグラフィックの作成
 - キーフレームではなく、ふるまいを宣言する**リレーション**でアニメーション
@@ -77,10 +77,13 @@ AI にこう頼んでみてください：
 代わりに動かします** — 同じツール、同じバージョン、HTTP 経由。インストールも
 ブラウザも不要です。
 
-ホスティングには費用がかかるため有料です: **Starter 月額 $4.99**
-(1 日 500 リクエスト)、**Pro 月額 $14.99** (1 日 5,000、アニメーション
-テンプレート付き)。ローカルで動かせるなら、ローカルで動かしてください。
-それで失うものはありません。
+ホスティングには費用がかかるため有料で、クレジット制で動作します。現在の
+料金は [cloud.pinepaper.studio](https://cloud.pinepaper.studio) をご覧ください。可能なら
+ローカルで動かしてください。ただし同一ではありません: ホスティング版は検証済みの
+LLM を用い、生成コードをキャンバスに渡す前に修復します — ローカルサーバーが
+自力では行えない処理です。どのモデルが適しているかはご自分で確かめられます:
+ベンチマークが 1 つのプロンプトを複数モデルで実行し、結果を並べて表示します。
+実行結果は共有できます。現在は招待制のベータです。
 
 ## さらに詳しく
 

package/README.ko.md

@@ -14,7 +14,7 @@
 
 PinePaper MCP 서버는 AI 어시스턴트가 MCP를 통해 [PinePaper Studio](https://pinepaper.studio)에서 그래픽을 만들고 애니메이션하게 해줍니다. MCP 툴 콜을 지원하는 모든 AI(Claude, GPT, Gemini, 로컬 모델 등)와 호환됩니다.
 
-**144개의 툴** 제공 — 드로잉, 애니메이션, 다이어그램, 지도, 타이포그래피, 물리, 이미지 편집, 데이터 시각화, 내보내기:
+**152개의 툴** 제공 — 드로잉, 애니메이션, 다이어그램, 지도, 타이포그래피, 물리, 이미지 편집, 데이터 시각화, 내보내기:
 
 - 텍스트·도형·기하·복잡한 그래픽 생성
 - 키프레임 대신 행동을 선언하는 **릴레이션**으로 애니메이션
@@ -77,9 +77,13 @@ VPS나 제한된 업무용 컴퓨터에서는 부담스러울 수 있습니다.
 실행합니다** — 같은 도구, 같은 버전, HTTP 방식이며 설치도 브라우저도 필요
 없습니다.
 
-호스팅에는 비용이 들기 때문에 유료입니다: **Starter 월 $4.99**
-(하루 500회), **Pro 월 $14.99** (하루 5,000회, 애니메이션 템플릿 라이브러리
-포함). 로컬에서 실행할 수 있다면 로컬로 실행하세요 — 잃는 것은 없습니다.
+호스팅에는 비용이 들기 때문에 유료이며, 크레딧으로 운영됩니다. 현재 가격은
+[cloud.pinepaper.studio](https://cloud.pinepaper.studio)를 참고하세요. 가능하면 로컬로
+실행하세요. 다만 완전히 같지는 않습니다: 호스팅 서비스는 검증된 LLM 세트를
+사용하고, 생성된 코드를 캔버스에 반영하기 전에 복구합니다 — 로컬 서버가
+스스로 할 수 없는 일입니다. 어떤 모델이 나은지는 직접 확인할 수 있습니다:
+벤치마크가 하나의 프롬프트를 여러 모델에서 실행해 결과를 나란히 보여주며,
+실행 결과는 공유할 수 있습니다. 현재는 초대 전용 베타입니다.
 
 ## 더 보기
 

package/README.md

@@ -25,19 +25,18 @@
 
 PinePaper MCP Server enables AI assistants to create and animate graphics in [PinePaper Studio](https://pinepaper.studio) via the Model Context Protocol (MCP). Works with any AI that supports MCP tool calling (Claude, GPT, Gemini, local models, etc.).
 
-The server exposes **144 tools** across drawing, animation, diagrams, maps, typography, physics, image editing, data visualization, and export. Using natural language, you can:
+The server exposes **152 tools** across drawing, animation, diagrams, maps, typography, physics, image editing, data visualization, and export. Using natural language, you can:
 
-- Create text, shapes, geometry, and complex graphics
-- Animate items with behavior-driven **relations** rather than keyframes
-- Build long scenes as **event-driven chains** that stay scrub- and replay-stable
-- Generate procedural backgrounds and parametric/equation-driven paths
-- Author diagrams, maps, charts, and letter collages
-- Edit images: crop, chroma-key background removal, GPU filters, lasso cutouts, object detection
-- Export animated SVG, video frames, embeddable widgets, and LLM training data
+- Create geometric shapes, text collages, diagrams, and data charts
+- Apply 37+ character-level text effects and 28+ vertex deformation presets
+- Wire behavioral relationships between objects (orbit, follow, point-at, mirror, parallax, morph)
+- Animate with keyframes, timeline sequencing, and physics simulations
+- Build interactive widgets with click/hover/drag event bindings
+- Export to SVG, self-contained interactive HTML, MP4, and animated formats
 
 ## Running it: local or hosted
 
-**Local is free and complete.** Every one of the 144 tools works when you run
+**Local is free and complete.** Every one of the 152 tools works when you run
 this server yourself. There is no reduced tier and nothing held back.
 
 What it needs:
@@ -56,9 +55,14 @@ for you** — same tools, same version, over HTTP with no install and no browser
 on your machine. It exists for three cases: you have no MCP client, you cannot
 install one, or your machine cannot spare the browser.
 
-Hosting costs money, so it is paid: **Starter $4.99/mo** (500 requests/day) and
-**Pro $14.99/mo** (5,000/day, plus the animation template library). If you can
-run it locally, run it locally — you lose nothing by doing so.
+Hosting costs money, so the hosted option is paid — it runs on credits. See
+[cloud.pinepaper.studio](https://cloud.pinepaper.studio) for current pricing. Run it
+locally if you can, but it is not identical: the hosted service runs a tested
+set of LLMs and repairs generated code before it reaches the canvas, which a
+local server structurally cannot do for itself. Which model to trust is a
+question you can answer yourself rather than take on trust: a benchmark runs one
+prompt across several models and puts the results side by side, any run
+shareable. It is in invite-only beta.
 
 ## Made with tool calls
 
@@ -179,6 +183,223 @@ app.animate(sq, { animationType: 'rotate' });
 
 The same code an agent generates is the code you can paste — the canvas is yours either way, undo included.
 
+## Security: yes, it executes code
+
+**Supply-chain scanners flag this package, and they are not wrong about the mechanism.** Socket and tools like it mark it as malware-adjacent because it evaluates JavaScript at runtime. The detection is correct about the capability and wrong about the intent, so here is exactly what happens.
+
+**Every tool emits JavaScript — that is the architecture, not an exception.** A tool call is compiled into a snippet written against the PinePaper and Paper.js APIs; the snippet is the product. `pinepaper_execute_custom_code` is simply the case where the *agent* writes the snippet instead of the server generating it, which is what lets a model draw something no other tool has a name for. Removing execution would not harden this package, it would delete it.
+
+**Where the code runs.** In a browser page on your own machine, against your own canvas. It does not run in the server process, and nothing is sent anywhere else to be executed.
+
+**Two modes, and one of them never executes anything:**
+
+| Mode | What happens |
+|---|---|
+| `code` (`PINEPAPER_EXECUTION_MODE=code`) | The tool returns the JavaScript and stops. Nothing runs. You read it and paste it if you want it. |
+| `puppeteer` (default) | The server launches Chrome and runs the snippet in the page via `page.evaluate()`. |
+
+If you do not want an agent executing anything, `code` mode is a first-class path, not a degraded one — the same snippet, handed to you instead of run.
+
+**What guards execution.** On current engine builds the snippet goes through `app.runGenerated(code, { source: 'agent' })` — a governor with seeded determinism, loop and item budgets, and a machine-readable report — rather than a bare `eval`. Older engine builds fall back to `eval`.
+
+**What to weigh before running it.**
+
+- Code an agent writes runs with whatever that browser page has. Give this server the same trust you would give anything else you let write and run code on your machine — which is the trust you already extend to an MCP client with tool access.
+- Puppeteer mode launches Chrome with `--no-sandbox` and `--disable-setuid-sandbox`. That is routine for headless automation and it does weaken Chrome's own process sandbox. If that matters where you are running it, use `code` mode or put the server in a container.
+- Puppeteer itself is an **optional** peer dependency, kept out of the default tree precisely because a headless browser plus an install script is what scanners flag hardest. Install it only if you want the executing mode.
+
+## What's new in 1.6.9
+
+### New: `pinepaper_export_store`
+
+Recover an export the studio is still holding, instead of re-rendering it.
+
+- `list` — what is held: `{id, format, size, createdAt}`, newest first. IDs survive a page reload.
+- `save` — page it out to a file and release it. Returns a `filePath`, and is safe to repeat.
+- `release` — drop it without saving.
+
+Reach for it when an export fails with `Failed to write data to data pipe` — that is the browser's transport, not the encoder, so the bytes are often already stored — or when an error names an `exportId`.
+
+**Retention:** held exports last until released, or until a later export needs the space, and eviction drops the oldest first. Save or release each export before starting the next one.
+
+### New: `scale` on `pinepaper_agent_export`
+
+Render video at a fraction of the platform preset (`0.1`–`1`).
+
+- `scale: 0.5` with `quality: "draft"` is a fast look-check before committing to a full render.
+- Smaller frames also mean smaller files: the encoder derives its target from resolution, so this is the size control. There is no bitrate option.
+- Video only (`mp4`/`webm`/`gif`) — passing it to `png`/`svg`/`pdf`/`wav` is rejected rather than ignored. Omitting it leaves exports exactly as before.
+
+### New: `list_motion` on `pinepaper_design_system`
+
+Returns each licensed design system's motion curves **and** its durations; previously only the curves were reachable. Durations come back in milliseconds and in seconds.
+
+These are the design systems' motion scales — Material's duration ladder, and so on. Aesthetic styles such as `bauhaus_geometric` carry no motion data of their own, so pair a system's motion with a style.
+
+### `list_styles` now returns style tokens
+
+`pinepaper_design_system` `list_styles` returns each style's palette, background, font stacks, type sizes and variants, not just its name. Building in a style by hand no longer means reading the generator source to find its colours.
+
+### Fixed: `compose` placed everything off-centre
+
+`compose` positioned items by their top-left corner while the canvas positions by centre, so every composed scene was displaced and left-aligned headlines ran off the edge of the canvas. Composed scenes now land where the layout intends.
+
+### Fixed: exports could report success while failing
+
+`pinepaper_agent_export` could return success when the export itself had failed, so a failed render passed silently and a batch could lose chunks without saying so. A failed export is now an error, and names a recovery path when the failure looks like a transport problem.
+
+### Fixed: long exports timed out at ten seconds
+
+Video exports running longer than about ten seconds failed with a `PP_TIMEOUT` that looked like a problem with the scene.
+
+- `PINEPAPER_EXPORT_TIMEOUT` sets the budget (default `300000` ms). For exports over five minutes, raise `PINEPAPER_TIMEOUT` to match.
+- `PINEPAPER_GOVERNOR=off` is an escape hatch for older studio builds.
+
+### Fixed: exports failed on a fresh session
+
+Exporting immediately after connecting failed with a message blaming the studio's version. The export now waits for the studio's export subsystem to finish loading.
+
+### Fixed: large exports could be left undeliverable
+
+A read failure partway through paging a large export left the file unrecoverable. Reads now retry at a smaller size, and anything still held can be recovered with `pinepaper_export_store`.
+
+### Fixed: connection failures behind proxies, and a false "ready"
+
+Connecting could burn the full timeout against a studio that was already usable, and the connection had no configuration.
+
+- `PINEPAPER_WAIT_UNTIL` — what a navigation waits for (default `domcontentloaded`; set `networkidle2` for the previous behaviour).
+- `PINEPAPER_TIMEOUT` — navigation and readiness timeout in ms (default `30000`).
+- `PINEPAPER_PROXY` — routes Chrome through a proxy, for origins that reject headless Chrome. Setting it also relaxes certificate checking, which an intercepting proxy requires.
+
+Connections now wait for the studio's API rather than for its canvas library, so "connected" means tool calls will work.
+
+### Fixed: `pinepaper_animate_letter_collage` ignored its animation type
+
+The requested animation type was discarded on every call. **This fix also needs a studio update** — the other half is an engine change that has not shipped yet, so collage animation stays static until it does.
+
+### Documentation
+
+- **Rotation** — `pinepaper_create_item` documents `properties: { rotation: 45 }`, and that rotation is baked into the geometry, so reading `item.rotation` back returns `0`. Verify a rotation by geometry or pixels, not by re-reading the property.
+- **Dense motion** — `pinepaper_keyframe_animate` points at cheaper routes before you author hundreds of keyframes: the `time_expression` relation for motion that is a function of time, `staggered_with` / `wave_through` for a whole group, and `pinepaper_execute_custom_code` for procedural scenes.
+
+## What's new in 1.6.8
+
+**Long-form export stops crossing the bridge as one string.** `pinepaper_agent_export` handed the bytes back as a base64 data URL. Two things were wrong with that and only one of them was a bug.
+
+- The bug: a **streamed** export returns a `{streamed:true}` marker rather than a Blob, and `FileReader.readAsDataURL` throws on it — so any export that streamed *broke* this path instead of extending it.
+- The ceiling: base64 of a ten-minute 1080p video is a ~1.6 GB string before JSON transport. No memory fix reaches that.
+- But the ceiling was never the MCP response. This server already wrote video and PDF to a file above 500 KB and handed back a `filePath` — the only real limit was the single `page.evaluate` return value. So the paging belongs *inside* the tool: the studio holds the encoded file in its export store and returns an id, and the server pages it into the file it was going to write anyway. One tool call, one `filePath`, at any size, with at most one 4 MB chunk in memory on either side. An agent-facing pager would only have exposed a transport limit the agent cannot act on.
+- `duration` goes from a 60-second cap to **600**. Ten minutes was unreachable regardless of how the bytes came back, so the cap was the other half of the ceiling. GIF keeps its own 15-second cap: it has a different encoder and does not stream.
+- Failure leaves the export **held**. The store is the only copy, so the error names the id and the bytes reached, deletes the partial file, and does not release. An eviction mid-read is reported as an eviction, never as a missing file, and re-exporting stays the caller's decision.
+- **This needs a studio with the export store** — `exportToStore` / `readExport` / `releaseExport`, which are live in the engine. An older studio takes the buffered path exactly as before, and both of its failures are now *named* instead of fatal: the marker says it streamed and there is nothing to page it from, and an export past a 96 MB inline ceiling gives its size, the ceiling and what to do. That ceiling sits above what the buffered path could already deliver, so nothing that worked before starts refusing.
+
+**`pinepaper_instantiate_ontology` builds through the studio's own compiler.** The server-side port placed items as boxes — no paint, no text, no keyframes, no masks. The engine's compiler reads every node facet and builds through the template loader's own paths, which is the round trip the studio's pixel tests verify. The box loop survives only as the fallback for studios that predate the facade, and says what it lost.
+
+- **A failed image reported success.** The door returned three of the counts the compiler gives it and dropped nine, `imagesFailed` among them — so a raster that never decoded read back as `success: true` with a full `itemIds` array. All the counts are surfaced now, and `imagesFailed` alone is enough to make the call unsuccessful, whether or not the compiler also logged an error diagnostic.
+
+**The design graph keeps the recipes for everything code drew.** Three kinds of node have no geometry to round-trip, because code drew them and the code's inputs *are* their geometry. The graph kept a generator's name and not its parameters — enough to name a generator, not enough to re-run one.
+
+- Nodes now carry `generator`, `generatorParams` and `generatorRole`; a mesh carries `meshProvenance` (`op`, the node it was derived from, and the options); the 3D stage rides at document level as `world`. All of it reaches the JSON-LD.
+- The parameters have to be the **merged** set. What a generator hands its registry is empty, or two keys of thirty for the GPU generators, and a recipe built from that names a generator it cannot reproduce — which is indistinguishable from a working one until someone re-runs it.
+- `pp:world` is a **sibling** of `pp:generator`, never nested inside it. A World3D scene has no generator, so a stage read inside `if (generator)` is dropped from exactly the scenes that cannot rebuild without it.
+
+**Relation presets are adoptable.** `pinepaper_add_relation` takes a `presetId` — a community motion someone already tuned, with its symbols exposed as knobs — instead of making a caller name a type and guess at params. The preset decides the relation type, and any symbol you omit takes the midpoint of its declared range, so a preset applies sensibly with no values at all. List them through the new `catalogue`, which also returns what this build **rejected**: a preset for a relation type this engine does not have is a named absence, where dropping it silently would read as the catalogue simply being smaller.
+
+**`pinepaper_query_capabilities` gains `catalogue`** — the eight registries the engine's own aggregate does not gather: rig presets, shader effects, stroke decorations, the precomp list, the image library, segment-edit kinds, shatter orders and world meshes. Each was a capability an agent had to guess at, which by this project's rule is the same as its not existing. A missing facade is named rather than answered with an empty list, because an empty list reads as "none exist" and that is a different, worse answer.
+
+**Four more reachable things, and a note on the ones that turned out not to be gaps.** `pinepaper_text_style` gains `cursive` (text written as a **stroked path** rather than set in a glyph, so draw-on animation and `outline_stroke` both apply to it), `wrap`/`unwrap` (break a text item to a width, reversibly), and `to_collage` (convert an *existing* text item in place). `pinepaper_equation_path` gains `solveOde` — integrate an ODE and get the **trajectory back as data** rather than a drawn path, to inspect, feed to a path, or drive keyframes with.
+
+What was *not* a gap is worth saying too, because it was on the list: `createFoldedText`, `createGradientText`, `createMagazineText`, `createPaperCutText` and `createTileText` are one-line wrappers over the letter-collage styles this server already offers, and `plotFunction`/`plotParametric`/`plotSurface` wrap three generators it already exposes. A method-name diff cannot tell "no tool reaches this" from "a tool reaches it under another name."
+
+**Animated character parts no longer jump the moment they start moving.** `pinepaper_character` places each part at its path's bounding-box centre — the point PinePaper's `position` names — while the keyframe tracks were anchored on the depiction's declared anchor. The two are not the same point, so every animated part snapped between them as soon as its t=0 keyframe evaluated: measured at 19.6px for a pigeon's beak, which detaches it from the head. A track is relative motion around a base, so re-basing it on the centre the part was actually placed at preserves every displacement and removes the snap — now 0.000000px, with a test that also checks the performance did not flatten into a constant in the process.
+
+**A concept that inherits performs and inks like the one it inherits from.** Two defects in the same resolver, both measured. Channels were read off the concept alone, so `pp:Bus` — which composes `pp:Vehicle`'s parts and inherits its `jounce` and `travel` — returned **zero tracks** with every beat reported ignored, while claiming success. And ink was keyed on the concept *requested* rather than the depiction actually composed, so `pp:Bus` drew 0 stroked parts where `pp:Vehicle`, the same geometry, drew 3 — the "flat art dropped into an inked scene reads as pasted in" failure the ink exists to avoid, hitting exactly the concepts that inherit rather than declare. Both now match their parent measure for measure, `pp:House` included.
+
+**`pinepaper_character` stops silently ignoring four arguments it documents.** `position`, `scale`, `palette` and `ink` were all handled by the resolver and absent from the schema, so zod stripped them and a call written the way the rest of this vocabulary reads landed dead-centre at the default size — the precise outcome the resolver's own comment says must not happen.
+
+**Two production advisories cleared, both found by validating the release rather than by anything failing.** `fast-uri` (HIGH — host confusion via skipped IDN canonicalization, SSRF via malformed IPv6 normalization, SSRF via repeated hostname percent-decoding, host confusion via percent-encoded scheme normalization) and `hono` (MODERATE — `toSSG()` writing outside its output directory, unbounded dot-notation nesting in `parseBody()`, a query parser reading past the URL fragment). Both arrive transitively and are pinned to floors in `overrides`, so neither resolver can drift back; both lockfiles re-resolved and `npm audit --omit=dev` reports zero.
+
+**`pinepaper_design_medium`'s thread surface is now the whole engine's, and the second tool over it is gone.** `pinepaper_create_stitchcraft` was removed: **all six** of its presets dispatched into the same `ThreadPainting` module `apply_thread` already reaches — `embroidery_satin` → satinBetween/fillRegion, `running_seam` → runningStitchContour, `cross_stitch` → crossStitchFill, `stem_outline` → stemAlong, `seed_texture` → seedFill, `needlepainting` → fillRegion. Two tools over one engine is exactly the drift this surface keeps paying to remove.
+
+- `apply_thread` now offers **all six stitches the engine publishes**, not four: `runningSeam` and `crossStitch` were missing, and they are what a caller reaching for stitchcraft wanted. It also gained the per-stitch parameters `STITCH_OPS` declares and nothing named — `slant`, `overlap`, `stagger`, `gapLen`, `gridSize`. `slant` is the one that matters most: a satin fill laid at a slant is what separates embroidery from ruling.
+- `roughness` is hand wobble, applied by the tool *after* the engine lays the stitches, since the engine has no such option. Every point of every stitch takes its own phase off the seed, so a long contour wobbles along its whole length rather than shearing at one end, and a given seed sews the same irregularities every run.
+- `pp:Stitchcraft` points at `pinepaper_design_medium` now.
+- **And the list has one definition.** It had four copies here — two Zod enums and their two JSON mirrors — so correcting one left `pinepaper_compose` unable to ask for two stitches `apply_thread` could. The engine had the identical split for the identical reason on the same day: `MEDIA.thread.stitches` was hardcoded to the same stale four while `STITCH_OPS` published six. Two repos, four copies, one list, drifted the same direction — because neither read the published table. It is `THREAD_STITCHES`, declared once and spread, with a test asserting every served copy matches.
+
+*Two corrections to this note, made in place rather than quietly edited.*
+
+The removal was first justified as a tool "built on a phantom", because `app.applyStitchcraftToItem` had zero hits in the engine. The grep was accurate and the inference was not, twice over: the capability is real — it lives in `js/core/StitchcraftPresets.js`, imported as a module by the code runner and never exposed as an `app.*` method — and it returned zero hits only because that file was unpushed when the search ran. A missing method and an unpushed commit look identical to a grep and call for opposite responses. The redundancy was always the real reason, and it is the better one.
+
+The replacement enum was then built by scraping quoted strings out of `ThreadPainting.js`, which is not the same thing as reading what it publishes. `STITCH_OPS` is the vocabulary, and it holds exactly six names. The scrape added eight that are planner functions and field kinds — `satinBetween`, `fillRegion`, `radial`, `spine` and the rest, every one of which `applyThreadPainting` refuses — and it dropped `runningSeam` and `crossStitch`, which are real. For one commit this surface advertised eight stitches that error and hid two that work, while removing the tool that had offered them. Enum parity means diffing against the published vocabulary, not against the file.
+
+**New tool: `pinepaper_design_system`** — the design vocabulary as data, and eighteen styles that build a scene. Two different things, kept apart because they are not the same claim:
+
+- A **design system** is a real, licensed, versioned product — Material Design 3, IBM Carbon, Polaris, Fluent 2, Spectrum, Primer, USWDS, GOV.UK and more. Twenty-one of them, as W3C DTCG tokens. `list_easings` returns every motion curve across all of them as a named easing with its licence — and with `pinepaper:authored` on the three we had to fill in, so a vendor's published curve and one of ours are never mistaken for each other.
+- An **aesthetic style** is a look: Bauhaus, Art Deco, Swiss, De Stijl, vaporwave, risograph, brutalist, Memphis, claymorphism, op art, pixel art. Thirty-one named, eighteen of which `compose` a titled scene. `draw: false` returns the scene and the ops as data and draws nothing — read the composition before committing to it, the way `pinepaper_story`'s `distill` works.
+
+This runs in the server, not the browser: a design decision does not need the canvas to be open. The data is **vendored** from mcp-cloud by `scripts/sync-design-systems.mjs`, the same shape as the engine's stick-figure sync — one authored copy upstream, a mechanical mirror here, a sha256 in every header, and a provenance test that fails on a hand edit. A partial composition reports as a failure naming the elements that did not create, rather than as a success with half a poster.
+
+**New tools: `pinepaper_stick` and `pinepaper_story`.**
+
+- `pinepaper_stick` is the vendored stick-figure kit — a rigged figure posed, walking, travelling, holding a prop, with a garment and hair and a timeline of expressions, plus the floor and wall it stands on. Distinct from `pinepaper_character`, which places a figure from the *design graph* by concept. Its options were discoverable only by reading the engine's source. The geometry is vendored from mcp-cloud, which makes it a three-repo artifact, and the failure message says so — the fix for a missing kit is in another repository.
+- `pinepaper_story` turns prose into a scene. `distill` reduces an article to its beats and **draws nothing**, which is the half worth having on its own: read what the distiller made of the text, edit the beats, and only then assemble. Discovering that reading by looking at a finished scene is the expensive way round.
+
+**New tool: `pinepaper_interchange`** — Lottie, dotLottie, GLB, BVH and PNG sequence. `pinepaper_agent_export` covers the *platform* formats sized for Instagram or YouTube; these are the ones another tool reads, and they had no tool at all. Import is here too, because a format you can only write is half a bridge.
+
+- `exportGLB` and `exportBVH` refuse through `console.warn` and a falsy return, and the production build strips the console — over MCP that is a silent nothing. Both preconditions are checked before the call and named: "no perspective objects to export — create one with `createObject3D` first", "no rig to export — create a skeleton first".
+
+**New tool: `pinepaper_sound`** — synthesis, and the drawing that is the same object. The engine carries a whole audio graph and nothing reached it; `pinepaper_audio_beats` *analyses* audio that already exists, and this *makes* audio.
+
+- Tones, chords (by name, with the Hz readable without playing), named percussion and SFX, and plain-language descriptions — `from_text` resolves "a soft warm bell on A4" to a spec **without** playing it, so a caller can inspect or edit before committing.
+- **Sound and drawing are one object, both ways.** `create` draws a sound *as* a waveform path: edit the path and the timbre changes with it. `timbre_from_path` reads any drawn path back as harmonic content — a curve someone drew by hand becomes the partials of a note.
+- `timbreFromPath` answers a flat single-partial timbre for anything that is not a path with length, which is a legitimate timbre *and* the refusal, indistinguishable once returned. So the item is checked before the call and a non-path is refused by name.
+
+**New tool: `pinepaper_motion`** — the generators' Animation knob, pointed at anything. The motion engine every generator's own animation runs on was reachable from the code console and from custom generators, and from no tool call.
+
+- A **group** motion (drift, sway, rotate, pulse, wave, bounce) moves the target as one. A **field** motion (ripple, breathe, undulate) sweeps a crest *through* the children from an origin, with a chosen waveform — a wave passing through a crowd rather than a crowd moving together. Nothing else on this surface could do the second kind: `pinepaper_animate` applies a loop preset to one item.
+- `action: 'list'` returns the engine's own catalogue. `motion` is deliberately a free string rather than an enum: pinning the names here is exactly how `add_relation` came to list 39 of the engine's 134 relations.
+- Origins include `random` (every element on its own phase — a twinkle, not a wave) and `roam` (hopping between the corners and the centre); pass a `seed` to make `random` reproducible.
+- The waveform `spike` is a narrow bump. It was called `pulse` until the engine noticed one word was naming both a waveform and an animation; saved scenes still carry the old spelling and it is still accepted, but it is not offered as a choice.
+
+**New tool: `pinepaper_path`** — the destructive path operations Paper.js has always had and nothing here could reach. Booleans (`unite`, `subtract`, `intersect`, `exclude`, `divide`), `simplify`, `outline_stroke`, `toggle_closed`, repeat `pattern`s (concentric, radial, grid, extrude), `get_geometry`, and a lock.
+
+- They live apart from `pinepaper_modify_item` on purpose: modify restyles an item and keeps its id, while every action here changes what items *exist*. A boolean **consumes its operands** — they stop existing, and their relations and keyframes go with them. The tool description says so, because a caller who reads a boolean as a restyle loses work.
+- `outline_stroke` is the one worth knowing about: it turns a stroked line into a filled shape of the same width, which is what you do before exporting to a format with no stroke model, or before a boolean against a line.
+- Each refusal is the engine's own — "a boolean needs at least two paths", "that path has no stroke to outline", "simplify needs a path" — passed through rather than reworded, because two wordings for one condition is the defect this project keeps fixing. The single exception is `get_geometry`, whose facade returns a bare `null`; that one place supplies a wording.
+
+**`pinepaper_world3d` gains the mesh half, the import half and the physics half — 33 actions.** The graph learned to record `meshProvenance` above, and nothing could author a mesh: it could describe a thing the tool surface could not make.
+
+- `extrude_path` sweeps a canvas path along a depth; `lathe_path` revolves its profile. The path itself is untouched — the mesh is new, and the engine records the op, the source path and the options as the mesh's provenance, so a captured scene can rebuild it rather than merely recognise it. **The option names on this action are exactly the names in that record**, pinned by a test, so `meshProvenance.opts` spreads straight back in.
+- Lights (`add_light` / `set_light` / `remove_light` / `list_lights`) and shared materials (`add_material` / `set_material` / `remove_material` / `list_materials`), plus `list_meshes` and `remove_mesh`. At most 8 point lights exist at once: the shader array is fixed-size, so a ninth is refused by name rather than ignored.
+- **`rotY` is radians, and says so.** It is stored raw and handed to `cos()`/`sin()` in the shader with no conversion anywhere on the path — an exception to the degrees convention the rest of this surface follows, and the sort of thing that silently produces a scene rotated by a factor of 57. `rotYDegrees` is the convenience spelling and is folded in before the engine sees it. (`arc` on `lathe_path` *is* degrees; the engine converts that one.)
+- **Import and navigation.** `import_obj` and `import_gltf` bring real geometry in; `list_mesh_clips` and `set_mesh_clip` play what a skinned model arrived with. `set_nav_target` decides whether the pointer drives the 2D canvas or the 3D world, `ground_height` and `canvas_to_ground` and `world_to_canvas` convert between them, `raycast` picks, and `dolly_camera` / `pan_camera` move the view.
+- **Physics in the world**, distinct from `pinepaper_physics` (which is the 2D `physicsWorld`) and deliberately narrower: a sphere or capsule under gravity, colliding with terrain, objects, actors and imported meshes. No stacking solver and no joints. `step_physics` reports the contacts made and the bodies removed — and returns `{contacts: [], removed: []}` with *no world*, which is exactly what a quiet step returns, so the guard is what separates them.
+- **Several of those facades answer `null` — or `0` — when there is no world**, which is indistinguishable from a real answer: ground really can be at height 0, and a ray really can hit nothing. Each is guarded ahead of the call, so "there is no world" never arrives disguised as a measurement. Once past the guard, a null from `raycast` can only mean a miss, and is reported as one.
+- **`add_object` stops advertising knobs that reach no pixel.** It offered `metalness`, `roughness` and `emissiveIntensity` — but a plain object is drawn by the prop shader, which declares no such uniform, so those were stored, listed and ignored. They render on the mesh path only, and the description now says which is which instead of letting a caller set one and see nothing.
+
+**`attracts` was live in the engine and unnameable here.** The relation-parity guard compares the tool enum against a fixture of the engine's relation map — but the fixture is copied by hand, so the guard passed while the engine moved. The fixture is refreshed and `attracts` is callable. The exclusion list that keeps tool-emitted families (`deform_*`, `effect_*`, `geo_*`, the rigging set) out of `add_relation` is unchanged, and still written down with its reason.
+
+**`pinepaper_character` was defined and dispatched nowhere.** It shipped in 1.6.7 as a schema with no handler behind it — the worst version of the problem this project keeps naming, because the tool *listed*. It is wired now, and a test fails the build if any defined tool has nothing dispatching it.
+
+**Four chart types classified as `pp:Group`.** The graph's type lookup lowercased the item type before consulting its map, so every camelCase key in that map was unreachable — `barChart`, `lineChart`, `scatterPlot` and `areaChart` answered `pp:Group` instead of their own types. Nothing errored; a caller got a readable graph of the wrong thing. The lookup tries the key as spelled before folding case, and a test now asserts every key in the map is reachable, so the next camelCase key the engine adds fails a test instead of quietly answering `pp:Group`.
+
+**The error path could throw while reporting an error.** Canvas-state capture promises never to throw and returns whatever the studio handed back, but the formatter read its fields unguarded — so a partial state replaced a real failure with a `TypeError` from the error path itself. Every field is read defensively now.
+
+**The instrument catalogue stopped being a ceiling, and the soundtrack can be rendered.** Five audio facade methods landed in the engine after `pinepaper_sound` was written, and the tool could list and play the seventeen built-in sounds and nothing else — so a rhodes, a koto or a taiko was unreachable, while the engine's own comment calls those tables "a curated starting set, not a claim that music contains six instruments."
+
+- `define_instrument`, `define_percussion` and `define_sfx` register a sound at runtime. It is first-class from then on: `listInstruments()` reads the live table, so it appears in the `list_*` catalogues and plays by name like a built-in. The response returns the **canonical** name — registration normalises to `[a-z][a-z0-9_-]`, so a model that registers `Rhodes` and plays `Rhodes` is naming something that does not exist.
+- The engine's rules are mirrored rather than tightened. A melodic instrument needs a partial table because one without renders silence; percussion and SFX may be **pure noise**, because a hat and a whoosh are, and tightening that would refuse exactly the sounds the relaxation exists for. `pitch: {from, tau}` is carried through — the glide *is* the drum, and without it a defined kick comes out a beep.
+- `pinepaper_agent_export` takes **format: `wav`** — the soundtrack on its own, off the visual path. No platform preset resolves to it, so a request for a picture can never come back as audio; it has to be asked for by name. `framing: camera` and the audio knobs on a visual format are *rejected* rather than ignored, because silently dropping them leaves a caller believing something untrue about the output, and `estimateOnly` reports confidence `exact` — uncompressed PCM size is arithmetic, and a model would only be less true. The empty case distinguishes two things the engine distinguishes: a scene with **uploaded** audio renders to nothing here (the offline renderer bakes only what it can synthesize) and is routed to mp4/webm, which mux it — telling that caller "no audio" would be false.
+- `render_soundtrack` mixes every placed sound to a WAV **offline** — no Web Audio, no playback, which is what makes it work in a headless studio — and writes it to a file through the same path video and PDF take. An empty scene is refused by name instead of producing a silent file, and any sound that could not be mixed is reported as `dropped`: a soundtrack missing a track otherwise looks exactly like a complete one.
+
+**Eleven shapes the engine draws were reachable from nothing.** FxTool's `ShapeRegistry` registers 34 shapes and `create()` delegates any of them. Flowchart, UML and network route through `pinepaper_create_diagram_shape`, so 23 were callable — and the other eleven appeared in no tool enum anywhere: `disk`, `circle-outline`, `arrow-right`, and the **entire** annotation set (`speech-bubble`, `speech-bubble-square`, `speech-bubble-pointed`, `thought-bubble`, `comment-box`, `callout-box`, `double-bubble`, `quote-bubble`). The renderer was never the limit: `create()` already forwards `tailDirection` and `tailSize`, parameters that exist only for bubbles. So an agent asked for a comic panel or an annotated diagram had to hand-build the outline or decline, for a shape the engine had the whole time. `itemType` goes 17 → 28, each one documented with the engine's own description rather than a guess, and the emitted code is *executed* against a stub in the suite — reading a spread operator and inferring the rest is how a widened enum ships a dead door.
+
+**The media list advertised seven of nine.** `hatch` and `watercolor` — both native fidelity, and `hatch` has its own `apply_hatch` action in the same tool — were missing from the served JSON description while the Zod copy beside it and the agent guide both listed them. Three copies, and the stale one was the copy a model reads. `pinepaper_compose`'s two-medium enum was checked against the engine for the same reason and is correct: `COMPOSABLE_MEDIA` is frozen at `['vector','thread']`, and both tables are fixtures now.
+
+**A scene read could be 500 items of 800 and say nothing.** `exportCanvasOntology` returns the true `itemCount` beside an item list capped at `maxItems`, and `childCount` beside a capped children array — so a partial answer was indistinguishable from a complete one unless the caller thought to compare two fields that look like they agree. Truncation is now reported when, and only when, something was clipped: both numbers, the knob to raise, and what to do past 500 where the cap truncates rather than paginates. An older studio that omits `itemCount` is reported as unknown, never as partial.
+
+**The server's own identity string banned two tools it ships.** `SERVER_INFO.description` carried a flat prohibition on producing HTML or React — no qualifier, no tool named — while this server ships `pinepaper_export_widget_html` and `pinepaper_export_widget`, which produce exactly those. That string is the first text a client shows a model, before any tool, every session. Same defect as the `agent_start_job` description fixed above, in the widest-read place available. The rule is substitution, not format — and the prohibition is described here rather than quoted, because the guard flags a banned imperative in this README too, and it is right to: a model reads the sentence, not the quotation marks around it. The guard that catches it had been reading two surfaces out of four; it now sweeps all 19 resources, every prompt, all three verbosity tiers, the manifest and this README, and its liveness floor compares against the declared lists name by name rather than counting.
+
 ## What's new in 1.6.7
 
 **Four more item-stage shader effects** — `electric_arc`, `vortex`, `rain_veil`, `caustics` (ABYSSAL's noise library). The `item` shader stage went from four built-ins to eight and nothing here named the new half.
@@ -281,7 +502,7 @@ The relation catalogue in the tool description now names families rather than al
 
 **`pinepaper_connect` / `connect_ports` accept an `id`.** `update_connector` and `remove_connector` address a connector by `connectorId`, and there was previously no value a caller could correctly pass — creation returns code rather than a result, and the engine's fallback is timestamp-based. Assign your own and reuse it.
 
-**`pinepaper_world3d` `add_object` forwards PBR material fields** — `metalness`, `roughness`, `emissiveIntensity`.
+**`pinepaper_world3d` `add_object` forwards PBR material fields** — `metalness`, `roughness`, `emissiveIntensity`. *(Corrected in 1.6.8: `metalness` and `roughness` are accepted and ignored on a plain object — the prop shader declares no such uniform. They render on the mesh path. Left here rather than quietly edited, because a drifted claim is worse than a missing one.)*
 
 Follows 1.6.6, whose dependency-security work is described below.
 
@@ -343,7 +564,7 @@ Fourteen new tools (121 → 135) and new actions across the surface — the rele
 
 ## Toolkits & Token Budget
 
-144 tools is a lot of context. The server ships a **toolkit** system that serves only the tools a given client needs, plus a **verbosity** system that controls how long each tool description is.
+152 tools is a lot of context. The server ships a **toolkit** system that serves only the tools a given client needs, plus a **verbosity** system that controls how long each tool description is.
 
 **Toolkit profiles** (`PINEPAPER_TOOLKIT`):
 
@@ -514,7 +735,7 @@ Choropleths, region styling, and data-driven map animation via `pinepaper_map`,
 Search and import free SVG assets from multiple repositories:
 
 - **SVGRepo**: 500,000+ icons with various licenses
-- **OpenClipart**: 150,000+ public domain clipart (CC0)
+- **OpenClipart**: 151,000+ public domain clipart (CC0)
 - **Iconify**: 200,000+ icons from multiple icon sets
 - **Font Awesome**: 2,000+ free icons (CC BY 4.0)
 
@@ -548,7 +769,7 @@ Generate instruction/code pairs for LLM fine-tuning:
 
 ## Tools Reference
 
-All 144 tools, grouped by the tag used for toolkit filtering.
+All 152 tools, grouped by the tag used for toolkit filtering.
 
 ### Canvas (`canvas`)
 | Tool | Description |
@@ -572,6 +793,7 @@ All 144 tools, grouped by the tag used for toolkit filtering.
 | `pinepaper_geometry` | Geometric construction primitives |
 | `pinepaper_group` | Group / ungroup / break apart |
 | `pinepaper_arrange` | Z-order: bring forward/back/front/back |
+| `pinepaper_path` | Booleans, simplify, outline stroke, repeat patterns, lock |
 
 ### Batch (`batch`)
 | Tool | Description |
@@ -605,6 +827,8 @@ All 144 tools, grouped by the tag used for toolkit filtering.
 ### Animation (`animation`)
 | Tool | Description |
 |------|-------------|
+| `pinepaper_sound` | Synthesis: tones, chords, SFX, sound-as-waveform-path |
+| `pinepaper_motion` | Generator motion engine: group and field motions |
 | `pinepaper_animate` | Apply a simple loop animation |
 | `pinepaper_keyframe_animate` | Timed keyframe animation |
 | `pinepaper_play_timeline` | Control playback, rate, progress, scroll-driven scrubbing |
@@ -724,6 +948,9 @@ All 144 tools, grouped by the tag used for toolkit filtering.
 |------|-------------|
 | `pinepaper_rigging` | Skeletons, bones, IK, breakdown poses; BVH mocap import/retarget, Spine import |
 | `pinepaper_import_layered_character` | Decomposed character layers → role-bound parts (blink/smile work immediately) |
+| `pinepaper_design_system` | DTCG design systems + 18 composable aesthetic styles |
+| `pinepaper_stick` | The vendored stick-figure kit: figure and set |
+| `pinepaper_story` | Prose becomes a scene: distill, assemble, plan a book |
 | `pinepaper_character` | Place a figure from the design graph and direct it with beats — no geometry, no bones, no poses |
 
 ### Typography (`font`, `letter_collage`)
@@ -781,7 +1008,9 @@ All 144 tools, grouped by the tag used for toolkit filtering.
 | `pinepaper_agent_end_job` | End job with summary and recommendations |
 | `pinepaper_agent_reset` | Quick canvas reset without page refresh |
 | `pinepaper_agent_batch_execute` | Execute multiple operations in batch |
+| `pinepaper_interchange` | Lottie, dotLottie, GLB, BVH, PNG sequence |
 | `pinepaper_agent_export` | Smart export with platform auto-detection |
+| `pinepaper_export_store` | Recover an export the studio is still holding — list, save to a file, or release |
 | `pinepaper_agent_analyze` | Analyze content for export recommendations |
 
 ### Browser (`browser`)
@@ -815,7 +1044,7 @@ All 144 tools, grouped by the tag used for toolkit filtering.
 1. Create a yellow circle as the sun (radius 60) at center
 2. Create a blue circle as Earth (radius 20)
 3. Create a gray circle as the Moon (radius 8)
-4. Add relation: Earth orbits Sun at radius 150, speed 0.3
+4. Add relation: Earth orbits Sun at radius 151, speed 0.3
 5. Add relation: Moon orbits Earth at radius 40, speed 0.8
 ```
 
@@ -1043,6 +1272,16 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines.
 | `PINEPAPER_METRICS_ENABLED` | Enable performance metrics tracking | `true` |
 | `PINEPAPER_METRICS_RETENTION` | Max metrics to retain in memory | `1000` |
 | `PINEPAPER_SCREENSHOT_MODE` | Screenshot mode (`on_request`/`always`/`never`) | `on_request` |
+| `PINEPAPER_WAIT_UNTIL` | What a navigation waits for (`load`/`domcontentloaded`/`networkidle0`/`networkidle2`) | `domcontentloaded` |
+| `PINEPAPER_TIMEOUT` | Navigation and readiness timeout, in ms | `30000` |
+| `PINEPAPER_PROXY` | Chrome `--proxy-server` value; also ignores certificate errors, for an intercepting proxy | unset |
+| `PINEPAPER_EXPORT_TIMEOUT` | Governor budget for an export run, in ms (raise `PINEPAPER_TIMEOUT` alongside it) | `300000` |
+| `PINEPAPER_GOVERNOR` | `off` runs code by raw eval — no governor report, no error codes, no seeded determinism | on |
+
+Behind a proxy, or against a Studio with analytics or polling connections open,
+`networkidle2` may never settle: set `PINEPAPER_WAIT_UNTIL` only if you need the
+old behaviour back. Readiness does not depend on it — the connection waits for
+Studio's `app.create` either way.
 
 ### Performance Metrics
 

package/README.pt-BR.md

@@ -14,7 +14,7 @@
 
 O servidor MCP do PinePaper permite que assistentes de IA criem e animem gráficos no [PinePaper Studio](https://pinepaper.studio) via Model Context Protocol. Funciona com qualquer IA que suporte chamadas de ferramenta MCP (Claude, GPT, Gemini, modelos locais etc.).
 
-São **144 ferramentas**: desenho, animação, diagramas, mapas, tipografia, física, edição de imagens, visualização de dados e exportação:
+São **152 ferramentas**: desenho, animação, diagramas, mapas, tipografia, física, edição de imagens, visualização de dados e exportação:
 
 - Criar texto, formas, geometria e gráficos complexos
 - Animar com **relações** declarativas em vez de keyframes
@@ -78,10 +78,14 @@ restrita, nem tanto.
 servidor para você** — mesmas ferramentas, mesma versão, por HTTP, sem
 instalação e sem navegador na sua máquina.
 
-Hospedagem custa dinheiro, então é paga: **Starter US$ 4,99/mês**
-(500 requisições/dia) e **Pro US$ 14,99/mês** (5.000/dia, mais a biblioteca de
-modelos de animação). Se você consegue rodar localmente, rode localmente — você
-não perde nada.
+Hospedagem custa dinheiro, então é paga — funciona por créditos. Os preços
+atuais estão em [cloud.pinepaper.studio](https://cloud.pinepaper.studio). Rode localmente
+se puder, mas não é idêntico: o serviço hospedado usa um conjunto testado de
+LLMs e repara o código gerado antes que ele chegue ao canvas — algo que um
+servidor local não consegue fazer sozinho. Em qual modelo confiar é uma
+pergunta que você mesmo pode responder: um benchmark roda um prompt em vários
+modelos e mostra os resultados lado a lado, com qualquer execução
+compartilhável. Está em beta apenas por convite.
 
 ## Mais