← PicsartCONTENT HISTORY

Update to Picsart

Snapshot Nov 11, 2026 · 00:08 UTC · version 2.5.0

Collection source: downloaded plugin package.

WHAT CHANGED

Instructions updated for character-rigging

Full description — Now says: rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync, a cut-out puppet built from named...

Observed in instructions or declared skills. Runtime behavior has not been tested.

Save Picsart and check future changes in Following.

Up to 3 plugins free · no card required.

All fields and original values.

Full description

Before

Nov 7, 2026 · 00:09 UTC

rig-face, their control names and ranges, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting...

After

Nov 11, 2026 · 00:08 UTC

rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync, a cut-out puppet built from named SVG parts, sockets, reach and held props — and the craft of morphing a shape's ...

Skill instructions

Before

Nov 7, 2026 · 00:09 UTC

rig-face, their control names and ranges, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting...

After

Nov 11, 2026 · 00:08 UTC

rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync, a cut-out puppet built from named SVG parts, sockets, reach and held props — and the craft of morphing a shape's ...

Supporting files

Before

Nov 7, 2026 · 00:09 UTC

[{"relative_path":"references/art-mesh.md","size_in_bytes":9305},{"relative_path":"references/character-motion.md","size_in_bytes":19529},{"relative_path":"references/layer-follow-through.md","size_in_bytes":1217},{"relative_path":"refer...

After

Nov 11, 2026 · 00:08 UTC

[{"relative_path":"references/art-mesh.md","size_in_bytes":9305},{"relative_path":"references/character-motion.md","size_in_bytes":20752},{"relative_path":"references/cut-out-puppet.md","size_in_bytes":12651},{"relative_path":"references...

Compare saved observations

Download comparison JSON

SKILL.md text changes

− removed · + added

--- before
+++ after
@@ -1,10 +1,10 @@
 ---
 name: character-rigging
-description: Build and animate a 2D cartoon character in a scene — rig-humanoid and rig-face, their control names and ranges, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting, choosing between outline keyframes, morph targets, per-vertex tracks and outline expressions, blend-target hygiene, timing (anticipation, overshoot, holds), volume-keeping squash, face visemes and blinks, scene-to-scene morph transitions, bending a picture over an art mesh, and explicit skin weights. Use when a cartoon character, mascot or face walks, waves or talks; when a path's outline changes shape over time — one drawing becomes another; a jelly, blob or character squashes, stretches, bounces, wobbles or breathes; a cartoon face talks (lip sync, mouth shapes), smiles or blinks; a cut is hidden by a morph; or an image, text or composition has to bend.
+description: Build and animate a 2D cartoon character in a scene — rig-humanoid and rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync, a cut-out puppet built from named SVG parts, sockets, reach and held props — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting, choosing between outline keyframes, morph targets and per-vertex tracks, blend-target hygiene, timing (anticipation, overshoot, holds), volume-keeping squash, face visemes and blinks, scene-to-scene morph transitions, bending a picture over an art mesh, and explicit skin weights. Use when a cartoon character, mascot or face walks, waves or talks; when a path's outline changes shape over time — one drawing becomes another; a jelly, blob or character squashes, stretches, bounces, wobbles or breathes; a cartoon face talks (lip sync, mouth shapes), smiles or blinks; a cut is hidden by a morph; or an image, text or composition has to bend.
 metadata:
   category: authoring
   version: '1.7'
-  ported-from: shape-morphing 1.7 at 55.104.0
+  ported-from: shape-morphing 1.7 at 55.130.0
 ---
 
 # Cartoon characters and shape morphing
@@ -31,9 +31,10 @@
 
 ## 0. Cartoon character rigs
 
-A 2D cartoon character starts from a catalog rig when one fits, not from a 3D
-model and not from hand-written joint Lua; one no rig fits is built by hand from bent limbs and `ik`
-([references/character-motion.md](references/character-motion.md)), its ink lines
+A 2D cartoon character starts from a catalog rig when one fits, or from `picsart_scene_build_model` with
+`character: {svg, duration: 4}` for named SVG parts ("Named SVG cut-outs" below); without `svg` that tool builds a 3D
+model. Not from hand-written joint Lua: one no rig fits is built by hand from bent limbs and `ik`
+([references/character-motion.md](references/character-motion.md), which also builds an arm as one shape), its ink lines
 pointed at the ends with a stroke `taper` ("Ink lines" below).
 `picsart_scene_templates` with `tags: ["cartoon", "rig"]` lists them:
 
@@ -64,12 +65,13 @@
 | both | `lookUp`, `lookDown`, `lookLeft`, `lookRight` | 0..1 | irises' direction; `lookLeft` is + x on screen (on the humanoid an eye turned away travels less across) |
 | both | `ih`, `ou`, `ee`, `oh` | 0..1 | the other visemes |
 | humanoid | `browInnerUp`, `browOuterUpLeft`, `browOuterUpRight`, `eyeWideLeft`, `eyeWideRight` | 0..1 | both brows' inner ends up; one brow's outer end up; one eye opened wide (a blink still shuts it) |
-| face | `sad`, `angry`, `surprised`, `relaxed` | 0..1 | moods (mouth, eyes, brows) |
+| face | `sad`, `angry`, `surprised`, `relaxed` | 0..1 | moods (mouth, eyes, brows); the humanoid rigs and `rig-face` carry them with `happy`. The six mood actions are `happy`, `sad`, `angry`, `surprised`, `scared` (sad + surprised + `browInnerUp`) and `sleepy` (relaxed): no `scared` or `sleepy` dial |
 | humanoid | `spineLean`, `hipsRaise`, `hipsTilt` | −1..1 | torso lean ±20° (+ forward); hips ±60 px (+ up); pelvis roll ±10° (+ clockwise, the + x hip drops), the legs following on their IK and the shoulders tilting against it |
 | humanoid | `breath` | 0..1 | breath: the chest swells, shoulders and head rise |
-| humanoid | `<side>UpperArmSwing` / `UpperArmRaise` / `LowerArmSwing` / `HandSwing` | −1..1 / 0..1 / 0..1 / −1..1 | arm ±80° (+ forward); raised forward and up 0..160° (0 hangs, 0.5 forward, 1 overhead); elbow 0..150°; wrist ±40° |
+| humanoid | `<side>UpperArmSwing` / `UpperArmRaise` / `UpperArmOpen` / `ShoulderRaise` / `LowerArmSwing` / `HandSwing` | −1..1 / 0..1 / 0..1 / 0..1 / −1..1 / −1..1 | arm ±80° (+ forward); raised forward and up 0..160° (0 hangs, 0.5 forward, 1 overhead; the front view draws it foreshortened); opened out to the side and up 0..180° (0 hangs, 0.5 sideways, 1 overhead; drawn foreshortened as it opens toward or away from the camera on the side and three-quarter views); shoulder lifted 15 px at 1 (the shrug); elbow ±150° (+ folds forward, toward the midline on a front view; − the other way: up beside the head on an opened near arm; on the far three-quarter arm, which opens forward, up beside the head is +); wrist ±40° |
 | humanoid | `<side>UpperLegSwing` / `LowerLegSwing` / `FootSwing` | −1..1 / 0..1 / −1..1 | leg ±70°; knee 0..140° (elbow and knee limits are their bends' `min`/`max`, binding IK too); toe up ±35° |
-| humanoid | `<side>HandSpread`, `<side>HandPoint`, `<side>HandFist` | 0..1 | hand poses on a palm, four fingers and a thumb, the relaxed open hand at 0: fingers fanned (the waving hand), the index pointing, a fist; the three share the hand (scaled to 1 above a sum of 1, the relaxed hand filling the rest), so a crossfade is two keyed weights |
+| humanoid | `<side>HandSpread`, `<side>HandPoint`, `<side>HandFist`, `<side>HandGrip`, `<side>HandThumbsUp` | 0..1 | hand poses on a palm, four fingers and a thumb, the relaxed open hand at 0: fingers fanned (the waving hand), the index pointing, a fist, curled fingers with an opposing thumb (grip), the thumb out from curled fingers; the five share the hand (scaled to 1 above a sum of 1, the relaxed hand filling the rest), so a crossfade is two keyed weights over 0.4 s, `ease_in_out`; every pose has the same path topology, so there is no swap between duplicate hands. A grip is a silhouette, not a prop contact |
+| humanoid | `held`, `heldBy`, `<side>HandToHeld`, `<side>HandHeldAt` | clip / right·left·chest·mouth·none / 0..1 / vec2 | the prop the character holds, who carries it, a hand brought onto it, and where on the prop that wrist lands ([references/sockets-and-props.md](references/sockets-and-props.md)) |
 | humanoid | `<side>HandIk`, `<side>FootIk` | 0..1 | the limb's `ik` `mix`: from the swings to the target (feet default 1, hands 0) |
 | humanoid | `<side>HandX/Y`, `<side>FootX/Y` | −400..400 | the target layer, rig px from the resting wrist or ankle |
 | humanoid | `hairSway`, `hairRaise`, `earSway` | −1..1 | follow-through, morphs inside the head: hair and quiff swing (+ toward + x), hair raise (+ up), ear rim swing (+ toward + x); key them a few frames behind the head |
@@ -78,25 +80,44 @@
 
 `<side>` is `left` (the far side, behind the body) or `right` (the near side).
 
+**Named SVG cut-outs.** An editable vector character from an approved SVG drawing, with no generation, bitmaps or Blender:
+`picsart_scene_build_model` with `character: {svg, view, duration}` replies `{scene, sockets}`. Pass `svgUrl`, the `url` of the generation result that drew the sheet, in place of `svg`: the server fetches it (Picsart-hosted https only), so the markup never passes through your context. `view` is `front`, `threeQuarter` or `side` (a multi-view
+sheet without `view` is refused; a single-view SVG declares `data-view` and `data-facing`).
+
+- **Draw the sheet from the frozen turnaround prompt** in [references/part-sheet-prompt.md](references/part-sheet-prompt.md): one 1536×1024 sheet, front and three-quarter A-poses, relaxed profile, same outfit, complete overlapping parts, full-width far arm, one closed hair mass, round strokes, optional gradients. The whole body must be requested turned; near side = ear side.
+- **Check before building.** `character: {svg, check: true}` checks the whole sheet and builds nothing. Open `pictureCheck.path` (body | near arm+leg | far arm+leg in each view row) and read its named pass/fail checks for parts, joint union, far-arm width, hair closure and head group. Check proportions, arm and neck/collar order and complete parts with markers hidden, and get the user's OK on the picture before building; an approved picture stays valid.
+- **The builder owns sides and order.** Geometry assigns character sides (front right = image-left; facing right, right = near = the image-left ear side; facing left, left = near = image-right); source suffixes and socket labels are advisory. Role order throughout motion: far hand < lowerArm < upperArm < torso < near upperArm < hand < lowerArm; head above neck and torso; neck below the collar. Rest angles come from the source joints; presets use absolute targets.
+- **Parts:** torso, head, optional hips and neck, paired upperArm, lowerArm, hand, upperLeg, lowerLeg, foot, and skirt, coat, coatBack, tail, scarf, backpack, cap, straps, strapL, strapR, hairBack (follows the head, below the torso). A named skirt keeps its complete hem rigid on the hips; other lower garments share hip and thigh skin. A marker lies in the union of adjacent parts or the covering garment (four source px edge tolerance, twelve on hidden far parts); paired links normalise within 8%. Exactly one unnamed top-level non-marker group may supply an absent head.
+- **Face and hands.** Named head `eyeL/R`, nested `pupilL/R`, `browL/R`, `mouth` and `hairFront` expose blink, look, brow and closed-mouth viseme controls; the profile hides the far eye and brow, and brows draw over hair. No mouth artwork is invented, and unnamed face art stays static. Hands and shoes stay rigid unless a complete matching set of hand poses is authored. Unsupported SVG constructs refuse by id; linear and radial gradients are supported.
+- **Walk it.** Side defaults are stride 160 rig px (±80), lift 40 and armSwing .22; the three-quarter view scales stride and armSwing by cos 45° (113, .16) and keeps lift 40, and turned views walk with closed arms. Explicit arguments win. Prefer three-quarter or side for walks and front for rest, idle and face shots. Hosting, framing and the walk are tool calls only (the "Prompt to walk" steps in the sheet reference).
+
+Rig behaviour (controls, a garment over the legs, draw order) and the checks to run after a build: [references/cut-out-puppet.md](references/cut-out-puppet.md).
+
 **IK.** A limb on IK puts its wrist or ankle on the target and bends at the elbow or knee to reach it
 (knees fold forward, elbows back); a target out of reach straightens the limb toward it. The swings
 still pose the limb under a partial `mix`. The targets are in the rig's own space and stay where they
 are while the body moves, so a foot that keeps its target is planted: lower
-`hipsRaise` and the knees bend. To touch something, set `<side>HandIk` 1 and key `<side>HandX/Y`.
+`hipsRaise` and the knees bend. To touch something, set `<side>HandIk` 1 and bind the absolute, composition-space `<side>HandTarget` parameter; its default follows `<side>HandX/Y` offsets from the resting wrist. The parameter drives the same-named target layer, whose final placement is the arm solve's goal, so an `attach` or `ik` constraint on that layer overrides the input through the same path. Those constraints stay inside the rig's composition; a parent binds inputs through the instance and reads its published sockets, without addressing internal layers.
+
+**Sockets, reach and held props.** A placed character publishes sockets (`head`, `chin`, `chest`, hands, grips, feet, `seat`, `mouth`, `held`; a dog or cat `mouth`, paws, `body`, `tail`): a parent targets `{"layer", "socket"}` and Lua reads `getSocket`. A `reach` constraint on the instance layer puts a socket on a stage point (`{"type": "reach", "socket": "rightHand", "target": {"layer": "ball"}, "mix": 1}` lands a hand on a ball; `"seat"` on a bench seats the character). A humanoid rig or a dog or cat holds a prop itself through `held` and `heldBy` (`right`, `left`, `chest`, `mouth`, `none`; an animal only `mouth` or `none`), two hands by `<side>HandToHeld`. Tables, the `via` dial, carriers and worked cases: [references/sockets-and-props.md](references/sockets-and-props.md).
+
+**Read the bone map.** `picsart_scene_inspect` with `mode: "rig"`; pass an embedded rig asset key as `scope` and optionally `layer` for a subtree. Read entries in order, indenting by `level`: hips first, parents before children. The map derives bones from skins and constraints, so an unreferenced joint mark is absent; `parentId` is parenting, not art ownership. A standard name is that bone (`leftUpperArm` names the left upper arm). Keep imports' source names; any non-standard layer, including an imported bone or a plain parent frame, reads `helper` (IK targets read `target`); a helper is an ordinary layer, not a separate skeleton declaration. Placements resolve `$eval` at scoped parameter defaults, without use-site bindings: read them as authored rest, not a posed measurement. Drivers are lexical reads; Lua, time tracks, poses and automatic weights are not evaluated. Use `picsart_scene_query_layout` for evaluated geometry.
 
 **Gesture arms: raise × elbow.** Up to a 60° raise (`UpperArmRaise` ≤ 0.375), the natural
-elbow bend folds the hand onto the face. Measured safe pair for a wave or a talking gesture:
+elbow bend folds the hand onto the face. Measured safe pair for a talking gesture, a point or a shrug:
 `UpperArmRaise` 0.25–0.36 with `LowerArmSwing` 0.45–0.55. Unsafe, hand at the nose or mouth: raise 0.36
 with elbow 0.85, raise 0.2 with elbow 0.7. Swing the hand with `HandSwing`, not by bending the elbow
 further, and check a `picsart_scene_contact_sheet` for the hand against the head.
 
+**The wave rule** (stated once; the presets, the actions and the robot all follow it). A wave keys one world pose: the arm out and up beside the head, the forearm up (an opening near 0.7). Where that pose runs through the arm's pole (pointing at the camera) on a 2D rig, the preset keys the in-plane dial instead, picking its row by the rig's `viewAngle`, with the forearm's sign following the view's + side: one preset, three rows, no new control. Front (0): `UpperArmOpen` 0.68–0.76 with `LowerArmSwing` −0.2 to −0.35. Three-quarter (45) and side (90): `UpperArmRaise` 0.5–0.6 with `LowerArmSwing` +0.25 to +0.35, the hand standing in front of the head, clear of the face. `HandSwing` swings on every row.
+
 **Draw order.** The far arm and leg draw behind the torso and the near ones in front, by document
 order; an arm hangs outside its thigh, so the far arm draws behind the far leg and the near arm in
-front of the near leg. An `ik` chain authors no depth, so the order holds in every pose: a raised far
+front of the near leg. An `ik` chain authors no depth (a `z` within ±1, static or a keyed `by` track with no expression, only orders the drawing and is allowed on a chain bone), so the order holds in every pose of a flat scene: a raised far
 arm stays behind the head (wave with the near arm, or the far arm forward beside the face), and a far
 hand swung forward past the far thigh stays behind it. The near hand shows its back, the far hand its
 palm; both thumbs sit on the forward edge. A turned face's far ear goes behind the head, driven by
-`headTurn`: don't key `z` yourself.
+`headTurn`: don't key `z` yourself. The order holds only while the whole composition is flat: put one layer in depth (a `z` beyond ±1, an expression `z`, `rotationX`/`rotationY`) or orbit the camera and every `z` of the scene, the rig's too, is depth (an `ik`, `skin`, `follow_through` or preset travel on a chain is then refused, and the validator warns `z_order_mixed_with_depth`).
 
 **Motion.** Everything goes on the rig's `scene_ref` layer with `picsart_scene_apply_preset`
 (`preset` `motionPreset:<id>`, `layerId` the rig layer), and writes bindings in its `content.parameters`:
@@ -126,8 +147,8 @@
 - Gestures (tag `rig-motion`, `gesture`): `wave`, `talk_beat`, `point` and `shrug`, each `start`,
   `duration` (seconds from the arm leaving rest to its return), `amount` 0..1, and for `wave`, `talk_beat`
   and `point` a `side` (`right` the near arm, `left` the far one); `wave` and `talk_beat` also `count`
-  (swings or beats). They lift the arm inside the safe pair (raise 0.25 to 0.36 at an elbow of 0.45 to
-  0.55, so the hand stays off the face) and return every control to rest. `wave`: the hand swings from the
+  (swings or beats). They return every control to rest (`wave` keys the wave rule above; the others lift the arm inside the safe pair, raise 0.25 to 0.36 at an
+  elbow of 0.45 to 0.55, so the hand stays off the face). `wave`: the hand swings from the
   wrist `count` times. `talk_beat`: the forearm beats with the speech, the hand follows. `point`: the arm's
   IK takes the wrist to `targetX`, `targetY` (rig px from where it rests, y down, default up and
   forward); the limb straightens toward a target out of reach, and the hand forms a point (`HandPoint`). `shrug`: both arms, the hands turned, the
@@ -153,6 +174,25 @@
   which it leaves free. The clips key standard
   names only, so any rig with them acts. One `action` serves every rig in its scene: give each character its own scene to act
   apart.
+- Actions (tag `rig-motion`): `jog`, `jump`, `think` and `idle`, each `start`, on every humanoid rig (rig-humanoid,
+  rig-humanoid-front, a cut-out of either view). `jog` loops in place: `stepDuration` (0.3 or less) per step, both feet
+  off the ground for about 0.4 of it, `lift`, `bob`, `armSwing`, `elbow`, `lean`; `view` `side` (default) swings the feet
+  fore and aft over `stride` / 4 (pair it with `ground_scroll`, `pace` `constant`, the same `stride`), `front` for
+  rig-humanoid-front or a front cut-out lifts them on the spot. `jump` (`duration` 1.2, `height` up to 60, `tuck`,
+  `crouch` 1, `view`): crouch of the hips' full 60 px with the arms back, spring, knees tucked at the top, land, take
+  the landing and settle on the rest pose; the rise is the hips' own, so the figure stays in its frame. `think`
+  (`duration` 3, `side`): the arm's IK reaches toward the rig's chin and holds through the middle 40%, the other arm
+  hangs; it keys `<side>HandIk` and `<side>HandToChin` (0..1, default 0), which blends the `<side>HandTarget` layer toward
+  an `attach` target on the head (the chin plus the rig's wrist-contact offset, carried through the head's placement and
+  deformers), so contact geometry stays inside the rig. `idle` (`period` 3, `amount`): breath, head sway a quarter
+  period behind it, a weight shift and one blink a period, looping seamlessly, the arms left at the sides.
+  Each rig also declares `<side>AnchorShoulder` and `<side>AnchorEye` (vec2, absolute rig px): the shoulder a `point`
+  aims from and the eye its head follows; a rig missing one is refused (`rig_parameters_missing`). Every humanoid rig
+  declares read-only `viewAngle` (degrees from facing the camera: front 0, three-quarter 45, side 90), read into a
+  preset's scope beside the anchors; a rig that declares none is not assumed to be a side view, and `point` is refused
+  by the name. The anchors and the angle are the rig's own geometry: a `scene_ref` binding one is refused by name. An
+  arm opened toward the lens has no direction on a side or three-quarter view, so its drawn length fades to nothing
+  there and the forearm takes its direction from the arm's 3D pose; no joint jumps.
 - Everything else is a parameter driver with `parameter` naming the rig's control — the "Parameter
   drivers" table in [references/character-motion.md](references/character-motion.md):
   `random_pulse` on `blink`, `cycle` on `breath` (sine, ~3.5 s, `to` ≈ 0.6), `random_hold` on the
@@ -169,7 +209,7 @@
 you keyed by hand, replaces that binding and says so in `notes`.
 
 Verify a walk on a contact sheet (`picsart_scene_contact_sheet`): the legs alternate, the arms swing
-against them, and the planted foot does not slide.
+against them, and the planted foot does not slide. `lift` is the foot's clearance in rig px, not a 0..1 dial: a walk lifts about 24–40, a run up to about 100, and `lift: 1` barely steps. After setting the walk or jog numbers, check one loop with `picsart_scene_check_motion` `value_range` on `<side>FootArt` `centerY` for both feet (the amplitude, in the host's root pixels, is at least 0.8 × `lift` × the rig layer's scale: a rig placed at 0.25 moves a quarter as far), and look at the frames for clearance and for contact alternating. Show a walk, jog or run only in the three-quarter or side view, never the front view: the front view gets the rest or idle pose and face acting.
 
 **Ink lines.** A hand-drawn line thins at its ends and swells in the middle: a stroke with a `taper`.
 
@@ -184,46 +224,7 @@
 the outline as drawn, after a `bend` or a `trim`, so a bent limb keeps its thin ends and a draw-on
 keeps its point on the moving end. `wave` swells and narrows the width along the line.
 
-**A 2D head turn.** `headTurn` (0 face on, ±1 a three-quarter view, + toward + x) and `headTilt`
-are the one turn and tilt dials of both rigs: key them, never the features. rig-face turns its
-features on their layers' transforms (`nose`, `leftEye`/`rightEye`, the brows, `mouth`, the ears),
-so a drawing put in a feature layer turns the same way. A face built by hand turns the same way:
-
-- **Depths.** Each feature turns round the head's vertical axis at its own depth `r`, starting at
-  angle `φ = asin(x / r)` for its face-on `x`: `x = r · sin(φ + a)`, `a` the turn's angle (rig-face:
-  40° at ±1). The nose stands proudest (rig-face 250 px on a 500 px head), then the mouth (210),
-  then the eyes and brows (190); the outline moves least, by its morph. A nod moves each feature
-  round the head's centre too, and a feature nodded low turns at the narrower jaw: scale `r` by the
-  head's width at its new height.
-- **Eyes.** The far eye is the one on the side the face turns toward: it narrows (scale x
-  `cos(φ + a) / cos φ`, held at 0.55 or more), moves less and ends near the silhouette. The near
-  eye keeps its width or grows a little (up to 1.08) and moves more. Both pupils lead the turn
-  (rig-face: 16 px at ±1). Brows narrow with their eyes.
-- **Outline.** Give the head outline a `turnRight` and a `turnLeft` morph target (the mirror),
-  weighted by `max(0, ±sin a) / sin a_max`. Move the points mostly along x: the cheek and brow ridge
-  push out on the face side, the jaw and chin come round more than the crown, the back flattens.
-  Keep the handles, and lengthen them only where the outline flattens, so it stays round. Hair
-  morphs with it, its fringe wrapping round with the face. Check every outline at a sweep of turns
-  for a self-crossing: a fringe end that slides past the tip it hangs from loops there.
-- **Ears.** Hang each ear on the outline's side at its height and slide it round with that side,
-  not on the turning sphere: an ear placed past the 90° silhouette swings against the turn while
-  the outline moves with it, and comes away from the head. The near ear widens and comes over the
-  side toward the cheek, the far one narrows and tucks behind the outline; both move the way the
-  face turns and touch the outline at every turn. Each ear's `z` follows the turn's sign: the near
-  ear 1, over the head, the far one −1, behind it. Stand both ears just clear of the outline face on,
-  so the swap at 0 changes nothing drawn.
-- **Timing.** Lead with the eyes: the pupils (`look*`) a few frames before the head. Then key the
-  turn past where it settles and back: to 0.95 and settle at 0.85 over about 0.2 s. Keys outside the
-  dial's `min`/`max` warn, so the overshoot stays inside ±1. Hair and ears trail by a couple of
-  frames (`hairSway`, `earSway` on the humanoid).
-- **Profile.** Beyond about 0.8 a three-quarter drawing stops reading; swap to a profile drawing
-  with `step` keys `by` the dial: its `opacity` `{"by": "headTurn", "keyframes": [{"at": 0.8, "value": 0,
-  "easing": "step"}, {"at": 0.81, "value": 1}]}`, and the front features' `opacity` the reverse. A full
-  turnaround needs a drawing per angle.
-- **Several characters from one rig.** Set `headSize`, `hairStyle` and `faceShape` per instance (the `scene_ref` `parameters`): a child is `headSize` 1.15 with a short `faceShape`; a grown-up a long one at 0.9. They are fixed per character: do not key them across a shot (a keyed `hairStyle` pops). A different build (taller, broader) is a second rig, not a dial. Pitfall: `headSize` above about 1.2 with hairStyle 2 lifts the quiff 80 px higher, so leave headroom in the frame.
-- **Verify** with a rendered sweep −1 → 0 → 1: every feature stays inside the silhouette, nothing
-  jumps between frames, the features' x offsets keep the depth order, and at |turn| 1 the eye on the
-  turn side is the narrower one and both pupils are offset toward the turn.
+**A 2D head turn.** `headTurn` (0 face on, ±1 a three-quarter view, + toward + x) and `headTilt` are the one turn and tilt dials of both rigs: key them, never the features. A face built by hand turns the same way (feature depths, eyes, outline morphs, ears, timing, profile swap, verify sweep): read [references/head-turn.md](references/head-turn.md). Set `headSize`, `hairStyle` and `faceShape` per instance, never keyed across a shot (a keyed `hairStyle` pops); a different build is a second rig. `headSize` above about 1.2 with hairStyle 2 lifts the quiff 80 px higher, so leave headroom.
 
 ## 1. Prepare the drawings
 
@@ -284,34 +285,7 @@
 past B at 1.0 → settle on B at 1.2. Each pose carries its own handles (`0.552 ×` its half-width or
 half-height), so the circle stays round on its way to the tall ellipse.
 
-### Puff or pinch a whole outline: `puckerBloat`
-
-`{ "type": "puckerBloat", "amount": 40 }` reshapes every geometry item above it in its group (nested
-groups included) around each contour's centre, the average of its vertices. A positive `amount`
-bloats: each vertex moves `amount` percent of the way to the centre while its handles push out, so the
-edges bow outward. A negative `amount` puckers: the vertices move out and the handles move in, into
-spikes. `amount` is animatable, so one item takes a star to a flower and back:
-
-```json
-{ "kind": "shape", "items": [
-  { "type": "polystar", "starType": "star", "points": 6, "outerRadius": 120, "innerRadius": 60 },
-  { "type": "puckerBloat", "amount": { "keyframes": [
-    { "time": 0, "value": 0 }, { "time": 2, "value": 60 }, { "time": 4, "value": -40 } ] } },
-  { "type": "fill", "color": "#F2A33A" } ] }
-```
-
-A rounded badge whose sides puff out: bloat a SHARP `rect`, then round it with `offsetPaths`. Bloat on
-a `rect` with `roundness` pinches each rounded corner into ears, and `roundCorners` after the bloat does
-not smooth them. `offsetPaths` grows the outline by `amount` with round corners, so draw the rect
-`2 × amount` smaller than the badge:
-
-```json
-{ "kind": "shape", "items": [
-  { "type": "rect", "size": [232, 92] },
-  { "type": "puckerBloat", "amount": 14 },
-  { "type": "offsetPaths", "amount": 24 },
-  { "type": "fill", "color": "#3A7BF2" } ] }
-```
+A `puckerBloat` item puffs or pinches a whole outline (`amount` animatable): see [references/outline-mechanics.md](references/outline-mechanics.md) "Puff or pinch a whole outline".
 
 ## 3. Targets (blend-shape hygiene)
 
@@ -413,6 +387,7 @@
 - Name mouth targets by the VRM presets: `aa`, `ih`, `ou`, `ee`, `oh`; eyes `blink`, `blinkLeft`,
   `blinkRight`; moods `happy`, `angry`, `sad`, `relaxed`, `surprised`. Consonants borrow the nearest
   vowel at a lower weight.
+- Mood geometry owns the corners, brows and lids; `aa`, `ih`, `ou`, `ee`, `oh` own the aperture and speech shape, whatever the mood strength. `speech` 1 reserves the aperture through the whole dialogue, pauses and closures included (a surprised O closes on m, b, p only inside that window); `speech` 0 restores the mood's resting mouth. Pass `visemes: ["aa","ih","ou","ee","oh","speech"]` to `lipSync:visemes` and merge every returned track into the rig instance's parameters. A mood change eases 0.4 s from the evaluated current weights: key the current values, then the next recipe 0.4 s later with `ease_in_out` on the outgoing keys, and clear the outgoing mood weights; never reset to neutral at the change or step-select a mouth drawing to change a vector mood.
 - Visemes cross-fade: at any moment the viseme weights sum to about 1, each segment eased, with a
   short hold on a stressed vowel.
 - Lip sync from word timings: `picsart_scene_apply_preset` with `preset` `lipSync:visemes`, `layerId` the
@@ -484,7 +459,7 @@
 
 ## Tuning by hand — `picsart_scene_tune`
 
-Open it as `motion-design-craft` describes. `rig-humanoid` and `rig-face` already declare their controls; a custom character exposes its own as `scene-building-basics` "Reusable parts" says.
+Open it as `motion-design-craft` describes. `rig-humanoid` and `rig-face` already declare their controls; a custom character exposes its own as `scene-building-basics` "Reusable parts" says. To keep a finished character, `picsart_scene_library_save` saves it under `Picsart Scene Library/Characters/<name>` with `name`, `kind: "character"`, `rights: "own"` (or `"licensed"` with a `license` note), and `scene` (the document or its HTTPS URL). Put render kinds (`vector`, `cutout`, `3d`, `live2d`, `spine`) in `tags`; assets and controls are derived from the scene. `previewUrl` supplies the portrait, or omit it to render one at `previewTime` (default 0); `videoUrl` is an optional demo. `pick: true` picks that version. `picsart_scene_library_list` with `kind: "character"` returns the picked version or newest, its durable `sceneUrl`, controls and version count; `tag`, `name` and `folderUid` filter it. USE a saved character with `picsart_scene_apply_template`, `uri: "library:<libraryId>"` (picked version or newest) or its `sceneUrl`: reference mode places its URL in a `scene_ref`, and inline mode copies its body into the host as a scene asset.
 
 ## Not expressible (format findings, not rules)
 
Full technical diff · 3 changed fields

changed /description

BEFORE
"Build and animate a 2D cartoon character in a scene — rig-humanoid and rig-face, their control names and ranges, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting, choosing between outline keyframes, morph targets, per-vertex tracks and outline expressions, blend-target hygiene, timing (anticipation, overshoot, holds), volume-keeping squash, face visemes and blinks, scene-to-scene morph transitions, bending a picture over an art mesh, and explicit skin weights. Use when a cartoon character, mascot or face walks, waves or talks; when a path's outline changes shape over time — one drawing becomes another; a jelly, blob or character squashes, stretches, bounces, wobbles or breathes; a cartoon face talks (lip sync, mouth shapes), smiles or blinks; a cut is hidden by a morph; or an image, text or composition has to bend."
AFTER
"Build and animate a 2D cartoon character in a scene — rig-humanoid and rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync, a cut-out puppet built from named SVG parts, sockets, reach and held props — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting, choosing between outline keyframes, morph targets and per-vertex tracks, blend-target hygiene, timing (anticipation, overshoot, holds), volume-keeping squash, face visemes and blinks, scene-to-scene morph transitions, bending a picture over an art mesh, and explicit skin weights. Use when a cartoon character, mascot or face walks, waves or talks; when a path's outline changes shape over time — one drawing becomes another; a jelly, blob or character squashes, stretches, bounces, wobbles or breathes; a cartoon face talks (lip sync, mouth shapes), smiles or blinks; a cut is hidden by a morph; or an image, text or composition has to bend."

changed /included_files

BEFORE
[
  {
    "relative_path": "references/art-mesh.md",
    "size_in_bytes": 9305
  },
  {
    "relative_path": "references/character-motion.md",
    "size_in_bytes": 19529
  },
  {
    "relative_path": "references/layer-follow-through.md",
    "size_in_bytes": 1217
  },
  {
    "relative_path": "references/live-pins.md",
    "size_in_bytes": 11333
  },
  {
    "relative_path": "references/outline-mechanics.md",
    "size_in_bytes": 16636
  },
  {
    "relative_path": "references/skin-weights.md",
    "size_in_bytes": 7651
  },
  {
    "relative_path": "references/traced-svg.md",
    "size_in_bytes": 1408
  }
]
AFTER
[
  {
    "relative_path": "references/art-mesh.md",
    "size_in_bytes": 9305
  },
  {
    "relative_path": "references/character-motion.md",
    "size_in_bytes": 20752
  },
  {
    "relative_path": "references/cut-out-puppet.md",
    "size_in_bytes": 12651
  },
  {
    "relative_path": "references/head-turn.md",
    "size_in_bytes": 3994
  },
  {
    "relative_path": "references/layer-follow-through.md",
    "size_in_bytes": 1217
  },
  {
    "relative_path": "references/live-pins.md",
    "size_in_bytes": 11333
  },
  {
    "relative_path": "references/outline-mechanics.md",
    "size_in_bytes": 18106
  },
  {
    "relative_path": "references/part-sheet-prompt.md",
    "size_in_bytes": 15280
  },
  {
    "relative_path": "references/skin-weights.md",
    "size_in_bytes": 7651
  },
  {
    "relative_path": "references/sockets-and-props.md",
    "size_in_bytes": 7378
  },
  {
    "relative_path": "references/traced-svg.md",
    "size_in_bytes": 1408
  }
]

changed /skill_md_contents

BEFORE
"---\nname: character-rigging\ndescription: Build and animate a 2D cartoon character in a scene — rig-humanoid and rig-face, their control names and ranges, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting, choosing between outline keyframes, morph targets, per-vertex tracks and outline expressions, blend-target hygiene, timing (anticipation, overshoot, holds), volume-keeping squash, face visemes and blinks, scene-to-scene morph transitions, bending a picture over an art mesh, and explicit skin weights. Use when a cartoon character, mascot or face walks, waves or talks; when a path's outline changes shape over time — one drawing becomes another; a jelly, blob or character squashes, stretches, bounces, wobbles or breathes; a cartoon face talks (lip sync, mouth shapes), smiles or blinks; a cut is hidden by a morph; or an image, text or composition has to bend.\nmetadata:\n  category: authoring\n  version: '1.7'\n  ported-from: shape-morphing 1.7 at 55.104.0\n---\n\n# Cartoon characters and shape morphing\n\nField names are the `path` item's (`picsart_scene_capabilities` with `sections: [\"schema:ShapeContent\"]`); the outline mechanics are in\n[references/outline-mechanics.md](references/outline-mechanics.md).\n\n## Named motions on a rig\n\nA rig document can declare root `actions`, named motions an instance plays: bone tracks go in\n`actions.<name>.layers`, drawing and order selectors in `actions.<name>.parameters`. Keep the\nskeleton and painted weights once, with static rest transforms; place the rig once and use the\n`scene_ref`'s `content.animation` to blend one action into the next (walk→idle). Set\n`content.blending: \"pass_through\"` so limbs can reach beyond the rig's frame without canvas padding:\nunder pass_through the frame sizes and places, it does not clip. A layer treatment that needs a\ncomposited result (mask, effect, non-normal blend, opacity below 1, motion blur, mesh, stroke or shadow,\nadjustment or look) isolates and clips it. Action bodies have time keys, no `$eval` or expressions;\nlayer expressions and constraints run after the mix. Step channels switch immediately. Delayed first\nkeys need the `beforeFirst: \"rest\"` action policy. `animations` is a layer field and the action stack is\n`content.animation`; root `actions` are distinct from a track content's sequential `clips`. `rig-humanoid` and\n`rig-humanoid-front` (the same body from the front) declare actions: `scene-animation-reference`. The schema is `picsart_scene_capabilities` with\n`sections: [\"schema:SceneAction\"]`; the full crossfade example is in\n`picsart_scene_recipe scene-animation-reference`.\n\n## 0. Cartoon character rigs\n\nA 2D cartoon character starts from a catalog rig when one fits, not from a 3D\nmodel and not from hand-written joint Lua; one no rig fits is built by hand from bent limbs and `ik`\n([references/character-motion.md](references/character-motion.md)), its ink lines\npointed at the ends with a stroke `taper` (\"Ink lines\" below).\n`picsart_scene_templates` with `tags: [\"cartoon\", \"rig\"]` lists them:\n\n| Template | What it is |\n|---|---|\n| `scene://rig-humanoid` | A whole body, three-quarter view facing right, 600×1000, transparent |\n| `scene://rig-face` | A face from the front, 800×800, transparent |\n\nPlace one as a `scene_ref` layer (`picsart_scene_apply_template`, reference mode); size it with the layer's\n`transform.scale` or `bounds`, and mirror it (`scale` x negative) to face left. Every part is a shape\nlayer pivoting on its joint. Each arm and leg is one outline bent at the elbow or knee (a `bend` with\nan `id`), posed by an `ik` constraint that reaches for a target layer (`leftFootTarget`,\n`rightHandTarget`, ...); the hand or foot is `attach`ed to the limb's end\n([references/character-motion.md](references/character-motion.md)). The torso and neck are one outline\n`skin`ned to the empty `spine` and `neck` bone layers, which `spineLean` and `headNod` turn inside\nthe `min`/`max` on their rotation tracks; the arms hang from `spine` and the head from `neck`.\nThe template poses the parts from its parameters, and each FK parameter's `min`/`max` is its joint's\nlimit. Animate only the parameters: key them in the layer's\n`content.parameters` (`{\"leftUpperArmRaise\": {\"keyframes\": [...]}}`), or apply a rig preset.\n\n**Standard control names**, shared with 3D characters: a face takes VRM expressions, a body `<vrmBone><Motion>`, hair, ears and tails `<part><Motion>` (`Sway` is a side-to-side pendulum). Any rig of the same type uses the same names\nand ranges, so a preset or a keyed track moves every one of them.\n\n| Rig | Parameter | Range | Meaning |\n|---|---|---|---|\n| both | `blink`, `blinkLeft`, `blinkRight`, `aa`, `happy` | 0..1 | eyes shut, one eye shut (the left eye is on + x), mouth open, smile |\n| both | `headTurn`, `headNod`, `headTilt` | −1..1 | turn toward the viewer's right (0 face on, ±1 a three-quarter view; on the humanoid + toward +x the way its body faces), chin down, roll clockwise |\n| both | `lookUp`, `lookDown`, `lookLeft`, `lookRight` | 0..1 | irises' direction; `lookLeft` is + x on screen (on the humanoid an eye turned away travels less across) |\n| both | `ih`, `ou`, `ee`, `oh` | 0..1 | the other visemes |\n| humanoid | `browInnerUp`, `browOuterUpLeft`, `browOuterUpRight`, `eyeWideLeft`, `eyeWideRight` | 0..1 | both brows' inner ends up; one brow's outer end up; one eye opened wide (a blink still shuts it) |\n| face | `sad`, `angry`, `surprised`, `relaxed` | 0..1 | moods (mouth, eyes, brows) |\n| humanoid | `spineLean`, `hipsRaise`, `hipsTilt` | −1..1 | torso lean ±20° (+ forward); hips ±60 px (+ up); pelvis roll ±10° (+ clockwise, the + x hip drops), the legs following on their IK and the shoulders tilting against it |\n| humanoid | `breath` | 0..1 | breath: the chest swells, shoulders and head rise |\n| humanoid | `<side>UpperArmSwing` / `UpperArmRaise` / `LowerArmSwing` / `HandSwing` | −1..1 / 0..1 / 0..1 / −1..1 | arm ±80° (+ forward); raised forward and up 0..160° (0 hangs, 0.5 forward, 1 overhead); elbow 0..150°; wrist ±40° |\n| humanoid | `<side>UpperLegSwing` / `LowerLegSwing` / `FootSwing` | −1..1 / 0..1 / −1..1 | leg ±70°; knee 0..140° (elbow and knee limits are their bends' `min`/`max`, binding IK too); toe up ±35° |\n| humanoid | `<side>HandSpread`, `<side>HandPoint`, `<side>HandFist` | 0..1 | hand poses on a palm, four fingers and a thumb, the relaxed open hand at 0: fingers fanned (the waving hand), the index pointing, a fist; the three share the hand (scaled to 1 above a sum of 1, the relaxed hand filling the rest), so a crossfade is two keyed weights |\n| humanoid | `<side>HandIk`, `<side>FootIk` | 0..1 | the limb's `ik` `mix`: from the swings to the target (feet default 1, hands 0) |\n| humanoid | `<side>HandX/Y`, `<side>FootX/Y` | −400..400 | the target layer, rig px from the resting wrist or ankle |\n| humanoid | `hairSway`, `hairRaise`, `earSway` | −1..1 | follow-through, morphs inside the head: hair and quiff swing (+ toward + x), hair raise (+ up), ear rim swing (+ toward + x); key them a few frames behind the head |\n| humanoid | `headSize` | 0.8..1.25 (1) | head size: the whole head (features, hair, ears) scales about the neck, the body does not; the planted feet and every limb are untouched |\n| humanoid | `hairStyle`, `faceShape` | whole numbers 0..2 | which drawing shows: hair 0 the cap with a fringe, 1 cropped, 2 a tall quiff with long sideburns; skull 0 round, 1 long (chin 14 px lower), 2 short (chin 14 px higher). Drawings swap with `step` keys, they do not blend; the other head controls (`hairSway`, `hairRaise`, `headTurn`) move every style |\n\n`<side>` is `left` (the far side, behind the body) or `right` (the near side).\n\n**IK.** A limb on IK puts its wrist or ankle on the target and bends at the elbow or knee to reach it\n(knees fold forward, elbows back); a target out of reach straightens the limb toward it. The swings\nstill pose the limb under a partial `mix`. The targets are in the rig's own space and stay where they\nare while the body moves, so a foot that keeps its target is planted: lower\n`hipsRaise` and the knees bend. To touch something, set `<side>HandIk` 1 and key `<side>HandX/Y`.\n\n**Gesture arms: raise × elbow.** Up to a 60° raise (`UpperArmRaise` ≤ 0.375), the natural\nelbow bend folds the hand onto the face. Measured safe pair for a wave or a talking gesture:\n`UpperArmRaise` 0.25–0.36 with `LowerArmSwing` 0.45–0.55. Unsafe, hand at the nose or mouth: raise 0.36\nwith elbow 0.85, raise 0.2 with elbow 0.7. Swing the hand with `HandSwing`, not by bending the elbow\nfurther, and check a `picsart_scene_contact_sheet` for the hand against the head.\n\n**Draw order.** The far arm and leg draw behind the torso and the near ones in front, by document\norder; an arm hangs outside its thigh, so the far arm draws behind the far leg and the near arm in\nfront of the near leg. An `ik` chain authors no depth, so the order holds in every pose: a raised far\narm stays behind the head (wave with the near arm, or the far arm forward beside the face), and a far\nhand swung forward past the far thigh stays behind it. The near hand shows its back, the far hand its\npalm; both thumbs sit on the forward edge. A turned face's far ear goes behind the head, driven by\n`headTurn`: don't key `z` yourself.\n\n**Motion.** Everything goes on the rig's `scene_ref` layer with `picsart_scene_apply_preset`\n(`preset` `motionPreset:<id>`, `layerId` the rig layer), and writes bindings in its `content.parameters`:\n\n- `walk_cycle` (tag `rig-motion`): one stride of keys (two steps of `stepDuration`) from `start`,\n  looped with `ctx:loopOut`; keys the foot targets (`<side>FootX/Y`, `FootIk` 1) and `FootSwing`,\n  `hipsRaise`, `spineLean`, `headNod` and the arms' swings, forearms and hands lagging, and moves the\n  layer (`travel` `forward`, or `in_place`). Each step the body eases one stride forward while the\n  planted foot's target eases the same stride back, so the foot stays put. A rig missing one of those\n  names is refused, naming it.\n  **A walk that stops** (a walk-in, a stop, an action, a walk on): `steps` `N` walks `N` whole steps and\n  stops with every walking parameter on its rest value, instead of looping. `from` `rest` opens with a\n  half-step out of the rest pose and ends with the half-step back, so the layer carries `N` × `stride`\n  (the half-steps count as one of the `N`); `from` `walking` (the default) starts on the first walking pose\n  and adds the closing half-step. Both feet are planted whenever neither is lifted, in the half-steps too.\n  Pitfall: never settle the rig by hand after a `steps` walk (a key on the same parameters is a second\n  writer, and pops at the stop); the arms take 0.15 s longer than the feet to come to rest. Use a fresh\n  `walk_cycle` for the next walk, `start` after the action. `steps` with `travel` `forward` needs the same\n  plain layer as the loop.\n- `ground_scroll` (tag `rig-motion`): the set's side of a walk across a scrolling background. Walk the rig\n  `in_place`, put the scenery under one parent layer (an empty one is fine), and apply `ground_scroll` to\n  that parent with the walk's own `start`, `stepDuration`, `stride`, `steps` and `from`, `direction`\n  `right` for the rig as drawn (`left` for a mirrored one) and `walkerScale` the walker layer's drawn size\n  (its scale times its fit; `stride` is in rig px). The parent moves against the travel on the same clock,\n  so the planted foot stays still on the ground; pair it with the camera's `push_in` on a pivot at the\n  walker. Pitfall: change a walk's numbers in both presets, or the feet slide.\n- Gestures (tag `rig-motion`, `gesture`): `wave`, `talk_beat`, `point` and `shrug`, each `start`,\n  `duration` (seconds from the arm leaving rest to its return), `amount` 0..1, and for `wave`, `talk_beat`\n  and `point` a `side` (`right` the near arm, `left` the far one); `wave` and `talk_beat` also `count`\n  (swings or beats). They lift the arm inside the safe pair (raise 0.25 to 0.36 at an elbow of 0.45 to\n  0.55, so the hand stays off the face) and return every control to rest. `wave`: the hand swings from the\n  wrist `count` times. `talk_beat`: the forearm beats with the speech, the hand follows. `point`: the arm's\n  IK takes the wrist to `targetX`, `targetY` (rig px from where it rests, y down, default up and\n  forward); the limb straightens toward a target out of reach, and the hand forms a point (`HandPoint`). `shrug`: both arms, the hands turned, the\n  head tilts and the breath rises (no `side`, no `count`). Use cases: a greeting, a character talking with\n  its hands, indicating an object, an \"I don't know\". Pitfalls: a gesture replaces a walk's bindings of the\n  same arm (the result's notes say so), so apply it after the walk and give it a `start` inside the\n  walk; `point` is IK, so a hand at a fixed target stays there while the body moves.\n- `acting` (tag `rig-motion`): the character acts from commands. Key the text parameter `action` on\n  the scene holding the rig layer (the preset declares it, default `idle`, when it has none) and the\n  rig plays each key's motion from that key: `idle` (weight shifting leg to leg),\n  `wave` (the near arm), `point` (the near arm, head and eyes at `pointX`/`pointY`, rig px),\n  `talk` (head nods, brow lifts and hand gestures on beats; the mouth is the visemes', keyed apart),\n  `walk` (`walk_cycle` from a half step on the key, closing the feet with a step when it stops, so no\n  planted foot slides; `stepDuration`, `stride`, `lift`, `armSwing`, `bob`, `lean`, `travel` as\n  `walk_cycle`'s). Its text parameter `action` selects a preset command; the `action` field in\n  `content.animation` selects a named action from the rig document. Any other text plays `idle`.\n  Each switch crossfades over `fade` (0.2 s), longer for a joint with further to go, what was playing carrying on under it, the forearm, hand and head\n  trailing by 2 frames or more:\n  `{\"action\": {\"type\": \"text\", \"animatable\": true, \"default\": {\"keyframes\": [{\"time\": 0, \"value\": \"idle\"},\n  {\"time\": 2, \"value\": \"wave\"}, {\"time\": 4, \"value\": \"walk\"}, {\"time\": 7, \"value\": \"point\"}]}}}`.\n  It drives every name its clips key and the walk's, so on one rig it takes the place of\n  `walk_cycle`, never beside it; for life add `random_pulse` on `blink` and `cycle` on `breath`,\n  which it leaves free. The clips key standard\n  names only, so any rig with them acts. One `action` serves every rig in its scene: give each character its own scene to act\n  apart.\n- Everything else is a parameter driver with `parameter` naming the rig's control — the \"Parameter\n  drivers\" table in [references/character-motion.md](references/character-motion.md):\n  `random_pulse` on `blink`, `cycle` on `breath` (sine, ~3.5 s, `to` ≈ 0.6), `random_hold` on the\n  `look*` gaze. A different `seed` per character keeps two from blinking together. Parameter-mode\n  `follow_through` on catalog-rig controls needs an owned scene body: a binding reads its host's\n  parameters, not the rig's. Omit `parameter` to apply world-motion layer physics to a rig layer.\n\nThey combine on names they do not share: `walk_cycle` or `acting` with the blink and breath\ndrivers. A walk's travel follows the layer's size\nwhen it is applied: set the layer's scale first. Travel needs a plain layer (no look, effect,\nparent, transform track or component ahead, speed 1, untrimmed); anything else takes `in_place`. One\npreset drives a name on a rig: a preset writing a name another preset already drives there is\nrefused as `rig_parameter_driven`, naming both; re-applying the same preset, or writing over a name\nyou keyed by hand, replaces that binding and says so in `notes`.\n\nVerify a walk on a contact sheet (`picsart_scene_contact_sheet`): the legs alternate, the arms swing\nagainst them, and the planted foot does not slide.\n\n**Ink lines.** A hand-drawn line thins at its ends and swells in the middle: a stroke with a `taper`.\n\n```json\n{\"type\": \"stroke\", \"color\": \"#1a1a1a\", \"width\": 7, \"lineCap\": \"round\",\n \"taper\": {\"startLength\": 0.5, \"endLength\": 0.5}}\n```\n\n`startLength`/`endLength` are shares of each contour's length (`lengthUnits: \"pixels\"` for px), and\nthe line narrows to `startWidth`/`endWidth` (shares of `width`, default 0, a point) over them;\n`startEase`/`endEase` (0..1) bow the ramp so the width recovers sooner. The lengths are measured on\nthe outline as drawn, after a `bend` or a `trim`, so a bent limb keeps its thin ends and a draw-on\nkeeps its point on the moving end. `wave` swells and narrows the width along the line.\n\n**A 2D head turn.** `headTurn` (0 face on, ±1 a three-quarter view, + toward + x) and `headTilt`\nare the one turn and tilt dials of both rigs: key them, never the features. rig-face turns its\nfeatures on their layers' transforms (`nose`, `leftEye`/`rightEye`, the brows, `mouth`, the ears),\nso a drawing put in a feature layer turns the same way. A face built by hand turns the same way:\n\n- **Depths.** Each feature turns round the head's vertical axis at its own depth `r`, starting at\n  angle `φ = asin(x / r)` for its face-on `x`: `x = r · sin(φ + a)`, `a` the turn's angle (rig-face:\n  40° at ±1). The nose stands proudest (rig-face 250 px on a 500 px head), then the mouth (210),\n  then the eyes and brows (190); the outline moves least, by its morph. A nod moves each feature\n  round the head's centre too, and a feature nodded low turns at the narrower jaw: scale `r` by the\n  head's width at its new height.\n- **Eyes.** The far eye is the one on the side the face turns toward: it narrows (scale x\n  `cos(φ + a) / cos φ`, held at 0.55 or more), moves less and ends near the silhouette. The near\n  eye keeps its width or grows a little (up to 1.08) and moves more. Both pupils lead the turn\n  (rig-face: 16 px at ±1). Brows narrow with their eyes.\n- **Outline.** Give the head outline a `turnRight` and a `turnLeft` morph target (the mirror),\n  weighted by `max(0, ±sin a) / sin a_max`. Move the points mostly along x: the cheek and brow ridge\n  push out on the face side, the jaw and chin come round more than the crown, the back flattens.\n  Keep the handles, and lengthen them only where the outline flattens, so it stays round. Hair\n  morphs with it, its fringe wrapping round with the face. Check every outline at a sweep of turns\n  for a self-crossing: a fringe end that slides past the tip it hangs from loops there.\n- **Ears.** Hang each ear on the outline's side at its height and slide it round with that side,\n  not on the turning sphere: an ear placed past the 90° silhouette swings against the turn while\n  the outline moves with it, and comes away from the head. The near ear widens and comes over the\n  side toward the cheek, the far one narrows and tucks behind the outline; both move the way the\n  face turns and touch the outline at every turn. Each ear's `z` follows the turn's sign: the near\n  ear 1, over the head, the far one −1, behind it. Stand both ears just clear of the outline face on,\n  so the swap at 0 changes nothing drawn.\n- **Timing.** Lead with the eyes: the pupils (`look*`) a few frames before the head. Then key the\n  turn past where it settles and back: to 0.95 and settle at 0.85 over about 0.2 s. Keys outside the\n  dial's `min`/`max` warn, so the overshoot stays inside ±1. Hair and ears trail by a couple of\n  frames (`hairSway`, `earSway` on the humanoid).\n- **Profile.** Beyond about 0.8 a three-quarter drawing stops reading; swap to a profile drawing\n  with `step` keys `by` the dial: its `opacity` `{\"by\": \"headTurn\", \"keyframes\": [{\"at\": 0.8, \"value\": 0,\n  \"easing\": \"step\"}, {\"at\": 0.81, \"value\": 1}]}`, and the front features' `opacity` the reverse. A full\n  turnaround needs a drawing per angle.\n- **Several characters from one rig.** Set `headSize`, `hairStyle` and `faceShape` per instance (the `scene_ref` `parameters`): a child is `headSize` 1.15 with a short `faceShape`; a grown-up a long one at 0.9. They are fixed per character: do not key them across a shot (a keyed `hairStyle` pops). A different build (taller, broader) is a second rig, not a dial. Pitfall: `headSize` above about 1.2 with hairStyle 2 lifts the quiff 80 px higher, so leave headroom in the frame.\n- **Verify** with a rendered sweep −1 → 0 → 1: every feature stays inside the silhouette, nothing\n  jumps between frames, the features' x offsets keep the depth order, and at |turn| 1 the eye on the\n  turn side is the narrower one and both pupils are offset toward the turn.\n\n## 1. Prepare the drawings\n\n- Draw A and B each as its own best outline, then match them — the three things a morph needs:\n  the same vertex count, the same winding (the sign of the signed area, Σ (xᵢ·yᵢ₊₁ − xᵢ₊₁·yᵢ),\n  agrees) and the same start vertex on the same feature of both drawings.\n- A missing vertex is added, not faked with a handle: an eased segment needs equal counts\n  (`shape_path_vertex_count_mismatch`), and a handle dragged to stand in for a corner bulges mid-morph.\n- Corresponding vertices should sit on the same feature of both drawings (top-centre to top-centre,\n  tip to tip). Every vertex travels a straight line to its twin; unrelated twins cross and the\n  outline twists through itself.\n- Give the outline enough vertices for its roundest pose, and no more: 8 round a blob or a mouth,\n  evenly spread, a flat contact edge included. With fewer, each span carries a bigger bend and the\n  squashed, stretched or opened poses go lumpy. A morph reads through clear silhouettes. A drawing with many sub-shapes, holes or an\n  open↔closed change does not morph; it swaps (§2) or dissolves.\n- Round stays round: every smooth vertex carries `inTangent`/`outTangent` in every pose, sized to\n  that pose (`r · 4/3 · tan(π / 2N)` for N vertices on a circle of radius r, `0.552·r` at 4). A pose\n  that opens, widens or grows lengthens its handles in proportion; handles kept from a smaller pose\n  flatten the curve and leave corners. A vertex without handles is a deliberate corner.\n- A morph changes the outline only: the drawing's `fill` and `stroke` (width, join, cap) stay as\n  drawn. A colour change rides on the fill's own keyframes, not on the outline.\n\n## 2. Choose the technique\n\n| Need | Write |\n|---|---|\n| One drawing becomes another (A→B, A→B→C) | `vertices` keyframe track, one `easing` per segment |\n| Independent changes that mix (open + smile + blink) | `morphs`: named targets, each with its own `weight` |\n| One part on its own timing (tail tip lags, one mouth corner) | static `vertices` list, that vertex's `point`/handles keyframed |\n| Replace drawings without blending (mouth charts, frame-by-frame) | `\"easing\": \"step\"` on the earlier keyframe; counts may differ |\n| A catalog mouth or cartoon wipe, no outlines of your own | `picsart_scene_looks {\"tags\": [\"cartoon\"]}`: `mouth_shapes` takes `shape` as a name (the visemes `rest`/`aa`/`oh`) or a step track of names; `squash_wipe` uncovers its layer |\n| Loop, breathe, wobble | `vertices.expression`: `return ctx:loopOut(\"cycle\")` repeats the outline keyframes; or a target whose `weight.expression` cycles (`return picsart.oscillate(time, 0, 1, 1.2)`), or a `scale` expression |\n\nA path has one driver: a `vertices` track or per-vertex tracks, never both (`shape_path_driven_twice`).\n`morphs` add on top of either, so a wobbling base can still smile.\n\n```json\n{ \"type\": \"path\", \"closed\": true,\n  \"vertices\": { \"keyframes\": [\n    { \"time\": 0.0, \"easing\": \"step\", \"value\": [\n      {\"point\": [0, -80], \"inTangent\": [-44, 0], \"outTangent\": [44, 0]}, {\"point\": [80, 0], \"inTangent\": [0, -44], \"outTangent\": [0, 44]},\n      {\"point\": [0, 80], \"inTangent\": [44, 0], \"outTangent\": [-44, 0]}, {\"point\": [-80, 0], \"inTangent\": [0, 44], \"outTangent\": [0, -44]}] },\n    { \"time\": 0.4, \"easing\": \"ease_in\", \"value\": [\n      {\"point\": [0, -80], \"inTangent\": [-44, 0], \"outTangent\": [44, 0]}, {\"point\": [80, 0], \"inTangent\": [0, -44], \"outTangent\": [0, 44]},\n      {\"point\": [0, 80], \"inTangent\": [44, 0], \"outTangent\": [-44, 0]}, {\"point\": [-80, 0], \"inTangent\": [0, 44], \"outTangent\": [0, -44]}] },\n    { \"time\": 0.7, \"easing\": \"ease_out\", \"value\": [\n      {\"point\": [12, -96], \"inTangent\": [-46, 0], \"outTangent\": [46, 0]}, {\"point\": [96, 10], \"inTangent\": [0, -46], \"outTangent\": [0, 46]},\n      {\"point\": [-8, 70], \"inTangent\": [46, 0], \"outTangent\": [-46, 0]}, {\"point\": [-70, -14], \"inTangent\": [0, 46], \"outTangent\": [0, -46]}] },\n    { \"time\": 1.0, \"easing\": \"ease_in_out\", \"value\": [\n      {\"point\": [0, -130], \"inTangent\": [-22, 0], \"outTangent\": [22, 0]}, {\"point\": [40, 0], \"inTangent\": [0, -72], \"outTangent\": [0, 72]},\n      {\"point\": [0, 130], \"inTangent\": [22, 0], \"outTangent\": [-22, 0]}, {\"point\": [-40, 0], \"inTangent\": [0, 72], \"outTangent\": [0, -72]}] },\n    { \"time\": 1.2, \"value\": [\n      {\"point\": [0, -120], \"inTangent\": [-26, 0], \"outTangent\": [26, 0]}, {\"point\": [48, 0], \"inTangent\": [0, -66], \"outTangent\": [0, 66]},\n      {\"point\": [0, 120], \"inTangent\": [26, 0], \"outTangent\": [-26, 0]}, {\"point\": [-48, 0], \"inTangent\": [0, 66], \"outTangent\": [0, -66]}] }\n  ] } }\n```\nHold (0–0.4, `step` on an identical outline) → breakdown at 0.7 that is not the midpoint → overshoot\npast B at 1.0 → settle on B at 1.2. Each pose carries its own handles (`0.552 ×` its half-width or\nhalf-height), so the circle stays round on its way to the tall ellipse.\n\n### Puff or pinch a whole outline: `puckerBloat`\n\n`{ \"type\": \"puckerBloat\", \"amount\": 40 }` reshapes every geometry item above it in its group (nested\ngroups included) around each contour's centre, the average of its vertices. A positive `amount`\nbloats: each vertex moves `amount` percent of the way to the centre while its handles push out, so the\nedges bow outward. A negative `amount` puckers: the vertices move out and the handles move in, into\nspikes. `amount` is animatable, so one item takes a star to a flower and back:\n\n```json\n{ \"kind\": \"shape\", \"items\": [\n  { \"type\": \"polystar\", \"starType\": \"star\", \"points\": 6, \"outerRadius\": 120, \"innerRadius\": 60 },\n  { \"type\": \"puckerBloat\", \"amount\": { \"keyframes\": [\n    { \"time\": 0, \"value\": 0 }, { \"time\": 2, \"value\": 60 }, { \"time\": 4, \"value\": -40 } ] } },\n  { \"type\": \"fill\", \"color\": \"#F2A33A\" } ] }\n```\n\nA rounded badge whose sides puff out: bloat a SHARP `rect`, then round it with `offsetPaths`. Bloat on\na `rect` with `roundness` pinches each rounded corner into ears, and `roundCorners` after the bloat does\nnot smooth them. `offsetPaths` grows the outline by `amount` with round corners, so draw the rect\n`2 × amount` smaller than the badge:\n\n```json\n{ \"kind\": \"shape\", \"items\": [\n  { \"type\": \"rect\", \"size\": [232, 92] },\n  { \"type\": \"puckerBloat\", \"amount\": 14 },\n  { \"type\": \"offsetPaths\", \"amount\": 24 },\n  { \"type\": \"fill\", \"color\": \"#3A7BF2\" } ] }\n```\n\n## 3. Targets (blend-shape hygiene)\n\n- One target, one change, small: `jawOpen` moves the jaw vertices only, `{}` for every other vertex.\n  Targets that each touch everything fight when mixed.\n- A target that moves a smooth vertex moves its handles too: offset `inTangent`/`outTangent` along\n  with `point` so that in the target pose the handles still point along the outline (parallel to the\n  line between the vertex's two neighbours) and stay in proportion to the new curve (an opening lip's\n  handles lengthen as it drops). An offset with `point` alone keeps the base's handles: what grew goes\n  flat, what turned kinks.\n- A corner that opens gains handles in the target: a closed mouth meets at sharp corners, an open one\n  is rounded there, so `aa`/`oh` give each mouth corner short handles along the lips. A corner stays\n  sharp only where the open drawing is sharp too.\n- Offsets are relative to the base outline, so the base may be redrawn; the vertex count may not —\n  every target has one offset per vertex (`shape_path_morph_vertex_count_mismatch`).\n- A combination that looks wrong (smile × jawOpen pinches the corners) gets a corrective target whose\n  offsets are only the fix, weighted by the product of the two drivers. Drive the two from\n  `animatable` parameters and read them in the corrective's `weight.expression`.\n- An in-between (the half-open mouth is not half of the open mouth): author a second target for the\n  mid pose and cross-fade — `mid` rises 0→1 while `full` stays 0, then `mid` falls 1→0 as `full`\n  rises 0→1.\n- Keep weights in 0..1 except for a deliberate overshoot or anticipation (§4); weights are not clamped.\n\n```json\n\"parameters\": { \"smile\": { \"type\": \"number\", \"default\": 0, \"animatable\": true },\n                \"jaw\":   { \"type\": \"number\", \"default\": 0, \"animatable\": true } },\n...\n{ \"type\": \"path\", \"closed\": true, \"vertices\": [\n    {\"point\": [-60, 0]},\n    {\"point\": [-30, -8], \"inTangent\": [-19, 2], \"outTangent\": [9, -1]},\n    {\"point\": [0, -9], \"inTangent\": [-11, 0], \"outTangent\": [11, 0]},\n    {\"point\": [30, -8], \"inTangent\": [-9, -1], \"outTangent\": [19, 2]},\n    {\"point\": [60, 0]},\n    {\"point\": [30, 8], \"inTangent\": [19, -2], \"outTangent\": [-9, 1]},\n    {\"point\": [0, 9], \"inTangent\": [11, 0], \"outTangent\": [-11, 0]},\n    {\"point\": [-30, 8], \"inTangent\": [9, 1], \"outTangent\": [-19, -2]}],\n  \"morphs\": {\n    \"happy\": { \"offsets\": [\n        {\"point\": [-2, -10]}, {\"inTangent\": [0, -2], \"outTangent\": [0, 1]}, {},\n        {\"inTangent\": [0, 1], \"outTangent\": [0, -2]}, {\"point\": [2, -10]},\n        {\"inTangent\": [-1, -4], \"outTangent\": [0, 2]}, {}, {\"inTangent\": [0, 2], \"outTangent\": [1, -4]}],\n      \"weight\": { \"expression\": \"return ctx.composition:getParameters():smile()\" } },\n    \"aa\": { \"offsets\": [\n        {\"point\": [4, 16], \"inTangent\": [0, 12], \"outTangent\": [0, -12]},\n        {\"point\": [2, -6], \"inTangent\": [1, 4], \"outTangent\": [-1, -2]},\n        {\"point\": [0, -9], \"inTangent\": [1, 0], \"outTangent\": [-1, 0]},\n        {\"point\": [-2, -6], \"inTangent\": [1, -2], \"outTangent\": [-1, 4]},\n        {\"point\": [-4, 16], \"inTangent\": [0, -12], \"outTangent\": [0, 12]},\n        {\"point\": [-2, 38], \"inTangent\": [-1, -4], \"outTangent\": [1, 2]},\n        {\"point\": [0, 41], \"inTangent\": [-1, 0], \"outTangent\": [1, 0]},\n        {\"point\": [2, 38], \"inTangent\": [-1, 2], \"outTangent\": [1, -4]}],\n      \"weight\": { \"expression\": \"return ctx.composition:getParameters():jaw()\" } },\n    \"happyAa\": { \"offsets\": [{\"point\": [2, 3]}, {}, {}, {}, {\"point\": [-2, 3]}, {}, {}, {}],\n      \"weight\": { \"expression\": \"local p = ctx.composition:getParameters() return p:smile() * p:jaw()\" } } } }\n```\nEight vertices clockwise from the left corner: corners 0 and 4, upper lip 1–3, lower lip 5–7. The\nlips are smooth, each handle `4/3 · tan(Δθ/4)` of the arc it spans. `aa` opens to a round mouth\n(a 56 × 34 half-axis ellipse): every lip vertex moves with its handles, and the corners gain handles\nof 12 so the open mouth rounds off there. `happy` lifts the corners without handles, because a\nsmile's corners stay sharp, and re-aims the lip handles along the lifted line.\nOn the eye path, a blink is one target with a hold at closed:\n```json\n\"morphs\": { \"blink\": { \"offsets\": [{}, {\"point\": [0, 14]}, {}, {\"point\": [0, -14]}],\n  \"weight\": { \"keyframes\": [{\"time\": 1.40, \"value\": 0, \"easing\": \"ease_in\"}, {\"time\": 1.48, \"value\": 1, \"easing\": \"step\"},\n                            {\"time\": 1.54, \"value\": 1, \"easing\": \"ease_out\"}, {\"time\": 1.66, \"value\": 0}] } } }\n```\n\n## 4. Timing\n\n- Anticipation: a small move the other way first — `weight` 0 → −0.15 → 1, or an outline keyframe\n  a little \"before A\" ahead of the main segment. Short: a few frames.\n- Overshoot and settle: `weight` 1.2 → 1, an outline keyframe past B followed by B, or a\n  `cubic_bezier` easing whose `y` leaves 0..1 (`[0.175, 0.885, 0.32, 1.275]`); render to check the\n  peak, the control number is not the overshoot.\n- Slow in / slow out: `easing` on the starting keyframe of every segment, per target weight; a\n  keyframe without `easing` is `linear` — right for a hold-to-swap, wrong for a pose change.\n- Holds: repeat the value on the next keyframe, or `\"easing\": \"step\"`. Keys read when they rest.\n- Follow-through: parts arrive at different times — a second target whose weight keyframes are\n  delayed, or a per-vertex track lagging the body.\n- Timing is the count of frames between poses; spacing near a pose is tight (ease), the middle is\n  wide. A morph under ~0.2 s reads as a swap — then write the swap.\n\n## 5. Breakdowns\n\nThe middle drawing is not the average of A and B. Favour one key, and add the extra movement the\nstraight path lacks (A → Z → B): a third outline keyframe, or a transient target that peaks mid-way\n(`weight` 0 → 1 → 0 across the A→B segment) on top of the track. Vertices travel straight lines, so\nan arc, a bulge or a lean exists only as a breakdown.\n\n## 6. Volume\n\nA squash keeps its area: lower by ×0.8, widen by ×1.25. For a target, the squash offsets lower\nthe top and push the sides out together, and stretch the horizontal handles of the top and bottom\nby the same ×1.25 (shorten the vertical ones by ×0.8) so the widened body stays round; for a whole-layer squash, `scale` `[1.25, 0.8]` with the\n`anchor` on the contact edge. Measure the ink area on `picsart_scene_contact_sheet` frames rather than trusting the numbers; the eye reads volume loss as deflation.\n\n## 7. Faces\n\n- Name mouth targets by the VRM presets: `aa`, `ih`, `ou`, `ee`, `oh`; eyes `blink`, `blinkLeft`,\n  `blinkRight`; moods `happy`, `angry`, `sad`, `relaxed`, `surprised`. Consonants borrow the nearest\n  vowel at a lower weight.\n- Visemes cross-fade: at any moment the viseme weights sum to about 1, each segment eased, with a\n  short hold on a stressed vowel.\n- Lip sync from word timings: `picsart_scene_apply_preset` with `preset` `lipSync:visemes`, `layerId` the\n  rig layer and in `params` the transcript (a `captions` `transcript`, as transcription returns it) and\n  the face's `visemes`; it merges one track per control into the rig layer's `content.parameters`. It opens a syllable per vowel group, leads the sound by 50 ms,\n  dips rather than shuts inside fast words, and closes on rests and on every m, b and p (60 ms shut up\n  to the release; `closures` lists them). `speaker` picks one singer's segments, `gain` scales the\n  opening, and `start`/`end` cut and rebase the tracks for a layer that plays only part of the song.\n- Replacement drawings: pass `mouthShapes` mapping each drawing's name to its number on a `mouth`\n  dial (`{\"rest\": 0, \"aa\": 1, \"oh\": 2}`) and a `mouth` track of `step` keys, one drawing per frame,\n  joins the others. A viseme without a drawing takes its nearest one.\n- \"Make this character say the line\" is `lipSync:visemes` on the rig. \"Make this photo talk\" is not: that\n  is a pixel video from the Picsart lip-sync models (`kling-avatar`, `heygen-talking-photo`,\n  `minimax-h3-max-lip-sync`, `bytedance-omnihuman-v1.5`), not editable animation.\n- A blink is in fast (~0.08 s), held closed (~0.06 s), out slower (~0.12 s), and keeps the face's\n  other targets running.\n- Talking while smiling = `happy` steady + visemes cycling + a corrective per viseme that dents or\n  pinches under the smile (`happyAa`, `happyOh`). Shape each viseme on the mouth as it is seen, the\n  held mood applied, then render every viseme at full weight with the mood on: a dent, a flat lip\n  or a pinched corner there is a missing corrective. The mouth and eyes sit before the head in\n  `items` so they paint on top.\n- Draw the mouth with a darker `stroke` over its `fill`, `\"lineJoin\": \"round\"`: the lip line reads at every\n  opening, and the round join softens the corners. The stroke follows the morphed outline.\n- End a grin in the silence: when a smile control opens the mouth (rig-humanoid's `happy` does past\n  about 0.6), ease it after the last word over ~0.12 s to where it rests closed. Check that every silent frame reads closed.\n- Keep a head turn moderate: talking to camera reads at about half the turn's range, and the full turn\n  only where the body itself is turned that far. An ear slides round the head with the turn and never\n  fades; hair trails the head by a couple of frames.\n- A wave lifts the hand up and forward at shoulder height, clear of the face outline: a forearm bent\n  across the cheek reads as a reach. Measure the clearance from geometry on every frame of the gesture.\n\n## 8. Scene-to-scene morph transitions\n\n- Three ways: direct (A's outline becomes B's, every frame honest); fast swap (the outline swaps\n  under `motionBlur: true` and a large move or spin, the eye fills in); hybrid (the key object\n  morphs directly, the rest leaves under a `mask` or slides out, new details enter last).\n- Pick 1–3 key pairs that share two of colour, shape, volume. Morph those first; if they do not\n  read, nothing else will.\n- Order: key pairs → the largest, least-detailed objects → small details last; the morphing layer\n  spans the cut (its `start`/`duration` cover both scenes), it belongs to neither scene.\n- Every moving element shares one direction and speed across the cut; colour changes ride on the\n  fill's keyframes timed with the outline's.\n- Verify with `picsart_scene_contact_sheet` stills at the cut ±2 frames and `picsart_media_track_motion` on the key pair.\n\n## 9. When not to morph\n\n- No two of colour/shape/volume in common → cut, dissolve or a catalog transition.\n- Raster media and text are not outlines; a `media` or `text` layer does not morph — bend it over an\n  art mesh (§10), or mask, scale or transition it.\n- Topology changes (open↔closed, a hole appears, a shape splits) → `step` swap or a dissolve.\n- Under ~0.2 s, or more than a few dozen vertices → a swap reads the same and is cheaper to author.\n\n## 10. Bending a picture and live pins\n\nA layer's `mesh` draws a `media`, `text`, composition or `scene_ref` picture over triangles so it\nbends: a `grid`, explicit `vertices` + `triangles`, or a mesh that follows a cut-out's transparency\nfrom `picsart_scene_apply_preset` with `preset` `mesh:auto`; then `deformers` (`bend`, `push`, `stretch`, `warp`, `skin`, `pins`)\nmove its points over time, each fading in and out on its `mix`. `pins` give free handles to a flag,\ntail, ear or sticker corner, with `stiffnessRegions` to keep a head firm on a bending body. Read\n[references/art-mesh.md](references/art-mesh.md) before writing a mesh, and\n[references/live-pins.md](references/live-pins.md) before writing pins. See also [traced SVG](references/traced-svg.md) and [follow-through, pixel art](references/layer-follow-through.md).\n\n## 11. Explicit skin weights\n\nWhen a limb, sleeve or imported mesh should follow painted bone influences instead of the automatic\nradius falloff, give the `skin` deformer `weights`, one row per mesh vertex or outline point. Read\n[references/skin-weights.md](references/skin-weights.md) before writing them: the rest-pose\nalignment, the row numbering, the blend band a bend needs, and the limits.\n\n## Tuning by hand — `picsart_scene_tune`\n\nOpen it as `motion-design-craft` describes. `rig-humanoid` and `rig-face` already declare their controls; a custom character exposes its own as `scene-building-basics` \"Reusable parts\" says.\n\n## Not expressible (format findings, not rules)\n\n- Weight-indexed in-betweens: no target \"at weight 0.5\"; the mid pose is a second target cross-faded\n  by hand (§3).\n- Curved vertex trajectories: a vertex keyframe takes no spatial tangents (`inTangent`/`outTangent`\n  are honoured on `position`/`anchor` only), so an arc needs a breakdown keyframe.\n- A target's `weight.expression` reading another target's weight directly: unverified; the\n  corrective pattern goes through parameters.\n- No priority/override between procedural targets (VRM `overrideMouth`/`overrideBlink` block/blend):\n  conflicts are authored by hand.\n- `closed` is static and the hole count fixed: topology never morphs.\n- No automatic volume preservation under a squash target.\n"
AFTER
"---\nname: character-rigging\ndescription: Build and animate a 2D cartoon character in a scene — rig-humanoid and rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync, a cut-out puppet built from named SVG parts, sockets, reach and held props — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting, choosing between outline keyframes, morph targets and per-vertex tracks, blend-target hygiene, timing (anticipation, overshoot, holds), volume-keeping squash, face visemes and blinks, scene-to-scene morph transitions, bending a picture over an art mesh, and explicit skin weights. Use when a cartoon character, mascot or face walks, waves or talks; when a path's outline changes shape over time — one drawing becomes another; a jelly, blob or character squashes, stretches, bounces, wobbles or breathes; a cartoon face talks (lip sync, mouth shapes), smiles or blinks; a cut is hidden by a morph; or an image, text or composition has to bend.\nmetadata:\n  category: authoring\n  version: '1.7'\n  ported-from: shape-morphing 1.7 at 55.130.0\n---\n\n# Cartoon characters and shape morphing\n\nField names are the `path` item's (`picsart_scene_capabilities` with `sections: [\"schema:ShapeContent\"]`); the outline mechanics are in\n[references/outline-mechanics.md](references/outline-mechanics.md).\n\n## Named motions on a rig\n\nA rig document can declare root `actions`, named motions an instance plays: bone tracks go in\n`actions.<name>.layers`, drawing and order selectors in `actions.<name>.parameters`. Keep the\nskeleton and painted weights once, with static rest transforms; place the rig once and use the\n`scene_ref`'s `content.animation` to blend one action into the next (walk→idle). Set\n`content.blending: \"pass_through\"` so limbs can reach beyond the rig's frame without canvas padding:\nunder pass_through the frame sizes and places, it does not clip. A layer treatment that needs a\ncomposited result (mask, effect, non-normal blend, opacity below 1, motion blur, mesh, stroke or shadow,\nadjustment or look) isolates and clips it. Action bodies have time keys, no `$eval` or expressions;\nlayer expressions and constraints run after the mix. Step channels switch immediately. Delayed first\nkeys need the `beforeFirst: \"rest\"` action policy. `animations` is a layer field and the action stack is\n`content.animation`; root `actions` are distinct from a track content's sequential `clips`. `rig-humanoid` and\n`rig-humanoid-front` (the same body from the front) declare actions: `scene-animation-reference`. The schema is `picsart_scene_capabilities` with\n`sections: [\"schema:SceneAction\"]`; the full crossfade example is in\n`picsart_scene_recipe scene-animation-reference`.\n\n## 0. Cartoon character rigs\n\nA 2D cartoon character starts from a catalog rig when one fits, or from `picsart_scene_build_model` with\n`character: {svg, duration: 4}` for named SVG parts (\"Named SVG cut-outs\" below); without `svg` that tool builds a 3D\nmodel. Not from hand-written joint Lua: one no rig fits is built by hand from bent limbs and `ik`\n([references/character-motion.md](references/character-motion.md), which also builds an arm as one shape), its ink lines\npointed at the ends with a stroke `taper` (\"Ink lines\" below).\n`picsart_scene_templates` with `tags: [\"cartoon\", \"rig\"]` lists them:\n\n| Template | What it is |\n|---|---|\n| `scene://rig-humanoid` | A whole body, three-quarter view facing right, 600×1000, transparent |\n| `scene://rig-face` | A face from the front, 800×800, transparent |\n\nPlace one as a `scene_ref` layer (`picsart_scene_apply_template`, reference mode); size it with the layer's\n`transform.scale` or `bounds`, and mirror it (`scale` x negative) to face left. Every part is a shape\nlayer pivoting on its joint. Each arm and leg is one outline bent at the elbow or knee (a `bend` with\nan `id`), posed by an `ik` constraint that reaches for a target layer (`leftFootTarget`,\n`rightHandTarget`, ...); the hand or foot is `attach`ed to the limb's end\n([references/character-motion.md](references/character-motion.md)). The torso and neck are one outline\n`skin`ned to the empty `spine` and `neck` bone layers, which `spineLean` and `headNod` turn inside\nthe `min`/`max` on their rotation tracks; the arms hang from `spine` and the head from `neck`.\nThe template poses the parts from its parameters, and each FK parameter's `min`/`max` is its joint's\nlimit. Animate only the parameters: key them in the layer's\n`content.parameters` (`{\"leftUpperArmRaise\": {\"keyframes\": [...]}}`), or apply a rig preset.\n\n**Standard control names**, shared with 3D characters: a face takes VRM expressions, a body `<vrmBone><Motion>`, hair, ears and tails `<part><Motion>` (`Sway` is a side-to-side pendulum). Any rig of the same type uses the same names\nand ranges, so a preset or a keyed track moves every one of them.\n\n| Rig | Parameter | Range | Meaning |\n|---|---|---|---|\n| both | `blink`, `blinkLeft`, `blinkRight`, `aa`, `happy` | 0..1 | eyes shut, one eye shut (the left eye is on + x), mouth open, smile |\n| both | `headTurn`, `headNod`, `headTilt` | −1..1 | turn toward the viewer's right (0 face on, ±1 a three-quarter view; on the humanoid + toward +x the way its body faces), chin down, roll clockwise |\n| both | `lookUp`, `lookDown`, `lookLeft`, `lookRight` | 0..1 | irises' direction; `lookLeft` is + x on screen (on the humanoid an eye turned away travels less across) |\n| both | `ih`, `ou`, `ee`, `oh` | 0..1 | the other visemes |\n| humanoid | `browInnerUp`, `browOuterUpLeft`, `browOuterUpRight`, `eyeWideLeft`, `eyeWideRight` | 0..1 | both brows' inner ends up; one brow's outer end up; one eye opened wide (a blink still shuts it) |\n| face | `sad`, `angry`, `surprised`, `relaxed` | 0..1 | moods (mouth, eyes, brows); the humanoid rigs and `rig-face` carry them with `happy`. The six mood actions are `happy`, `sad`, `angry`, `surprised`, `scared` (sad + surprised + `browInnerUp`) and `sleepy` (relaxed): no `scared` or `sleepy` dial |\n| humanoid | `spineLean`, `hipsRaise`, `hipsTilt` | −1..1 | torso lean ±20° (+ forward); hips ±60 px (+ up); pelvis roll ±10° (+ clockwise, the + x hip drops), the legs following on their IK and the shoulders tilting against it |\n| humanoid | `breath` | 0..1 | breath: the chest swells, shoulders and head rise |\n| humanoid | `<side>UpperArmSwing` / `UpperArmRaise` / `UpperArmOpen` / `ShoulderRaise` / `LowerArmSwing` / `HandSwing` | −1..1 / 0..1 / 0..1 / 0..1 / −1..1 / −1..1 | arm ±80° (+ forward); raised forward and up 0..160° (0 hangs, 0.5 forward, 1 overhead; the front view draws it foreshortened); opened out to the side and up 0..180° (0 hangs, 0.5 sideways, 1 overhead; drawn foreshortened as it opens toward or away from the camera on the side and three-quarter views); shoulder lifted 15 px at 1 (the shrug); elbow ±150° (+ folds forward, toward the midline on a front view; − the other way: up beside the head on an opened near arm; on the far three-quarter arm, which opens forward, up beside the head is +); wrist ±40° |\n| humanoid | `<side>UpperLegSwing` / `LowerLegSwing` / `FootSwing` | −1..1 / 0..1 / −1..1 | leg ±70°; knee 0..140° (elbow and knee limits are their bends' `min`/`max`, binding IK too); toe up ±35° |\n| humanoid | `<side>HandSpread`, `<side>HandPoint`, `<side>HandFist`, `<side>HandGrip`, `<side>HandThumbsUp` | 0..1 | hand poses on a palm, four fingers and a thumb, the relaxed open hand at 0: fingers fanned (the waving hand), the index pointing, a fist, curled fingers with an opposing thumb (grip), the thumb out from curled fingers; the five share the hand (scaled to 1 above a sum of 1, the relaxed hand filling the rest), so a crossfade is two keyed weights over 0.4 s, `ease_in_out`; every pose has the same path topology, so there is no swap between duplicate hands. A grip is a silhouette, not a prop contact |\n| humanoid | `held`, `heldBy`, `<side>HandToHeld`, `<side>HandHeldAt` | clip / right·left·chest·mouth·none / 0..1 / vec2 | the prop the character holds, who carries it, a hand brought onto it, and where on the prop that wrist lands ([references/sockets-and-props.md](references/sockets-and-props.md)) |\n| humanoid | `<side>HandIk`, `<side>FootIk` | 0..1 | the limb's `ik` `mix`: from the swings to the target (feet default 1, hands 0) |\n| humanoid | `<side>HandX/Y`, `<side>FootX/Y` | −400..400 | the target layer, rig px from the resting wrist or ankle |\n| humanoid | `hairSway`, `hairRaise`, `earSway` | −1..1 | follow-through, morphs inside the head: hair and quiff swing (+ toward + x), hair raise (+ up), ear rim swing (+ toward + x); key them a few frames behind the head |\n| humanoid | `headSize` | 0.8..1.25 (1) | head size: the whole head (features, hair, ears) scales about the neck, the body does not; the planted feet and every limb are untouched |\n| humanoid | `hairStyle`, `faceShape` | whole numbers 0..2 | which drawing shows: hair 0 the cap with a fringe, 1 cropped, 2 a tall quiff with long sideburns; skull 0 round, 1 long (chin 14 px lower), 2 short (chin 14 px higher). Drawings swap with `step` keys, they do not blend; the other head controls (`hairSway`, `hairRaise`, `headTurn`) move every style |\n\n`<side>` is `left` (the far side, behind the body) or `right` (the near side).\n\n**Named SVG cut-outs.** An editable vector character from an approved SVG drawing, with no generation, bitmaps or Blender:\n`picsart_scene_build_model` with `character: {svg, view, duration}` replies `{scene, sockets}`. Pass `svgUrl`, the `url` of the generation result that drew the sheet, in place of `svg`: the server fetches it (Picsart-hosted https only), so the markup never passes through your context. `view` is `front`, `threeQuarter` or `side` (a multi-view\nsheet without `view` is refused; a single-view SVG declares `data-view` and `data-facing`).\n\n- **Draw the sheet from the frozen turnaround prompt** in [references/part-sheet-prompt.md](references/part-sheet-prompt.md): one 1536×1024 sheet, front and three-quarter A-poses, relaxed profile, same outfit, complete overlapping parts, full-width far arm, one closed hair mass, round strokes, optional gradients. The whole body must be requested turned; near side = ear side.\n- **Check before building.** `character: {svg, check: true}` checks the whole sheet and builds nothing. Open `pictureCheck.path` (body | near arm+leg | far arm+leg in each view row) and read its named pass/fail checks for parts, joint union, far-arm width, hair closure and head group. Check proportions, arm and neck/collar order and complete parts with markers hidden, and get the user's OK on the picture before building; an approved picture stays valid.\n- **The builder owns sides and order.** Geometry assigns character sides (front right = image-left; facing right, right = near = the image-left ear side; facing left, left = near = image-right); source suffixes and socket labels are advisory. Role order throughout motion: far hand < lowerArm < upperArm < torso < near upperArm < hand < lowerArm; head above neck and torso; neck below the collar. Rest angles come from the source joints; presets use absolute targets.\n- **Parts:** torso, head, optional hips and neck, paired upperArm, lowerArm, hand, upperLeg, lowerLeg, foot, and skirt, coat, coatBack, tail, scarf, backpack, cap, straps, strapL, strapR, hairBack (follows the head, below the torso). A named skirt keeps its complete hem rigid on the hips; other lower garments share hip and thigh skin. A marker lies in the union of adjacent parts or the covering garment (four source px edge tolerance, twelve on hidden far parts); paired links normalise within 8%. Exactly one unnamed top-level non-marker group may supply an absent head.\n- **Face and hands.** Named head `eyeL/R`, nested `pupilL/R`, `browL/R`, `mouth` and `hairFront` expose blink, look, brow and closed-mouth viseme controls; the profile hides the far eye and brow, and brows draw over hair. No mouth artwork is invented, and unnamed face art stays static. Hands and shoes stay rigid unless a complete matching set of hand poses is authored. Unsupported SVG constructs refuse by id; linear and radial gradients are supported.\n- **Walk it.** Side defaults are stride 160 rig px (±80), lift 40 and armSwing .22; the three-quarter view scales stride and armSwing by cos 45° (113, .16) and keeps lift 40, and turned views walk with closed arms. Explicit arguments win. Prefer three-quarter or side for walks and front for rest, idle and face shots. Hosting, framing and the walk are tool calls only (the \"Prompt to walk\" steps in the sheet reference).\n\nRig behaviour (controls, a garment over the legs, draw order) and the checks to run after a build: [references/cut-out-puppet.md](references/cut-out-puppet.md).\n\n**IK.** A limb on IK puts its wrist or ankle on the target and bends at the elbow or knee to reach it\n(knees fold forward, elbows back); a target out of reach straightens the limb toward it. The swings\nstill pose the limb under a partial `mix`. The targets are in the rig's own space and stay where they\nare while the body moves, so a foot that keeps its target is planted: lower\n`hipsRaise` and the knees bend. To touch something, set `<side>HandIk` 1 and bind the absolute, composition-space `<side>HandTarget` parameter; its default follows `<side>HandX/Y` offsets from the resting wrist. The parameter drives the same-named target layer, whose final placement is the arm solve's goal, so an `attach` or `ik` constraint on that layer overrides the input through the same path. Those constraints stay inside the rig's composition; a parent binds inputs through the instance and reads its published sockets, without addressing internal layers.\n\n**Sockets, reach and held props.** A placed character publishes sockets (`head`, `chin`, `chest`, hands, grips, feet, `seat`, `mouth`, `held`; a dog or cat `mouth`, paws, `body`, `tail`): a parent targets `{\"layer\", \"socket\"}` and Lua reads `getSocket`. A `reach` constraint on the instance layer puts a socket on a stage point (`{\"type\": \"reach\", \"socket\": \"rightHand\", \"target\": {\"layer\": \"ball\"}, \"mix\": 1}` lands a hand on a ball; `\"seat\"` on a bench seats the character). A humanoid rig or a dog or cat holds a prop itself through `held` and `heldBy` (`right`, `left`, `chest`, `mouth`, `none`; an animal only `mouth` or `none`), two hands by `<side>HandToHeld`. Tables, the `via` dial, carriers and worked cases: [references/sockets-and-props.md](references/sockets-and-props.md).\n\n**Read the bone map.** `picsart_scene_inspect` with `mode: \"rig\"`; pass an embedded rig asset key as `scope` and optionally `layer` for a subtree. Read entries in order, indenting by `level`: hips first, parents before children. The map derives bones from skins and constraints, so an unreferenced joint mark is absent; `parentId` is parenting, not art ownership. A standard name is that bone (`leftUpperArm` names the left upper arm). Keep imports' source names; any non-standard layer, including an imported bone or a plain parent frame, reads `helper` (IK targets read `target`); a helper is an ordinary layer, not a separate skeleton declaration. Placements resolve `$eval` at scoped parameter defaults, without use-site bindings: read them as authored rest, not a posed measurement. Drivers are lexical reads; Lua, time tracks, poses and automatic weights are not evaluated. Use `picsart_scene_query_layout` for evaluated geometry.\n\n**Gesture arms: raise × elbow.** Up to a 60° raise (`UpperArmRaise` ≤ 0.375), the natural\nelbow bend folds the hand onto the face. Measured safe pair for a talking gesture, a point or a shrug:\n`UpperArmRaise` 0.25–0.36 with `LowerArmSwing` 0.45–0.55. Unsafe, hand at the nose or mouth: raise 0.36\nwith elbow 0.85, raise 0.2 with elbow 0.7. Swing the hand with `HandSwing`, not by bending the elbow\nfurther, and check a `picsart_scene_contact_sheet` for the hand against the head.\n\n**The wave rule** (stated once; the presets, the actions and the robot all follow it). A wave keys one world pose: the arm out and up beside the head, the forearm up (an opening near 0.7). Where that pose runs through the arm's pole (pointing at the camera) on a 2D rig, the preset keys the in-plane dial instead, picking its row by the rig's `viewAngle`, with the forearm's sign following the view's + side: one preset, three rows, no new control. Front (0): `UpperArmOpen` 0.68–0.76 with `LowerArmSwing` −0.2 to −0.35. Three-quarter (45) and side (90): `UpperArmRaise` 0.5–0.6 with `LowerArmSwing` +0.25 to +0.35, the hand standing in front of the head, clear of the face. `HandSwing` swings on every row.\n\n**Draw order.** The far arm and leg draw behind the torso and the near ones in front, by document\norder; an arm hangs outside its thigh, so the far arm draws behind the far leg and the near arm in\nfront of the near leg. An `ik` chain authors no depth (a `z` within ±1, static or a keyed `by` track with no expression, only orders the drawing and is allowed on a chain bone), so the order holds in every pose of a flat scene: a raised far\narm stays behind the head (wave with the near arm, or the far arm forward beside the face), and a far\nhand swung forward past the far thigh stays behind it. The near hand shows its back, the far hand its\npalm; both thumbs sit on the forward edge. A turned face's far ear goes behind the head, driven by\n`headTurn`: don't key `z` yourself. The order holds only while the whole composition is flat: put one layer in depth (a `z` beyond ±1, an expression `z`, `rotationX`/`rotationY`) or orbit the camera and every `z` of the scene, the rig's too, is depth (an `ik`, `skin`, `follow_through` or preset travel on a chain is then refused, and the validator warns `z_order_mixed_with_depth`).\n\n**Motion.** Everything goes on the rig's `scene_ref` layer with `picsart_scene_apply_preset`\n(`preset` `motionPreset:<id>`, `layerId` the rig layer), and writes bindings in its `content.parameters`:\n\n- `walk_cycle` (tag `rig-motion`): one stride of keys (two steps of `stepDuration`) from `start`,\n  looped with `ctx:loopOut`; keys the foot targets (`<side>FootX/Y`, `FootIk` 1) and `FootSwing`,\n  `hipsRaise`, `spineLean`, `headNod` and the arms' swings, forearms and hands lagging, and moves the\n  layer (`travel` `forward`, or `in_place`). Each step the body eases one stride forward while the\n  planted foot's target eases the same stride back, so the foot stays put. A rig missing one of those\n  names is refused, naming it.\n  **A walk that stops** (a walk-in, a stop, an action, a walk on): `steps` `N` walks `N` whole steps and\n  stops with every walking parameter on its rest value, instead of looping. `from` `rest` opens with a\n  half-step out of the rest pose and ends with the half-step back, so the layer carries `N` × `stride`\n  (the half-steps count as one of the `N`); `from` `walking` (the default) starts on the first walking pose\n  and adds the closing half-step. Both feet are planted whenever neither is lifted, in the half-steps too.\n  Pitfall: never settle the rig by hand after a `steps` walk (a key on the same parameters is a second\n  writer, and pops at the stop); the arms take 0.15 s longer than the feet to come to rest. Use a fresh\n  `walk_cycle` for the next walk, `start` after the action. `steps` with `travel` `forward` needs the same\n  plain layer as the loop.\n- `ground_scroll` (tag `rig-motion`): the set's side of a walk across a scrolling background. Walk the rig\n  `in_place`, put the scenery under one parent layer (an empty one is fine), and apply `ground_scroll` to\n  that parent with the walk's own `start`, `stepDuration`, `stride`, `steps` and `from`, `direction`\n  `right` for the rig as drawn (`left` for a mirrored one) and `walkerScale` the walker layer's drawn size\n  (its scale times its fit; `stride` is in rig px). The parent moves against the travel on the same clock,\n  so the planted foot stays still on the ground; pair it with the camera's `push_in` on a pivot at the\n  walker. Pitfall: change a walk's numbers in both presets, or the feet slide.\n- Gestures (tag `rig-motion`, `gesture`): `wave`, `talk_beat`, `point` and `shrug`, each `start`,\n  `duration` (seconds from the arm leaving rest to its return), `amount` 0..1, and for `wave`, `talk_beat`\n  and `point` a `side` (`right` the near arm, `left` the far one); `wave` and `talk_beat` also `count`\n  (swings or beats). They return every control to rest (`wave` keys the wave rule above; the others lift the arm inside the safe pair, raise 0.25 to 0.36 at an\n  elbow of 0.45 to 0.55, so the hand stays off the face). `wave`: the hand swings from the\n  wrist `count` times. `talk_beat`: the forearm beats with the speech, the hand follows. `point`: the arm's\n  IK takes the wrist to `targetX`, `targetY` (rig px from where it rests, y down, default up and\n  forward); the limb straightens toward a target out of reach, and the hand forms a point (`HandPoint`). `shrug`: both arms, the hands turned, the\n  head tilts and the breath rises (no `side`, no `count`). Use cases: a greeting, a character talking with\n  its hands, indicating an object, an \"I don't know\". Pitfalls: a gesture replaces a walk's bindings of the\n  same arm (the result's notes say so), so apply it after the walk and give it a `start` inside the\n  walk; `point` is IK, so a hand at a fixed target stays there while the body moves.\n- `acting` (tag `rig-motion`): the character acts from commands. Key the text parameter `action` on\n  the scene holding the rig layer (the preset declares it, default `idle`, when it has none) and the\n  rig plays each key's motion from that key: `idle` (weight shifting leg to leg),\n  `wave` (the near arm), `point` (the near arm, head and eyes at `pointX`/`pointY`, rig px),\n  `talk` (head nods, brow lifts and hand gestures on beats; the mouth is the visemes', keyed apart),\n  `walk` (`walk_cycle` from a half step on the key, closing the feet with a step when it stops, so no\n  planted foot slides; `stepDuration`, `stride`, `lift`, `armSwing`, `bob`, `lean`, `travel` as\n  `walk_cycle`'s). Its text parameter `action` selects a preset command; the `action` field in\n  `content.animation` selects a named action from the rig document. Any other text plays `idle`.\n  Each switch crossfades over `fade` (0.2 s), longer for a joint with further to go, what was playing carrying on under it, the forearm, hand and head\n  trailing by 2 frames or more:\n  `{\"action\": {\"type\": \"text\", \"animatable\": true, \"default\": {\"keyframes\": [{\"time\": 0, \"value\": \"idle\"},\n  {\"time\": 2, \"value\": \"wave\"}, {\"time\": 4, \"value\": \"walk\"}, {\"time\": 7, \"value\": \"point\"}]}}}`.\n  It drives every name its clips key and the walk's, so on one rig it takes the place of\n  `walk_cycle`, never beside it; for life add `random_pulse` on `blink` and `cycle` on `breath`,\n  which it leaves free. The clips key standard\n  names only, so any rig with them acts. One `action` serves every rig in its scene: give each character its own scene to act\n  apart.\n- Actions (tag `rig-motion`): `jog`, `jump`, `think` and `idle`, each `start`, on every humanoid rig (rig-humanoid,\n  rig-humanoid-front, a cut-out of either view). `jog` loops in place: `stepDuration` (0.3 or less) per step, both feet\n  off the ground for about 0.4 of it, `lift`, `bob`, `armSwing`, `elbow`, `lean`; `view` `side` (default) swings the feet\n  fore and aft over `stride` / 4 (pair it with `ground_scroll`, `pace` `constant`, the same `stride`), `front` for\n  rig-humanoid-front or a front cut-out lifts them on the spot. `jump` (`duration` 1.2, `height` up to 60, `tuck`,\n  `crouch` 1, `view`): crouch of the hips' full 60 px with the arms back, spring, knees tucked at the top, land, take\n  the landing and settle on the rest pose; the rise is the hips' own, so the figure stays in its frame. `think`\n  (`duration` 3, `side`): the arm's IK reaches toward the rig's chin and holds through the middle 40%, the other arm\n  hangs; it keys `<side>HandIk` and `<side>HandToChin` (0..1, default 0), which blends the `<side>HandTarget` layer toward\n  an `attach` target on the head (the chin plus the rig's wrist-contact offset, carried through the head's placement and\n  deformers), so contact geometry stays inside the rig. `idle` (`period` 3, `amount`): breath, head sway a quarter\n  period behind it, a weight shift and one blink a period, looping seamlessly, the arms left at the sides.\n  Each rig also declares `<side>AnchorShoulder` and `<side>AnchorEye` (vec2, absolute rig px): the shoulder a `point`\n  aims from and the eye its head follows; a rig missing one is refused (`rig_parameters_missing`). Every humanoid rig\n  declares read-only `viewAngle` (degrees from facing the camera: front 0, three-quarter 45, side 90), read into a\n  preset's scope beside the anchors; a rig that declares none is not assumed to be a side view, and `point` is refused\n  by the name. The anchors and the angle are the rig's own geometry: a `scene_ref` binding one is refused by name. An\n  arm opened toward the lens has no direction on a side or three-quarter view, so its drawn length fades to nothing\n  there and the forearm takes its direction from the arm's 3D pose; no joint jumps.\n- Everything else is a parameter driver with `parameter` naming the rig's control — the \"Parameter\n  drivers\" table in [references/character-motion.md](references/character-motion.md):\n  `random_pulse` on `blink`, `cycle` on `breath` (sine, ~3.5 s, `to` ≈ 0.6), `random_hold` on the\n  `look*` gaze. A different `seed` per character keeps two from blinking together. Parameter-mode\n  `follow_through` on catalog-rig controls needs an owned scene body: a binding reads its host's\n  parameters, not the rig's. Omit `parameter` to apply world-motion layer physics to a rig layer.\n\nThey combine on names they do not share: `walk_cycle` or `acting` with the blink and breath\ndrivers. A walk's travel follows the layer's size\nwhen it is applied: set the layer's scale first. Travel needs a plain layer (no look, effect,\nparent, transform track or component ahead, speed 1, untrimmed); anything else takes `in_place`. One\npreset drives a name on a rig: a preset writing a name another preset already drives there is\nrefused as `rig_parameter_driven`, naming both; re-applying the same preset, or writing over a name\nyou keyed by hand, replaces that binding and says so in `notes`.\n\nVerify a walk on a contact sheet (`picsart_scene_contact_sheet`): the legs alternate, the arms swing\nagainst them, and the planted foot does not slide. `lift` is the foot's clearance in rig px, not a 0..1 dial: a walk lifts about 24–40, a run up to about 100, and `lift: 1` barely steps. After setting the walk or jog numbers, check one loop with `picsart_scene_check_motion` `value_range` on `<side>FootArt` `centerY` for both feet (the amplitude, in the host's root pixels, is at least 0.8 × `lift` × the rig layer's scale: a rig placed at 0.25 moves a quarter as far), and look at the frames for clearance and for contact alternating. Show a walk, jog or run only in the three-quarter or side view, never the front view: the front view gets the rest or idle pose and face acting.\n\n**Ink lines.** A hand-drawn line thins at its ends and swells in the middle: a stroke with a `taper`.\n\n```json\n{\"type\": \"stroke\", \"color\": \"#1a1a1a\", \"width\": 7, \"lineCap\": \"round\",\n \"taper\": {\"startLength\": 0.5, \"endLength\": 0.5}}\n```\n\n`startLength`/`endLength` are shares of each contour's length (`lengthUnits: \"pixels\"` for px), and\nthe line narrows to `startWidth`/`endWidth` (shares of `width`, default 0, a point) over them;\n`startEase`/`endEase` (0..1) bow the ramp so the width recovers sooner. The lengths are measured on\nthe outline as drawn, after a `bend` or a `trim`, so a bent limb keeps its thin ends and a draw-on\nkeeps its point on the moving end. `wave` swells and narrows the width along the line.\n\n**A 2D head turn.** `headTurn` (0 face on, ±1 a three-quarter view, + toward + x) and `headTilt` are the one turn and tilt dials of both rigs: key them, never the features. A face built by hand turns the same way (feature depths, eyes, outline morphs, ears, timing, profile swap, verify sweep): read [references/head-turn.md](references/head-turn.md). Set `headSize`, `hairStyle` and `faceShape` per instance, never keyed across a shot (a keyed `hairStyle` pops); a different build is a second rig. `headSize` above about 1.2 with hairStyle 2 lifts the quiff 80 px higher, so leave headroom.\n\n## 1. Prepare the drawings\n\n- Draw A and B each as its own best outline, then match them — the three things a morph needs:\n  the same vertex count, the same winding (the sign of the signed area, Σ (xᵢ·yᵢ₊₁ − xᵢ₊₁·yᵢ),\n  agrees) and the same start vertex on the same feature of both drawings.\n- A missing vertex is added, not faked with a handle: an eased segment needs equal counts\n  (`shape_path_vertex_count_mismatch`), and a handle dragged to stand in for a corner bulges mid-morph.\n- Corresponding vertices should sit on the same feature of both drawings (top-centre to top-centre,\n  tip to tip). Every vertex travels a straight line to its twin; unrelated twins cross and the\n  outline twists through itself.\n- Give the outline enough vertices for its roundest pose, and no more: 8 round a blob or a mouth,\n  evenly spread, a flat contact edge included. With fewer, each span carries a bigger bend and the\n  squashed, stretched or opened poses go lumpy. A morph reads through clear silhouettes. A drawing with many sub-shapes, holes or an\n  open↔closed change does not morph; it swaps (§2) or dissolves.\n- Round stays round: every smooth vertex carries `inTangent`/`outTangent` in every pose, sized to\n  that pose (`r · 4/3 · tan(π / 2N)` for N vertices on a circle of radius r, `0.552·r` at 4). A pose\n  that opens, widens or grows lengthens its handles in proportion; handles kept from a smaller pose\n  flatten the curve and leave corners. A vertex without handles is a deliberate corner.\n- A morph changes the outline only: the drawing's `fill` and `stroke` (width, join, cap) stay as\n  drawn. A colour change rides on the fill's own keyframes, not on the outline.\n\n## 2. Choose the technique\n\n| Need | Write |\n|---|---|\n| One drawing becomes another (A→B, A→B→C) | `vertices` keyframe track, one `easing` per segment |\n| Independent changes that mix (open + smile + blink) | `morphs`: named targets, each with its own `weight` |\n| One part on its own timing (tail tip lags, one mouth corner) | static `vertices` list, that vertex's `point`/handles keyframed |\n| Replace drawings without blending (mouth charts, frame-by-frame) | `\"easing\": \"step\"` on the earlier keyframe; counts may differ |\n| A catalog mouth or cartoon wipe, no outlines of your own | `picsart_scene_looks {\"tags\": [\"cartoon\"]}`: `mouth_shapes` takes `shape` as a name (the visemes `rest`/`aa`/`oh`) or a step track of names; `squash_wipe` uncovers its layer |\n| Loop, breathe, wobble | `vertices.expression`: `return ctx:loopOut(\"cycle\")` repeats the outline keyframes; or a target whose `weight.expression` cycles (`return picsart.oscillate(time, 0, 1, 1.2)`), or a `scale` expression |\n\nA path has one driver: a `vertices` track or per-vertex tracks, never both (`shape_path_driven_twice`).\n`morphs` add on top of either, so a wobbling base can still smile.\n\n```json\n{ \"type\": \"path\", \"closed\": true,\n  \"vertices\": { \"keyframes\": [\n    { \"time\": 0.0, \"easing\": \"step\", \"value\": [\n      {\"point\": [0, -80], \"inTangent\": [-44, 0], \"outTangent\": [44, 0]}, {\"point\": [80, 0], \"inTangent\": [0, -44], \"outTangent\": [0, 44]},\n      {\"point\": [0, 80], \"inTangent\": [44, 0], \"outTangent\": [-44, 0]}, {\"point\": [-80, 0], \"inTangent\": [0, 44], \"outTangent\": [0, -44]}] },\n    { \"time\": 0.4, \"easing\": \"ease_in\", \"value\": [\n      {\"point\": [0, -80], \"inTangent\": [-44, 0], \"outTangent\": [44, 0]}, {\"point\": [80, 0], \"inTangent\": [0, -44], \"outTangent\": [0, 44]},\n      {\"point\": [0, 80], \"inTangent\": [44, 0], \"outTangent\": [-44, 0]}, {\"point\": [-80, 0], \"inTangent\": [0, 44], \"outTangent\": [0, -44]}] },\n    { \"time\": 0.7, \"easing\": \"ease_out\", \"value\": [\n      {\"point\": [12, -96], \"inTangent\": [-46, 0], \"outTangent\": [46, 0]}, {\"point\": [96, 10], \"inTangent\": [0, -46], \"outTangent\": [0, 46]},\n      {\"point\": [-8, 70], \"inTangent\": [46, 0], \"outTangent\": [-46, 0]}, {\"point\": [-70, -14], \"inTangent\": [0, 46], \"outTangent\": [0, -46]}] },\n    { \"time\": 1.0, \"easing\": \"ease_in_out\", \"value\": [\n      {\"point\": [0, -130], \"inTangent\": [-22, 0], \"outTangent\": [22, 0]}, {\"point\": [40, 0], \"inTangent\": [0, -72], \"outTangent\": [0, 72]},\n      {\"point\": [0, 130], \"inTangent\": [22, 0], \"outTangent\": [-22, 0]}, {\"point\": [-40, 0], \"inTangent\": [0, 72], \"outTangent\": [0, -72]}] },\n    { \"time\": 1.2, \"value\": [\n      {\"point\": [0, -120], \"inTangent\": [-26, 0], \"outTangent\": [26, 0]}, {\"point\": [48, 0], \"inTangent\": [0, -66], \"outTangent\": [0, 66]},\n      {\"point\": [0, 120], \"inTangent\": [26, 0], \"outTangent\": [-26, 0]}, {\"point\": [-48, 0], \"inTangent\": [0, 66], \"outTangent\": [0, -66]}] }\n  ] } }\n```\nHold (0–0.4, `step` on an identical outline) → breakdown at 0.7 that is not the midpoint → overshoot\npast B at 1.0 → settle on B at 1.2. Each pose carries its own handles (`0.552 ×` its half-width or\nhalf-height), so the circle stays round on its way to the tall ellipse.\n\nA `puckerBloat` item puffs or pinches a whole outline (`amount` animatable): see [references/outline-mechanics.md](references/outline-mechanics.md) \"Puff or pinch a whole outline\".\n\n## 3. Targets (blend-shape hygiene)\n\n- One target, one change, small: `jawOpen` moves the jaw vertices only, `{}` for every other vertex.\n  Targets that each touch everything fight when mixed.\n- A target that moves a smooth vertex moves its handles too: offset `inTangent`/`outTangent` along\n  with `point` so that in the target pose the handles still point along the outline (parallel to the\n  line between the vertex's two neighbours) and stay in proportion to the new curve (an opening lip's\n  handles lengthen as it drops). An offset with `point` alone keeps the base's handles: what grew goes\n  flat, what turned kinks.\n- A corner that opens gains handles in the target: a closed mouth meets at sharp corners, an open one\n  is rounded there, so `aa`/`oh` give each mouth corner short handles along the lips. A corner stays\n  sharp only where the open drawing is sharp too.\n- Offsets are relative to the base outline, so the base may be redrawn; the vertex count may not —\n  every target has one offset per vertex (`shape_path_morph_vertex_count_mismatch`).\n- A combination that looks wrong (smile × jawOpen pinches the corners) gets a corrective target whose\n  offsets are only the fix, weighted by the product of the two drivers. Drive the two from\n  `animatable` parameters and read them in the corrective's `weight.expression`.\n- An in-between (the half-open mouth is not half of the open mouth): author a second target for the\n  mid pose and cross-fade — `mid` rises 0→1 while `full` stays 0, then `mid` falls 1→0 as `full`\n  rises 0→1.\n- Keep weights in 0..1 except for a deliberate overshoot or anticipation (§4); weights are not clamped.\n\n```json\n\"parameters\": { \"smile\": { \"type\": \"number\", \"default\": 0, \"animatable\": true },\n                \"jaw\":   { \"type\": \"number\", \"default\": 0, \"animatable\": true } },\n...\n{ \"type\": \"path\", \"closed\": true, \"vertices\": [\n    {\"point\": [-60, 0]},\n    {\"point\": [-30, -8], \"inTangent\": [-19, 2], \"outTangent\": [9, -1]},\n    {\"point\": [0, -9], \"inTangent\": [-11, 0], \"outTangent\": [11, 0]},\n    {\"point\": [30, -8], \"inTangent\": [-9, -1], \"outTangent\": [19, 2]},\n    {\"point\": [60, 0]},\n    {\"point\": [30, 8], \"inTangent\": [19, -2], \"outTangent\": [-9, 1]},\n    {\"point\": [0, 9], \"inTangent\": [11, 0], \"outTangent\": [-11, 0]},\n    {\"point\": [-30, 8], \"inTangent\": [9, 1], \"outTangent\": [-19, -2]}],\n  \"morphs\": {\n    \"happy\": { \"offsets\": [\n        {\"point\": [-2, -10]}, {\"inTangent\": [0, -2], \"outTangent\": [0, 1]}, {},\n        {\"inTangent\": [0, 1], \"outTangent\": [0, -2]}, {\"point\": [2, -10]},\n        {\"inTangent\": [-1, -4], \"outTangent\": [0, 2]}, {}, {\"inTangent\": [0, 2], \"outTangent\": [1, -4]}],\n      \"weight\": { \"expression\": \"return ctx.composition:getParameters():smile()\" } },\n    \"aa\": { \"offsets\": [\n        {\"point\": [4, 16], \"inTangent\": [0, 12], \"outTangent\": [0, -12]},\n        {\"point\": [2, -6], \"inTangent\": [1, 4], \"outTangent\": [-1, -2]},\n        {\"point\": [0, -9], \"inTangent\": [1, 0], \"outTangent\": [-1, 0]},\n        {\"point\": [-2, -6], \"inTangent\": [1, -2], \"outTangent\": [-1, 4]},\n        {\"point\": [-4, 16], \"inTangent\": [0, -12], \"outTangent\": [0, 12]},\n        {\"point\": [-2, 38], \"inTangent\": [-1, -4], \"outTangent\": [1, 2]},\n        {\"point\": [0, 41], \"inTangent\": [-1, 0], \"outTangent\": [1, 0]},\n        {\"point\": [2, 38], \"inTangent\": [-1, 2], \"outTangent\": [1, -4]}],\n      \"weight\": { \"expression\": \"return ctx.composition:getParameters():jaw()\" } },\n    \"happyAa\": { \"offsets\": [{\"point\": [2, 3]}, {}, {}, {}, {\"point\": [-2, 3]}, {}, {}, {}],\n      \"weight\": { \"expression\": \"local p = ctx.composition:getParameters() return p:smile() * p:jaw()\" } } } }\n```\nEight vertices clockwise from the left corner: corners 0 and 4, upper lip 1–3, lower lip 5–7. The\nlips are smooth, each handle `4/3 · tan(Δθ/4)` of the arc it spans. `aa` opens to a round mouth\n(a 56 × 34 half-axis ellipse): every lip vertex moves with its handles, and the corners gain handles\nof 12 so the open mouth rounds off there. `happy` lifts the corners without handles, because a\nsmile's corners stay sharp, and re-aims the lip handles along the lifted line.\nOn the eye path, a blink is one target with a hold at closed:\n```json\n\"morphs\": { \"blink\": { \"offsets\": [{}, {\"point\": [0, 14]}, {}, {\"point\": [0, -14]}],\n  \"weight\": { \"keyframes\": [{\"time\": 1.40, \"value\": 0, \"easing\": \"ease_in\"}, {\"time\": 1.48, \"value\": 1, \"easing\": \"step\"},\n                            {\"time\": 1.54, \"value\": 1, \"easing\": \"ease_out\"}, {\"time\": 1.66, \"value\": 0}] } } }\n```\n\n## 4. Timing\n\n- Anticipation: a small move the other way first — `weight` 0 → −0.15 → 1, or an outline keyframe\n  a little \"before A\" ahead of the main segment. Short: a few frames.\n- Overshoot and settle: `weight` 1.2 → 1, an outline keyframe past B followed by B, or a\n  `cubic_bezier` easing whose `y` leaves 0..1 (`[0.175, 0.885, 0.32, 1.275]`); render to check the\n  peak, the control number is not the overshoot.\n- Slow in / slow out: `easing` on the starting keyframe of every segment, per target weight; a\n  keyframe without `easing` is `linear` — right for a hold-to-swap, wrong for a pose change.\n- Holds: repeat the value on the next keyframe, or `\"easing\": \"step\"`. Keys read when they rest.\n- Follow-through: parts arrive at different times — a second target whose weight keyframes are\n  delayed, or a per-vertex track lagging the body.\n- Timing is the count of frames between poses; spacing near a pose is tight (ease), the middle is\n  wide. A morph under ~0.2 s reads as a swap — then write the swap.\n\n## 5. Breakdowns\n\nThe middle drawing is not the average of A and B. Favour one key, and add the extra movement the\nstraight path lacks (A → Z → B): a third outline keyframe, or a transient target that peaks mid-way\n(`weight` 0 → 1 → 0 across the A→B segment) on top of the track. Vertices travel straight lines, so\nan arc, a bulge or a lean exists only as a breakdown.\n\n## 6. Volume\n\nA squash keeps its area: lower by ×0.8, widen by ×1.25. For a target, the squash offsets lower\nthe top and push the sides out together, and stretch the horizontal handles of the top and bottom\nby the same ×1.25 (shorten the vertical ones by ×0.8) so the widened body stays round; for a whole-layer squash, `scale` `[1.25, 0.8]` with the\n`anchor` on the contact edge. Measure the ink area on `picsart_scene_contact_sheet` frames rather than trusting the numbers; the eye reads volume loss as deflation.\n\n## 7. Faces\n\n- Name mouth targets by the VRM presets: `aa`, `ih`, `ou`, `ee`, `oh`; eyes `blink`, `blinkLeft`,\n  `blinkRight`; moods `happy`, `angry`, `sad`, `relaxed`, `surprised`. Consonants borrow the nearest\n  vowel at a lower weight.\n- Mood geometry owns the corners, brows and lids; `aa`, `ih`, `ou`, `ee`, `oh` own the aperture and speech shape, whatever the mood strength. `speech` 1 reserves the aperture through the whole dialogue, pauses and closures included (a surprised O closes on m, b, p only inside that window); `speech` 0 restores the mood's resting mouth. Pass `visemes: [\"aa\",\"ih\",\"ou\",\"ee\",\"oh\",\"speech\"]` to `lipSync:visemes` and merge every returned track into the rig instance's parameters. A mood change eases 0.4 s from the evaluated current weights: key the current values, then the next recipe 0.4 s later with `ease_in_out` on the outgoing keys, and clear the outgoing mood weights; never reset to neutral at the change or step-select a mouth drawing to change a vector mood.\n- Visemes cross-fade: at any moment the viseme weights sum to about 1, each segment eased, with a\n  short hold on a stressed vowel.\n- Lip sync from word timings: `picsart_scene_apply_preset` with `preset` `lipSync:visemes`, `layerId` the\n  rig layer and in `params` the transcript (a `captions` `transcript`, as transcription returns it) and\n  the face's `visemes`; it merges one track per control into the rig layer's `content.parameters`. It opens a syllable per vowel group, leads the sound by 50 ms,\n  dips rather than shuts inside fast words, and closes on rests and on every m, b and p (60 ms shut up\n  to the release; `closures` lists them). `speaker` picks one singer's segments, `gain` scales the\n  opening, and `start`/`end` cut and rebase the tracks for a layer that plays only part of the song.\n- Replacement drawings: pass `mouthShapes` mapping each drawing's name to its number on a `mouth`\n  dial (`{\"rest\": 0, \"aa\": 1, \"oh\": 2}`) and a `mouth` track of `step` keys, one drawing per frame,\n  joins the others. A viseme without a drawing takes its nearest one.\n- \"Make this character say the line\" is `lipSync:visemes` on the rig. \"Make this photo talk\" is not: that\n  is a pixel video from the Picsart lip-sync models (`kling-avatar`, `heygen-talking-photo`,\n  `minimax-h3-max-lip-sync`, `bytedance-omnihuman-v1.5`), not editable animation.\n- A blink is in fast (~0.08 s), held closed (~0.06 s), out slower (~0.12 s), and keeps the face's\n  other targets running.\n- Talking while smiling = `happy` steady + visemes cycling + a corrective per viseme that dents or\n  pinches under the smile (`happyAa`, `happyOh`). Shape each viseme on the mouth as it is seen, the\n  held mood applied, then render every viseme at full weight with the mood on: a dent, a flat lip\n  or a pinched corner there is a missing corrective. The mouth and eyes sit before the head in\n  `items` so they paint on top.\n- Draw the mouth with a darker `stroke` over its `fill`, `\"lineJoin\": \"round\"`: the lip line reads at every\n  opening, and the round join softens the corners. The stroke follows the morphed outline.\n- End a grin in the silence: when a smile control opens the mouth (rig-humanoid's `happy` does past\n  about 0.6), ease it after the last word over ~0.12 s to where it rests closed. Check that every silent frame reads closed.\n- Keep a head turn moderate: talking to camera reads at about half the turn's range, and the full turn\n  only where the body itself is turned that far. An ear slides round the head with the turn and never\n  fades; hair trails the head by a couple of frames.\n- A wave lifts the hand up and forward at shoulder height, clear of the face outline: a forearm bent\n  across the cheek reads as a reach. Measure the clearance from geometry on every frame of the gesture.\n\n## 8. Scene-to-scene morph transitions\n\n- Three ways: direct (A's outline becomes B's, every frame honest); fast swap (the outline swaps\n  under `motionBlur: true` and a large move or spin, the eye fills in); hybrid (the key object\n  morphs directly, the rest leaves under a `mask` or slides out, new details enter last).\n- Pick 1–3 key pairs that share two of colour, shape, volume. Morph those first; if they do not\n  read, nothing else will.\n- Order: key pairs → the largest, least-detailed objects → small details last; the morphing layer\n  spans the cut (its `start`/`duration` cover both scenes), it belongs to neither scene.\n- Every moving element shares one direction and speed across the cut; colour changes ride on the\n  fill's keyframes timed with the outline's.\n- Verify with `picsart_scene_contact_sheet` stills at the cut ±2 frames and `picsart_media_track_motion` on the key pair.\n\n## 9. When not to morph\n\n- No two of colour/shape/volume in common → cut, dissolve or a catalog transition.\n- Raster media and text are not outlines; a `media` or `text` layer does not morph — bend it over an\n  art mesh (§10), or mask, scale or transition it.\n- Topology changes (open↔closed, a hole appears, a shape splits) → `step` swap or a dissolve.\n- Under ~0.2 s, or more than a few dozen vertices → a swap reads the same and is cheaper to author.\n\n## 10. Bending a picture and live pins\n\nA layer's `mesh` draws a `media`, `text`, composition or `scene_ref` picture over triangles so it\nbends: a `grid`, explicit `vertices` + `triangles`, or a mesh that follows a cut-out's transparency\nfrom `picsart_scene_apply_preset` with `preset` `mesh:auto`; then `deformers` (`bend`, `push`, `stretch`, `warp`, `skin`, `pins`)\nmove its points over time, each fading in and out on its `mix`. `pins` give free handles to a flag,\ntail, ear or sticker corner, with `stiffnessRegions` to keep a head firm on a bending body. Read\n[references/art-mesh.md](references/art-mesh.md) before writing a mesh, and\n[references/live-pins.md](references/live-pins.md) before writing pins. See also [traced SVG](references/traced-svg.md) and [follow-through, pixel art](references/layer-follow-through.md).\n\n## 11. Explicit skin weights\n\nWhen a limb, sleeve or imported mesh should follow painted bone influences instead of the automatic\nradius falloff, give the `skin` deformer `weights`, one row per mesh vertex or outline point. Read\n[references/skin-weights.md](references/skin-weights.md) before writing them: the rest-pose\nalignment, the row numbering, the blend band a bend needs, and the limits.\n\n## Tuning by hand — `picsart_scene_tune`\n\nOpen it as `motion-design-craft` describes. `rig-humanoid` and `rig-face` already declare their controls; a custom character exposes its own as `scene-building-basics` \"Reusable parts\" says. To keep a finished character, `picsart_scene_library_save` saves it under `Picsart Scene Library/Characters/<name>` with `name`, `kind: \"character\"`, `rights: \"own\"` (or `\"licensed\"` with a `license` note), and `scene` (the document or its HTTPS URL). Put render kinds (`vector`, `cutout`, `3d`, `live2d`, `spine`) in `tags`; assets and controls are derived from the scene. `previewUrl` supplies the portrait, or omit it to render one at `previewTime` (default 0); `videoUrl` is an optional demo. `pick: true` picks that version. `picsart_scene_library_list` with `kind: \"character\"` returns the picked version or newest, its durable `sceneUrl`, controls and version count; `tag`, `name` and `folderUid` filter it. USE a saved character with `picsart_scene_apply_template`, `uri: \"library:<libraryId>\"` (picked version or newest) or its `sceneUrl`: reference mode places its URL in a `scene_ref`, and inline mode copies its body into the host as a scene asset.\n\n## Not expressible (format findings, not rules)\n\n- Weight-indexed in-betweens: no target \"at weight 0.5\"; the mid pose is a second target cross-faded\n  by hand (§3).\n- Curved vertex trajectories: a vertex keyframe takes no spatial tangents (`inTangent`/`outTangent`\n  are honoured on `position`/`anchor` only), so an arc needs a breakdown keyframe.\n- A target's `weight.expression` reading another target's weight directly: unverified; the\n  corrective pattern goes through parameters.\n- No priority/override between procedural targets (VRM `overrideMouth`/`overrideBlink` block/blend):\n  conflicts are authored by hand.\n- `closed` is static and the hole count fixed: topology never morphs.\n- No automatic volume preservation under a squash target.\n"
Full snapshot data
{
  "description": "Build and animate a 2D cartoon character in a scene — rig-humanoid and rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync, a cut-out puppet built from named SVG parts, sockets, reach and held props — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting, choosing between outline keyframes, morph targets and per-vertex tracks, blend-target hygiene, timing (anticipation, overshoot, holds), volume-keeping squash, face visemes and blinks, scene-to-scene morph transitions, bending a picture over an art mesh, and explicit skin weights. Use when a cartoon character, mascot or face walks, waves or talks; when a path's outline changes shape over time — one drawing becomes another; a jelly, blob or character squashes, stretches, bounces, wobbles or breathes; a cartoon face talks (lip sync, mouth shapes), smiles or blinks; a cut is hidden by a morph; or an image, text or composition has to bend.",
  "included_files": [
    {
      "relative_path": "references/art-mesh.md",
      "size_in_bytes": 9305
    },
    {
      "relative_path": "references/character-motion.md",
      "size_in_bytes": 20752
    },
    {
      "relative_path": "references/cut-out-puppet.md",
      "size_in_bytes": 12651
    },
    {
      "relative_path": "references/head-turn.md",
      "size_in_bytes": 3994
    },
    {
      "relative_path": "references/layer-follow-through.md",
      "size_in_bytes": 1217
    },
    {
      "relative_path": "references/live-pins.md",
      "size_in_bytes": 11333
    },
    {
      "relative_path": "references/outline-mechanics.md",
      "size_in_bytes": 18106
    },
    {
      "relative_path": "references/part-sheet-prompt.md",
      "size_in_bytes": 15280
    },
    {
      "relative_path": "references/skin-weights.md",
      "size_in_bytes": 7651
    },
    {
      "relative_path": "references/sockets-and-props.md",
      "size_in_bytes": 7378
    },
    {
      "relative_path": "references/traced-svg.md",
      "size_in_bytes": 1408
    }
  ],
  "name": "character-rigging",
  "skill_md_contents": "---\nname: character-rigging\ndescription: Build and animate a 2D cartoon character in a scene — rig-humanoid and rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync, a cut-out puppet built from named SVG parts, sockets, reach and held props — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting, choosing between outline keyframes, morph targets and per-vertex tracks, blend-target hygiene, timing (anticipation, overshoot, holds), volume-keeping squash, face visemes and blinks, scene-to-scene morph transitions, bending a picture over an art mesh, and explicit skin weights. Use when a cartoon character, mascot or face walks, waves or talks; when a path's outline changes shape over time — one drawing becomes another; a jelly, blob or character squashes, stretches, bounces, wobbles or breathes; a cartoon face talks (lip sync, mouth shapes), smiles or blinks; a cut is hidden by a morph; or an image, text or composition has to bend.\nmetadata:\n  category: authoring\n  version: '1.7'\n  ported-from: shape-morphing 1.7 at 55.130.0\n---\n\n# Cartoon characters and shape morphing\n\nField names are the `path` item's (`picsart_scene_capabilities` with `sections: [\"schema:ShapeContent\"]`); the outline mechanics are in\n[references/outline-mechanics.md](references/outline-mechanics.md).\n\n## Named motions on a rig\n\nA rig document can declare root `actions`, named motions an instance plays: bone tracks go in\n`actions.<name>.layers`, drawing and order selectors in `actions.<name>.parameters`. Keep the\nskeleton and painted weights once, with static rest transforms; place the rig once and use the\n`scene_ref`'s `content.animation` to blend one action into the next (walk→idle). Set\n`content.blending: \"pass_through\"` so limbs can reach beyond the rig's frame without canvas padding:\nunder pass_through the frame sizes and places, it does not clip. A layer treatment that needs a\ncomposited result (mask, effect, non-normal blend, opacity below 1, motion blur, mesh, stroke or shadow,\nadjustment or look) isolates and clips it. Action bodies have time keys, no `$eval` or expressions;\nlayer expressions and constraints run after the mix. Step channels switch immediately. Delayed first\nkeys need the `beforeFirst: \"rest\"` action policy. `animations` is a layer field and the action stack is\n`content.animation`; root `actions` are distinct from a track content's sequential `clips`. `rig-humanoid` and\n`rig-humanoid-front` (the same body from the front) declare actions: `scene-animation-reference`. The schema is `picsart_scene_capabilities` with\n`sections: [\"schema:SceneAction\"]`; the full crossfade example is in\n`picsart_scene_recipe scene-animation-reference`.\n\n## 0. Cartoon character rigs\n\nA 2D cartoon character starts from a catalog rig when one fits, or from `picsart_scene_build_model` with\n`character: {svg, duration: 4}` for named SVG parts (\"Named SVG cut-outs\" below); without `svg` that tool builds a 3D\nmodel. Not from hand-written joint Lua: one no rig fits is built by hand from bent limbs and `ik`\n([references/character-motion.md](references/character-motion.md), which also builds an arm as one shape), its ink lines\npointed at the ends with a stroke `taper` (\"Ink lines\" below).\n`picsart_scene_templates` with `tags: [\"cartoon\", \"rig\"]` lists them:\n\n| Template | What it is |\n|---|---|\n| `scene://rig-humanoid` | A whole body, three-quarter view facing right, 600×1000, transparent |\n| `scene://rig-face` | A face from the front, 800×800, transparent |\n\nPlace one as a `scene_ref` layer (`picsart_scene_apply_template`, reference mode); size it with the layer's\n`transform.scale` or `bounds`, and mirror it (`scale` x negative) to face left. Every part is a shape\nlayer pivoting on its joint. Each arm and leg is one outline bent at the elbow or knee (a `bend` with\nan `id`), posed by an `ik` constraint that reaches for a target layer (`leftFootTarget`,\n`rightHandTarget`, ...); the hand or foot is `attach`ed to the limb's end\n([references/character-motion.md](references/character-motion.md)). The torso and neck are one outline\n`skin`ned to the empty `spine` and `neck` bone layers, which `spineLean` and `headNod` turn inside\nthe `min`/`max` on their rotation tracks; the arms hang from `spine` and the head from `neck`.\nThe template poses the parts from its parameters, and each FK parameter's `min`/`max` is its joint's\nlimit. Animate only the parameters: key them in the layer's\n`content.parameters` (`{\"leftUpperArmRaise\": {\"keyframes\": [...]}}`), or apply a rig preset.\n\n**Standard control names**, shared with 3D characters: a face takes VRM expressions, a body `<vrmBone><Motion>`, hair, ears and tails `<part><Motion>` (`Sway` is a side-to-side pendulum). Any rig of the same type uses the same names\nand ranges, so a preset or a keyed track moves every one of them.\n\n| Rig | Parameter | Range | Meaning |\n|---|---|---|---|\n| both | `blink`, `blinkLeft`, `blinkRight`, `aa`, `happy` | 0..1 | eyes shut, one eye shut (the left eye is on + x), mouth open, smile |\n| both | `headTurn`, `headNod`, `headTilt` | −1..1 | turn toward the viewer's right (0 face on, ±1 a three-quarter view; on the humanoid + toward +x the way its body faces), chin down, roll clockwise |\n| both | `lookUp`, `lookDown`, `lookLeft`, `lookRight` | 0..1 | irises' direction; `lookLeft` is + x on screen (on the humanoid an eye turned away travels less across) |\n| both | `ih`, `ou`, `ee`, `oh` | 0..1 | the other visemes |\n| humanoid | `browInnerUp`, `browOuterUpLeft`, `browOuterUpRight`, `eyeWideLeft`, `eyeWideRight` | 0..1 | both brows' inner ends up; one brow's outer end up; one eye opened wide (a blink still shuts it) |\n| face | `sad`, `angry`, `surprised`, `relaxed` | 0..1 | moods (mouth, eyes, brows); the humanoid rigs and `rig-face` carry them with `happy`. The six mood actions are `happy`, `sad`, `angry`, `surprised`, `scared` (sad + surprised + `browInnerUp`) and `sleepy` (relaxed): no `scared` or `sleepy` dial |\n| humanoid | `spineLean`, `hipsRaise`, `hipsTilt` | −1..1 | torso lean ±20° (+ forward); hips ±60 px (+ up); pelvis roll ±10° (+ clockwise, the + x hip drops), the legs following on their IK and the shoulders tilting against it |\n| humanoid | `breath` | 0..1 | breath: the chest swells, shoulders and head rise |\n| humanoid | `<side>UpperArmSwing` / `UpperArmRaise` / `UpperArmOpen` / `ShoulderRaise` / `LowerArmSwing` / `HandSwing` | −1..1 / 0..1 / 0..1 / 0..1 / −1..1 / −1..1 | arm ±80° (+ forward); raised forward and up 0..160° (0 hangs, 0.5 forward, 1 overhead; the front view draws it foreshortened); opened out to the side and up 0..180° (0 hangs, 0.5 sideways, 1 overhead; drawn foreshortened as it opens toward or away from the camera on the side and three-quarter views); shoulder lifted 15 px at 1 (the shrug); elbow ±150° (+ folds forward, toward the midline on a front view; − the other way: up beside the head on an opened near arm; on the far three-quarter arm, which opens forward, up beside the head is +); wrist ±40° |\n| humanoid | `<side>UpperLegSwing` / `LowerLegSwing` / `FootSwing` | −1..1 / 0..1 / −1..1 | leg ±70°; knee 0..140° (elbow and knee limits are their bends' `min`/`max`, binding IK too); toe up ±35° |\n| humanoid | `<side>HandSpread`, `<side>HandPoint`, `<side>HandFist`, `<side>HandGrip`, `<side>HandThumbsUp` | 0..1 | hand poses on a palm, four fingers and a thumb, the relaxed open hand at 0: fingers fanned (the waving hand), the index pointing, a fist, curled fingers with an opposing thumb (grip), the thumb out from curled fingers; the five share the hand (scaled to 1 above a sum of 1, the relaxed hand filling the rest), so a crossfade is two keyed weights over 0.4 s, `ease_in_out`; every pose has the same path topology, so there is no swap between duplicate hands. A grip is a silhouette, not a prop contact |\n| humanoid | `held`, `heldBy`, `<side>HandToHeld`, `<side>HandHeldAt` | clip / right·left·chest·mouth·none / 0..1 / vec2 | the prop the character holds, who carries it, a hand brought onto it, and where on the prop that wrist lands ([references/sockets-and-props.md](references/sockets-and-props.md)) |\n| humanoid | `<side>HandIk`, `<side>FootIk` | 0..1 | the limb's `ik` `mix`: from the swings to the target (feet default 1, hands 0) |\n| humanoid | `<side>HandX/Y`, `<side>FootX/Y` | −400..400 | the target layer, rig px from the resting wrist or ankle |\n| humanoid | `hairSway`, `hairRaise`, `earSway` | −1..1 | follow-through, morphs inside the head: hair and quiff swing (+ toward + x), hair raise (+ up), ear rim swing (+ toward + x); key them a few frames behind the head |\n| humanoid | `headSize` | 0.8..1.25 (1) | head size: the whole head (features, hair, ears) scales about the neck, the body does not; the planted feet and every limb are untouched |\n| humanoid | `hairStyle`, `faceShape` | whole numbers 0..2 | which drawing shows: hair 0 the cap with a fringe, 1 cropped, 2 a tall quiff with long sideburns; skull 0 round, 1 long (chin 14 px lower), 2 short (chin 14 px higher). Drawings swap with `step` keys, they do not blend; the other head controls (`hairSway`, `hairRaise`, `headTurn`) move every style |\n\n`<side>` is `left` (the far side, behind the body) or `right` (the near side).\n\n**Named SVG cut-outs.** An editable vector character from an approved SVG drawing, with no generation, bitmaps or Blender:\n`picsart_scene_build_model` with `character: {svg, view, duration}` replies `{scene, sockets}`. Pass `svgUrl`, the `url` of the generation result that drew the sheet, in place of `svg`: the server fetches it (Picsart-hosted https only), so the markup never passes through your context. `view` is `front`, `threeQuarter` or `side` (a multi-view\nsheet without `view` is refused; a single-view SVG declares `data-view` and `data-facing`).\n\n- **Draw the sheet from the frozen turnaround prompt** in [references/part-sheet-prompt.md](references/part-sheet-prompt.md): one 1536×1024 sheet, front and three-quarter A-poses, relaxed profile, same outfit, complete overlapping parts, full-width far arm, one closed hair mass, round strokes, optional gradients. The whole body must be requested turned; near side = ear side.\n- **Check before building.** `character: {svg, check: true}` checks the whole sheet and builds nothing. Open `pictureCheck.path` (body | near arm+leg | far arm+leg in each view row) and read its named pass/fail checks for parts, joint union, far-arm width, hair closure and head group. Check proportions, arm and neck/collar order and complete parts with markers hidden, and get the user's OK on the picture before building; an approved picture stays valid.\n- **The builder owns sides and order.** Geometry assigns character sides (front right = image-left; facing right, right = near = the image-left ear side; facing left, left = near = image-right); source suffixes and socket labels are advisory. Role order throughout motion: far hand < lowerArm < upperArm < torso < near upperArm < hand < lowerArm; head above neck and torso; neck below the collar. Rest angles come from the source joints; presets use absolute targets.\n- **Parts:** torso, head, optional hips and neck, paired upperArm, lowerArm, hand, upperLeg, lowerLeg, foot, and skirt, coat, coatBack, tail, scarf, backpack, cap, straps, strapL, strapR, hairBack (follows the head, below the torso). A named skirt keeps its complete hem rigid on the hips; other lower garments share hip and thigh skin. A marker lies in the union of adjacent parts or the covering garment (four source px edge tolerance, twelve on hidden far parts); paired links normalise within 8%. Exactly one unnamed top-level non-marker group may supply an absent head.\n- **Face and hands.** Named head `eyeL/R`, nested `pupilL/R`, `browL/R`, `mouth` and `hairFront` expose blink, look, brow and closed-mouth viseme controls; the profile hides the far eye and brow, and brows draw over hair. No mouth artwork is invented, and unnamed face art stays static. Hands and shoes stay rigid unless a complete matching set of hand poses is authored. Unsupported SVG constructs refuse by id; linear and radial gradients are supported.\n- **Walk it.** Side defaults are stride 160 rig px (±80), lift 40 and armSwing .22; the three-quarter view scales stride and armSwing by cos 45° (113, .16) and keeps lift 40, and turned views walk with closed arms. Explicit arguments win. Prefer three-quarter or side for walks and front for rest, idle and face shots. Hosting, framing and the walk are tool calls only (the \"Prompt to walk\" steps in the sheet reference).\n\nRig behaviour (controls, a garment over the legs, draw order) and the checks to run after a build: [references/cut-out-puppet.md](references/cut-out-puppet.md).\n\n**IK.** A limb on IK puts its wrist or ankle on the target and bends at the elbow or knee to reach it\n(knees fold forward, elbows back); a target out of reach straightens the limb toward it. The swings\nstill pose the limb under a partial `mix`. The targets are in the rig's own space and stay where they\nare while the body moves, so a foot that keeps its target is planted: lower\n`hipsRaise` and the knees bend. To touch something, set `<side>HandIk` 1 and bind the absolute, composition-space `<side>HandTarget` parameter; its default follows `<side>HandX/Y` offsets from the resting wrist. The parameter drives the same-named target layer, whose final placement is the arm solve's goal, so an `attach` or `ik` constraint on that layer overrides the input through the same path. Those constraints stay inside the rig's composition; a parent binds inputs through the instance and reads its published sockets, without addressing internal layers.\n\n**Sockets, reach and held props.** A placed character publishes sockets (`head`, `chin`, `chest`, hands, grips, feet, `seat`, `mouth`, `held`; a dog or cat `mouth`, paws, `body`, `tail`): a parent targets `{\"layer\", \"socket\"}` and Lua reads `getSocket`. A `reach` constraint on the instance layer puts a socket on a stage point (`{\"type\": \"reach\", \"socket\": \"rightHand\", \"target\": {\"layer\": \"ball\"}, \"mix\": 1}` lands a hand on a ball; `\"seat\"` on a bench seats the character). A humanoid rig or a dog or cat holds a prop itself through `held` and `heldBy` (`right`, `left`, `chest`, `mouth`, `none`; an animal only `mouth` or `none`), two hands by `<side>HandToHeld`. Tables, the `via` dial, carriers and worked cases: [references/sockets-and-props.md](references/sockets-and-props.md).\n\n**Read the bone map.** `picsart_scene_inspect` with `mode: \"rig\"`; pass an embedded rig asset key as `scope` and optionally `layer` for a subtree. Read entries in order, indenting by `level`: hips first, parents before children. The map derives bones from skins and constraints, so an unreferenced joint mark is absent; `parentId` is parenting, not art ownership. A standard name is that bone (`leftUpperArm` names the left upper arm). Keep imports' source names; any non-standard layer, including an imported bone or a plain parent frame, reads `helper` (IK targets read `target`); a helper is an ordinary layer, not a separate skeleton declaration. Placements resolve `$eval` at scoped parameter defaults, without use-site bindings: read them as authored rest, not a posed measurement. Drivers are lexical reads; Lua, time tracks, poses and automatic weights are not evaluated. Use `picsart_scene_query_layout` for evaluated geometry.\n\n**Gesture arms: raise × elbow.** Up to a 60° raise (`UpperArmRaise` ≤ 0.375), the natural\nelbow bend folds the hand onto the face. Measured safe pair for a talking gesture, a point or a shrug:\n`UpperArmRaise` 0.25–0.36 with `LowerArmSwing` 0.45–0.55. Unsafe, hand at the nose or mouth: raise 0.36\nwith elbow 0.85, raise 0.2 with elbow 0.7. Swing the hand with `HandSwing`, not by bending the elbow\nfurther, and check a `picsart_scene_contact_sheet` for the hand against the head.\n\n**The wave rule** (stated once; the presets, the actions and the robot all follow it). A wave keys one world pose: the arm out and up beside the head, the forearm up (an opening near 0.7). Where that pose runs through the arm's pole (pointing at the camera) on a 2D rig, the preset keys the in-plane dial instead, picking its row by the rig's `viewAngle`, with the forearm's sign following the view's + side: one preset, three rows, no new control. Front (0): `UpperArmOpen` 0.68–0.76 with `LowerArmSwing` −0.2 to −0.35. Three-quarter (45) and side (90): `UpperArmRaise` 0.5–0.6 with `LowerArmSwing` +0.25 to +0.35, the hand standing in front of the head, clear of the face. `HandSwing` swings on every row.\n\n**Draw order.** The far arm and leg draw behind the torso and the near ones in front, by document\norder; an arm hangs outside its thigh, so the far arm draws behind the far leg and the near arm in\nfront of the near leg. An `ik` chain authors no depth (a `z` within ±1, static or a keyed `by` track with no expression, only orders the drawing and is allowed on a chain bone), so the order holds in every pose of a flat scene: a raised far\narm stays behind the head (wave with the near arm, or the far arm forward beside the face), and a far\nhand swung forward past the far thigh stays behind it. The near hand shows its back, the far hand its\npalm; both thumbs sit on the forward edge. A turned face's far ear goes behind the head, driven by\n`headTurn`: don't key `z` yourself. The order holds only while the whole composition is flat: put one layer in depth (a `z` beyond ±1, an expression `z`, `rotationX`/`rotationY`) or orbit the camera and every `z` of the scene, the rig's too, is depth (an `ik`, `skin`, `follow_through` or preset travel on a chain is then refused, and the validator warns `z_order_mixed_with_depth`).\n\n**Motion.** Everything goes on the rig's `scene_ref` layer with `picsart_scene_apply_preset`\n(`preset` `motionPreset:<id>`, `layerId` the rig layer), and writes bindings in its `content.parameters`:\n\n- `walk_cycle` (tag `rig-motion`): one stride of keys (two steps of `stepDuration`) from `start`,\n  looped with `ctx:loopOut`; keys the foot targets (`<side>FootX/Y`, `FootIk` 1) and `FootSwing`,\n  `hipsRaise`, `spineLean`, `headNod` and the arms' swings, forearms and hands lagging, and moves the\n  layer (`travel` `forward`, or `in_place`). Each step the body eases one stride forward while the\n  planted foot's target eases the same stride back, so the foot stays put. A rig missing one of those\n  names is refused, naming it.\n  **A walk that stops** (a walk-in, a stop, an action, a walk on): `steps` `N` walks `N` whole steps and\n  stops with every walking parameter on its rest value, instead of looping. `from` `rest` opens with a\n  half-step out of the rest pose and ends with the half-step back, so the layer carries `N` × `stride`\n  (the half-steps count as one of the `N`); `from` `walking` (the default) starts on the first walking pose\n  and adds the closing half-step. Both feet are planted whenever neither is lifted, in the half-steps too.\n  Pitfall: never settle the rig by hand after a `steps` walk (a key on the same parameters is a second\n  writer, and pops at the stop); the arms take 0.15 s longer than the feet to come to rest. Use a fresh\n  `walk_cycle` for the next walk, `start` after the action. `steps` with `travel` `forward` needs the same\n  plain layer as the loop.\n- `ground_scroll` (tag `rig-motion`): the set's side of a walk across a scrolling background. Walk the rig\n  `in_place`, put the scenery under one parent layer (an empty one is fine), and apply `ground_scroll` to\n  that parent with the walk's own `start`, `stepDuration`, `stride`, `steps` and `from`, `direction`\n  `right` for the rig as drawn (`left` for a mirrored one) and `walkerScale` the walker layer's drawn size\n  (its scale times its fit; `stride` is in rig px). The parent moves against the travel on the same clock,\n  so the planted foot stays still on the ground; pair it with the camera's `push_in` on a pivot at the\n  walker. Pitfall: change a walk's numbers in both presets, or the feet slide.\n- Gestures (tag `rig-motion`, `gesture`): `wave`, `talk_beat`, `point` and `shrug`, each `start`,\n  `duration` (seconds from the arm leaving rest to its return), `amount` 0..1, and for `wave`, `talk_beat`\n  and `point` a `side` (`right` the near arm, `left` the far one); `wave` and `talk_beat` also `count`\n  (swings or beats). They return every control to rest (`wave` keys the wave rule above; the others lift the arm inside the safe pair, raise 0.25 to 0.36 at an\n  elbow of 0.45 to 0.55, so the hand stays off the face). `wave`: the hand swings from the\n  wrist `count` times. `talk_beat`: the forearm beats with the speech, the hand follows. `point`: the arm's\n  IK takes the wrist to `targetX`, `targetY` (rig px from where it rests, y down, default up and\n  forward); the limb straightens toward a target out of reach, and the hand forms a point (`HandPoint`). `shrug`: both arms, the hands turned, the\n  head tilts and the breath rises (no `side`, no `count`). Use cases: a greeting, a character talking with\n  its hands, indicating an object, an \"I don't know\". Pitfalls: a gesture replaces a walk's bindings of the\n  same arm (the result's notes say so), so apply it after the walk and give it a `start` inside the\n  walk; `point` is IK, so a hand at a fixed target stays there while the body moves.\n- `acting` (tag `rig-motion`): the character acts from commands. Key the text parameter `action` on\n  the scene holding the rig layer (the preset declares it, default `idle`, when it has none) and the\n  rig plays each key's motion from that key: `idle` (weight shifting leg to leg),\n  `wave` (the near arm), `point` (the near arm, head and eyes at `pointX`/`pointY`, rig px),\n  `talk` (head nods, brow lifts and hand gestures on beats; the mouth is the visemes', keyed apart),\n  `walk` (`walk_cycle` from a half step on the key, closing the feet with a step when it stops, so no\n  planted foot slides; `stepDuration`, `stride`, `lift`, `armSwing`, `bob`, `lean`, `travel` as\n  `walk_cycle`'s). Its text parameter `action` selects a preset command; the `action` field in\n  `content.animation` selects a named action from the rig document. Any other text plays `idle`.\n  Each switch crossfades over `fade` (0.2 s), longer for a joint with further to go, what was playing carrying on under it, the forearm, hand and head\n  trailing by 2 frames or more:\n  `{\"action\": {\"type\": \"text\", \"animatable\": true, \"default\": {\"keyframes\": [{\"time\": 0, \"value\": \"idle\"},\n  {\"time\": 2, \"value\": \"wave\"}, {\"time\": 4, \"value\": \"walk\"}, {\"time\": 7, \"value\": \"point\"}]}}}`.\n  It drives every name its clips key and the walk's, so on one rig it takes the place of\n  `walk_cycle`, never beside it; for life add `random_pulse` on `blink` and `cycle` on `breath`,\n  which it leaves free. The clips key standard\n  names only, so any rig with them acts. One `action` serves every rig in its scene: give each character its own scene to act\n  apart.\n- Actions (tag `rig-motion`): `jog`, `jump`, `think` and `idle`, each `start`, on every humanoid rig (rig-humanoid,\n  rig-humanoid-front, a cut-out of either view). `jog` loops in place: `stepDuration` (0.3 or less) per step, both feet\n  off the ground for about 0.4 of it, `lift`, `bob`, `armSwing`, `elbow`, `lean`; `view` `side` (default) swings the feet\n  fore and aft over `stride` / 4 (pair it with `ground_scroll`, `pace` `constant`, the same `stride`), `front` for\n  rig-humanoid-front or a front cut-out lifts them on the spot. `jump` (`duration` 1.2, `height` up to 60, `tuck`,\n  `crouch` 1, `view`): crouch of the hips' full 60 px with the arms back, spring, knees tucked at the top, land, take\n  the landing and settle on the rest pose; the rise is the hips' own, so the figure stays in its frame. `think`\n  (`duration` 3, `side`): the arm's IK reaches toward the rig's chin and holds through the middle 40%, the other arm\n  hangs; it keys `<side>HandIk` and `<side>HandToChin` (0..1, default 0), which blends the `<side>HandTarget` layer toward\n  an `attach` target on the head (the chin plus the rig's wrist-contact offset, carried through the head's placement and\n  deformers), so contact geometry stays inside the rig. `idle` (`period` 3, `amount`): breath, head sway a quarter\n  period behind it, a weight shift and one blink a period, looping seamlessly, the arms left at the sides.\n  Each rig also declares `<side>AnchorShoulder` and `<side>AnchorEye` (vec2, absolute rig px): the shoulder a `point`\n  aims from and the eye its head follows; a rig missing one is refused (`rig_parameters_missing`). Every humanoid rig\n  declares read-only `viewAngle` (degrees from facing the camera: front 0, three-quarter 45, side 90), read into a\n  preset's scope beside the anchors; a rig that declares none is not assumed to be a side view, and `point` is refused\n  by the name. The anchors and the angle are the rig's own geometry: a `scene_ref` binding one is refused by name. An\n  arm opened toward the lens has no direction on a side or three-quarter view, so its drawn length fades to nothing\n  there and the forearm takes its direction from the arm's 3D pose; no joint jumps.\n- Everything else is a parameter driver with `parameter` naming the rig's control — the \"Parameter\n  drivers\" table in [references/character-motion.md](references/character-motion.md):\n  `random_pulse` on `blink`, `cycle` on `breath` (sine, ~3.5 s, `to` ≈ 0.6), `random_hold` on the\n  `look*` gaze. A different `seed` per character keeps two from blinking together. Parameter-mode\n  `follow_through` on catalog-rig controls needs an owned scene body: a binding reads its host's\n  parameters, not the rig's. Omit `parameter` to apply world-motion layer physics to a rig layer.\n\nThey combine on names they do not share: `walk_cycle` or `acting` with the blink and breath\ndrivers. A walk's travel follows the layer's size\nwhen it is applied: set the layer's scale first. Travel needs a plain layer (no look, effect,\nparent, transform track or component ahead, speed 1, untrimmed); anything else takes `in_place`. One\npreset drives a name on a rig: a preset writing a name another preset already drives there is\nrefused as `rig_parameter_driven`, naming both; re-applying the same preset, or writing over a name\nyou keyed by hand, replaces that binding and says so in `notes`.\n\nVerify a walk on a contact sheet (`picsart_scene_contact_sheet`): the legs alternate, the arms swing\nagainst them, and the planted foot does not slide. `lift` is the foot's clearance in rig px, not a 0..1 dial: a walk lifts about 24–40, a run up to about 100, and `lift: 1` barely steps. After setting the walk or jog numbers, check one loop with `picsart_scene_check_motion` `value_range` on `<side>FootArt` `centerY` for both feet (the amplitude, in the host's root pixels, is at least 0.8 × `lift` × the rig layer's scale: a rig placed at 0.25 moves a quarter as far), and look at the frames for clearance and for contact alternating. Show a walk, jog or run only in the three-quarter or side view, never the front view: the front view gets the rest or idle pose and face acting.\n\n**Ink lines.** A hand-drawn line thins at its ends and swells in the middle: a stroke with a `taper`.\n\n```json\n{\"type\": \"stroke\", \"color\": \"#1a1a1a\", \"width\": 7, \"lineCap\": \"round\",\n \"taper\": {\"startLength\": 0.5, \"endLength\": 0.5}}\n```\n\n`startLength`/`endLength` are shares of each contour's length (`lengthUnits: \"pixels\"` for px), and\nthe line narrows to `startWidth`/`endWidth` (shares of `width`, default 0, a point) over them;\n`startEase`/`endEase` (0..1) bow the ramp so the width recovers sooner. The lengths are measured on\nthe outline as drawn, after a `bend` or a `trim`, so a bent limb keeps its thin ends and a draw-on\nkeeps its point on the moving end. `wave` swells and narrows the width along the line.\n\n**A 2D head turn.** `headTurn` (0 face on, ±1 a three-quarter view, + toward + x) and `headTilt` are the one turn and tilt dials of both rigs: key them, never the features. A face built by hand turns the same way (feature depths, eyes, outline morphs, ears, timing, profile swap, verify sweep): read [references/head-turn.md](references/head-turn.md). Set `headSize`, `hairStyle` and `faceShape` per instance, never keyed across a shot (a keyed `hairStyle` pops); a different build is a second rig. `headSize` above about 1.2 with hairStyle 2 lifts the quiff 80 px higher, so leave headroom.\n\n## 1. Prepare the drawings\n\n- Draw A and B each as its own best outline, then match them — the three things a morph needs:\n  the same vertex count, the same winding (the sign of the signed area, Σ (xᵢ·yᵢ₊₁ − xᵢ₊₁·yᵢ),\n  agrees) and the same start vertex on the same feature of both drawings.\n- A missing vertex is added, not faked with a handle: an eased segment needs equal counts\n  (`shape_path_vertex_count_mismatch`), and a handle dragged to stand in for a corner bulges mid-morph.\n- Corresponding vertices should sit on the same feature of both drawings (top-centre to top-centre,\n  tip to tip). Every vertex travels a straight line to its twin; unrelated twins cross and the\n  outline twists through itself.\n- Give the outline enough vertices for its roundest pose, and no more: 8 round a blob or a mouth,\n  evenly spread, a flat contact edge included. With fewer, each span carries a bigger bend and the\n  squashed, stretched or opened poses go lumpy. A morph reads through clear silhouettes. A drawing with many sub-shapes, holes or an\n  open↔closed change does not morph; it swaps (§2) or dissolves.\n- Round stays round: every smooth vertex carries `inTangent`/`outTangent` in every pose, sized to\n  that pose (`r · 4/3 · tan(π / 2N)` for N vertices on a circle of radius r, `0.552·r` at 4). A pose\n  that opens, widens or grows lengthens its handles in proportion; handles kept from a smaller pose\n  flatten the curve and leave corners. A vertex without handles is a deliberate corner.\n- A morph changes the outline only: the drawing's `fill` and `stroke` (width, join, cap) stay as\n  drawn. A colour change rides on the fill's own keyframes, not on the outline.\n\n## 2. Choose the technique\n\n| Need | Write |\n|---|---|\n| One drawing becomes another (A→B, A→B→C) | `vertices` keyframe track, one `easing` per segment |\n| Independent changes that mix (open + smile + blink) | `morphs`: named targets, each with its own `weight` |\n| One part on its own timing (tail tip lags, one mouth corner) | static `vertices` list, that vertex's `point`/handles keyframed |\n| Replace drawings without blending (mouth charts, frame-by-frame) | `\"easing\": \"step\"` on the earlier keyframe; counts may differ |\n| A catalog mouth or cartoon wipe, no outlines of your own | `picsart_scene_looks {\"tags\": [\"cartoon\"]}`: `mouth_shapes` takes `shape` as a name (the visemes `rest`/`aa`/`oh`) or a step track of names; `squash_wipe` uncovers its layer |\n| Loop, breathe, wobble | `vertices.expression`: `return ctx:loopOut(\"cycle\")` repeats the outline keyframes; or a target whose `weight.expression` cycles (`return picsart.oscillate(time, 0, 1, 1.2)`), or a `scale` expression |\n\nA path has one driver: a `vertices` track or per-vertex tracks, never both (`shape_path_driven_twice`).\n`morphs` add on top of either, so a wobbling base can still smile.\n\n```json\n{ \"type\": \"path\", \"closed\": true,\n  \"vertices\": { \"keyframes\": [\n    { \"time\": 0.0, \"easing\": \"step\", \"value\": [\n      {\"point\": [0, -80], \"inTangent\": [-44, 0], \"outTangent\": [44, 0]}, {\"point\": [80, 0], \"inTangent\": [0, -44], \"outTangent\": [0, 44]},\n      {\"point\": [0, 80], \"inTangent\": [44, 0], \"outTangent\": [-44, 0]}, {\"point\": [-80, 0], \"inTangent\": [0, 44], \"outTangent\": [0, -44]}] },\n    { \"time\": 0.4, \"easing\": \"ease_in\", \"value\": [\n      {\"point\": [0, -80], \"inTangent\": [-44, 0], \"outTangent\": [44, 0]}, {\"point\": [80, 0], \"inTangent\": [0, -44], \"outTangent\": [0, 44]},\n      {\"point\": [0, 80], \"inTangent\": [44, 0], \"outTangent\": [-44, 0]}, {\"point\": [-80, 0], \"inTangent\": [0, 44], \"outTangent\": [0, -44]}] },\n    { \"time\": 0.7, \"easing\": \"ease_out\", \"value\": [\n      {\"point\": [12, -96], \"inTangent\": [-46, 0], \"outTangent\": [46, 0]}, {\"point\": [96, 10], \"inTangent\": [0, -46], \"outTangent\": [0, 46]},\n      {\"point\": [-8, 70], \"inTangent\": [46, 0], \"outTangent\": [-46, 0]}, {\"point\": [-70, -14], \"inTangent\": [0, 46], \"outTangent\": [0, -46]}] },\n    { \"time\": 1.0, \"easing\": \"ease_in_out\", \"value\": [\n      {\"point\": [0, -130], \"inTangent\": [-22, 0], \"outTangent\": [22, 0]}, {\"point\": [40, 0], \"inTangent\": [0, -72], \"outTangent\": [0, 72]},\n      {\"point\": [0, 130], \"inTangent\": [22, 0], \"outTangent\": [-22, 0]}, {\"point\": [-40, 0], \"inTangent\": [0, 72], \"outTangent\": [0, -72]}] },\n    { \"time\": 1.2, \"value\": [\n      {\"point\": [0, -120], \"inTangent\": [-26, 0], \"outTangent\": [26, 0]}, {\"point\": [48, 0], \"inTangent\": [0, -66], \"outTangent\": [0, 66]},\n      {\"point\": [0, 120], \"inTangent\": [26, 0], \"outTangent\": [-26, 0]}, {\"point\": [-48, 0], \"inTangent\": [0, 66], \"outTangent\": [0, -66]}] }\n  ] } }\n```\nHold (0–0.4, `step` on an identical outline) → breakdown at 0.7 that is not the midpoint → overshoot\npast B at 1.0 → settle on B at 1.2. Each pose carries its own handles (`0.552 ×` its half-width or\nhalf-height), so the circle stays round on its way to the tall ellipse.\n\nA `puckerBloat` item puffs or pinches a whole outline (`amount` animatable): see [references/outline-mechanics.md](references/outline-mechanics.md) \"Puff or pinch a whole outline\".\n\n## 3. Targets (blend-shape hygiene)\n\n- One target, one change, small: `jawOpen` moves the jaw vertices only, `{}` for every other vertex.\n  Targets that each touch everything fight when mixed.\n- A target that moves a smooth vertex moves its handles too: offset `inTangent`/`outTangent` along\n  with `point` so that in the target pose the handles still point along the outline (parallel to the\n  line between the vertex's two neighbours) and stay in proportion to the new curve (an opening lip's\n  handles lengthen as it drops). An offset with `point` alone keeps the base's handles: what grew goes\n  flat, what turned kinks.\n- A corner that opens gains handles in the target: a closed mouth meets at sharp corners, an open one\n  is rounded there, so `aa`/`oh` give each mouth corner short handles along the lips. A corner stays\n  sharp only where the open drawing is sharp too.\n- Offsets are relative to the base outline, so the base may be redrawn; the vertex count may not —\n  every target has one offset per vertex (`shape_path_morph_vertex_count_mismatch`).\n- A combination that looks wrong (smile × jawOpen pinches the corners) gets a corrective target whose\n  offsets are only the fix, weighted by the product of the two drivers. Drive the two from\n  `animatable` parameters and read them in the corrective's `weight.expression`.\n- An in-between (the half-open mouth is not half of the open mouth): author a second target for the\n  mid pose and cross-fade — `mid` rises 0→1 while `full` stays 0, then `mid` falls 1→0 as `full`\n  rises 0→1.\n- Keep weights in 0..1 except for a deliberate overshoot or anticipation (§4); weights are not clamped.\n\n```json\n\"parameters\": { \"smile\": { \"type\": \"number\", \"default\": 0, \"animatable\": true },\n                \"jaw\":   { \"type\": \"number\", \"default\": 0, \"animatable\": true } },\n...\n{ \"type\": \"path\", \"closed\": true, \"vertices\": [\n    {\"point\": [-60, 0]},\n    {\"point\": [-30, -8], \"inTangent\": [-19, 2], \"outTangent\": [9, -1]},\n    {\"point\": [0, -9], \"inTangent\": [-11, 0], \"outTangent\": [11, 0]},\n    {\"point\": [30, -8], \"inTangent\": [-9, -1], \"outTangent\": [19, 2]},\n    {\"point\": [60, 0]},\n    {\"point\": [30, 8], \"inTangent\": [19, -2], \"outTangent\": [-9, 1]},\n    {\"point\": [0, 9], \"inTangent\": [11, 0], \"outTangent\": [-11, 0]},\n    {\"point\": [-30, 8], \"inTangent\": [9, 1], \"outTangent\": [-19, -2]}],\n  \"morphs\": {\n    \"happy\": { \"offsets\": [\n        {\"point\": [-2, -10]}, {\"inTangent\": [0, -2], \"outTangent\": [0, 1]}, {},\n        {\"inTangent\": [0, 1], \"outTangent\": [0, -2]}, {\"point\": [2, -10]},\n        {\"inTangent\": [-1, -4], \"outTangent\": [0, 2]}, {}, {\"inTangent\": [0, 2], \"outTangent\": [1, -4]}],\n      \"weight\": { \"expression\": \"return ctx.composition:getParameters():smile()\" } },\n    \"aa\": { \"offsets\": [\n        {\"point\": [4, 16], \"inTangent\": [0, 12], \"outTangent\": [0, -12]},\n        {\"point\": [2, -6], \"inTangent\": [1, 4], \"outTangent\": [-1, -2]},\n        {\"point\": [0, -9], \"inTangent\": [1, 0], \"outTangent\": [-1, 0]},\n        {\"point\": [-2, -6], \"inTangent\": [1, -2], \"outTangent\": [-1, 4]},\n        {\"point\": [-4, 16], \"inTangent\": [0, -12], \"outTangent\": [0, 12]},\n        {\"point\": [-2, 38], \"inTangent\": [-1, -4], \"outTangent\": [1, 2]},\n        {\"point\": [0, 41], \"inTangent\": [-1, 0], \"outTangent\": [1, 0]},\n        {\"point\": [2, 38], \"inTangent\": [-1, 2], \"outTangent\": [1, -4]}],\n      \"weight\": { \"expression\": \"return ctx.composition:getParameters():jaw()\" } },\n    \"happyAa\": { \"offsets\": [{\"point\": [2, 3]}, {}, {}, {}, {\"point\": [-2, 3]}, {}, {}, {}],\n      \"weight\": { \"expression\": \"local p = ctx.composition:getParameters() return p:smile() * p:jaw()\" } } } }\n```\nEight vertices clockwise from the left corner: corners 0 and 4, upper lip 1–3, lower lip 5–7. The\nlips are smooth, each handle `4/3 · tan(Δθ/4)` of the arc it spans. `aa` opens to a round mouth\n(a 56 × 34 half-axis ellipse): every lip vertex moves with its handles, and the corners gain handles\nof 12 so the open mouth rounds off there. `happy` lifts the corners without handles, because a\nsmile's corners stay sharp, and re-aims the lip handles along the lifted line.\nOn the eye path, a blink is one target with a hold at closed:\n```json\n\"morphs\": { \"blink\": { \"offsets\": [{}, {\"point\": [0, 14]}, {}, {\"point\": [0, -14]}],\n  \"weight\": { \"keyframes\": [{\"time\": 1.40, \"value\": 0, \"easing\": \"ease_in\"}, {\"time\": 1.48, \"value\": 1, \"easing\": \"step\"},\n                            {\"time\": 1.54, \"value\": 1, \"easing\": \"ease_out\"}, {\"time\": 1.66, \"value\": 0}] } } }\n```\n\n## 4. Timing\n\n- Anticipation: a small move the other way first — `weight` 0 → −0.15 → 1, or an outline keyframe\n  a little \"before A\" ahead of the main segment. Short: a few frames.\n- Overshoot and settle: `weight` 1.2 → 1, an outline keyframe past B followed by B, or a\n  `cubic_bezier` easing whose `y` leaves 0..1 (`[0.175, 0.885, 0.32, 1.275]`); render to check the\n  peak, the control number is not the overshoot.\n- Slow in / slow out: `easing` on the starting keyframe of every segment, per target weight; a\n  keyframe without `easing` is `linear` — right for a hold-to-swap, wrong for a pose change.\n- Holds: repeat the value on the next keyframe, or `\"easing\": \"step\"`. Keys read when they rest.\n- Follow-through: parts arrive at different times — a second target whose weight keyframes are\n  delayed, or a per-vertex track lagging the body.\n- Timing is the count of frames between poses; spacing near a pose is tight (ease), the middle is\n  wide. A morph under ~0.2 s reads as a swap — then write the swap.\n\n## 5. Breakdowns\n\nThe middle drawing is not the average of A and B. Favour one key, and add the extra movement the\nstraight path lacks (A → Z → B): a third outline keyframe, or a transient target that peaks mid-way\n(`weight` 0 → 1 → 0 across the A→B segment) on top of the track. Vertices travel straight lines, so\nan arc, a bulge or a lean exists only as a breakdown.\n\n## 6. Volume\n\nA squash keeps its area: lower by ×0.8, widen by ×1.25. For a target, the squash offsets lower\nthe top and push the sides out together, and stretch the horizontal handles of the top and bottom\nby the same ×1.25 (shorten the vertical ones by ×0.8) so the widened body stays round; for a whole-layer squash, `scale` `[1.25, 0.8]` with the\n`anchor` on the contact edge. Measure the ink area on `picsart_scene_contact_sheet` frames rather than trusting the numbers; the eye reads volume loss as deflation.\n\n## 7. Faces\n\n- Name mouth targets by the VRM presets: `aa`, `ih`, `ou`, `ee`, `oh`; eyes `blink`, `blinkLeft`,\n  `blinkRight`; moods `happy`, `angry`, `sad`, `relaxed`, `surprised`. Consonants borrow the nearest\n  vowel at a lower weight.\n- Mood geometry owns the corners, brows and lids; `aa`, `ih`, `ou`, `ee`, `oh` own the aperture and speech shape, whatever the mood strength. `speech` 1 reserves the aperture through the whole dialogue, pauses and closures included (a surprised O closes on m, b, p only inside that window); `speech` 0 restores the mood's resting mouth. Pass `visemes: [\"aa\",\"ih\",\"ou\",\"ee\",\"oh\",\"speech\"]` to `lipSync:visemes` and merge every returned track into the rig instance's parameters. A mood change eases 0.4 s from the evaluated current weights: key the current values, then the next recipe 0.4 s later with `ease_in_out` on the outgoing keys, and clear the outgoing mood weights; never reset to neutral at the change or step-select a mouth drawing to change a vector mood.\n- Visemes cross-fade: at any moment the viseme weights sum to about 1, each segment eased, with a\n  short hold on a stressed vowel.\n- Lip sync from word timings: `picsart_scene_apply_preset` with `preset` `lipSync:visemes`, `layerId` the\n  rig layer and in `params` the transcript (a `captions` `transcript`, as transcription returns it) and\n  the face's `visemes`; it merges one track per control into the rig layer's `content.parameters`. It opens a syllable per vowel group, leads the sound by 50 ms,\n  dips rather than shuts inside fast words, and closes on rests and on every m, b and p (60 ms shut up\n  to the release; `closures` lists them). `speaker` picks one singer's segments, `gain` scales the\n  opening, and `start`/`end` cut and rebase the tracks for a layer that plays only part of the song.\n- Replacement drawings: pass `mouthShapes` mapping each drawing's name to its number on a `mouth`\n  dial (`{\"rest\": 0, \"aa\": 1, \"oh\": 2}`) and a `mouth` track of `step` keys, one drawing per frame,\n  joins the others. A viseme without a drawing takes its nearest one.\n- \"Make this character say the line\" is `lipSync:visemes` on the rig. \"Make this photo talk\" is not: that\n  is a pixel video from the Picsart lip-sync models (`kling-avatar`, `heygen-talking-photo`,\n  `minimax-h3-max-lip-sync`, `bytedance-omnihuman-v1.5`), not editable animation.\n- A blink is in fast (~0.08 s), held closed (~0.06 s), out slower (~0.12 s), and keeps the face's\n  other targets running.\n- Talking while smiling = `happy` steady + visemes cycling + a corrective per viseme that dents or\n  pinches under the smile (`happyAa`, `happyOh`). Shape each viseme on the mouth as it is seen, the\n  held mood applied, then render every viseme at full weight with the mood on: a dent, a flat lip\n  or a pinched corner there is a missing corrective. The mouth and eyes sit before the head in\n  `items` so they paint on top.\n- Draw the mouth with a darker `stroke` over its `fill`, `\"lineJoin\": \"round\"`: the lip line reads at every\n  opening, and the round join softens the corners. The stroke follows the morphed outline.\n- End a grin in the silence: when a smile control opens the mouth (rig-humanoid's `happy` does past\n  about 0.6), ease it after the last word over ~0.12 s to where it rests closed. Check that every silent frame reads closed.\n- Keep a head turn moderate: talking to camera reads at about half the turn's range, and the full turn\n  only where the body itself is turned that far. An ear slides round the head with the turn and never\n  fades; hair trails the head by a couple of frames.\n- A wave lifts the hand up and forward at shoulder height, clear of the face outline: a forearm bent\n  across the cheek reads as a reach. Measure the clearance from geometry on every frame of the gesture.\n\n## 8. Scene-to-scene morph transitions\n\n- Three ways: direct (A's outline becomes B's, every frame honest); fast swap (the outline swaps\n  under `motionBlur: true` and a large move or spin, the eye fills in); hybrid (the key object\n  morphs directly, the rest leaves under a `mask` or slides out, new details enter last).\n- Pick 1–3 key pairs that share two of colour, shape, volume. Morph those first; if they do not\n  read, nothing else will.\n- Order: key pairs → the largest, least-detailed objects → small details last; the morphing layer\n  spans the cut (its `start`/`duration` cover both scenes), it belongs to neither scene.\n- Every moving element shares one direction and speed across the cut; colour changes ride on the\n  fill's keyframes timed with the outline's.\n- Verify with `picsart_scene_contact_sheet` stills at the cut ±2 frames and `picsart_media_track_motion` on the key pair.\n\n## 9. When not to morph\n\n- No two of colour/shape/volume in common → cut, dissolve or a catalog transition.\n- Raster media and text are not outlines; a `media` or `text` layer does not morph — bend it over an\n  art mesh (§10), or mask, scale or transition it.\n- Topology changes (open↔closed, a hole appears, a shape splits) → `step` swap or a dissolve.\n- Under ~0.2 s, or more than a few dozen vertices → a swap reads the same and is cheaper to author.\n\n## 10. Bending a picture and live pins\n\nA layer's `mesh` draws a `media`, `text`, composition or `scene_ref` picture over triangles so it\nbends: a `grid`, explicit `vertices` + `triangles`, or a mesh that follows a cut-out's transparency\nfrom `picsart_scene_apply_preset` with `preset` `mesh:auto`; then `deformers` (`bend`, `push`, `stretch`, `warp`, `skin`, `pins`)\nmove its points over time, each fading in and out on its `mix`. `pins` give free handles to a flag,\ntail, ear or sticker corner, with `stiffnessRegions` to keep a head firm on a bending body. Read\n[references/art-mesh.md](references/art-mesh.md) before writing a mesh, and\n[references/live-pins.md](references/live-pins.md) before writing pins. See also [traced SVG](references/traced-svg.md) and [follow-through, pixel art](references/layer-follow-through.md).\n\n## 11. Explicit skin weights\n\nWhen a limb, sleeve or imported mesh should follow painted bone influences instead of the automatic\nradius falloff, give the `skin` deformer `weights`, one row per mesh vertex or outline point. Read\n[references/skin-weights.md](references/skin-weights.md) before writing them: the rest-pose\nalignment, the row numbering, the blend band a bend needs, and the limits.\n\n## Tuning by hand — `picsart_scene_tune`\n\nOpen it as `motion-design-craft` describes. `rig-humanoid` and `rig-face` already declare their controls; a custom character exposes its own as `scene-building-basics` \"Reusable parts\" says. To keep a finished character, `picsart_scene_library_save` saves it under `Picsart Scene Library/Characters/<name>` with `name`, `kind: \"character\"`, `rights: \"own\"` (or `\"licensed\"` with a `license` note), and `scene` (the document or its HTTPS URL). Put render kinds (`vector`, `cutout`, `3d`, `live2d`, `spine`) in `tags`; assets and controls are derived from the scene. `previewUrl` supplies the portrait, or omit it to render one at `previewTime` (default 0); `videoUrl` is an optional demo. `pick: true` picks that version. `picsart_scene_library_list` with `kind: \"character\"` returns the picked version or newest, its durable `sceneUrl`, controls and version count; `tag`, `name` and `folderUid` filter it. USE a saved character with `picsart_scene_apply_template`, `uri: \"library:<libraryId>\"` (picked version or newest) or its `sceneUrl`: reference mode places its URL in a `scene_ref`, and inline mode copies its body into the host as a scene asset.\n\n## Not expressible (format findings, not rules)\n\n- Weight-indexed in-betweens: no target \"at weight 0.5\"; the mid pose is a second target cross-faded\n  by hand (§3).\n- Curved vertex trajectories: a vertex keyframe takes no spatial tangents (`inTangent`/`outTangent`\n  are honoured on `position`/`anchor` only), so an arc needs a breakdown keyframe.\n- A target's `weight.expression` reading another target's weight directly: unverified; the\n  corrective pattern goes through parameters.\n- No priority/override between procedural targets (VRM `overrideMouth`/`overrideBlink` block/blend):\n  conflicts are authored by hand.\n- `closed` is static and the hole count fixed: topology never morphs.\n- No automatic volume preservation under a squash target.\n"
}

SHA-256 of public snapshot: 8e8b3c0b289a98ec973f82fe237029b21d18ff1891bc53ead57a6c5de9b9860b