@nodaro/prompts 1.27.0 → 1.29.0

package/src/__tests__/transitions-scope.test.ts

@@ -20,9 +20,12 @@ const INSTANT_IDS = TRANSITIONS.filter((t) => t.instant).map((t) => t.id)
 const NON_INSTANT_IDS = TRANSITIONS.filter((t) => !t.instant && t.id !== "auto").map((t) => t.id)
 const FULL_CLAUSE = "the transition spans the entire clip"
 const FULL_SHOT_CLAUSE = "the transition spans this entire shot"
-const MATCH_CUT_BASE =
-  "match cut (the final composition of the first shot matches the opening composition of the second shot " +
-  "in shape, color, and motion, so the cut feels like a visual rhyme; " + INSTANT_CUT_CLAUSE + ")"
+const MATCH_CUT_BODY =
+  "the last picture of the first shot and the first picture of the second share one shape, at the same " +
+  "place and the same size in the frame. The camera holds that shape in place across the cut. On the ne" +
+  "xt frame everything around the shape has changed while the shape itself stays put. The shot ends on " +
+  "the second shot, fully resolved, with no flash frame or zoom between the two"
+const MATCH_CUT_BASE = `match cut (${MATCH_CUT_BODY}; ${INSTANT_CUT_CLAUSE})`
 
 describe("approved row bodies", () => {
   it("aging", () => {
@@ -357,9 +360,422 @@ describe("shockwave body (2026-09-25 rework: shockwave3 E1)", () => {
   })
 })
 
+describe("roll-transition body (2026-09-25 A/B: F6 arm B)", () => {
+  // The F6 roll draft, tidied (first letter lower-cased, final full stop dropped): one full turn one way
+  // that stops level, with no swing back. The rendered string at the tile default is byte-identical to
+  // the clause the winning take was generated from. The other F6 rows keep today's text.
+  const TERM = "camera roll transition"
+  const BODY =
+    "the picture rolls around its centre in one smooth, fast turn, blurred by the speed of the turn. The " +
+    "camera stays in the same spot, turning only around its lens axis. During the turn the second shot ta" +
+    "kes over, and the roll slows and stops with it level and upright. The shot ends on the second shot, " +
+    "level, upright and still. The roll turns one way only and stops once, with no swing back"
+
+  it("renders `term (body)` at the tile-default levers", () => {
+    expect(getTransitionPromptHint("roll-transition")).toBe(BODY)
+    expect(composeTransitionHintFromConnections("roll-transition", [], [], {}, "full", { scope: "shot" })).toBe(`${TERM} (${BODY})`)
+  })
+
+  it("at middle / short / natural", () => {
+    expect(composeTransitionHintFromConnections("roll-transition", [], [], { position: "middle", duration: "short", intensity: "natural" })).toBe(
+      `${TERM} (${BODY}), the transition occurs in the middle of the clip, lasting approximately 1 second, with natural timing`,
+    )
+  })
+})
+
+describe("time-lapse bodies (2026-09-24 A/B at full / long: descab3 row 26)", () => {
+  // Day → night ships arm B, the audit body (B 5 > A 4). Night → day was a tie (A 4 · B 4), so the shorter
+  // body stays: today's (179 characters against B's 220). Both rows keep their "fast-forward time-lapse
+  // transition:" heading, which the renderer strips. Day → night's body has a colon of its own after a
+  // 61-character lead-in; it is a description lead-in, not a heading, and the heading guard in
+  // transitions-instant.test.ts still passes for it. The term + body is byte-identical to the clause the
+  // winning take (d4546594) was generated from.
+  const DN_TERM = "day-to-night time-lapse"
+  const DN_BODY =
+    "the same view with framing locked while hours pass in seconds: light and shadows sweep across the sc" +
+    "ene, daylight warms to dusk and fades to night, lights come on, until the picture matches the end frame"
+  const ND_TERM = "night-to-day time-lapse"
+  const ND_BODY =
+    "stars fade, the sky shifts from deep night through pre-dawn blue to golden sunrise, shadows sweep in r" +
+    "everse, all while framing and camera position remain locked on the same scene"
+  const HEADING = "fast-forward time-lapse transition: "
+
+  it("day → night: the catalog hint keeps its heading and carries the B body", () => {
+    expect(getTransitionPromptHint("fast-forward-day-night")).toBe(HEADING + DN_BODY)
+  })
+
+  it("day → night renders `term (body)` at the tile-default levers", () => {
+    expect(composeTransitionHintFromConnections("fast-forward-day-night", [], [], {}, "full", { scope: "shot" })).toBe(
+      `${DN_TERM} (${DN_BODY})`,
+    )
+  })
+
+  it("day → night at full / long / natural (the levers the take was rendered at)", () => {
+    expect(composeTransitionHintFromConnections("fast-forward-day-night", [], [], { position: "full", duration: "long", intensity: "natural" })).toBe(
+      `${DN_TERM} (${DN_BODY}), ${FULL_CLAUSE}, lasting approximately 3 seconds, with natural timing`,
+    )
+  })
+
+  it("day → night at middle / short / natural", () => {
+    expect(composeTransitionHintFromConnections("fast-forward-day-night", [], [], { position: "middle", duration: "short", intensity: "natural" })).toBe(
+      `${DN_TERM} (${DN_BODY}), the transition occurs in the middle of the clip, lasting approximately 1 second, with natural timing`,
+    )
+  })
+
+  it("night → day keeps today's body", () => {
+    expect(getTransitionPromptHint("fast-forward-night-day")).toBe(HEADING + ND_BODY)
+    expect(composeTransitionHintFromConnections("fast-forward-night-day", [], [], {}, "full", { scope: "shot" })).toBe(
+      `${ND_TERM} (${ND_BODY})`,
+    )
+  })
+})
+
+describe("zoom-into-mirror body (2026-10-03 redraft: mirror3 D2, liquid ripple)", () => {
+  // The mirror3 D2 draft ("liquid ripple"), rated 4/5 against D1 3/5 and D3 2/5. It was tested already
+  // tidied (lower-case start, no final full stop), so it ships exactly as the take was generated (job
+  // 5821fa22): the rendered string at the tile default is byte-identical to the clause in that prompt.
+  const TERM = "zoom into mirror"
+  const BODY =
+    "the camera pushes straight at a mirror in the frame. As the lens meets the glass, the mirror's " +
+    "surface turns liquid and rings ripple out across the whole picture, and the camera keeps moving " +
+    "forward through the rippling surface, out the far side into the second shot. Until the lens touches " +
+    "the glass, the mirror keeps its own reflection. The shot ends in the second shot, still and fully " +
+    "resolved, with no ripples left"
+
+  it("renders `term (body)` at the tile-default levers", () => {
+    expect(getTransitionPromptHint("zoom-into-mirror")).toBe(BODY)
+    expect(composeTransitionHintFromConnections("zoom-into-mirror", [], [], {}, "full", { scope: "shot" })).toBe(`${TERM} (${BODY})`)
+  })
+
+  it("at middle / short / natural", () => {
+    expect(composeTransitionHintFromConnections("zoom-into-mirror", [], [], { position: "middle", duration: "short", intensity: "natural" })).toBe(
+      `${TERM} (${BODY}), the transition occurs in the middle of the clip, lasting approximately 1 second, with natural timing`,
+    )
+  })
+})
+
+describe("F8 cut bodies (2026-10-03 A/B: F8 arm B on snap-to-black, jump-match and match-cut)", () => {
+  // Arm B, the F8 draft with the ship tidy (first letter lower-cased; the drafts carry no final full stop, so
+  // the anti-blend sentence reads on after the body). Each is byte-identical to the body inside the prompt of
+  // the take it was rated on: snap-to-black 03-B-t2 (2bcc8b81), jump-match 04-B-t1 (b9027a0a), match-cut
+  // 07-B (4c6e3ecd). snap-to-black and match-cut keep their "<label>:" heading, which the renderer strips;
+  // jump-match never had one. None of the three bodies contains a colon, so the heading guard in
+  // transitions-instant.test.ts cannot match them, and no comma item equals its row's term. All three are
+  // cuts: the cut sentence rides inside the parentheses, and duration and intensity are dropped.
+  const ROWS = [
+    {
+      id: "snap-to-black",
+      term: "snap to black",
+      heading: "snap to black: ",
+      body:
+        "the first shot cuts straight to full black on a single frame. The camera holds its framing right up " +
+        "to the cut. The frame stays pure black for a single beat, then the second shot cuts in at full brigh" +
+        "tness on a single frame. The shot ends on the second shot, fully resolved",
+    },
+    {
+      id: "jump-match",
+      term: "match cut on a jump",
+      heading: "",
+      body:
+        "the subject launches into a jump, and at the height of the leap the picture cuts to a new place. The" +
+        " camera follows the arc of the jump at the same speed on both sides of the cut, and the subject stay" +
+        "s at the same place in the frame. In the second shot the same jump carries on without a break, and t" +
+        "he subject comes down and lands in the new place. The shot ends on the subject landed in the second " +
+        "shot, fully resolved",
+    },
+    {
+      id: "match-cut",
+      term: "match cut",
+      heading: "match cut: ",
+      body:
+        "the last picture of the first shot and the first picture of the second share one shape, at the same " +
+        "place and the same size in the frame. The camera holds that shape in place across the cut. On the ne" +
+        "xt frame everything around the shape has changed while the shape itself stays put. The shot ends on " +
+        "the second shot, fully resolved, with no flash frame or zoom between the two",
+    },
+  ] as const
+
+  it.each(ROWS)("$id: the catalog hint carries the new body (heading kept where the row had one)", ({ id, heading, body }) => {
+    expect(getTransitionPromptHint(id)).toBe(heading + body)
+  })
+
+  it.each(ROWS)("$id renders `term (body; cut sentence)` at the tile-default levers", ({ id, term, body }) => {
+    const clause = `${term} (${body}; ${INSTANT_CUT_CLAUSE})`
+    expect(composeTransitionHintFromConnections(id, [], [], {}, "full", { scope: "shot" })).toBe(clause)
+    expect(composeTransitionHintFromConnections(id, [], [], {}, "compact", { scope: "shot" })).toBe(clause)
+    expect(composeTransitionHintFromConnections(id, [], [])).toBe(clause)
+  })
+
+  // `long`: a duration every cut ignores. Short on `jump-match` is a blended cut, pinned in
+  // transitions-blended-cut.test.ts.
+  it.each(ROWS)("$id at middle / long / natural keeps only the position", ({ id, term, body }) => {
+    const levers = { position: "middle", duration: "long", intensity: "natural" } as const
+    expect(composeTransitionHintFromConnections(id, [], [], levers)).toBe(
+      `${term} (${body}; ${INSTANT_CUT_CLAUSE}), the transition occurs in the middle of the clip`,
+    )
+    expect(composeTransitionHintFromConnections(id, [], [], levers, "full", { scope: "shot" })).toBe(
+      `${term} (${body}; ${INSTANT_CUT_CLAUSE}), the transition occurs in the middle of this shot`,
+    )
+  })
+
+  // The other F8 rows keep today's text (jump-cut's body changes in the 2026-10-04 block below).
+  const KEPT: Record<string, string> = {
+    "none":
+      "no transition, hard cut, instantaneous switch from first shot to second shot",
+    "smash-cut":
+      "smash cut: an abrupt jarring transition between two visually or tonally contrasting shots with no fa" +
+      "de, on a beat",
+    "seamless-match":
+      "hidden seamless transition: the camera motion, color palette, and on-screen motion at the end of the" +
+      " first shot continue exactly across the cut into the second shot, so the boundary is invisible and t" +
+      "he two shots feel like one unbroken take",
+    "action-relay":
+      "match cut on action: the subject exits the frame on a committed action — a stride, a throw, a turn —" +
+      " and enters the new scene on the same beat continuing that movement at matched speed and direction, " +
+      "so the action carries unbroken across the cut",
+  }
+
+  it.each(Object.entries(KEPT))("%s keeps today's text", (id, hint) => {
+    expect(getTransitionPromptHint(id)).toBe(hint)
+  })
+})
+
+describe("F9 time bodies (2026-10-03 A/B at full / long: F9 arm B on seasonal-shift and flashback)", () => {
+  // Arm B, the F9 draft with the ship tidy (first letter lower-cased, no final full stop). Each is byte-identical to
+  // the body inside the prompt of the take it was rated on: seasonal-shift 01-B (428e79c6) and flashback 02-B
+  // (bc236b0c), both rendered at position full / duration long (the time-row rule), no intensity, scope shot. Both
+  // rows keep their heading, which the renderer strips. Neither body contains a colon, so the heading guard in
+  // transitions-instant.test.ts has nothing to match, and no comma item equals its row's term. weather-shift was a
+  // tie (A 4 · B 4), so the shorter body stays: today's.
+  const ROWS = [
+    {
+      id: "seasonal-shift",
+      term: "seasonal time-lapse",
+      heading: "accelerated seasonal time-lapse: ",
+      body:
+        "the same view races through the seasons in fast motion, from the season of the first shot to the sea" +
+        "son of the second, as growing things bud, turn and fall and snow comes or goes. The camera stays whe" +
+        "re it is and the framing does not change. The change flows continuously across the whole picture, ev" +
+        "ery part moving on together, until the view matches the second shot. The shot ends on the second sho" +
+        "t's season, still and fully resolved. Only the season changes, and the layout of the view stays exac" +
+        "tly the same",
+    },
+    {
+      id: "flashback",
+      term: "flashback",
+      heading: "brief flashback transition: ",
+      body:
+        "a soft warm wash spreads over the whole picture and a faint ripple drifts across it as the present m" +
+        "oment fades. The camera stays where it is and the framing does not change. Through the ripple an ear" +
+        "lier moment of the same subject comes into focus, like a memory. The shot ends on the remembered mom" +
+        "ent, steady and fully resolved, with the ripple gone. The subject stays at the same place in the fra" +
+        "me while the moment around it changes",
+    },
+  ] as const
+
+  it.each(ROWS)("$id: the catalog hint keeps its heading and carries the B body", ({ id, heading, body }) => {
+    expect(getTransitionPromptHint(id)).toBe(heading + body)
+  })
+
+  it.each(ROWS)("$id renders `term (body)` at the tile-default levers", ({ id, term, body }) => {
+    expect(composeTransitionHintFromConnections(id, [], [], {}, "full", { scope: "shot" })).toBe(`${term} (${body})`)
+  })
+
+  it.each(ROWS)("$id at full / long in a shot window (the levers the take was rendered at)", ({ id, term, body }) => {
+    expect(composeTransitionHintFromConnections(id, [], [], { position: "full", duration: "long" }, "full", { scope: "shot" })).toBe(
+      `${term} (${body}), ${FULL_SHOT_CLAUSE}, lasting approximately 3 seconds`,
+    )
+  })
+
+  it.each(ROWS)("$id at middle / short / natural", ({ id, term, body }) => {
+    expect(composeTransitionHintFromConnections(id, [], [], { position: "middle", duration: "short", intensity: "natural" })).toBe(
+      `${term} (${body}), the transition occurs in the middle of the clip, lasting approximately 1 second, with natural timing`,
+    )
+  })
+
+  it("weather-shift keeps today's body", () => {
+    const body =
+      "same scene, framing locked — clear sky darkens to storm clouds, rain begins and intensifies then cle" +
+      "ars, sun returns through breaking clouds"
+    expect(getTransitionPromptHint("weather-shift")).toBe(`accelerated weather transition: ${body}`)
+    expect(composeTransitionHintFromConnections("weather-shift", [], [], {}, "full", { scope: "shot" })).toBe(`weather time-lapse (${body})`)
+  })
+})
+
+describe("F7 glitch and light bodies (2026-10-03 A/B: F7 arm B on channel-flip, display-wipe and color-invert)", () => {
+  // Arm B, the F7 draft with the ship tidy (first letter lower-cased, final full stop dropped). Each is
+  // byte-identical to the body inside the prompt of the take it was rated on: channel-flip 01-B (7f7829ec),
+  // display-wipe 03-B (c66d59bc) and color-invert 04-B (18d66f83), all at the tile-default levers. None of the
+  // three rows has a heading, none of the bodies contains a colon (so the heading guard in
+  // transitions-instant.test.ts has nothing to match), and no comma item equals its row's term. The other F7
+  // rows keep today's text.
+  const ROWS = [
+    {
+      id: "channel-flip",
+      term: "tv channel flip with static",
+      body:
+        "the whole picture breaks into a brief burst of black-and-white static, the image jumping and tearing" +
+        " as if the channel were being changed. The camera stays where it is and the framing does not change." +
+        " The static clears as quickly as it came, and the second shot snaps in, steady, like the next channe" +
+        "l. The shot ends on the second shot, clean and fully resolved, with no static left. The static cover" +
+        "s the whole frame, so the picture itself is what changes channel",
+    },
+    {
+      id: "display-wipe",
+      term: "compress into a screen and expand out",
+      body:
+        "the whole first shot shrinks toward the centre of the frame into a small glowing rectangle, then col" +
+        "lapses to a bright line and a dot as if its power were cut. The camera stays where it is and the fra" +
+        "ming does not change. From the dot a line snaps open and widens into a rectangle showing the second " +
+        "shot, which grows until it fills the frame. The shot ends on the second shot, full frame and fully r" +
+        "esolved, with no border or scanlines left. The picture itself shrinks and grows on a black field, wi" +
+        "th the camera holding still throughout",
+    },
+    {
+      id: "color-invert",
+      term: "color invert flash",
+      body:
+        "the colours of the whole picture turn to their photographic negative in an instant. The camera stays" +
+        " where it is and the framing does not change. The negative holds for a single beat, and when the col" +
+        "ours snap back to normal the second shot is in place. The shot ends on the second shot in natural co" +
+        "lour, fully resolved. The change of shot happens while the picture is in negative, and the picture s" +
+        "tays upright and in place throughout",
+    },
+  ] as const
+
+  it.each(ROWS)("$id: the catalog hint is the B body", ({ id, body }) => {
+    expect(getTransitionPromptHint(id)).toBe(body)
+  })
+
+  it.each(ROWS)("$id renders `term (body)` at the tile-default levers", ({ id, term, body }) => {
+    expect(composeTransitionHintFromConnections(id, [], [], {}, "full", { scope: "shot" })).toBe(`${term} (${body})`)
+    expect(composeTransitionHintFromConnections(id, [], [], {}, "compact", { scope: "shot" })).toBe(`${term} (${body})`)
+    expect(composeTransitionHintFromConnections(id, [], [])).toBe(`${term} (${body})`)
+  })
+
+  it.each(ROWS)("$id at middle / short / natural", ({ id, term, body }) => {
+    expect(composeTransitionHintFromConnections(id, [], [], { position: "middle", duration: "short", intensity: "natural" })).toBe(
+      `${term} (${body}), the transition occurs in the middle of the clip, lasting approximately 1 second, with natural timing`,
+    )
+  })
+})
+
+describe("Redrafted glitch bodies and the jump-cut negative sentence (2026-10-04: hologram-flicker D2, datamosh D1, jump-cut C)", () => {
+  // Each body is byte-identical to the body inside the prompt of the take its tile shows, at the tile-default
+  // levers: hologram-flicker from the F7 redraft's D2, a scan-line rebuild (17245f6b); datamosh from its D1,
+  // blocks that tear loose and pile up into the second shot (a16f906b); jump-cut from the jump-cut retest's arm
+  // C, today's body plus one negative sentence (2bfc4380). datamosh and jump-cut keep their "<label>:" heading,
+  // which the renderer strips; hologram-flicker never had one. No body contains a colon, so the heading guard in
+  // transitions-instant.test.ts cannot match them, and no comma item equals its row's term.
+  const ROWS = [
+    {
+      id: "hologram-flicker",
+      term: "hologram flicker",
+      heading: "",
+      body:
+        "the first shot breaks into thin lines of cyan light that flicker out from the top down, leaving the " +
+        "frame black. The camera stays where it is and the framing does not change. A bright scan line sweeps" +
+        " down and draws the second shot behind it in flickering cyan lines that steady into natural colour. " +
+        "The shot ends on the second shot, solid and fully resolved, with no scan lines left. The second shot" +
+        " is drawn only on black, never over the first shot",
+    },
+    {
+      id: "datamosh",
+      term: "datamosh",
+      heading: "datamosh transition: ",
+      body:
+        "the first shot's pixels tear loose in square compression blocks and slide sideways across the frame " +
+        "in long smeared streaks. The camera stays where it is and the framing does not change. The blocks pi" +
+        "le up into the shapes of the second shot, still in the first shot's colours, until the true colours " +
+        "snap in block by block. The shot ends on the second shot, sharp and fully resolved, with no smears o" +
+        "r blocks left. The smear covers the whole frame",
+    },
+  ] as const
+
+  it.each(ROWS)("$id: the catalog hint carries the new body (heading kept where the row had one)", ({ id, heading, body }) => {
+    expect(getTransitionPromptHint(id)).toBe(heading + body)
+  })
+
+  it.each(ROWS)("$id renders `term (body)` at the tile-default levers", ({ id, term, body }) => {
+    expect(composeTransitionHintFromConnections(id, [], [], {}, "full", { scope: "shot" })).toBe(`${term} (${body})`)
+    expect(composeTransitionHintFromConnections(id, [], [], {}, "compact", { scope: "shot" })).toBe(`${term} (${body})`)
+    expect(composeTransitionHintFromConnections(id, [], [])).toBe(`${term} (${body})`)
+  })
+
+  it.each(ROWS)("$id at middle / short / natural", ({ id, term, body }) => {
+    expect(composeTransitionHintFromConnections(id, [], [], { position: "middle", duration: "short", intensity: "natural" })).toBe(
+      `${term} (${body}), the transition occurs in the middle of the clip, lasting approximately 1 second, with natural timing`,
+    )
+  })
+
+  // jump-cut is a cut: the anti-blend sentence rides inside the parentheses after the body, and duration and
+  // intensity are dropped. The new body has a semicolon of its own; the restatement dedupe splits on commas
+  // only, so it is untouched, and the cut sentence still appears exactly once.
+  const JUMP_CUT_BODY =
+    "the framing, lens, and camera position stay identical across the cut while time skips abruptly forwa" +
+    "rd, so the subject snaps to a new position inside what still reads as one continuous shot. No leap, " +
+    "no run, no lunge and no motion blur between the two positions; the subject is in the old place on on" +
+    "e frame and already in the new place on the next"
+  const JUMP_CUT_CLAUSE = `jump cut (${JUMP_CUT_BODY}; ${INSTANT_CUT_CLAUSE})`
+
+  it("jump-cut: the catalog hint carries the new body after its heading", () => {
+    expect(getTransitionPromptHint("jump-cut")).toBe(`jump cut: ${JUMP_CUT_BODY}`)
+  })
+
+  it("jump-cut renders `term (body; cut sentence)` at the tile-default levers, the cut sentence once", () => {
+    expect(composeTransitionHintFromConnections("jump-cut", [], [], {}, "full", { scope: "shot" })).toBe(JUMP_CUT_CLAUSE)
+    expect(composeTransitionHintFromConnections("jump-cut", [], [], {}, "compact", { scope: "shot" })).toBe(JUMP_CUT_CLAUSE)
+    expect(composeTransitionHintFromConnections("jump-cut", [], [])).toBe(JUMP_CUT_CLAUSE)
+    expect(JUMP_CUT_CLAUSE.split(INSTANT_CUT_CLAUSE).length).toBe(2)
+  })
+
+  it("jump-cut at middle / short / natural keeps only the position", () => {
+    const levers = { position: "middle", duration: "short", intensity: "natural" } as const
+    expect(composeTransitionHintFromConnections("jump-cut", [], [], levers)).toBe(
+      `${JUMP_CUT_CLAUSE}, the transition occurs in the middle of the clip`,
+    )
+    expect(composeTransitionHintFromConnections("jump-cut", [], [], levers, "full", { scope: "shot" })).toBe(
+      `${JUMP_CUT_CLAUSE}, the transition occurs in the middle of this shot`,
+    )
+  })
+})
+
+describe("double-exposure body (2026-10-04: dblexp3 D1, the silhouette wording)", () => {
+  // The D1 draft (first written for dblexp2), byte-identical to the body inside the prompt of the take the
+  // row's tile shows: dblexp3 D1 (c55f1176), rendered at the tile-default levers on a dark profile
+  // silhouette over a near-white ground, cutting to a mountain lake. The row has no heading, the body has no
+  // colon (so the heading guard in transitions-instant.test.ts cannot match it), and no comma item equals the
+  // term. No other row changes.
+  const TERM = "double exposure"
+  const BODY =
+    "the first subject becomes a crisp silhouette filled solid with the second shot, while the rest of th" +
+    "e first shot stays untouched around it. The camera stays where it is and the framing does not change" +
+    ". The silhouette holds for a clear beat, both pictures plainly seen at once, then the first shot aro" +
+    "und it gives way to the second shot. The shot ends on the second shot alone, fully resolved"
+  const CLAUSE = `${TERM} (${BODY})`
+
+  it("the catalog hint is the D1 body", () => {
+    expect(getTransitionPromptHint("double-exposure")).toBe(BODY)
+  })
+
+  it("renders `term (body)` at the tile-default levers", () => {
+    expect(composeTransitionHintFromConnections("double-exposure", [], [], {}, "full", { scope: "shot" })).toBe(CLAUSE)
+    expect(composeTransitionHintFromConnections("double-exposure", [], [], {}, "compact", { scope: "shot" })).toBe(CLAUSE)
+    expect(composeTransitionHintFromConnections("double-exposure", [], [])).toBe(CLAUSE)
+  })
+
+  it("at middle / short / natural", () => {
+    expect(composeTransitionHintFromConnections("double-exposure", [], [], { position: "middle", duration: "short", intensity: "natural" })).toBe(
+      `${CLAUSE}, the transition occurs in the middle of the clip, lasting approximately 1 second, with natural timing`,
+    )
+  })
+})
+
 describe("L1 — a cut spans nothing, so `full` adds no clause", () => {
+  // `long`: a duration every cut ignores. Short on `seamless-match` / `jump-match` is a blended cut, and
+  // its `full` (also dropped) is pinned in transitions-blended-cut.test.ts.
   it.each(INSTANT_IDS)("%s + full renders no position clause", (id) => {
-    const out = composeTransitionHintFromConnections(id, [], [], { position: "full", duration: "short", intensity: "natural" })
+    const out = composeTransitionHintFromConnections(id, [], [], { position: "full", duration: "long", intensity: "natural" })
     expect(out).not.toContain("spans")
     expect(out).toBe(composeTransitionHintFromConnections(id, [], []))
   })

package/src/__tests__/video-own-motion.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from "vitest"
+import { DEFAULT_OWN_MOTION, ownMotionHint } from "../video-own-motion.js"
+
+describe("ownMotionHint", () => {
+  const on = { motionEnabled: true, motion: "dynamic" }
+
+  it("gives legacy Image to Video and Generate Video their own Motion clause", () => {
+    expect(ownMotionHint("image-to-video", on)).toBe("dynamic motion")
+    expect(ownMotionHint("generate-video", on)).toBe("dynamic motion")
+  })
+
+  it("gives none to a node type without the setting", () => {
+    expect(ownMotionHint("text-to-video", on)).toBeUndefined()
+    expect(ownMotionHint("video-to-video", on)).toBeUndefined()
+  })
+
+  it("gives none while the setting is off", () => {
+    expect(ownMotionHint("generate-video", { motionEnabled: false, motion: "dynamic" })).toBeUndefined()
+    expect(ownMotionHint("generate-video", { motion: "dynamic" })).toBeUndefined()
+  })
+
+  it("runs an enabled setting with no step stored as the step the panel shows", () => {
+    expect(ownMotionHint("generate-video", { motionEnabled: true })).toBe(`${DEFAULT_OWN_MOTION} motion`)
+    expect(ownMotionHint("image-to-video", { motionEnabled: true, motion: "" })).toBe(`${DEFAULT_OWN_MOTION} motion`)
+  })
+})

package/src/hint-join.ts

@@ -13,7 +13,9 @@
  * approved, and a user's preText/postText is never rewritten.
  */
 
-const ENDS_SENTENCE = /[.!?]$/
+/** A piece that already closes a sentence: a Latin or CJK full stop, question
+ *  or exclamation mark, or an ellipsis. */
+const ENDS_SENTENCE = /[.!?…。！？]$/
 
 export function joinHintFragments(fragments: ReadonlyArray<string>): string {
   let out = ""
@@ -24,3 +26,33 @@ export function joinHintFragments(fragments: ReadonlyArray<string>): string {
   }
   return out
 }
+
+/**
+ * Join prompt pieces as sentences: `". "` between two pieces, or a single
+ * space when the piece before already ends a sentence. Without that check a
+ * prompt typed with a closing period came out as
+ * "no watermark.. butterfly portrait lighting". Blank pieces are dropped. The
+ * pieces are otherwise kept verbatim, except that trailing space before a join
+ * is not carried into it ("cat " + "hint" gives "cat. hint").
+ */
+export function joinSentences(pieces: ReadonlyArray<string | undefined>): string {
+  let out = ""
+  for (const piece of pieces) {
+    if (!piece || !piece.trim()) continue
+    if (!out) { out = piece; continue }
+    const head = out.trimEnd()
+    out = ENDS_SENTENCE.test(head) ? `${head} ${piece}` : `${head}. ${piece}`
+  }
+  return out
+}
+
+/**
+ * Append wired picker hints to a prompt, the way both DAG engines fold them:
+ * the hints join as clauses (`joinHintFragments`), then follow the prompt as a
+ * new sentence (`joinSentences`). No hints (or only blank ones) gives the
+ * prompt back unchanged.
+ */
+export function appendPromptHints(prompt: string | undefined, hints: ReadonlyArray<string>): string {
+  const joined = joinHintFragments(hints)
+  return joined.trim() ? joinSentences([prompt, joined]) : (prompt ?? "")
+}

package/src/index.ts

@@ -14,6 +14,7 @@ export * from "./identity-lock.js"
 export * from "./reference-rules.js"
 export * from "./term.js"
 export * from "./parameter-prompt-hint.js"
+export * from "./video-own-motion.js"
 export * from "./entity-prompts.js"
 export * from "./brand-tokens.js"
 export * from "./described-references.js"

package/src/parameter-prompt-hint.ts

@@ -36,7 +36,7 @@ import { buildStylingHints } from "./styling.js"
 import { buildTemporalHints } from "./temporal.js"
 import { composeCameraMotionHintFromConnections } from "./camera-motions.js"
 import { joinHintFragments } from "./hint-join.js"
-import { composeTransitionHintFromConnections, type TransitionDuration, type TransitionIntensity, type TransitionPosition, type TransitionTiming } from "./transitions.js"
+import { composeTransitionHintFromConnections, readTransitionOptionValues, type TransitionDuration, type TransitionIntensity, type TransitionPosition, type TransitionTiming } from "./transitions.js"
 import { composeCharacterFxHintFromConnections, type CharacterFxDuration, type CharacterFxIntensity, type CharacterFxPosition, type CharacterFxTiming } from "./character-fx.js"
 import { composeCharacterMotionHintFromConnections, type CharacterMotionPace, type CharacterMotionPosition, type CharacterMotionTiming } from "./character-motion.js"
 import { containsMinorAgeHint, isMinorAge } from "./age-floor.js"
@@ -158,6 +158,14 @@ function byMode<T>(mode: PickerHintMode, full: T, compact: T): T {
   return mode === "compact" ? compact : full
 }
 
+/** How much a shot moves (the Motion node's three steps), as the clause it
+ *  adds to a video prompt; the compact form is the bare term. */
+const MOTION_INTENSITY_HINTS: Readonly<Record<string, { readonly full: string; readonly compact: string }>> = {
+  subtle: { full: "subtle, gentle motion with slow, minimal movement", compact: "subtle motion" },
+  moderate: { full: "moderate, natural motion at an even pace", compact: "moderate motion" },
+  dynamic: { full: "dynamic, energetic motion with fast, pronounced movement", compact: "dynamic motion" },
+}
+
 /**
  * Dispatch by parameter-node type to its prompt-hint string. For camera-motion,
  * pass `ctx` to include the composed start/end clauses; otherwise only the
@@ -227,8 +235,11 @@ function resolveParameterHint(
       duration:  asStr(data.duration)  as TransitionDuration  | undefined,
       intensity: asStr(data.intensity) as TransitionIntensity | undefined,
     }
+    // A picked row's own options (a wipe's `wipeDirection`), off the same node data.
+    const optionValues = readTransitionOptionValues(data)
+    const hintOptions = optionValues ? { optionValues } : undefined
     if (!ctx) {
-      return withCustomText(data, composeTransitionHintFromConnections(transitionId, [], [], timing, mode))
+      return withCustomText(data, composeTransitionHintFromConnections(transitionId, [], [], timing, mode, hintOptions))
     }
     const startHints: string[] = []
     const endHints: string[] = []
@@ -241,7 +252,7 @@ function resolveParameterHint(
       if      (edge.targetHandle === "startState") startHints.push(hint)
       else if (edge.targetHandle === "endState")   endHints.push(hint)
     }
-    return withCustomText(data, composeTransitionHintFromConnections(transitionId, startHints, endHints, timing, mode))
+    return withCustomText(data, composeTransitionHintFromConnections(transitionId, startHints, endHints, timing, mode, hintOptions))
   }
 
   if (node.type === "character-fx") {
@@ -409,6 +420,12 @@ function resolveBaseHint(
       return withCustomText(data, byMode(mode, getCompositionEffectPromptHint, getCompositionEffectTerm)(asStr(data.compositionEffect)))
     case "post-process-effects":
       return withCustomText(data, buildPostProcessHints(data.postProcess, mode).join(", "))
+    // Motion intensity: a Generation Settings node that a video node's
+    // Settings input takes as a prompt fragment (video only).
+    case "motion": {
+      const hint = MOTION_INTENSITY_HINTS[asStr(data.motion)]
+      return hint ? byMode(mode, hint.full, hint.compact) : ""
+    }
 
     // Free text authored by the user, not catalog copy — there is no shorter
     // professional form to swap in, so these are identical in both modes.

package/src/person.ts

@@ -1060,7 +1060,8 @@ export interface PersonValue {
   /** Specific age in years. Only consulted when `age === "age-custom"`. */
   customAge?: number
   /** Single id, or an array of up to 2 ids for mixed heritage (e.g.
-   *  ["slavic","mediterranean"] → "of mixed Slavic and Mediterranean heritage"). */
+   *  ["slavic","mediterranean"] → "of mixed Slavic Eastern European and
+   *  Mediterranean heritage"). */
   ethnicity?: string | ReadonlyArray<string>
   /** Regional / cultural aesthetic vibe (e.g. `"cali-beach"`, `"parisienne"`,
    *  `"kinshasa-sape"`). Composes with ethnicity, skin tone, hair, and
@@ -1238,16 +1239,31 @@ function normalizePickIds(value: unknown): string[] {
  */
 type PersonFragmentFor = (id: string | undefined | null) => string
 
+/**
+ * The heritage an ethnicity entry names, as a prompt-safe noun: its promptHint
+ * without the "of … descent" / "… heritage" wrapper ("of Mediterranean descent"
+ * → "Mediterranean"). NOT the short label — that is display copy for the
+ * picker grid ("Mediter.", "Pacific Isl.", "any", a bare "East"), which is what
+ * two picks used to put in the prompt ("of mixed Slavic and Mediter. heritage").
+ */
+function heritageNoun(id: string): string | undefined {
+  const noun = (getPerson(id)?.promptHint ?? "")
+    .trim()
+    .replace(/^of\s+/i, "")
+    .replace(/\s+(descent|heritage)$/i, "")
+    .trim()
+  return noun.length > 0 ? noun : undefined
+}
+
 function buildEthnicityFragment(value: unknown, fragmentFor: PersonFragmentFor): string {
-  const ids = normalizePickIds(value)
+  // "mixed" is itself the mixed-heritage pick; paired with a specific one it
+  // adds nothing, so the pair reads as that one.
+  const ids = normalizePickIds(value).filter((id, _, all) => all.length < 2 || id !== "mixed")
   if (ids.length === 0) return ""
   if (ids.length === 1) return fragmentFor(ids[0])
-  const labels = ids
-    .slice(0, 2)
-    .map((id) => getPerson(id)?.shortLabel ?? getPerson(id)?.label ?? "")
-    .filter((s): s is string => Boolean(s))
-  if (labels.length < 2) return fragmentFor(ids[0])
-  return `of mixed ${labels[0]} and ${labels[1]} heritage`
+  const nouns = ids.slice(0, 2).map(heritageNoun).filter((s): s is string => Boolean(s))
+  if (nouns.length < 2) return fragmentFor(ids[0])
+  return `of mixed ${nouns[0]} and ${nouns[1]} heritage`
 }
 
 /**