@nodaro/prompts 1.19.0 → 1.21.0

package/src/character-motion/walks-runs.ts

@@ -0,0 +1,97 @@
+import type { CharacterMotion } from "./types.js"
+
+/** walks-runs — authored motion fragments. Stable ids survive copy revisions. */
+export const WALKS_RUNS_MOTIONS: ReadonlyArray<CharacterMotion> = [
+  { "id": "stroll-casually", "label": "Casual stroll", "category": "walks-runs", "description": "Relaxed unhurried walk, loose arms, easy steps",
+    "promptHint": "the subject strolls forward with short relaxed steps, weight rolling easily heel to toe, arms swinging loosely at the sides, shoulders down and head drifting to look around", "term": "strolls casually, arms loose" },
+  { "id": "walk-briskly", "label": "Brisk walk", "category": "walks-runs", "description": "Purposeful clipped steps, arms swinging",
+    "promptHint": "the subject walks briskly with clipped purposeful steps, heels striking firmly, arms swinging in a tight rhythm, torso upright and eyes fixed on a point ahead", "term": "walks briskly with purpose" },
+  { "id": "power-walk", "label": "Power walk", "category": "walks-runs", "description": "Fitness walk, elbows bent, arms pumping hard",
+    "promptHint": "the subject power-walks with elbows bent at ninety degrees and arms pumping hard, pelvis driving each long stride, heels planting and toes pushing off with visible effort", "term": "power-walks, arms pumping" },
+  { "id": "stride-confidently", "label": "Confident stride", "category": "walks-runs", "description": "Long even strides, chest up, shoulders back",
+    "promptHint": "the subject strides forward with long even steps, chest lifted and shoulders back, arms swinging in a full relaxed arc, each foot landing squarely with the weight committed", "term": "strides forward confidently" },
+  { "id": "jog-forward", "label": "Jog", "category": "walks-runs", "description": "Light steady run, elbows bent, gentle bounce",
+    "promptHint": "the subject jogs forward, elbows bent and hands loose near the waist, short strides landing midfoot, a gentle bounce in each step and breathing even", "term": "jogs forward, elbows bent" },
+  { "id": "sprint-flat-out", "label": "Sprint", "category": "walks-runs", "description": "All-out run, knees driving, arms pumping",
+    "promptHint": "the subject sprints flat out, torso leaning forward, knees driving high, arms pumping in sharp opposition, feet striking on the balls and pushing off hard behind", "term": "sprints flat out" },
+  { "id": "tiptoe-forward", "label": "Tiptoe", "category": "walks-runs", "description": "Heels lifted, small careful steps on the toes",
+    "promptHint": "the subject rises onto the balls of the feet and tiptoes forward with heels lifted, small careful steps, arms held slightly out for balance and shoulders raised", "term": "tiptoes forward, heels lifted" },
+  { "id": "sneak-forward", "label": "Sneak", "category": "walks-runs", "description": "Low crouch, soft toe-first steps, eyes scanning",
+    "promptHint": "the subject sneaks forward in a low crouch, knees bent, placing each foot down softly toe first, arms drawn in close to the body, head turning to check both sides", "term": "sneaks forward in a crouch" },
+  { "id": "stagger-unsteadily", "label": "Stagger", "category": "walks-runs", "description": "Weaving unsteady walk, arms out for balance",
+    "promptHint": "the subject staggers forward unsteadily, weight lurching from one foot to the other, path weaving side to side, arms floating out to catch balance and head lolling", "term": "staggers unsteadily, weaving" },
+  { "id": "limp-forward", "label": "Limp", "category": "walks-runs", "description": "Favoring one leg, uneven dipping gait",
+    "promptHint": "the subject limps forward favoring one leg, the stiff leg taking a short guarded step while the other swings through, the body dipping on each weighted step", "term": "limps, favoring one leg" },
+  { "id": "march-in-cadence", "label": "March", "category": "walks-runs", "description": "Military cadence, high knees, stiff arm swing",
+    "promptHint": "the subject marches forward in strict military cadence, knees lifting high, legs snapping straight, arms swinging stiffly shoulder-high in opposition, spine rigid and chin level", "term": "marches in military cadence" },
+  { "id": "walk-backwards", "label": "Walk backwards", "category": "walks-runs", "description": "Stepping backward, glancing over one shoulder",
+    "promptHint": "the subject walks backwards, each foot reaching behind and landing toe first before the heel settles, weight shifting carefully, glancing over one shoulder to check the path", "term": "walks backwards" },
+  { "id": "skip-along", "label": "Skip", "category": "walks-runs", "description": "Step-hop bounce on alternating feet",
+    "promptHint": "the subject skips forward in a step-hop rhythm, alternating feet, bouncing up off each hop with arms swinging freely and a light springy lift through the whole body", "term": "skips along" },
+  { "id": "hop-on-one-foot", "label": "Hop", "category": "walks-runs", "description": "Bounding forward on one foot",
+    "promptHint": "the subject hops forward on one foot, the other leg bent and lifted, arms pumping with each push-off, landing and springing again in a chain of small bounds", "term": "hops on one foot" },
+  { "id": "crawl-on-all-fours", "label": "Crawl", "category": "walks-runs", "description": "Hands and knees, opposite limbs advancing",
+    "promptHint": "the subject crawls forward on hands and knees, opposite hand and knee advancing together, back level, head lifted to look ahead as the weight rocks from limb to limb", "term": "crawls on hands and knees" },
+  { "id": "army-crawl-forward", "label": "Army crawl", "category": "walks-runs", "description": "Flat on the belly, pulling forward on elbows",
+    "promptHint": "the subject drops flat and army-crawls forward on the belly, dragging the body along with alternating elbows and knees, head kept low and chest pressed to the ground", "term": "army-crawls on the belly" },
+  { "id": "wade-through-water", "label": "Wade", "category": "walks-runs", "description": "High deliberate steps against the water's drag",
+    "promptHint": "the subject wades forward through the water, lifting each knee high and pushing it through against the drag, arms raised clear of the surface, torso leaning slightly into each step as the weight commits late", "term": "wades through water" },
+  { "id": "shuffle-forward", "label": "Shuffle", "category": "walks-runs", "description": "Feet barely leaving the ground, slumped",
+    "promptHint": "the subject shuffles forward with feet barely leaving the ground, short scuffing steps, shoulders slumped, arms hanging still and the head bowed", "term": "shuffles, feet scuffing the ground" },
+  { "id": "scurry-forward", "label": "Scurry", "category": "walks-runs", "description": "Hurried tiny steps, hunched and leaning ahead",
+    "promptHint": "the subject scurries forward in hurried tiny steps, shoulders hunched, elbows tucked, upper body leaning ahead of the feet as if late, eyes darting", "term": "scurries with tiny hunched steps" },
+  { "id": "stroll-hands-in-pockets", "label": "Hands in pockets stroll", "category": "walks-runs", "description": "Elbows out, loose rolling steps, slight forward lean",
+    "promptHint": "the subject strolls forward with both hands tucked into pockets, elbows angled out, shoulders relaxed, loose rolling steps and a slight forward lean of the head", "term": "strolls with hands in pockets" },
+  { "id": "walk-while-talking", "label": "Walk & talk", "category": "walks-runs", "description": "Steady walk with hands gesturing mid-speech",
+    "promptHint": "the subject walks while talking, steps steady and unbroken, mouth moving in speech, hands gesturing in time with the words, head turning aside mid-sentence and back to the path ahead", "term": "walks and talks, gesturing" },
+  { "id": "trudge-wearily", "label": "Trudge", "category": "walks-runs", "description": "Heavy weary steps, head down, feet dragging",
+    "promptHint": "the subject trudges forward with heavy weary steps, feet dragging and landing flat, shoulders sagging under the effort, head down and arms hanging limp at the sides", "term": "trudges wearily" },
+  { "id": "prance-forward", "label": "Prance", "category": "walks-runs", "description": "Springy high-knee steps, toes pointed",
+    "promptHint": "the subject prances forward with springy high-knee steps, toes pointed on each lift, chest up and arms held out lightly, bouncing playfully off the balls of the feet", "term": "prances with high knees" },
+  { "id": "strut-boldly", "label": "Strut", "category": "walks-runs", "description": "Chest out, exaggerated arm swing, bold stamps",
+    "promptHint": "the subject struts forward with chest pushed out, chin raised, exaggerated arm swing and long bold steps that land with a deliberate stamp, shoulders squared", "term": "struts, chest out" },
+  { "id": "swagger-forward", "label": "Swagger", "category": "walks-runs", "description": "Wide lazy stride, shoulders rolling",
+    "promptHint": "the subject swaggers forward with a wide lazy stride, shoulders rolling side to side with each step, arms swinging loose and low, weight sinking into every landing", "term": "swaggers, shoulders rolling" },
+  { "id": "sashay-forward", "label": "Sashay", "category": "walks-runs", "description": "Hip-swaying walk, feet crossing on one line",
+    "promptHint": "the subject sashays forward with hips swaying side to side, each foot crossing in front of the other along a single line, shoulders back and one hand trailing at the hip", "term": "sashays with swaying hips" },
+  { "id": "run-in-panic", "label": "Panicked run", "category": "walks-runs", "description": "Frantic escape run, glancing back",
+    "promptHint": "the subject runs in panic, arms flailing loosely, strides uneven and frantic, torso twisting to glance back over a shoulder before facing forward and pushing harder", "term": "runs in panic, glancing back" },
+  { "id": "run-crouched", "label": "Crouched run", "category": "walks-runs", "description": "Low tactical run, knees bent, head ducked",
+    "promptHint": "the subject runs low in a crouch, knees deeply bent and torso folded forward, head ducked, arms tucked in, feet moving in short driving steps that keep the body down", "term": "runs low in a crouch" },
+  { "id": "climb-stairs", "label": "Climb stairs", "category": "walks-runs", "description": "Knee lifts to each step, hand sliding up the rail",
+    "promptHint": "the subject climbs a flight of stairs, lifting each knee to plant the whole foot on the next step, weight driving up through the leading leg, one hand sliding along the rail and torso tipped slightly forward", "term": "climbs the stairs" },
+  { "id": "descend-stairs", "label": "Descend stairs", "category": "walks-runs", "description": "Toe-first steps down, weight lowered under control",
+    "promptHint": "the subject descends a flight of stairs, each foot reaching down to the next step toe first before the heel settles, weight lowering under control, chin level and one hand trailing on the rail", "term": "descends the stairs" },
+  { "id": "push-through-crowd", "label": "Push through crowd", "category": "walks-runs", "description": "Shoulder wedged forward, forearm parting the way",
+    "promptHint": "the subject pushes through the crowd, turning one shoulder forward to wedge between bodies, forearm raised to part the way, pelvis twisting sideways and short driving steps forcing a path ahead", "term": "shoulders through the crowd" },
+  { "id": "sidle-along-wall", "label": "Sidle along wall", "category": "walks-runs", "description": "Back and palms flat to the wall, side-stepping",
+    "promptHint": "the subject sidles along the wall with back and palms pressed flat against it, stepping sideways one foot after the other, knees soft, head turned to watch the direction of travel", "term": "sidles along the wall, back pressed" },
+  { "id": "stomp-off-angrily", "label": "Stomp off", "category": "walks-runs", "description": "Storms away, flat heavy stamps, fists clenched",
+    "promptHint": "the subject turns sharply and stomps off, each foot slamming down flat and heavy, fists clenched and arms swinging stiffly, shoulders squared and head held rigidly forward without looking back", "term": "stomps off, fists clenched" },
+  { "id": "zombie-shamble", "label": "Zombie shamble", "category": "walks-runs", "description": "Stiff outstretched arms, pitched torso, one foot dragging",
+    "promptHint": "the subject shambles forward with both arms held stiffly outstretched, torso pitched forward off balance, one leg dragging behind as the other lurches ahead, head hanging to one side and jaw slack", "term": "shambles, arms stiffly outstretched" },
+  { "id": "sleepwalk-forward", "label": "Sleepwalk", "category": "walks-runs", "description": "Eyes half-closed, arms out ahead, flat-footed drift",
+    "promptHint": "the subject sleepwalks forward with eyes half-closed and face slack, both arms extended straight ahead, flat-footed steps drifting in a straight line, the body upright and not reacting to anything around it", "term": "sleepwalks, arms held out ahead" },
+  { "id": "run-in-circles", "label": "Run in circles", "category": "walks-runs", "description": "Tight looping run, body leaning into the turn",
+    "promptHint": "the subject runs in tight circles, body leaning into the turn, inside foot pivoting on each stride while the outside leg pushes wide, arms held out and head whipping around to keep looking ahead", "term": "runs in tight circles" },
+  { "id": "brace-against-wind", "label": "Brace against wind", "category": "walks-runs", "description": "Torso pitched forward, forearm shielding the face",
+    "promptHint": "the subject leans hard into the wind, torso pitched forward with one shoulder dropped, forearm raised to shield the face, feet planting wide in short braced steps that fight for every stride", "term": "leans into the wind, forearm up" },
+  { "id": "walk-with-cane", "label": "Walk with cane", "category": "walks-runs", "description": "Cane plants in time with the opposite foot",
+    "promptHint": "the subject walks forward with a cane, planting its tip ahead in time with the opposite foot, weight leaning briefly onto the cane hand as the other leg swings through, steps short and even", "term": "walks with a cane" },
+  { "id": "roll-forward-in-wheelchair", "label": "Wheelchair roll", "category": "walks-runs", "description": "Both hands drive the push rims in matched strokes",
+    "promptHint": "the subject rolls forward in a wheelchair, both hands gripping the push rims and driving them forward in matched strokes, shoulders rounding on each push and releasing on the return, chin up and looking ahead", "term": "rolls forward in a wheelchair" },
+  { "id": "pull-rolling-suitcase", "label": "Pull rolling suitcase", "category": "walks-runs", "description": "One arm trailing back on the handle, case on its wheels",
+    "promptHint": "the subject walks forward pulling a rolling suitcase, one arm trailing straight back to the extended handle, the case tilted onto its wheels behind, torso angled slightly toward the free side and the other arm swinging", "term": "walks pulling a rolling suitcase" },
+  { "id": "step-left", "label": "Step to subject’s left", "category": "walks-runs", "description": "Step to subject’s left.",
+    "term": "takes one step to their own left", "promptHint": "the subject takes one lateral step to the subject’s left and stops",
+    "startPose": "standing", "endPose": "standing", "aliases": ["sidestep left"] },
+  { "id": "step-right", "label": "Step to subject’s right", "category": "walks-runs", "description": "Step to subject’s right.",
+    "term": "takes one step to their own right", "promptHint": "the subject takes one lateral step to the subject’s right and stops",
+    "startPose": "standing", "endPose": "standing", "aliases": ["sidestep right"] },
+  { "id": "walk-with-crutches", "label": "Walk with crutches", "category": "walks-runs", "description": "Walk with crutches.",
+    "term": "advances with a pair of crutches", "promptHint": "the subject places both crutches ahead, shifts weight through the handles and advances using the established supported gait",
+    "requires": ["crutches"], "startPose": "standing", "endPose": "standing", "aliases": ["mobility aid"] },
+  { "id": "walk-with-walker", "label": "Walk with walker", "category": "walks-runs", "description": "Walk with walker.",
+    "term": "advances with a walker", "promptHint": "the subject moves the walker a short distance ahead and takes small supported steps into it, repeating steadily",
+    "requires": ["walker"], "startPose": "standing", "endPose": "standing", "aliases": ["mobility aid"] },
+]

