@pinepaper.studio/mcp-server 1.6.13 → 1.6.15

package/dist/types/schemas.js

@@ -1038,7 +1038,10 @@ export const BlastParamsSchema = z.object({
 // =============================================================================
 // FILTER TYPES
 // =============================================================================
-export const FilterTypeSchema = z.enum([
+// 'saturate' is what the published JSON schema offered for releases, while
+// the engine registers 'saturation' and this enum rejected 'saturate' — a
+// caller who followed the docs got a validation error. Accepted and mapped.
+export const FilterTypeSchema = z.preprocess((v) => (v === 'saturate' ? 'saturation' : v), z.enum([
     'grayscale',
     'sepia',
     'blur',
@@ -1053,7 +1056,7 @@ export const FilterTypeSchema = z.enum([
     'sharpen',
     'emboss',
     'posterize',
-]).describe('Type of visual filter to apply');
+])).describe('Type of visual filter to apply');
 // =============================================================================
 // TOOL INPUT SCHEMAS
 // =============================================================================
@@ -1087,6 +1090,14 @@ export const AddFilterInputSchema = z.object({
     params: z.record(z.unknown()).optional().default({}),
 });
 // Create Item
+// Item data flags. Advertised on create_item and modify_item for releases while
+// z.object() stripped them, so {data: {selectable: false}} was accepted and
+// did nothing. The engine reads all three off item.data.
+export const ItemDataFlagsSchema = z.object({
+    selectable: z.boolean().optional(),
+    isDraggable: z.boolean().optional(),
+    isDecorative: z.boolean().optional(),
+});
 export const CreateItemInputSchema = z.object({
     itemType: ItemTypeSchema,
     position: PositionSchema.optional().default({ x: 400, y: 300 }),
@@ -1096,6 +1107,11 @@ export const CreateItemInputSchema = z.object({
     animationIntensity: z.number().optional().describe('Loop animation amplitude (0.1 = ±10%, default 0.15). Drives pulse/wobble/bounce/breathe amplitude; honored by SVG/SMIL/widget export.'),
     animationDelay: z.number().optional().describe('Loop animation start delay in seconds.'),
     keyframes: z.array(KeyframeSchema).optional().describe('Required when animationType is "keyframe". Inline keyframe array attached at creation.'),
+    data: ItemDataFlagsSchema.optional(),
+    // Also accepted at the top level: it names which point `position` is, so it
+    // is read beside position as often as inside properties — and at the top
+    // level it was stripped without a word (round 7 retest, 1.63).
+    anchor: z.string().optional().describe("Which point position names: 'center' (default), 'top-left', 'top-right', 'bottom-left', 'bottom-right'. Same as properties.anchor."),
 });
 // Light direction for 3D effects
 export const LightDirectionSchema = z.enum([
@@ -1132,6 +1148,7 @@ export const CreateDiagonalStripesInputSchema = z.object({
 export const ModifyItemInputSchema = z.object({
     itemId: z.string().describe('Registry ID of the item'),
     properties: z.record(z.unknown()).describe('Properties to update'),
+    data: ItemDataFlagsSchema.optional(),
 });
 // Delete Item
 export const DeleteItemInputSchema = z.object({
@@ -1254,15 +1271,43 @@ export const ImportMotionCaptureInputSchema = z.object({
 //
 // Region (added FxTool c81781c): when set, the generator draws into a clipped
 // sub-group translated to (x,y) sized (width × height). Region runs imply
-// preserve (won't wipe the canvas) and re-running the same generator replaces
-// its prior region. Different generators' regions coexist. Invalid/zero-size
+// preserve (won't wipe the canvas). An instance is generator + box, or an
+// explicit region.id (FxTool 5adfcf1c): the same box or id replaces, another
+// box adds an instance. (Before 5adfcf1c a second box silently replaced the
+// first — "drawWaves in a roundedRect draws nothing".) Invalid/zero-size
 // regions fall back to full-canvas FxTool-side.
+//
+// Shape (FxTool c68524a2): the clip may be a rounded rect, ellipse, circle,
+// polygon, star, or an existing path's own geometry ({itemId}, whose bounds
+// are the box when none is given).
+export const GENERATOR_REGION_SHAPES = ['rect', 'roundedRect', 'ellipse', 'circle', 'polygon', 'star'];
 export const GeneratorRegionSchema = z.object({
-    x: z.number().describe('Region top-left X in canvas coords'),
-    y: z.number().describe('Region top-left Y in canvas coords'),
-    width: z.number().positive().describe('Region width in pixels'),
-    height: z.number().positive().describe('Region height in pixels'),
-}).describe('Optional sub-region {x, y, width, height} the generator draws into.');
+    x: z.number().optional().describe('Region top-left X in canvas coords'),
+    y: z.number().optional().describe('Region top-left Y in canvas coords'),
+    width: z.number().positive().optional().describe('Region width in pixels'),
+    height: z.number().positive().optional().describe('Region height in pixels'),
+    shape: z.union([z.enum(GENERATOR_REGION_SHAPES), z.object({ itemId: z.string().min(1) })]).optional()
+        .describe("Clip shape: 'rect' (default), 'roundedRect' (+radius), 'ellipse', 'circle', 'polygon' (+sides), 'star' (+points, innerRatio), or {itemId} — clip to that path's geometry (the box defaults to its bounds)."),
+    radius: z.number().min(0).optional().describe("roundedRect corner radius (default 20% of the shorter side)."),
+    sides: z.number().int().min(3).max(64).optional().describe('polygon sides (default 6).'),
+    points: z.number().int().min(3).max(64).optional().describe('star points (default 5).'),
+    innerRatio: z.number().min(0.05).max(0.95).optional().describe('star inner radius as a fraction of the outer (default 0.5).'),
+    id: z.string().trim().min(1).max(64).optional().describe('Names this region instance. Without it an instance is the generator plus its box: the same box replaces, a different box adds another. With it, re-running under the same id replaces that instance wherever its box now is.'),
+}).superRefine((r, ctx) => {
+    const box = [r.x, r.y, r.width, r.height].filter((v) => v !== undefined).length;
+    const fromItem = typeof r.shape === 'object';
+    if (box !== 4 && !(fromItem && box === 0)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: fromItem
+                ? 'give all of x, y, width, height, or none of them (the region is then the item\'s bounds).'
+                : 'a region needs x, y, width and height — unless shape is {itemId}, which takes the item\'s bounds.' });
+    }
+    const own = { radius: 'roundedRect', sides: 'polygon', points: 'star', innerRatio: 'star' };
+    for (const [k, shape] of Object.entries(own)) {
+        if (r[k] !== undefined && r.shape !== shape) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: [k], message: `${k} applies to shape '${shape}' only.` });
+        }
+    }
+}).describe('Optional sub-region the generator draws into, clipped to a shape.');
 export const ExecuteGeneratorInputSchema = z.object({
     generatorName: GeneratorNameSchema,
     params: z.record(z.unknown()).optional().default({}),
@@ -1321,8 +1366,13 @@ export const SetBackgroundColorInputSchema = z.object({
     color: SolidColorSchema.describe('Background color to set (solid colors only)'),
 });
 export const SetCanvasSizeInputSchema = z.object({
-    width: z.number().min(100).max(4096).describe('Canvas width (100-4096)'),
-    height: z.number().min(100).max(4096).describe('Canvas height (100-4096)'),
+    // 8192, not 4096: the artboard tool takes any size and a 5400x1350 carousel
+    // panorama exported exactly, while this refused it. 8192 stays well inside
+    // the browser's per-side canvas limit.
+    // The refusal NAMES the route: a 728x90 banner refused with a bare "too
+    // small" left a caller to export the preset instead (round 8 BB, 1.48).
+    width: z.number().min(100, "a canvas side under 100 px is not supported. For small assets (a 728x90 or 320x50 banner, a 28 px emote) design at 2-4x — e.g. 1456x180 — and export with agent_export region {x:0, y:0, width, height, outputWidth:728, outputHeight:90}. For VIDEO at a small size, design at 2x and export with agent_export scale: 0.5.").max(8192).describe('Canvas width (100-8192)'),
+    height: z.number().min(100, "a canvas side under 100 px is not supported. For small assets (a 728x90 or 320x50 banner, a 28 px emote) design at 2-4x — e.g. 1456x180 — and export with agent_export region {x:0, y:0, width, height, outputWidth:728, outputHeight:90}. For VIDEO at a small size, design at 2x and export with agent_export scale: 0.5.").max(8192).describe('Canvas height (100-8192)'),
     preset: z.string().optional().describe('Optional preset name'),
 });
 // Export
@@ -1432,7 +1482,10 @@ export const SceneItemSchema = z.object({
     /** Temporary ID for referencing in relations (e.g., "sun", "earth") */
     name: z.string().describe('Reference name for this item (used in relations)'),
     /** Item type to create */
-    itemType: z.enum(['text', 'circle', 'star', 'rectangle', 'triangle', 'polygon', 'ellipse', 'path', 'line', 'arc']),
+    // The canonical list, not a subset. This declared ten types while the tool
+    // hand-built four and turned the other six into a 30px circle; now that it
+    // routes through app.create, every type the engine has works here.
+    itemType: ItemTypeSchema,
     /** Position on canvas */
     position: PositionSchema.optional(),
     /** Item-specific properties */
@@ -1444,7 +1497,11 @@ export const SceneRelationSchema = z.object({
     /** Reference name of the target item */
     target: z.string().describe('Name of the item to relate to'),
     /** Type of relation */
-    type: z.enum(['orbits', 'follows', 'attached_to', 'maintains_distance', 'points_at', 'mirrors', 'parallax', 'bounds_to']),
+    // THE DOCS LISTED ~90 AND THIS ACCEPTED 8. A caller following the relation
+    // catalogue — grows_from, say — was rejected by validation before the call
+    // was made, with nothing to suggest the tool simply carried a smaller list
+    // than the documentation it shares. The catalogue is the contract.
+    type: RelationTypeSchema,
     /** Relation-specific parameters */
     params: z.record(z.unknown()).optional().describe('Relation parameters (radius, speed, distance, etc.)'),
 });
@@ -1455,6 +1512,7 @@ export const SceneAnimationSchema = z.object({
     type: z.enum(['bounce', 'breathe', 'fade', 'glow', 'jelly', 'path', 'pulse', 'rotate', 'scrollDown', 'scrollLeft', 'scrollRight', 'scrollUp', 'shake', 'slideLeftRight', 'slideUpDown', 'swing', 'typewriter', 'wobble']),
     /** Animation speed (default: 1.0) */
     speed: z.number().optional(),
+    startTime: z.number().min(0).optional().describe('Seconds before this animation begins. These are ambient LOOPS, so this staggers when each one starts rather than scheduling a one-shot — which is what makes a scene read as choreographed instead of everything moving at once from frame zero.'),
     /** Animation parameters */
     params: z.record(z.unknown()).optional().describe('Animation-specific parameters'),
 });
@@ -1822,12 +1880,31 @@ export const AgentPlatformSchema = z.enum([
     'web',
     'print-a4',
     'print-letter',
+    // Landscape print (round 8 DD, 8.18): the engine has a4-landscape and
+    // letter-landscape at 300 dpi, but no platform reached them, so a
+    // landscape print job had no preset carrying the print DPI.
+    'print-a4-landscape',
+    'print-letter-landscape',
 ]).describe('Target platform for export');
 /**
  * Export format types
  */
 export const AgentExportFormatSchema = z.enum([
     'svg', 'png', 'gif', 'mp4', 'webm', 'pdf',
+    // STILLS UNDER A BYTE BUDGET. Ad specs cap an image at ~150 KB, and PNG could
+    // not get there. Rendered as the png path (region included) and re-encoded in
+    // the page at the quality tier's compression. jpg has no alpha — see the tool text.
+    'jpg', 'webp',
+    // ANIMATION WITH FULL ALPHA (8.12): stepped PNG frames. webm cannot carry
+    // alpha with the studio's muxer, and gif's transparency is 1-bit.
+    'apng',
+    // ADS (8.21 / 8.24): the studio's standalone widget page, wrapped for a
+    // display network (a zip with ad.size + clickTag, and a backup image) or as
+    // an MRAID playable (one HTML file, CTA through mraid.open).
+    'html5-ad', 'playable',
+    // CAPTIONS: text items staged with bornAt / ttl, as a subtitle file —
+    // scc is CEA-608 (broadcast, 29.97 drop-frame).
+    'srt', 'vtt', 'scc',
     // AUDIO-ONLY. The soundtrack on its own, with no frames rendered — so
     // platform dimensions, framing and quality do not apply to it, and no
     // platform preset resolves to it. It has to be asked for by name.
@@ -1836,9 +1913,10 @@ export const AgentExportFormatSchema = z.enum([
 /**
  * Screenshot policy for agent jobs
  */
-export const AgentScreenshotPolicySchema = z.enum([
-    'none', 'on_error', 'on_complete', 'on_request',
-]).describe('When to take screenshots during agent job');
+// 'never' is what the published JSON schema offered for releases while this
+// enum rejected it, so a caller who followed the docs got a validation error.
+// Accepted and read as 'none'.
+export const AgentScreenshotPolicySchema = z.preprocess((v) => (v === 'never' ? 'none' : v), z.enum(['none', 'on_error', 'on_complete', 'on_request'])).describe('When to take screenshots during agent job');
 /**
  * Start job input schema
  */
@@ -1861,6 +1939,10 @@ export const AgentStartJobInputSchema = z.object({
  */
 export const AgentEndJobInputSchema = z.object({
     takeScreenshot: z.boolean().optional().default(true).describe('Take final screenshot'),
+    // The JSON schema has always published this name, and z.object() stripped it,
+    // so includeScreenshot:false still took a screenshot. It wins when given —
+    // see generateAgentEndJob.
+    includeScreenshot: z.boolean().optional(),
     analyzeContent: z.boolean().optional().default(true).describe('Analyze content for export recommendations'),
 }).describe('Options for ending an agent job');
 /**
@@ -1914,8 +1996,8 @@ export const AgentBatchOperationSchema = z.object({
     generatorParams: z.record(z.unknown()).optional().describe('Generator parameters'),
     generatorRegion: GeneratorRegionSchema.optional().describe('Optional sub-region {x, y, width, height} for execute_generator'),
     // Set canvas size fields
-    width: z.number().min(100).max(4096).optional().describe('Canvas width for set_canvas_size (100-4096)'),
-    height: z.number().min(100).max(4096).optional().describe('Canvas height for set_canvas_size (100-4096)'),
+    width: z.number().min(100).max(8192).optional().describe('Canvas width for set_canvas_size (100-8192)'),
+    height: z.number().min(100).max(8192).optional().describe('Canvas height for set_canvas_size (100-8192)'),
     preset: z.string().optional().describe('Canvas preset for set_canvas_size (e.g. instagram, youtube)'),
     // Keyframe animate fields
     keyframes: z.array(z.object({
@@ -2061,12 +2143,104 @@ export const AgentExportInputSchema = z.object({
     framing: z.enum(['canvas', 'camera']).optional().default('canvas').describe('Output framing: "canvas" (full canvas, default) or "camera" (camera_animates first-keyframe viewport — fails if no walkthrough exists). Camera animation still drives motion within the fixed output frame.'),
     duration: z.number().min(0.5).max(VIDEO_MAX_DURATION_S).optional().default(5).describe(`Video duration in seconds for animated formats (mp4/webm/gif). Default 5. Max ${VIDEO_MAX_DURATION_S} for mp4/webm, max ${GIF_MAX_DURATION_S} for gif (GIF is not codec-bounded, so file size scales with frames × dimensions, and it cannot stream to the export store). Static formats (png/svg/pdf) ignore this. Past roughly a minute the export is held in the studio's export store and paged back to a file rather than returned inline; a studio without that store refuses by name and says so.`),
     estimateOnly: z.boolean().optional().default(false).describe('Preflight only: return the estimated file size AND what this scene would lose to this format, rendering nothing. Use before a long or high-quality export to check the size first. Modeled for mp4/webm/gif; png/pdf/svg return confidence "none" because no dimension-based model exists for them; wav is reported as "exact", because uncompressed PCM size is arithmetic rather than a guess.'),
-    fps: z.number().int().min(1).max(120).optional().describe('Video only: frames per second, overriding whatever `quality` implies. The tiers set it — draft 15, standard 30, high 60 — so asking for higher quality DOUBLES the frame count and the render time unless you say otherwise. File size is bitrate x duration and does not move with fps, but the picture gets fewer bits per frame at a higher one.'),
-    scale: z.number().min(0.1).max(1).optional().describe('Video only: render at this fraction of the platform preset\'s dimensions (0.1-1). The engine derives its encode target from RESOLUTION, so this is the size control — there is no bitrate to set, and halving the frame roughly quarters the pixels and the file. It is also the preview knob: scale 0.5 with quality "draft" is the fast look-check before committing to a full render. Rounded to even dimensions, which H.264 requires.'),
+    // NTSC rates (round 9 FF, 1.75): CTV / OTT spots require 29.97 and it was
+    // refused as "Expected integer", though the engine exports true 30000/1001.
+    // A rational string ('30000/1001') or the NTSC decimals snap to the exact
+    // rational — 29.97 is 30000/1001, not the float 29.97, whose drift over a
+    // spot is a dropped frame.
+    fps: z.preprocess((v) => {
+        if (typeof v === 'string') {
+            const m = /^(\d+)\/(\d+)$/.exec(v.trim());
+            if (m && Number(m[2]) > 0)
+                return Number(m[1]) / Number(m[2]);
+            const n = Number(v);
+            return Number.isFinite(n) ? v === '' ? v : n : v;
+        }
+        return v;
+    }, z.number().min(1).max(120).transform((n) => {
+        const ntsc = { '23.976': 24000 / 1001, '29.97': 30000 / 1001, '59.94': 60000 / 1001, '119.88': 120000 / 1001 };
+        return ntsc[(Math.round(n * 1000) / 1000).toString()] ?? ntsc[(Math.round(n * 100) / 100).toString()] ?? n;
+    })).optional().describe('Video only: frames per second — an integer, an NTSC rate (23.976, 29.97, 59.94; snapped to the exact 24000/1001 …), or a rational string like "30000/1001". Overrides whatever `quality` implies. The tiers set it — draft 15, standard 30, high 60 — so asking for higher quality DOUBLES the frame count and the render time unless you say otherwise. File size is bitrate x duration and does not move with fps, but the picture gets fewer bits per frame at a higher one.'),
+    scale: z.number().min(0.1).max(1).optional().describe('Video only: render at this fraction of the platform preset\'s dimensions (0.1-1). The engine derives its encode target from RESOLUTION unless bitrate is given, so this is the size control; halving the frame roughly quarters the pixels and the file. It is also the preview knob: scale 0.5 with quality "draft" is the fast look-check before committing to a full render. Rounded to even dimensions, which H.264 requires.'),
     sampleRate: z.number().int().positive().optional().describe('wav only: samples per second (default 48000). Ignored by every other format.'),
     bitDepth: z.union([z.literal(16), z.literal(32)]).optional().describe('wav only: 16 (default) or 32-bit float. Ignored by every other format.'),
+    pdf: z.object({
+        paperFormat: z.string().optional().describe("Paper size: 'a4', 'a3', 'letter', … or 'custom' (the canvas's own size, the default)."),
+        orientation: z.enum(['portrait', 'landscape']).optional().describe('Default: from the canvas aspect.'),
+        bleed: z.number().min(0).max(20).optional().describe('Bleed in mm; > 0 includes the bleed area.'),
+        trimMarks: z.boolean().optional().describe('Add crop / trim marks.'),
+        searchableText: z.boolean().optional().describe('An invisible text layer over the artwork, so the PDF is selectable, searchable and screen-readable (default true where the studio supports it; lines no font in the PDF can carry are left out and counted). false omits it.'),
+        dpi: z.number().int().min(72).max(600).optional().describe('Rasterisation DPI (default: the quality tier\'s).'),
+        pages: z.union([
+            z.literal('scenes'),
+            z.array(z.union([z.string(), z.object({ sceneId: z.string(), width: z.number().positive(), height: z.number().positive() })])).min(1),
+        ]).optional().describe("Multi-page: 'scenes' = one page per saved scene in timeline order, or a list of scene ids — or {sceneId, width, height} to give a page its canvas size (scenes do not record one)."),
+    }).optional().describe('pdf only: print options.'),
+    ad: z.object({
+        clickUrl: z.string().url().optional().describe('html5-ad: the clickTag value for testing (networks replace it at serve time). playable: the store / landing URL the CTA opens — required.'),
+        ctaItemId: z.string().min(1).optional().describe('The item whose bounds are the click target. html5-ad: optional (default: the whole ad). playable: required — a playable is interactive, so only the CTA clicks through. The hotspot is where the item is at export time; it does not follow an animated CTA.'),
+        maxBytes: z.number().int().positive().optional().describe('Size budget for the upload (the zip for html5-ad, the HTML for playable). html5-ad defaults to 150000: Google Ads display HTML5 is 150 KB; some uploads allow 600 KB — set it to your network\'s figure. Over budget is a fidelity warning, not a refusal.'),
+    }).optional().describe('html5-ad / playable options.'),
+    transparent: z.boolean().optional().describe('apng: keep the alpha channel (the default; false fills the background colour). webm: true writes a VP9 alpha channel where the studio supports it (result.video.alpha confirms it).'),
+    alphaQuantizer: z.number().int().min(0).max(63).optional().describe('webm with transparent: quality of the alpha stream, 0 = lossless … 63 (the studio\'s default otherwise).'),
+    loop: z.union([z.boolean(), z.number().int().min(0).max(1000)]).optional().describe('gif / apng: true = loop forever, false / 0 / 1 = play once, n = play n times.'),
+    maxBytes: z.number().int().positive().optional().describe('gif only: a size budget in bytes (email wants <= 1 MB). Over it, the GIF is re-encoded smaller — frame size scaled from the overshoot — at most twice; the result reports each attempt and whether the budget was met.'),
+    broadcast: z.boolean().optional().describe('mp4 only: broadcast-safe — BT.709, limited range (samples 16-235), tagged bt709, constant bitrate with an 8 Mbps floor at 720p and up (4 below). result.video reports what the encoder did.'),
+    broadcastHeadroom: z.number().int().min(0).max(40).optional().describe('mp4 with broadcast only (default 12 with broadcast): luma codes kept clear at both ends of 16-235, so encoder ringing stays legal. 12 measured clean on hard edges; 4 cuts out-of-range samples ~100x, 12 ~1000x; never to zero, so a legaliser pass is still required (result fidelity names it).'),
+    bitrate: z.number().int().min(100_000).max(200_000_000).optional().describe('mp4 / webm: target bits per second, replacing the quality-derived one. The browser encoder treats it as a CEILING: simple content comes out lower, and result.video.achievedBitrate says what it was.'),
+    minBitrate: z.number().int().min(100_000).max(200_000_000).optional().describe('mp4 / webm: a floor under the target. If the achieved bitrate misses it, fidelity warns and names the re-encode a delivery spec needs.'),
+    bitrateMode: z.enum(['constant', 'variable']).optional().describe("mp4 / webm: 'constant' (the default with broadcast) or 'variable'."),
+    time: z.number().min(0).optional().describe('Stills only (png / jpg / webp / svg / pdf): render the scene at this time in seconds. Without it a still is taken at wherever the playhead happens to be, so two identical runs can differ.'),
+    region: z.object({
+        x: z.number(), y: z.number(),
+        width: z.number().positive(), height: z.number().positive(),
+        outputWidth: z.number().int().positive().max(8192).optional(),
+        outputHeight: z.number().int().positive().max(8192).optional(),
+        excludeForeign: z.boolean().optional().describe('Default true: an item that reaches into the region but is centred outside it (a neighbouring card\'s overflow) is left out of this image; result.excludedItems names them. false renders everything that touches the region.'),
+    }).optional().describe('png / jpg / webp only: export just this canvas region (canvas coordinates, top-left x/y) — carousel slices, crops. Output is the region\'s size unless outputWidth/outputHeight say otherwise; a different aspect is covered, not stretched.'),
 }).describe('Smart export options')
     .superRefine((val, ctx) => {
+    if (val.time !== undefined && ['mp4', 'webm', 'gif', 'apng', 'wav', 'srt', 'vtt', 'scc'].includes(String(val.format))) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['time'], message: "time picks the moment a STILL is taken; a video or audio export runs from 0 for its duration. Drop time, or export png / jpg / webp / svg / pdf." });
+    }
+    if (val.broadcast && val.format !== 'mp4') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['broadcast'], message: 'broadcast is an mp4 setting (BT.709 H.264). Export format: "mp4".' });
+    }
+    if (val.broadcastHeadroom !== undefined && !val.broadcast) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['broadcastHeadroom'], message: 'broadcastHeadroom applies only with broadcast: true (mp4).' });
+    }
+    for (const k of ['bitrate', 'minBitrate', 'bitrateMode']) {
+        if (val[k] !== undefined && val.format !== 'mp4' && val.format !== 'webm') {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: [k], message: `${k} is a video setting: mp4 or webm. A gif's size is set by maxBytes and scale.` });
+        }
+    }
+    if (val.bitrate !== undefined && val.minBitrate !== undefined && val.minBitrate > val.bitrate) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['minBitrate'], message: 'minBitrate is above bitrate; the floor would override the target. Drop one, or lower minBitrate.' });
+    }
+    if (val.ad !== undefined && val.format !== 'html5-ad' && val.format !== 'playable') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['ad'], message: 'ad options apply to format "html5-ad" or "playable".' });
+    }
+    if (val.format === 'playable' && (!val.ad?.ctaItemId || !val.ad?.clickUrl)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['ad'], message: 'a playable needs ad.ctaItemId (the install button — only it clicks through, so the rest stays playable) and ad.clickUrl (the store URL it opens).' });
+    }
+    if (val.transparent !== undefined && val.format !== 'apng' && val.format !== 'webm') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['transparent'], message: 'transparent applies to apng and webm: png keeps alpha already, and mp4 (H.264) / gif cannot carry it. For animation with alpha, export "webm" or "apng".' });
+    }
+    if (val.alphaQuantizer !== undefined && !(val.format === 'webm' && val.transparent === true)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['alphaQuantizer'], message: 'alphaQuantizer applies to a transparent webm (format "webm", transparent: true).' });
+    }
+    if (val.loop !== undefined && val.format !== 'gif' && val.format !== 'apng') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['loop'], message: "loop is a gif / apng setting. A video cannot carry a loop flag — for a seamless loop, key t = 0 and t = duration to the same state and export exactly that duration." });
+    }
+    if (val.maxBytes !== undefined && val.format !== 'gif') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['maxBytes'], message: "maxBytes is a gif budget. For mp4 / webm use scale and quality; for stills use jpg / webp with a lower quality." });
+    }
+    if (val.pdf !== undefined && val.format !== 'pdf') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['pdf'], message: "pdf options apply only to format: 'pdf'." });
+    }
+    if (val.region !== undefined && !['png', 'jpg', 'webp'].includes(String(val.format))) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['region'], message: "region applies only to a still — format 'png', 'jpg' or 'webp'. It renders one image of that part of the canvas." });
+    }
     // wav carries no picture, so the visual knobs are not merely ignored — a
     // caller who set them believes something about the output that is not
     // true. Said once, rather than silently dropped.
@@ -2519,6 +2693,7 @@ export const ImportImageInputSchema = z.object({
     maxWidth: z.number().optional().describe('Maximum width constraint in pixels'),
     maxHeight: z.number().optional().describe('Maximum height constraint in pixels'),
     mask: ImageMaskSchema.optional().describe('Optional mask shape to apply to the image'),
+    smoothing: z.enum(['off', 'low', 'medium', 'high']).optional().describe("Resampling when the image is scaled. 'off' = nearest-neighbour, hard pixel edges (pixel art). Default 'low'."),
 }).describe('Import image input');
 // =============================================================================
 // ONTOLOGY SCHEMAS
@@ -2970,6 +3145,25 @@ export const AudioBeatsInputSchema = z.object({
     sensitivity: z.number().optional(),
     minGap: z.number().optional(),
 });
+// ACCESSIBILITY CHECK: text contrast (WCAG 1.4.3) and flashing (2.3.1).
+export const AccessibilityCheckInputSchema = z.object({
+    checks: z.array(z.enum(['contrast', 'flash'])).min(1).optional().describe("Which checks (default both)."),
+    duration: z.number().positive().max(120).optional().describe('flash: seconds of the timeline to sample (default 5).'),
+    fps: z.number().int().min(10).max(60).optional().describe('flash: samples per second (default 20; a flash rate is only seen below half of it).'),
+});
+// RENDER BATCH (data-driven creative): one scene, many rows, one export per
+// row. The handler runs each row through modify_item / template_params and
+// then agent_export, so every per-tool check applies to every row.
+export const RenderBatchRowSchema = z.object({
+    id: z.string().min(1).max(64).optional().describe('A name for this row, echoed in its result.'),
+    changes: z.record(z.string(), z.record(z.unknown())).optional().describe('itemId → properties, applied with modify_item (content, fillColor, fit, …).'),
+    template: z.object({ templateId: z.string().min(1), params: z.record(z.unknown()) }).optional().describe('Apply a template\'s params (template_params apply).'),
+}).refine((r) => r.changes !== undefined || r.template !== undefined, { message: 'a row needs changes and / or template.' });
+export const RenderBatchInputSchema = z.object({
+    rows: z.array(RenderBatchRowSchema).min(1).max(100).describe('One entry per creative (max 100).'),
+    export: z.record(z.unknown()).describe('agent_export options used for every row (format, platform, quality, duration, ad, …).'),
+    estimateOnly: z.boolean().optional().describe('Validate the rows and return the plan without rendering.'),
+});
 export const TemplateParamsInputSchema = z.object({
     action: z.enum(['get', 'apply']),
     templateId: z.string(),
@@ -3000,8 +3194,13 @@ export const ImageFilterInputSchema = z.object({
     preserveShading: z.number().min(0).max(1).optional().describe('recolor_palette: how much of the original luminance detail survives (default 1).'),
 });
 export const LassoInputSchema = z.object({
-    action: z.enum(['activate', 'apply']),
+    action: z.enum(['cut', 'activate', 'apply']),
     itemId: z.string().optional(),
+    points: z.array(z.union([
+        z.tuple([z.number(), z.number()]),
+        z.object({ x: z.number(), y: z.number() }),
+    ])).optional(),
+    keepOriginal: z.boolean().optional(),
 });
 export const CutoutStyleInputSchema = z.object({
     action: z.enum(['apply', 'list']),
@@ -3124,6 +3323,11 @@ export const ExportWidgetInputSchema = z.object({
 export const ExportWidgetHtmlInputSchema = z.object({
     title: z.string().optional(),
     download: z.boolean().optional(),
+    // Accessibility / localisation (round 8 EE, 8.20): the engine writes
+    // <html lang="en"> with no dir and no text alternative for the canvas.
+    lang: z.string().regex(/^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/).optional().describe('BCP 47 language tag for the page, e.g. "ar", "hi", "zh-Hans".'),
+    dir: z.enum(['ltr', 'rtl', 'auto']).optional().describe('Text direction for the page.'),
+    alt: z.string().max(500).optional().describe('Text alternative for the animation: the canvas gets role="img" and this as its aria-label, and the page a meta description.'),
 });
 // =============================================================================
 // DATA VISUALIZATION (CHARTS)
@@ -3270,7 +3474,11 @@ export const LintSceneInputSchema = z.object({
 export const MediaInputSchema = z.object({
     action: z.enum(['upload_video', 'upload_audio', 'list', 'remove', 'set_playback_rate', 'set_clip', 'set_time_remap', 'speed_ramp', 'match_cut', 'apply_track_matte', 'stop_live_matte'])
         .describe("'upload_video' / 'upload_audio' (from a URL) · 'list' media · 'remove' by id · 'set_playback_rate' · 'set_clip' (re-trim) · 'set_time_remap' (canvas-time→source-time curve: ramps, freezes, reverse) · 'speed_ramp' ({duration, speed} segments — the human way to say a remap) · 'match_cut' (cut between two shots aligning the SUBJECT via on-device detection) · 'apply_track_matte' (an item's alpha driven by another item's luma/alpha — type-filled-with-footage; live:true keeps it tracking as the matte animates) · 'stop_live_matte'"),
-    url: z.string().url().optional().describe('Media URL — required for upload_video / upload_audio (fetched then imported).'),
+    // Not .url(): a bare absolute path is not a URL, and 48f3a2a made the server
+    // read local files — so `/Users/…/broll1.mp4` was advertised and then rejected
+    // by the schema before anything could read it. resolveMediaSource validates
+    // what it is given and names the problem.
+    url: z.string().min(1).optional().describe('Required for upload_video / upload_audio: an http(s) URL, a data: URL, or a local file path (absolute, relative to the server, or file://).'),
     id: z.string().optional().describe('Media id — required for remove / set_playback_rate / set_clip.'),
     rate: z.number().min(0.25).max(4).optional().describe('Playback rate 0.25–4 — required for set_playback_rate.'),
     inPoint: z.number().min(0).optional().describe('Clip in-point in media-time seconds — required for set_clip.'),
@@ -3513,10 +3721,20 @@ export const GameInputSchema = z.object({
         rows: z.number().int().positive(),
         cellSize: z.number().positive().optional().describe('World units per cell (default 1).'),
         origin: PositionSchema.optional().describe('World position of cell (0,0).'),
-        blocked: z.array(z.number()).optional().describe('Flat cols×rows array, 1 = blocked.'),
+        blocked: z.array(z.number()).optional().describe('A MASK, not a list of indices: one entry per cell, cols*rows long, row-major, non-zero meaning blocked. The engine reads blocked[y * cols + x].'),
         obstacles: z.array(z.object({ x: z.number(), y: z.number(), width: z.number(), height: z.number() }))
             .optional().describe('World-space rects to block — pass item bounds and the walls block the board.'),
-    }).optional().describe('pathfind: the board.'),
+    }).optional().describe('pathfind: the board.')
+        // A MASK AND AN INDEX LIST LOOK IDENTICAL TO A TYPE CHECKER.
+        //
+        // `blocked` is read as blocked[y * cols + x], so passing the INDICES of the
+        // blocked cells — the other obvious reading — blocks cells 0..n-1 by their
+        // values instead, and the answer comes back as a plausible "no path" with
+        // nothing wrong on the face of it. The length tells the two apart for free.
+        .refine((g) => !g?.blocked || g.blocked.length === g.cols * g.rows, {
+        message: 'grid.blocked must have exactly cols*rows entries — one per cell, non-zero meaning blocked. A list of blocked cell INDICES is a different thing and produces a wrong board rather than an error.',
+        path: ['blocked'],
+    }),
     start: PositionSchema.optional().describe('pathfind: start, WORLD coordinates.'),
     goal: PositionSchema.optional().describe('pathfind: goal, WORLD coordinates.'),
     diagonal: z.boolean().optional().describe('pathfind: 8-way movement (default true). Never cuts corners.'),
@@ -3582,6 +3800,13 @@ export const World3DInputSchema = z.object({
         segments: z.number().optional().describe('extrude_path: segments along the sweep · lathe_path: segments around the revolution.'),
         arc: z.number().optional().describe('lathe_path: how far round to revolve, in degrees. 360 is a full solid of revolution; less leaves it open.'),
         flatness: z.number().optional().describe('Curve flattening tolerance when the path is sampled into rings — smaller is finer and heavier.'),
+        // 5.64: these were read by the generator (65a1a21) but not declared here,
+        // so z.object() stripped them before it ran — every mesh came out the
+        // default grey. Declared, and tested through the handler this time.
+        color: z.union([z.string(), z.array(z.number())]).optional().describe('Mesh colour: hex or [r,g,b] (0..255 or 0..1). Default light grey.'),
+        metalness: z.number().min(0).max(1).optional(),
+        roughness: z.number().min(0).max(1).optional(),
+        uniforms: z.record(z.string(), z.unknown()).optional().describe('Raw shader uniforms (diffuse, metalness, roughness …) — win over color / metalness / roughness.'),
         x: z.number().optional().describe('Placement in world space.'),
         y: z.number().optional().describe('Placement in world space (omit to let it sit where the terrain puts it).'),
         z: z.number().optional().describe('Placement in world space.'),
@@ -3815,9 +4040,9 @@ export const SoundInputSchema = z.object({
         'list_instruments', 'list_percussion', 'list_sfx',
         'play_tone', 'play_chord', 'chord_frequencies', 'play_percussion', 'play_sfx',
         'play_spec', 'from_text', 'play_from_text',
-        'create', 'timbre_from_path', 'set_placement', 'remove', 'stop_all',
+        'create', 'sequence', 'timbre_from_path', 'set_placement', 'remove', 'stop_all',
         'define_instrument', 'define_percussion', 'define_sfx', 'render_soundtrack',
-    ]).describe("Catalogues: 'list_instruments' · 'list_percussion' · 'list_sfx'. Play: 'play_tone' · 'play_chord' · 'play_percussion' · 'play_sfx' · 'play_spec' · 'play_from_text'. Read without playing: 'chord_frequencies' · 'from_text' (a plain-language description resolved to a spec) · 'timbre_from_path'. Canvas: 'create' (a sound drawn AS a waveform path) · 'set_placement' · 'remove' · 'stop_all'. Define: 'define_instrument' · 'define_percussion' · 'define_sfx' — the six built-in instruments are a starting set, not a claim that music contains six; anything missing can be defined here and is then first-class, listed by the list_* actions and playable by name. Render: 'render_soundtrack' — mix every placed sound to a WAV file offline, with no Web Audio and no playback."),
+    ]).describe("Catalogues: 'list_instruments' · 'list_percussion' · 'list_sfx'. Play: 'play_tone' · 'play_chord' · 'play_percussion' · 'play_sfx' · 'play_spec' · 'play_from_text'. Read without playing: 'chord_frequencies' · 'from_text' (a plain-language description resolved to a spec) · 'timbre_from_path'. Canvas: 'create' (a sound drawn AS a waveform path) · 'sequence' (MANY cues in ONE call — a 112-cue music bed was 112 calls) · 'set_placement' · 'remove' · 'stop_all'. Define: 'define_instrument' · 'define_percussion' · 'define_sfx' — the six built-in instruments are a starting set, not a claim that music contains six; anything missing can be defined here and is then first-class, listed by the list_* actions and playable by name. Render: 'render_soundtrack' — mix every placed sound to a WAV file offline, with no Web Audio and no playback."),
     note: z.string().optional().describe("play_tone: scientific pitch, e.g. 'A4' or 'C#3'."),
     root: z.string().optional().describe("play_chord / chord_frequencies: the root note, e.g. 'C4'."),
     chord: z.string().optional().default('major').describe("play_chord / chord_frequencies: the chord kind, e.g. 'major', 'minor', 'maj7', 'dim'. Call the engine rather than guessing at exotic names."),
@@ -3849,6 +4074,14 @@ export const SoundInputSchema = z.object({
     itemId: z.string().optional().describe('timbre_from_path: the path whose SHAPE becomes the harmonic content. set_placement / remove: the sound item.'),
     samples: z.number().int().positive().optional().describe('timbre_from_path: how many points to sample along the path (default 256). More is a finer timbre and a slower read.'),
     placement: z.record(z.string(), z.unknown()).optional().describe('set_placement: where and when the sound sits on the timeline.'),
+    cues: z.array(z.object({
+        t: z.number().min(0).describe('When this cue sounds, in seconds.'),
+        spec: z.record(z.string(), z.unknown()).optional().describe('The synthesis spec, as create takes it.'),
+        preset: z.string().optional().describe("A named instrument, percussion or sfx instead of a spec — whatever the list_* actions report."),
+        note: z.string().optional().describe("Pitch for a preset instrument, e.g. 'A4'."),
+        duration: z.number().positive().optional().describe('Seconds this cue lasts.'),
+        visual: z.record(z.string(), z.unknown()).optional().describe('Per-cue waveform drawing options, as create takes them.'),
+    })).optional().describe('sequence: every cue in one call. Each is created and placed at its own t, so a music bed is ONE call rather than one per cue — a pilot spent 112 calls on a bed this expresses in a single array.'),
     visual: z.object({
         width: z.number().optional().describe('Waveform path width in canvas units (default 220).'),
         height: z.number().optional().describe('Waveform path height in canvas units (default 64).'),