@pinepaper.studio/mcp-server 1.6.19 → 1.6.21

package/dist/types/schemas.js

@@ -78,8 +78,18 @@ export const BlendModeSchema = z.enum([
  * one table, so every easing enum here is this list.
  */
 export const KEYFRAME_EASINGS = ENGINE_EASING_NAMES;
+/**
+ * Lines for easings an engine branch adds before the list is resynced
+ * (FxTool D11: hold / step). Spread in, so they satisfy the record the moment
+ * the sync brings the names, and are unused until then.
+ */
+const UPCOMING_EASING_DESCRIPTIONS = {
+    hold: 'Holds the previous value, then jumps at the next key (a cut, no in-between)',
+    step: 'Same as hold: jumps at the next key',
+};
 /** One line per easing, for tool descriptions and pinepaper_get_available_easings. */
 export const EASING_DESCRIPTIONS = {
+    ...UPCOMING_EASING_DESCRIPTIONS,
     linear: 'Constant speed',
     easeIn: 'Slow start, fast end',
     easeOut: 'Fast start, slow end',
@@ -195,9 +205,8 @@ export const ItemTypeSchema = z.enum([
     // and no tool has ever offered them, so the only way to reach one was to
     // hand-write a scene file.
     //
-    // In the browser they degrade to a flat plate of their own colour (see
-    // generateCreateItemCode) so a composition built with one still reads
-    // locally; the shaded surface appears in a cloud render.
+    // Created as a tagged plate (see generateCreateItemCode) that the studio and
+    // the cloud renderer both draw the surface over.
     'shader',
     'field',
 ]);
@@ -316,6 +325,8 @@ export const KeyframeSchema = z.object({
     time: z.number().describe('Time in seconds for this keyframe'),
     properties: z.record(z.unknown()).describe('Property values at this keyframe'),
     easing: KeyframeEasingSchema.optional().default('linear'),
+    interpolation: z.literal('hold').optional().describe("'hold': this key holds ITS OWN value until the next key, then jumps (FxTool D11). Refused on a studio without hold keys."),
+    hold: z.boolean().optional().describe("Same as interpolation: 'hold'."),
 });
 // =============================================================================
 // RELATION TYPES
@@ -396,6 +407,10 @@ export const RelationTypeSchema = z.enum([
     'on_event_toggle',
     'on_event_store_set',
     'on_event_store_increment',
+    'on_event_play_sound',
+    'looks_at',
+    'reacts_to',
+    'drag_to_turn',
     // --- Proximity — the pointer entering or leaving an item ---
     'on_enter_set_color',
     'on_enter_set_property',
@@ -724,6 +739,7 @@ export const EventInputSchema = z.object({
     payloadType: z.string().optional().describe("Payload type label (default 'Pulse') — action 'create'"),
     x: z.number().optional().describe('Canvas x for the event marker — action create'),
     y: z.number().optional().describe('Canvas y for the event marker — action create'),
+    at: z.union([z.number().min(0), z.array(z.number().min(0)).min(1)]).optional().describe('create: fire the event ITSELF at these scene times (seconds) — a timed trigger, so on_event_play_sound and every other reaction runs on the timeline and in video exports.'),
     eventId: z.string().optional().describe("Event id to fire — required for action 'pulse'"),
     payload: z.unknown().optional().describe("Optional value forwarded to listeners — action 'pulse'"),
 }).refine((v) => v.action !== 'create' || !!v.name, { message: "action 'create' requires name", path: ['name'] })
@@ -1150,6 +1166,40 @@ export const ItemDataFlagsSchema = z.object({
     isDraggable: z.boolean().optional(),
     isDecorative: z.boolean().optional(),
 });
+/**
+ * Per-item engine setters applied after create / modify (FxTool D20, D11).
+ * Sent through their own engine calls, never as create params: an engine
+ * without them would ignore an unknown param in silence, and the call says so
+ * instead.
+ */
+export const ScreenSpaceSchema = z.boolean()
+    .describe('HUD layer: true keeps the item fixed in the FRAME under camera moves (its x/y, keyframes and relations are then frame coordinates). Exports honour it; the live preview still tilts it; SVG and Lottie ignore it.');
+export const StepTimingSchema = z.union([
+    z.number().int().min(1),
+    z.object({ every: z.number().int().min(1), baseFps: z.number().positive().optional() }).strict(),
+    z.object({ fps: z.number().positive() }).strict(),
+    z.null(),
+]).describe("Animate this item 'on twos' (or threes…): N or {every: N, baseFps?} steps every N frames of a 30 fps base unless baseFps is given; {fps} steps at that rate; null turns it off. A stepped group steps its children. Not stepped: follows, spring_follow, auras, rigging and GPU generators.");
+/** A text item's counter (FxTool D70): a number that counts on the scene clock. */
+export const CounterSchema = z.union([
+    z.object({
+        from: z.number(), to: z.number(),
+        start: z.number().min(0).optional().describe('Seconds into the timeline (default 0).'),
+        duration: z.number().positive().optional().describe('Seconds to count (default 1).'),
+        easing: z.union([z.string(), z.tuple([z.number(), z.number(), z.number(), z.number()])]).optional().describe("Any engine easing (including 'hold' / 'step') or a cubic Bézier [x1, y1, x2, y2]; default linear."),
+        decimals: z.number().int().min(0).max(10).optional().describe('Default: the precision from / to were written with.'),
+        prefix: z.string().optional(), suffix: z.string().optional(),
+        locale: z.string().optional().describe("Number format locale (default 'en-US')."),
+        grouping: z.boolean().optional().describe('Thousands separators (default true).'),
+        padStart: z.number().int().min(1).max(21).optional().describe('Zero-pad to this many digits.'),
+        steps: z.number().int().positive().optional().describe('Count in N jumps instead of smoothly.'),
+        tabular: z.boolean().optional().describe('Fixed-width digits so the width stays steady (default true).'),
+        era: z.boolean().optional().describe("Years with an era: a negative prints as its magnitude + eraNegative ('30,000 BCE'), a positive + eraPositive ('2026 CE'). No year 0: the count crosses 1 BCE → 1 CE. Years group from five digits only ('1274 BCE'); grouping: false turns that off; prefix / suffix still wrap it."),
+        eraNegative: z.string().optional().describe("Era label for negative years (default 'BCE')."),
+        eraPositive: z.string().optional().describe("Era label for positive years (default 'CE'; '' for a bare year; 'AD' works)."),
+    }).strict(),
+    z.null(),
+]).describe("A text that COUNTS on the scene clock: {from, to, start?, duration?, easing?, decimals?, prefix?, suffix?, locale?, grouping?, padStart?, steps?, tabular?}; null removes it. Exact on every exported frame. To shape the count by hand, keyframe the numeric property counterValue instead.");
 export const CreateItemInputSchema = z.object({
     itemType: ItemTypeSchema,
     position: PositionSchema.optional().default({ x: 400, y: 300 }),
@@ -1164,6 +1214,9 @@ export const CreateItemInputSchema = z.object({
     // 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."),
+    screenSpace: ScreenSpaceSchema.optional(),
+    stepTiming: StepTimingSchema.optional(),
+    counter: CounterSchema.optional(),
 });
 // Light direction for 3D effects
 export const LightDirectionSchema = z.enum([
@@ -1203,6 +1256,9 @@ export const ModifyItemInputSchema = z.object({
     data: ItemDataFlagsSchema.optional(),
     atTime: z.number().min(0).optional().describe('AUTO-KEY: write these properties as keyframes at this time (seconds) instead of a static edit — eased from the previous value, other keys kept.'),
     easing: z.string().optional().describe('atTime: easing of the segment arriving at the new key (default linear).'),
+    screenSpace: ScreenSpaceSchema.optional(),
+    stepTiming: StepTimingSchema.optional(),
+    counter: CounterSchema.optional(),
 });
 // Delete Item
 export const DeleteItemInputSchema = z.object({
@@ -1300,6 +1356,34 @@ export const CharacterInputSchema = z.object({
     ink: z.string().optional()
         .describe("Ink colour for the stroked copies that make the figure read as drawn rather than filled. The style supplies its own; this overrides it."),
 });
+// Character tool aliases (compat with on-device / local model specs)
+export const CreateCharacterInputSchema = z.object({
+    characterId: z.string().optional().describe('Unique character identifier'),
+    name: z.string().optional().describe('Character display name'),
+    x: z.number().optional().describe('X coordinate on canvas (default: 400)'),
+    y: z.number().optional().describe('Y coordinate on canvas (default: 300)'),
+    scale: z.number().optional().describe('Scale multiplier (default: 1)'),
+    preset: z.string().optional().describe('Character preset/concept name (e.g. pp:Pigeon, pp:Character, person, robot)'),
+    concept: z.string().optional().describe('Alias for preset'),
+    base: z.string().optional().describe('Base rig name for original character (person, robot, cat, bird, blob)'),
+    variant: z.record(z.string(), z.unknown()).optional().describe('Variant parameters'),
+    bundle: z.record(z.string(), z.unknown()).optional().describe('Layered character bundle manifest'),
+}).passthrough();
+export const CharacterActionInputSchema = z.object({
+    characterId: z.string().optional().describe('Character identifier'),
+    itemId: z.string().optional().describe('Item identifier (alias for characterId)'),
+    action: z.string().default('walk').describe('Locomotion or motion action: walk, run, locomotion, wave, dance, jump, idle'),
+    speed: z.number().optional().describe('Speed in pixels/sec (default: 100)'),
+    direction: z.number().optional().describe('Movement direction (1 or -1)'),
+    duration: z.number().optional().describe('Duration in seconds'),
+}).passthrough();
+export const CharacterPoseInputSchema = z.object({
+    characterId: z.string().optional().describe('Character identifier'),
+    itemId: z.string().optional().describe('Item identifier (alias for characterId)'),
+    expression: z.string().default('smile').describe('Facial expression: blink, frown, smile, surprise, talk, wink'),
+    duration: z.number().nullable().optional().describe('Duration in seconds'),
+    interval: z.number().nullable().optional().describe('Repeat interval in seconds'),
+}).passthrough();
 // Motion Capture (BVH)
 //
 // FxTool exposes two distinct operations and the difference is the whole point:
@@ -2066,6 +2150,9 @@ export const AgentBatchOperationSchema = z.object({
     // PositionSchema, as create_item takes: [x, y] was refused here (1.6.19 gate).
     position: PositionSchema.optional().describe('Position for create operations: {x, y} or [x, y]'),
     properties: z.record(z.unknown()).optional().describe('Properties for create/modify operations'),
+    screenSpace: ScreenSpaceSchema.optional().describe('create: keep the item fixed in the frame under camera moves (HUD).'),
+    stepTiming: StepTimingSchema.optional().describe("create: step this item's animation (N, {every, baseFps?} or {fps})."),
+    counter: CounterSchema.optional().describe('create (text): count on the scene clock.'),
     // Modify/Animate/Delete/Keyframe/Mask/Effect target
     itemId: z.string().optional().describe('Target item ID or $N reference'),
     // Group operation fields
@@ -2081,6 +2168,7 @@ export const AgentBatchOperationSchema = z.object({
     relationOptions: z.record(z.unknown()).optional().describe('Relation options'),
     // Set background fields
     backgroundColor: z.string().optional().describe('Background color for set_background'),
+    color: z.string().optional().describe('Alias for backgroundColor in set_background, or color property'),
     // Execute generator fields
     generatorName: z.string().optional().describe('Generator name for execute_generator'),
     generatorParams: z.record(z.unknown()).optional().describe('Generator parameters'),
@@ -2097,6 +2185,7 @@ export const AgentBatchOperationSchema = z.object({
     })).optional().describe('Keyframes for keyframe_animate [{time, properties, easing}]'),
     duration: z.number().optional().describe('Duration in seconds for keyframe_animate or play_timeline'),
     loop: z.boolean().optional().describe('Loop for keyframe_animate or play_timeline'),
+    append: z.boolean().optional().describe("For keyframe_animate: add these keys to the item's existing track instead of replacing it (a key at the same time merges, the new values win). Without it the op replaces the track; the op's result says which happened."),
     // Apply mask fields
     maskPreset: z.string().optional().describe('Mask preset for apply_mask (wipeLeft, wipeRight, wipeUp, wipeDown, iris, irisOut, star, heart, curtainHorizontal, curtainVertical, cinematic, diagonalWipe, revealUp, revealDown)'),
     maskType: z.string().optional().describe('Mask shape for apply_mask (rectangle, circle, ellipse, star, triangle, hexagon, heart, rounded)'),
@@ -2107,7 +2196,7 @@ export const AgentBatchOperationSchema = z.object({
     // Play timeline fields
     action: z.string().optional().describe('Timeline action for play_timeline (play, stop, seek)'),
     time: z.number().optional().describe('Seek time for play_timeline'),
-}).describe('Single batch operation');
+}).passthrough().describe('Single batch operation');
 // Group / ungroup — combine the parts of a composite object into ONE draggable entity
 // (a car's body + wheels + windows), or break a group back into loose items.
 export const GroupInputSchema = z.object({
@@ -2914,6 +3003,8 @@ export const ScenePlaybackInputSchema = z.object({
     defaultDuration: z.number().optional(),
     defaultTransition: z.enum(['none', 'fade', 'zoom-in', 'zoom-out']).optional(),
     transitionDuration: z.number().optional(),
+    cutSound: z.union([z.string().min(1), z.object({ sound: z.string().min(1), gain: z.number().min(0).optional(), offset: z.number().optional() }).strict()]).optional()
+        .describe("create_chain: a sound at every cut — a catalogue name, or {sound, gain?, offset? (seconds, + later / − earlier)}. The scene_cut event also fires at each cut ({from, to, time, index})."),
     enabled: z.boolean().optional(),
     index: z.number().optional(),
 });
@@ -3118,7 +3209,7 @@ export const TransformInputSchema = z.object({
 // `pinepaper_media` / `pinepaper_transform` set the precedent.
 export const BrandKitInputSchema = z.object({
     /** 'plan' reports what WOULD change without touching the scene. 'from_url' reads a site into a proposed kit. */
-    action: z.enum(['plan', 'apply', 'from_url']),
+    action: z.enum(['plan', 'apply', 'from_url', 'set', 'get', 'clear']),
     url: z.string().url().optional().describe("from_url: the product's site (http/https). Read in an isolated browser context: the studio is not navigated."),
     screenshots: z.number().int().min(1).max(6).optional().describe('from_url: screenshots taken down the page (default 3).'),
     // Spelled out rather than a loose record. A first version typed this as
@@ -3144,7 +3235,7 @@ export const BrandKitInputSchema = z.object({
     }).optional(),
     selectionOnly: z.boolean().optional(),
 })
-    .refine((v) => v.action === 'from_url' || !!v.kit, { message: 'plan and apply require kit (from_url proposes one)', path: ['kit'] })
+    .refine((v) => !['plan', 'apply', 'set'].includes(v.action) || !!v.kit, { message: 'plan, apply and set require kit (from_url proposes one)', path: ['kit'] })
     .refine((v) => v.action !== 'from_url' || (!!v.url && /^https?:\/\//i.test(v.url)), { message: 'from_url requires an http(s) url', path: ['url'] });
 export const ComponentInputSchema = z.object({
     action: z.enum(['define', 'list', 'instantiate', 'set_override', 'sync', 'update_from_instance', 'detach']),
@@ -3403,6 +3494,33 @@ export const DeformInputSchema = z.object({
     speed: z.number().optional(),
     steps: z.number().optional(),
 });
+// Procedural Hand-Drawn Canvas Animation (Sketchy, Wobble, Stop-Motion, Reveal)
+export const HandDrawnInputSchema = z.object({
+    itemId: z.string().optional().describe('Target item ID (defaults to active selection)'),
+    style: z.enum(['sketchy', 'reveal', 'ink_reveal', 'wobble', 'stop_motion']).optional().describe("Hand-drawn style (default 'sketchy'). wobble and stop_motion are refused with the pinepaper_design_medium call that does it"),
+    mode: z.enum(['sketchy', 'reveal', 'ink_reveal', 'wobble', 'stop_motion']).optional().describe('Alias for style'),
+    roughness: z.number().optional().default(2).describe('Noise magnitude in pixels (default: 2)'),
+    bowing: z.number().optional().default(1).describe('Line bowing curve handle factor (default: 1)'),
+    fps: z.number().optional().describe('wobble/stop_motion: the boil rate handed to pinepaper_design_medium (default: 12)'),
+    posterizeFps: z.number().optional().describe('Alias for fps'),
+    seed: z.number().optional().default(1).describe('PRNG seed for deterministic vertex displacement (default: 1)'),
+    duration: z.number().positive().optional().describe('reveal: seconds to draw the stroke on (default: 2)'),
+});
+// Pen figures (FxTool 671d8a58): app.createFigure builds the ink and a pen and
+// joins them with draws_figure; the catalogue is the engine's (app.listFigures).
+export const PenFigureInputSchema = z.object({
+    action: z.enum(['create', 'list']).optional().describe("'create' (default) draws a figure; 'list' returns the catalogue: id, title and kind."),
+    figure: z.union([z.string(), z.record(z.unknown())]).optional().describe("create: a catalogue id from action 'list' (e.g. 'lorenz', 'lissajous', 'hilbert', 'harmonograph'), or an inline figure spec object."),
+    box: z.object({ x: z.number(), y: z.number(), width: z.number().positive(), height: z.number().positive() }).strict().optional().describe('Where to draw, in canvas px (default: the whole canvas). The figure is fitted by one uniform scale.'),
+    margin: z.number().min(0).max(0.45).optional().describe('Fraction of the box left clear (default 0.06).'),
+    duration: z.number().positive().optional().describe('Seconds the pen takes for the whole figure, pen-up travel included (default 6).'),
+    delay: z.number().min(0).optional().describe('Seconds before the pen starts (default 0).'),
+    loop: z.boolean().optional().describe('Draw the figure again after it finishes (default false: it stays drawn).'),
+    pen: z.boolean().optional().describe('false: the ink only, fully drawn, no pen and no animation (default true).'),
+    strokeColor: z.string().optional().describe("Ink colour (default '#1e293b')."),
+    penColor: z.string().optional().describe("Pen tip colour (default '#e11d48')."),
+    strokeWidth: z.number().positive().optional().describe('Ink width in px (default 2).'),
+}).strict();
 // =============================================================================
 // SPRITE SHEET TOOLS
 // =============================================================================
@@ -3952,6 +4070,105 @@ export const RelightInputSchema = z.object({
     preview: z.union([z.boolean(), z.object({ maxSide: z.number().min(64).max(4096) })]).optional()
         .describe('set: show it in the live preview (capped-resolution overlay); {maxSide} sets the cap.'),
 }).refine((v) => v.action !== 'set' || (Array.isArray(v.lights) && v.lights.length > 0) || v.enabled === false, { message: 'set requires at least one light (or enabled: false)', path: ['lights'] });
+/** pinepaper_emitter — the data-driven particle item (FxTool D29). The engine validates the spec and refuses by name. */
+export const EmitterInputSchema = z.object({
+    action: z.enum(['create', 'set']),
+    itemId: z.string().optional().describe('set: the emitter to change.'),
+    spec: z.record(z.string(), z.unknown()).describe('create: the whole spec. set: the keys to change (merged).'),
+}).refine((v) => v.action !== 'set' || !!v.itemId, { message: 'set requires itemId', path: ['itemId'] });
+/** pinepaper_look (D64): restyle an item, a subtree or the whole scene as a named look. */
+export const LookInputSchema = z.object({
+    action: z.enum(['list', 'describe', 'apply', 'remove', 'get', 'grid']),
+    look: z.union([z.string().min(1), z.record(z.string(), z.unknown())]).optional().describe('describe / apply: a look id from list, or a look spec.'),
+    target: z.string().optional().describe("apply / remove / get: an itemId, or 'scene' (default)."),
+    scope: z.enum(['item', 'subtree', 'scene']).optional().describe('apply: how far the look reaches (default: the item for an id, the scene for scene).'),
+    looks: z.array(z.string()).optional().describe('grid: which looks (default every one).'),
+    cols: z.number().int().positive().optional(), cellWidth: z.number().positive().optional(), t: z.number().min(0).optional(),
+})
+    .refine((v) => !['describe', 'apply'].includes(v.action) || v.look !== undefined, { message: 'describe and apply require look', path: ['look'] });
+/** pinepaper_original_character (D66): an ORIGINAL character from a base rig and a declarative variant. */
+export const OriginalCharacterInputSchema = z.object({
+    action: z.enum(['bases', 'describe', 'random', 'create']),
+    base: z.string().optional().describe('person | robot | cat | bird | blob (bases lists them).'),
+    variant: z.record(z.string(), z.unknown()).optional().describe('create: {palette, features, look, seed, name} — legal values from describe.'),
+    seed: z.number().int().optional().describe('random: same (base, seed) → the same variant.'),
+    fixed: z.record(z.string(), z.unknown()).optional().describe('random: traits every member shares (a look, proportions), merged over the random choice.'),
+    at: z.object({ x: z.number(), y: z.number() }).optional().describe('create: x, and y = the FEET.'),
+    height: z.number().positive().optional().describe('create: drawn height px (default 320).'),
+    scale: z.number().positive().optional().describe('create: multiplier of the default height.'),
+    rig: z.boolean().optional().describe('create: build the skeleton (default true).'),
+})
+    .refine((v) => !['random', 'create'].includes(v.action) || !!v.base, { message: 'random and create require base', path: ['base'] })
+    .refine((v) => v.action !== 'random' || v.seed !== undefined, { message: 'random requires seed', path: ['seed'] });
+/** pinepaper_morph_sequence (D73): one element through N states as a morphs_to chain. */
+export const MorphSequenceInputSchema = z.object({
+    itemId: z.string().describe('The element that morphs (it keeps its id through every state).'),
+    states: z.array(z.object({
+        at: z.number().min(0).describe('Seconds: when the morph INTO this state starts.'),
+        duration: z.number().positive().optional().describe('Seconds the morph takes (default 0.8).'),
+        to: z.string().optional().describe('An existing item whose shape this state takes (it is hidden; it is only the shape reference).'),
+        shape: z.object({
+            itemType: z.string(),
+            position: z.object({ x: z.number(), y: z.number() }),
+            properties: z.record(z.string(), z.unknown()).optional(),
+        }).optional().describe('Or describe the state: it is created hidden as the reference.'),
+    }).refine((s) => !!s.to !== !!s.shape, { message: 'each state takes exactly one of to or shape' })).min(1).max(40),
+    easing: z.enum(['linear', 'easeIn', 'easeOut', 'easeInOut']).optional().describe('Morph easing (default easeInOut) — the morph supports these four.'),
+    camera: z.union([z.boolean(), z.object({ fill: z.number().min(0.05).max(1).optional(), easing: z.string().optional() })]).optional()
+        .describe('true: the camera rides every morph on the same timing, framing each state (fill = share of the frame the state fills, default 0.45).'),
+    sound: z.union([z.boolean(), z.string().min(1)]).optional().describe("true: a whoosh at each morph start; or a catalogue sound name."),
+}).superRefine((v, ctx) => {
+    let end = -Infinity;
+    [...v.states].sort((a, b) => a.at - b.at).forEach((s, i) => {
+        if (s.at < end - 1e-6)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: `state at ${s.at} s starts before the previous morph ends at ${end} s`, path: ['states', i, 'at'] });
+        end = s.at + (s.duration ?? 0.8);
+    });
+});
+/** pinepaper_render_hook — per-frame drawing saved as SOURCE (FxTool D29). */
+export const RenderHookInputSchema = z.object({
+    action: z.enum(['register', 'unregister', 'list']),
+    id: z.string().min(1).optional(),
+    source: z.string().min(1).optional().describe('register: JS that evaluates to (ctx, t, info) => {}.'),
+    layer: z.enum(['above', 'below']).optional(),
+    deterministic: z.boolean().optional(),
+    seed: z.number().int().optional(),
+}).refine((v) => v.action === 'list' || !!v.id, { message: 'register / unregister require id', path: ['id'] })
+    .refine((v) => v.action !== 'register' || !!v.source, { message: 'register requires source', path: ['source'] });
+/** pinepaper_choreograph — beat verbs compiled to one squash-and-stretch track (D67). */
+const ChoreoPointSchema = z.union([z.tuple([z.number(), z.number()]), z.object({ x: z.number(), y: z.number() })]);
+const ChoreoEdgeSchema = z.enum(['left', 'right', 'top', 'bottom']);
+export const CHOREO_VERBS = ['pop', 'drop', 'hop', 'bounce', 'roll', 'fly', 'peek', 'shake', 'squash', 'enter', 'exit'];
+export const ChoreographBeatSchema = z.object({
+    at: z.number().min(0).describe('Seconds. Beats run one after another; one that starts before the previous ends is refused.'),
+    verb: z.enum(CHOREO_VERBS),
+    to: ChoreoPointSchema.optional().describe('Where the actor ends up (its centre, canvas px): hop / bounce / roll / fly / drop / enter. roll and fly require it.'),
+    duration: z.number().positive().optional().describe('Seconds for this beat (each verb has a sensible default).'),
+    height: z.number().positive().optional().describe('hop / bounce: jump height px (default 1.2× / 1.5× the actor).'),
+    times: z.number().int().min(1).max(12).optional().describe('bounce: number of bounces (default 3).'),
+    decay: z.number().min(0.1).max(0.95).optional().describe('bounce: each bounce is this fraction of the last (default 0.6).'),
+    arc: z.number().optional().describe('fly: how far above the higher end the path rises, px (default 2× the actor).'),
+    edge: ChoreoEdgeSchema.optional().describe('peek: the frame edge it peeks from (default left). exit: the edge it leaves by (default right).'),
+    from: ChoreoEdgeSchema.optional().describe('enter: the frame edge it comes in from (default left).'),
+    amount: z.number().min(0).max(1).optional().describe('peek: how much of it shows, 0..1 (default 0.5). squash: depth (default 0.25).'),
+    hold: z.number().min(0).optional().describe('peek: seconds it stays out (default 1).'),
+    intensity: z.number().positive().optional().describe('shake: px each way (default 8% of its width).'),
+}).strict().superRefine((b, ctx) => {
+    if ((b.verb === 'roll' || b.verb === 'fly') && !b.to)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: `${b.verb} needs to: [x, y]`, path: ['to'] });
+    if (b.verb === 'exit' && b.to !== undefined)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'exit leaves by an edge: pass edge (left | right | top | bottom), not to', path: ['to'] });
+});
+const ChoreoSoundName = z.union([z.string().min(1), z.literal(false)]);
+export const ChoreographInputSchema = z.object({
+    itemId: z.string().describe('The actor: any item — a shape, a group, an imported SVG character, a photo cut-out.'),
+    beats: z.array(ChoreographBeatSchema).min(1).max(60),
+    sound: z.union([z.boolean(), z.object({
+            pop: ChoreoSoundName.optional(), whoosh: ChoreoSoundName.optional(),
+            contact: ChoreoSoundName.optional(), shake: ChoreoSoundName.optional(),
+            gain: z.number().min(0).max(1).optional(),
+        }).strict()]).optional().describe("true: a sound on every pop, launch, landing and shake, its loudness following the motion (a bounce's contacts get quieter as it decays). An object picks the sound per moment by catalogue name (an SFX — beep, pop, wind, whoosh, zap — or a drum — kick, snare, tom, hat, clap — or one you defined), false to leave one silent, and gain 0..1. Placed on the timeline, baked into video and render_soundtrack."),
+});
 /**
  * pinepaper_shader_graph — validated JSON pixel graphs (FxTool D5), CPU-backed.
  * Linear chains only; the engine names every error (unknown type, duplicate,
@@ -4322,6 +4539,7 @@ export const StoryInputSchema = z.object({
     spec: z.record(z.string(), z.unknown()).optional().describe('apply_spec: the story spec — usually one from `distill`, edited.'),
     images: z.array(z.union([z.string(), z.record(z.string(), z.unknown())])).optional().describe('plan_book: the images to lay out, as ids or specs.'),
     options: z.record(z.string(), z.unknown()).optional().describe('Assembly or layout options, passed through.'),
+    nav: z.enum(['panels', 'scenes']).optional().describe("from_text / apply_spec: 'scenes' is the VIDEO form — one scene per part on a scene chain, cut in time (export it as MP4); 'panels' (default) the WIDGET form — tabs a viewer clicks through (export_widget_html)."),
 })
     .refine((v) => !['distill', 'from_text'].includes(v.action) || !!v.text, { message: 'this action requires text', path: ['text'] })
     .refine((v) => v.action !== 'apply_spec' || !!v.spec, { message: 'apply_spec requires spec', path: ['spec'] })
@@ -4659,4 +4877,88 @@ export const RiggingInputSchema = z.object({
     .refine((v) => !['import_bvh', 'retarget_bvh'].includes(v.action) || !!v.bvhText, { message: 'import_bvh/retarget_bvh require bvhText (the .bvh file contents)', path: ['bvhText'] })
     .refine((v) => v.action !== 'retarget_bvh' || v.skeletonId != null, { message: 'retarget_bvh requires skeletonId (the existing rig to drive)', path: ['skeletonId'] })
     .refine((v) => v.action !== 'import_spine' || !!v.spineJson, { message: 'import_spine requires spineJson', path: ['spineJson'] });
+// =============================================================================
+// CRAFT TOOLS SHARED WITH THE CLOUD (1.6.21): weave, knots, sashiko,
+// subdivision, UI kit. The JSON schemas are mcp-cloud's, vendored by
+// scripts/sync-design-systems.mjs; schema-parity.test.ts holds these to them.
+// The generators write colours into the script inside quotes and numbers bare,
+// so every value is checked here, before it becomes code.
+// =============================================================================
+const CRAFT_COLOUR = /^(#[0-9a-f]{3,8}|rgba?\([\d\s.,%]+\)|hsla?\([\d\s.,%deg]+\)|[a-z]{3,20})$/i;
+const CraftColour = z.string().trim().regex(CRAFT_COLOUR, 'a colour: #rrggbb, rgb(…), hsl(…) or a CSS name');
+const CraftNumber = z.number().finite();
+const CraftBounds = z.object({
+    x: CraftNumber.optional(),
+    y: CraftNumber.optional(),
+    width: z.number().finite().positive().optional(),
+    height: z.number().finite().positive().optional(),
+}).describe('Rectangle to fill. Default: the canvas.');
+export const DrawWeaveInputSchema = z.object({
+    weave: z.enum(['plain', 'twill', 'basket', 'herringbone']).optional(),
+    warpColor: CraftColour.optional(),
+    weftColor: CraftColour.optional(),
+    threadThickness: z.number().finite().positive().max(64).optional(),
+    density: z.number().finite().min(4).max(400).optional(),
+    floatRatio: z.number().finite().min(1).max(16).optional(),
+    twillVariant: z.enum(['standard', 'herringbone']).optional(),
+    chevronWidth: z.number().finite().positive().max(4000).optional(),
+    bundleSize: z.number().int().min(1).max(16).optional(),
+    bundleGap: z.number().finite().min(0).max(200).optional(),
+    slubJitter: z.number().finite().min(0).max(4).optional(),
+    opacity: z.number().finite().min(0).max(1).optional(),
+    bounds: CraftBounds.optional(),
+});
+const KnotPoint = z.object({
+    x: CraftNumber,
+    y: CraftNumber,
+    radius: z.number().finite().positive().max(500).optional(),
+    color: CraftColour.optional(),
+    highlightColor: CraftColour.optional(),
+    shadowColor: CraftColour.optional(),
+    length: z.number().finite().positive().max(2000).optional(),
+    angle: CraftNumber.optional(),
+});
+export const DrawKnotsInputSchema = z.object({
+    knotType: z.enum(['french_knot', 'bullion_roll', 'knot_anchor']).optional(),
+    points: z.array(KnotPoint).max(2000).optional(),
+    threadColor: CraftColour.optional(),
+    highlightColor: CraftColour.optional(),
+    shadowColor: CraftColour.optional(),
+    defaultRadius: z.number().finite().positive().max(500).optional(),
+});
+export const DrawSashikoInputSchema = z.object({
+    pattern: z.enum(['seigaiha', 'asanoha', 'hishi', 'kaki_no_hana']).optional(),
+    stitchLength: z.number().finite().positive().max(200).optional(),
+    gapLength: z.number().finite().min(0).max(200).optional(),
+    vertexGap: z.number().finite().min(0).max(200).optional(),
+    scale: z.number().finite().min(8).max(1000).optional(),
+    concentricArcs: z.number().int().min(1).max(12).optional(),
+    threadColor: CraftColour.optional(),
+    groundColor: CraftColour.optional(),
+    threadWidth: z.number().finite().positive().max(64).optional(),
+    bounds: CraftBounds.optional(),
+});
+export const DrawSubdivisionInputSchema = z.object({
+    preset: z.enum(['mondrian', 'swiss', 'bauhaus', 'minimal', 'custom']).optional(),
+    maxDepth: z.number().int().min(1).max(8).optional(),
+    minDepth: z.number().int().min(0).max(8).optional(),
+    splitBias: z.array(z.number().finite().min(0.05).max(0.95)).length(2).optional(),
+    colorProbability: z.number().finite().min(0).max(1).optional(),
+    nestedProbability: z.number().finite().min(0).max(1).optional(),
+    dividerWidth: z.number().finite().min(0).max(200).optional(),
+    dividerColor: CraftColour.optional(),
+    groundColor: CraftColour.optional(),
+    accentColors: z.array(CraftColour).max(16).optional(),
+    cellInset: z.number().finite().min(0).max(200).optional(),
+    bounds: CraftBounds.optional(),
+    seed: z.number().int().optional(),
+    idPrefix: z.string().regex(/^[A-Za-z][\w-]{0,40}$/, 'letters, digits, _ and -').optional(),
+});
+/**
+ * The UI kit's own lowering (vendor/design/ui-kit-tool-schema.ts) whitelists,
+ * types and JSON-encodes every argument, so only the action is checked here.
+ */
+export const UiKitInputSchema = z.object({
+    action: z.enum(['phone_lock_screen', 'notification', 'prompt_box', 'toggle', 'ad_card', 'calendar_card']),
+}).passthrough();
 //# sourceMappingURL=schemas.js.map