package/src/character-motion-diagnostics.ts

@@ -0,0 +1,49 @@
+import { getCharacterMotion, CHARACTER_MOTION_MAX_PICKS, type CharacterMotionTiming } from "./character-motion.js"
+
+export interface CharacterMotionDiagnostic {
+  readonly code: "unknown" | "omitted" | "retired" | "pose" | "visibility" | "hands" | "pace" | "requirements" | "compound" | "capacity" | "multiple-targets" | "roles"
+  readonly severity: "error" | "warning" | "info"
+  readonly ids: readonly string[]
+  readonly message: string
+}
+export interface CharacterMotionBindings {
+  readonly selfPairing?: boolean
+  readonly subjectMinor?: boolean
+  readonly partnerNames?: readonly string[]
+  readonly targetNames?: readonly string[]
+}
+
+/** Shared by editor, API clients and local review. Missing metadata means
+ * unknown; this never certifies a sequence or predicts clip duration. */
+export function getCharacterMotionDiagnostics(
+  value: string | readonly string[] | null | undefined,
+  timing?: CharacterMotionTiming,
+  bindings: CharacterMotionBindings = {},
+): readonly CharacterMotionDiagnostic[] {
+  const requested = typeof value === "string" ? [value] : Array.isArray(value) ? [...new Set(value)] : []
+  const result: CharacterMotionDiagnostic[] = []
+  const add = (code: CharacterMotionDiagnostic["code"], severity: CharacterMotionDiagnostic["severity"], ids: readonly string[], message: string) => result.push({ code, severity, ids, message })
+  if (requested.length > CHARACTER_MOTION_MAX_PICKS) add("capacity", "warning", requested, "Only the first three selections contribute. Remove extra selections.")
+  const picks = requested.slice(0, CHARACTER_MOTION_MAX_PICKS)
+  for (const id of picks) if (!getCharacterMotion(id)) add("unknown", "error", [id], `Motion “${id}” is unavailable and contributes no fragment. Remove or replace it.`)
+  const entries = picks.flatMap(id => { const entry = getCharacterMotion(id); return entry?.promptHint ? [entry] : [] })
+  const active = entries.filter(e => !bindings.subjectMinor || !e.adultOnly)
+  if (bindings.selfPairing && active.some(e => e.twoPerson || e.counterpart)) add("roles", "error", active.filter(e => e.twoPerson || e.counterpart).map(e => e.id), "The same reference is connected as Target and Partner. Connect distinct participants before running this interaction.")
+  const omitted = entries.filter(e => bindings.subjectMinor && e.adultOnly)
+  if (omitted.length) add("omitted", active.length ? "warning" : "error", omitted.map(e => e.id), `${omitted.map(e => e.label).join(", ")} omitted for a connected minor. ${active.length ? "Replace these selections." : "No selected motion contributes a fragment."}`)
+  if ((bindings.targetNames?.length ?? 0) > 1) add("multiple-targets", "warning", picks, "Each target performs a separate copy of the sequence. Use separate motion nodes for coordinated choreography.")
+  for (const entry of active) {
+    if (entry.deprecated) add("retired", "warning", [entry.id], `${entry.label} is retired from new choices but still resolves in saved workflows.${entry.replacementId ? ` Use ${getCharacterMotion(entry.replacementId)?.label ?? entry.replacementId}.` : ""}`)
+    if (entry.fixedPace && timing?.pace && timing.pace !== "auto") add("pace", "warning", [entry.id], `${entry.label} sets its own timing. Set Pace to Auto or replace the motion.`)
+    if (entry.requires?.length) add("requirements", "info", [entry.id], `${entry.label} requires: ${entry.requires.join(", ")}.${entry.twoPerson || entry.counterpart ? bindings.partnerNames?.length ? ` Partner reference: ${bindings.partnerNames.join(", ")}; confirm it matches the required recipient.` : " Connect a Partner reference to identify the recipient; otherwise the model chooses it." : " Establish these in the scene or prompt; the fragment does not supply reference media."}`)
+  }
+  for (let i = 1; i < active.length; i++) {
+    const before = active[i - 1]!, after = active[i]!, ids = [before.id, after.id]
+    if (before.endVisibility === "out-of-frame") add("visibility", "warning", ids, `${before.label} ends out of view before ${after.label}. Reorder or add an entrance.`)
+    if (before.endPose && after.startPose && before.endPose !== "any" && after.startPose !== "any" && before.endPose !== after.startPose) add("pose", "warning", ids, `${before.label} ends ${before.endPose}; ${after.label} starts ${after.startPose}. Add a transition or replace a motion.`)
+    if (before.handsAfter && before.handsAfter !== "free" && after.needsFreeHands) add("hands", "warning", ids, `${before.label} leaves hands occupied; ${after.label} needs free hands. Add a release first.`)
+  }
+  const compound = active.filter(e => e.kind === "compound")
+  if (compound.length) add("compound", "warning", compound.map(e => e.id), `${compound.length} selection${compound.length === 1 ? " is" : "s are"} compound choreography. Short clips may not fit every phase; test the sequence before adding more actions.`)
+  return result
+}

package/src/character-motion.ts

@@ -0,0 +1,362 @@
+/**
+ * Canonical catalog of CHARACTER MOTION choices — what the subject DOES across
+ * a video clip: walks in, turns to camera, breaks into a smile, ducks, draws and
+ * fires, runway-walks, dances. Temporal by definition.
+ *
+ * Distinct from:
+ *  - Pose            — a static SNAPSHOT of body position (serves still images too).
+ *  - Character FX    — supernatural change to the subject's body (werewolf, fire breath).
+ *  - Action FX       — a scene event (explosion, lightning); motion is the BODY acting.
+ *  - Camera Motion   — the camera moves, never the subject.
+ *
+ * Shared between the picker UI, the standalone Character Motion parameter node,
+ * and the prompt-hint injection on both the frontend DAG executor and the
+ * backend orchestrator. Video-only: never injected into still-image consumers.
+ *
+ * Every non-empty `promptHint` references "the subject" at least once — the
+ * composer does a global regex replace of "the subject" with the wired target's
+ * display name. Two-person moves ALSO contain the literal words "the partner",
+ * replaced with the wired partner's name on every occurrence. With nothing
+ * wired to the partner handle, the fallback "another person" INTRODUCES the
+ * referent at its first occurrence in THAT TARGET's clauses and every later
+ * occurrence of that target reads "that same person" — a hint that names the
+ * partner five times still describes one person, and a sequence of picks keeps
+ * that one person throughout. Multiple wired targets each perform a separate
+ * copy of the sequence, so each copy introduces its own partner rather than
+ * sharing one between two performers. See `referenceTo` in the composer.
+ *
+ * Multi-pick is an ORDERED SEQUENCE: value field accepts `string | string[]`
+ * (cap 3), joined with ", then " in BOTH hint modes (a movement happens after
+ * the previous one; Character FX joins with ", and " because effects coincide).
+ *
+ * `adultOnly` marks the W1-a minor-age floor. The composer drops flagged ids
+ * when its caller reports a minor subject (`floor.subjectMinor`); the AI Fill
+ * strip drops them from analyzer output. Hand-curated; the `adult-only-ratchet`
+ * test only ratchets. Never set on neutral movement or the `auto` / `none` heads.
+ */
+
+import { resolveTerm, type PickerHintMode } from "./term.js"
+import { overlayEntry } from "./catalog-overlay.js"
+export type { CharacterMotion, CharacterMotionCategory, CharacterMotionMetadata } from "./character-motion/types.js"
+import type { CharacterMotion, CharacterMotionCategory } from "./character-motion/types.js"
+import { ENTRANCES_EXITS_MOTIONS } from "./character-motion/entrances-exits.js"
+import { TURNS_LOOKS_MOTIONS } from "./character-motion/turns-looks.js"
+import { HEAD_GESTURES_MOTIONS } from "./character-motion/head-gestures.js"
+import { WALKS_RUNS_MOTIONS } from "./character-motion/walks-runs.js"
+import { RUNWAY_MOTIONS } from "./character-motion/runway.js"
+import { DANCE_MOTIONS } from "./character-motion/dance.js"
+import { FACE_EXPRESSION_MOTIONS } from "./character-motion/face-expression.js"
+import { GESTURES_MOTIONS } from "./character-motion/gestures.js"
+import { CAMERA_INTERACTION_MOTIONS } from "./character-motion/camera-interaction.js"
+import { COMBAT_WEAPONS_MOTIONS } from "./character-motion/combat-weapons.js"
+import { ATHLETIC_STUNTS_MOTIONS } from "./character-motion/athletic-stunts.js"
+import { EVASIVE_FALLS_MOTIONS } from "./character-motion/evasive-falls.js"
+import { POSTURE_SHIFTS_MOTIONS } from "./character-motion/posture-shifts.js"
+import { EVERYDAY_ACTIONS_MOTIONS } from "./character-motion/everyday-actions.js"
+import { VEHICLES_MOUNTS_MOTIONS } from "./character-motion/vehicles-mounts.js"
+import { ANIMALS_PETS_MOTIONS } from "./character-motion/animals-pets.js"
+import { TWO_PERSON_MOTIONS } from "./character-motion/two-person.js"
+import { IDLE_AMBIENT_MOTIONS } from "./character-motion/idle-ambient.js"
+import { STAGE_PERFORMANCE_MOTIONS } from "./character-motion/stage-performance.js"
+import { UNNATURAL_HORROR_MOTIONS } from "./character-motion/unnatural-horror.js"
+
+export const CHARACTER_MOTION_CATEGORY_ORDER: ReadonlyArray<CharacterMotionCategory> = [
+  "entrances-exits",
+  "turns-looks",
+  "head-gestures",
+  "walks-runs",
+  "runway",
+  "dance",
+  "face-expression",
+  "gestures",
+  "camera-interaction",
+  "combat-weapons",
+  "athletic-stunts",
+  "evasive-falls",
+  "posture-shifts",
+  "everyday-actions",
+  "vehicles-mounts",
+  "animals-pets",
+  "two-person",
+  "idle-ambient",
+  "stage-performance",
+  "unnatural-horror",
+] as const
+
+export const CHARACTER_MOTION_CATEGORY_LABELS: Readonly<Record<CharacterMotionCategory, string>> = {
+  "entrances-exits": "Entrances & Exits",
+  "turns-looks": "Turns & Looks",
+  "head-gestures": "Head Gestures",
+  "walks-runs": "Walks & Runs",
+  "runway": "Runway & Model",
+  "dance": "Dance",
+  "face-expression": "Face & Expression",
+  "gestures": "Gestures",
+  "camera-interaction": "Camera Interaction",
+  "combat-weapons": "Combat & Weapons",
+  "athletic-stunts": "Athletic & Stunts",
+  "evasive-falls": "Evasive & Falls",
+  "posture-shifts": "Posture Shifts",
+  "everyday-actions": "Everyday Actions",
+  "vehicles-mounts": "Vehicles & Mounts",
+  "animals-pets": "Animals & Pets",
+  "two-person": "Two-Person",
+  "idle-ambient": "Idle & Ambient",
+  "stage-performance": "Stage & Performance",
+  "unnatural-horror": "Unnatural & Horror",
+} as const
+
+/**
+ * The catalog: two no-op heads + every category array, in category order.
+ * Authored injecting entries across 20 categories.
+ */
+export const CHARACTER_MOTIONS: ReadonlyArray<CharacterMotion> = [
+  // Defaults — both inject nothing (empty promptHint ⇒ empty term).
+  { id: "auto", label: "Auto", category: "entrances-exits", description: "Let the model choose the movement", promptHint: "" },
+  { id: "none", label: "None", category: "entrances-exits", description: "No scripted character movement", promptHint: "" },
+  ...ENTRANCES_EXITS_MOTIONS,
+  ...TURNS_LOOKS_MOTIONS,
+  ...HEAD_GESTURES_MOTIONS,
+  ...WALKS_RUNS_MOTIONS,
+  ...RUNWAY_MOTIONS,
+  ...DANCE_MOTIONS,
+  ...FACE_EXPRESSION_MOTIONS,
+  ...GESTURES_MOTIONS,
+  ...CAMERA_INTERACTION_MOTIONS,
+  ...COMBAT_WEAPONS_MOTIONS,
+  ...ATHLETIC_STUNTS_MOTIONS,
+  ...EVASIVE_FALLS_MOTIONS,
+  ...POSTURE_SHIFTS_MOTIONS,
+  ...EVERYDAY_ACTIONS_MOTIONS,
+  ...VEHICLES_MOUNTS_MOTIONS,
+  ...ANIMALS_PETS_MOTIONS,
+  ...TWO_PERSON_MOTIONS,
+  ...IDLE_AMBIENT_MOTIONS,
+  ...STAGE_PERFORMANCE_MOTIONS,
+  ...UNNATURAL_HORROR_MOTIONS,
+]
+
+const characterMotionById = new Map<string, CharacterMotion>(
+  CHARACTER_MOTIONS.map((m) => [m.id, m]),
+)
+
+export function getCharacterMotion(id: string | undefined | null): CharacterMotion | undefined {
+  if (!id) return undefined
+  return overlayEntry("character-motion", id, characterMotionById.get(id))
+}
+
+export function getCharacterMotionLabel(id: string | undefined | null, fallback?: string): string {
+  const m = getCharacterMotion(id)
+  if (m) return m.label
+  if (fallback !== undefined) return fallback
+  return (id ?? "").replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())
+}
+
+export function getCharacterMotionPromptHint(id: string | undefined | null): string {
+  return getCharacterMotion(id)?.promptHint ?? ""
+}
+
+/** Compact counterpart of `getCharacterMotionPromptHint` — same lookup, same
+ *  empty-string-on-miss, and the no-op `auto` / `none` heads inject nothing. */
+export function getCharacterMotionTerm(id: string | undefined | null): string {
+  return resolveTerm(getCharacterMotion(id))
+}
+
+export const CHARACTER_MOTION_IDS: ReadonlyArray<string> = CHARACTER_MOTIONS.map((m) => m.id)
+
+/** Cap on ordered picks. Shared by the composer (`.slice(0, N)`), the picker
+ *  (`maxSelected`) and the config panel — the three must agree. */
+export const CHARACTER_MOTION_MAX_PICKS = 3
+
+// ---------------------------------------------------------------------------
+// Timing scales — Position + Pace. Own wording; NOT the character-fx or the
+// transition rows (an effect manifests, a transition occurs, a MOVEMENT is
+// performed). `POSITION_CLAUSES` / `PACE_CLAUSES` are DERIVED from these arrays
+// so the clause the composer injects and the hint the catalog advertises are
+// the same string by construction.
+// ---------------------------------------------------------------------------
+
+export interface CharacterMotionTimingOption {
+  readonly id: string
+  readonly label: string
+  readonly description: string
+  readonly promptHint: string
+  readonly term?: string
+}
+
+export const CHARACTER_MOTION_POSITIONS = [
+  { id: "auto",   label: "Auto",   description: "Let the model place the movement",          promptHint: "", term: "" },
+  { id: "start",  label: "Start",  description: "Begins at the opening of the clip",         promptHint: "the movement begins at the opening of the clip", term: "starting as the clip opens" },
+  { id: "middle", label: "Middle", description: "Begins midway through the clip",            promptHint: "the movement begins midway through the clip", term: "starting midway through the clip" },
+  { id: "end",    label: "End",    description: "Happens in the closing moments of the clip", promptHint: "the movement happens in the closing moments of the clip", term: "in the closing moments of the clip" },
+  { id: "full",   label: "Full",   description: "Plays out across the entire clip",          promptHint: "the movement plays out across the entire clip", term: "playing out across the whole clip" },
+] as const satisfies ReadonlyArray<CharacterMotionTimingOption>
+
+export const CHARACTER_MOTION_PACES = [
+  { id: "auto",        label: "Auto",        description: "Let the model set the tempo",                          promptHint: "", term: "" },
+  { id: "slow-motion", label: "Slow Motion", description: "The action itself is rendered in slow motion",         promptHint: "the action is rendered in slow motion, every phase of the movement stretched and drawn out", term: "in slow motion" },
+  { id: "slow",        label: "Slow",        description: "Performed slowly and deliberately",                    promptHint: "performed slowly and deliberately, each phase of the movement given its full time", term: "slow and deliberate" },
+  { id: "natural",     label: "Natural",     description: "Performed at an everyday tempo",                       promptHint: "performed at a natural everyday tempo, neither rushed nor drawn out", term: "at a natural everyday tempo" },
+  { id: "fast",        label: "Fast",        description: "Performed quickly, brisk and urgent",                  promptHint: "performed quickly, with brisk urgent tempo and sharp transitions between phases", term: "fast and brisk" },
+  { id: "explosive",   label: "Explosive",   description: "A sudden burst from stillness into full-speed motion", promptHint: "performed with an explosive burst of energy, snapping from stillness into full-speed motion", term: "with an explosive burst" },
+] as const satisfies ReadonlyArray<CharacterMotionTimingOption>
+
+export type CharacterMotionPosition = (typeof CHARACTER_MOTION_POSITIONS)[number]["id"]
+export type CharacterMotionPace     = (typeof CHARACTER_MOTION_PACES)[number]["id"]
+
+export interface CharacterMotionTiming {
+  position?: CharacterMotionPosition
+  pace?:     CharacterMotionPace
+}
+
+/** Private twin of the helper in character-fx.ts / transitions.ts — the
+ *  catalogs must stay independent. Total over the array by construction. */
+function clausesOf<T extends CharacterMotionTimingOption>(
+  options: ReadonlyArray<T>,
+): Record<Exclude<T["id"], "auto">, string> {
+  return Object.fromEntries(
+    options.filter((o) => o.id !== "auto").map((o) => [o.id, o.promptHint]),
+  ) as Record<Exclude<T["id"], "auto">, string>
+}
+
+const POSITION_CLAUSES = clausesOf(CHARACTER_MOTION_POSITIONS)
+const PACE_CLAUSES     = clausesOf(CHARACTER_MOTION_PACES)
+
+/** Widening guard — `as const` on the two arrays is load-bearing (see character-fx.ts). */
+type NarrowIds<T> = string extends T ? never : true
+const _timingIdsStayNarrow: [NarrowIds<CharacterMotionPosition>, NarrowIds<CharacterMotionPace>] = [true, true]
+void _timingIdsStayNarrow
+
+// ---------------------------------------------------------------------------
+// Graph-aware composer — target + partner handles, ordered multi-pick, timing
+// ---------------------------------------------------------------------------
+
+const PARTNER_FALLBACK = "another person"
+/** Last-resort recipient for a `counterpart` token whose entry authored no noun. */
+const COUNTERPART_FALLBACK = "the other participant"
+
+/**
+ * How an unwired partner / counterpart reads on its SECOND and later mention.
+ *
+ * Only an INDEFINITE noun phrase is rewritten. "another person" and "a horse"
+ * introduce a fresh referent every time they repeat, so a hint that mentions
+ * the partner five times would otherwise describe up to five different people.
+ * A DEFINITE phrase — "the held object", "the ducks", "the other participant" —
+ * already picks out one referent on every repetition, so it repeats verbatim:
+ * rewriting it would buy nothing and would mangle a plural ("that same ducks").
+ * That exemption is invisible on today's data (every counterpart noun mentioned
+ * more than once is indefinite) and exists so a future definite or plural noun
+ * cannot produce broken English here.
+ *
+ * A pronoun is deliberately NOT the fix: with two actors in the clause,
+ * "they" / "their" can attach to either one.
+ */
+function laterReferenceTo(phrase: string): string {
+  const indefinite = /^(?:another|an|a) (.+)$/.exec(phrase)
+  return indefinite ? `that same ${indefinite[1]}` : phrase
+}
+
+/** What the caller knows about the wired target. `subjectMinor: true` drops
+ *  every `adultOnly` pick after the cap; otherwise the output is unchanged. */
+export interface CharacterMotionFloor {
+  readonly subjectMinor?: boolean
+}
+
+/**
+ * Compose a character-motion prompt fragment from an ORDERED list of 1–3 move
+ * ids, the display names wired to the `target` and `partner` handles, and the
+ * optional Position / Pace timing.
+ *
+ * Full mode: each hint has "the subject" rewritten to the target name(s) (only
+ * when a target is wired) and "the partner" rewritten to the partner name, or —
+ * when nothing is wired to that handle — to "another person" on that target's
+ * first mention and "that same person" after; ALWAYS, so the literal words
+ * "the partner" never ship. Both BEFORE the ", then " join. Compact mode: terms joined with ", then ",
+ * prefixed `"{target}: "` when a target is wired. A term never contains "the
+ * subject" (the prefix names the target) but a two-person term always contains
+ * "the partner", which is substituted exactly as in full mode.
+ * Timing clauses follow in the fixed order position, pace, in both modes.
+ * `floor.subjectMinor` drops adult-only picks after the cap; none left ⇒ "".
+ */
+export function composeCharacterMotionHintFromConnections(
+  motionId: string | ReadonlyArray<string> | undefined | null,
+  targetHints: ReadonlyArray<string>,
+  partnerHints: ReadonlyArray<string>,
+  timing?: CharacterMotionTiming,
+  mode: PickerHintMode = "full",
+  floor?: CharacterMotionFloor,
+): string {
+  const picked = Array.isArray(motionId)
+    ? Array.from(new Set(motionId as ReadonlyArray<string>)).slice(0, CHARACTER_MOTION_MAX_PICKS)
+    : motionId ? [motionId as string] : []
+  // Cap the user's picks FIRST, then floor: a dropped pick never lets a later one backfill.
+  const ids = floor?.subjectMinor === true
+    ? picked.filter((id) => getCharacterMotion(id)?.adultOnly !== true)
+    : picked
+  const resolveBase = mode === "compact" ? getCharacterMotionTerm : getCharacterMotionPromptHint
+  const entries = ids.map((id) => ({ id, base: resolveBase(id) })).filter((e) => e.base.length > 0)
+  if (entries.length === 0) return ""
+
+  const targets = [...new Set(targetHints.filter((h) => h && h.length > 0))]
+  const targetClause = targets.join(" and ")
+  const partnerClause = partnerHints.filter((h) => h && h.length > 0).join(" and ")
+  const partnerName   = partnerClause || PARTNER_FALLBACK
+
+  /**
+   * One introduction PER TARGET. Within one target's clauses the partner handle
+   * names a single participant, so the first occurrence introduces it and every
+   * later occurrence refers back. The scope decisions, stated:
+   *  - ACROSS THE SEQUENCE (up to 3 picks): SHARED. Pick 2 reading "that same
+   *    person" refers to the person pick 1 introduced — one target doing two
+   *    moves does them to one partner.
+   *  - ACROSS MULTIPLE TARGETS: NOT SHARED. Each target performs a SEPARATE
+   *    COPY of the sequence — what the `multiple-targets` diagnostic promises —
+   *    so each copy introduces its own partner. Sharing one referent across the
+   *    "; separately, " clauses instead described one person being hugged,
+   *    dipped or bridal-carried by two people at once.
+   *  - COMPACT MODE: same rule, same scope, same helper. Its terms are shorter,
+   *    but a 3-pick compact sequence repeats the referent just as a full one
+   *    does, so it needs the same treatment.
+   *  - A WIRED NAME IS NEVER REWRITTEN: repeating "Theo" is already unambiguous,
+   *    which also keeps wired output byte-identical to the pre-fix composer.
+   * Each target's state is keyed by the resolved phrase rather than by one flag,
+   * because two picks can carry DIFFERENT counterpart nouns ("a dog", then
+   * "a horse") — two referents, each owed its own introduction.
+   *
+   * Call order is output order: `entries.map` runs in sequence order and, inside
+   * it, `targets.map` runs in the order those clauses are joined. A target's
+   * state therefore spans that target's picks and ignores the clauses of the
+   * other targets interleaved between them.
+   */
+  const introducedByTarget = new Map<string, Set<string>>()
+  const referenceTo = (target: string, phrase: string): string => {
+    if (partnerClause) return phrase
+    let introduced = introducedByTarget.get(target)
+    if (!introduced) introducedByTarget.set(target, (introduced = new Set<string>()))
+    if (introduced.has(phrase)) return laterReferenceTo(phrase)
+    introduced.add(phrase)
+    return phrase
+  }
+
+  const substituted = entries.map(({ id, base }) => {
+    // One pass with a callback: names are literal data, never replacement
+    // syntax ($&, $`, $') or a second set of template tokens to reprocess.
+    const substitute = (target: string) => base.replace(/\bthe (subject|partner|counterpart)\b/g, (token, role: string) => {
+      if (role === "subject") return mode !== "compact" && target ? target : token
+      if (role === "partner") return referenceTo(target, partnerName)
+      return referenceTo(target, partnerClause || getCharacterMotion(id)?.counterpart || COUNTERPART_FALLBACK)
+    })
+    // Each actor receives a grammatical singular clause. Do not invent a
+    // plural choreography or attach a singular verb to a joined name list.
+    return targets.length > 1
+      ? targets.map(target => mode === "compact" ? `${target}: ${substitute(target)}` : substitute(target)).join("; separately, ")
+      : substitute(targetClause)
+  })
+
+  const joined = substituted.join(", then ")
+  const combinedBase = mode === "compact" && targets.length === 1 ? `${targetClause}: ${joined}` : joined
+  const parts: string[] = [combinedBase]
+  if (timing?.position && timing.position !== "auto") parts.push(POSITION_CLAUSES[timing.position])
+  if (timing?.pace     && timing.pace     !== "auto") parts.push(PACE_CLAUSES[timing.pace])
+  return parts.join(", ")
+}

package/src/frame-delivery.ts

@@ -0,0 +1,106 @@
+/**
+ * HOW A START/END FRAME TRAVELS — one plan, read by both ends.
+ *
+ * A frame can reach a model two ways: as a real frame, or as a reference image
+ * bound in prose as the opening (or closing) frame. Which one is right is
+ * measured per model — the Seedance 2.0 family crop-zooms a frame 2% and drifts
+ * 11-26% darker within six frames, but holds its look from frame 0 when the same
+ * image rides as a reference; every other model measured reproduces the opening
+ * frame better as a frame (see `resolveFrameDelivery` in @nodaro/shared).
+ *
+ * The composition — where the frames sit in the reference list, which sentence
+ * binds them, when the switch is refused — lives HERE rather than at the
+ * dispatch site, because two places need the same answer:
+ *
+ *   - `backend/src/lib/video-frame-dispatch.ts` builds the actual request,
+ *   - the editor's config panel tells the user which mode their node will run in.
+ *
+ * When those two disagree the panel lies, which is worse than having no panel
+ * text at all. One function, two callers, no drift.
+ */
+import { VIDEO_REF_LIMITS_BY_PROVIDER, resolveFrameDelivery, type FrameDelivery } from "@nodaro/shared"
+import { REF_BINDING } from "./ref-binding.js"
+import { promptBindsFirstFrame } from "./seedance-2-inputs.js"
+
+export interface FrameDeliveryPlanArgs {
+  readonly provider: string | undefined
+  /** The node's / caller's choice. `auto` (or absent) resolves per model. */
+  readonly requested?: FrameDelivery
+  /** Whether the model accepts reference images at all. */
+  readonly supportsReferenceImages: boolean
+  readonly startFrameUrl?: string
+  readonly endFrameUrl?: string
+  /** The user's OWN reference images, in their existing order. */
+  readonly userReferenceUrls?: readonly string[]
+  /** Consulted only to avoid a duplicate opening-frame sentence. */
+  readonly prompt?: string
+}
+
+export interface FrameDeliveryPlan {
+  /** What will actually happen — never `auto`. */
+  readonly delivery: Exclude<FrameDelivery, "auto">
+  /** The full reference list to send. Equals the user's own list under `frame`. */
+  readonly referenceImageUrls: readonly string[]
+  /** Sentence(s) to append to the prompt. Empty under `frame`. */
+  readonly promptSuffix: string
+  /** Set when reference delivery was WANTED but refused, so a caller can say why. */
+  readonly refusedReason?: "no-reference-support" | "image-cap"
+}
+
+/**
+ * Resolve delivery and compose the request shape that follows from it.
+ *
+ * Two refusals, both deliberate:
+ *   - a model with no reference-image support keeps frame mode (there is nowhere
+ *     for the frame to go);
+ *   - a switch that would push past the model's image cap keeps frame mode,
+ *     because the alternative is dropping one of the USER's reference images to
+ *     make room for ours.
+ *
+ * The frames are appended AFTER the user's own images so their `@image_N`
+ * ordinals never shift, and the opening sentence is skipped when the prompt
+ * already binds its own first frame — a second binding at another position
+ * dilutes the first back into coin-flip behaviour (field finding 2026-07-20).
+ */
+export function planFrameDelivery(args: FrameDeliveryPlanArgs): FrameDeliveryPlan {
+  const userRefs = (args.userReferenceUrls ?? []).filter(Boolean)
+  const requested = args.requested ?? "auto"
+  const delivery = resolveFrameDelivery({
+    provider: args.provider,
+    requested,
+    supportsReferenceImages: args.supportsReferenceImages,
+  })
+
+  const frames = [args.startFrameUrl, args.endFrameUrl].filter((u): u is string => Boolean(u))
+
+  if (delivery === "frame" || frames.length === 0) {
+    return {
+      delivery: "frame",
+      referenceImageUrls: userRefs,
+      promptSuffix: "",
+      ...(requested === "reference" && !args.supportsReferenceImages
+        ? { refusedReason: "no-reference-support" as const }
+        : {}),
+    }
+  }
+
+  const cap = VIDEO_REF_LIMITS_BY_PROVIDER[args.provider ?? ""]?.images
+  if (cap !== undefined && userRefs.length + frames.length > cap) {
+    return { delivery: "frame", referenceImageUrls: userRefs, promptSuffix: "", refusedReason: "image-cap" }
+  }
+
+  const referenceImageUrls = [...userRefs]
+  const sentences: string[] = []
+  if (args.startFrameUrl) {
+    referenceImageUrls.push(args.startFrameUrl)
+    if (!promptBindsFirstFrame(args.prompt)) {
+      sentences.push(REF_BINDING.frame(referenceImageUrls.length, "opening"))
+    }
+  }
+  if (args.endFrameUrl) {
+    referenceImageUrls.push(args.endFrameUrl)
+    sentences.push(REF_BINDING.frame(referenceImageUrls.length, "closing"))
+  }
+
+  return { delivery: "reference", referenceImageUrls, promptSuffix: sentences.join(" ") }
+}