@nodaro/prompts 1.36.0 → 1.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/prompts",
-  "version": "1.36.0",
+  "version": "1.37.0",
   "description": "Nodaro's prompt-engineering layer — person/picker catalogs with prompt hints, identity-lock clauses, entity prompt builders, brand presets, and prompt/reference assembly shared by the Nodaro platform and SDK.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",

package/src/__tests__/creator-presets.test.ts

@@ -4,6 +4,7 @@ import { aspectRatioOptionsByKind, captionRoutesToRemotion, MODELS_WITH_REFERENC
 import { getFactoryPresets, type FactoryPreset } from "../factory-presets.js"
 import { assembleImageInput } from "../assemble-image-input.js"
 import { computeNodePrompt } from "../resolve-prompt.js"
+import { resolveReferenceTokens } from "../video-reference-resolver.js"
 import { NEUTRAL_PERSON, REALISM_FINISH, REALISM_PASS_INSTRUCTION, REALISM_SKIN, realismEmptyHands, realismViewpoint } from "../realism-wording.js"
 
 /** Words that name a recording or viewing device. Plural forms included. */
@@ -238,8 +239,8 @@ describe("Wave 1 — Realism & Authentic", () => {
   })
 
   it("every subject slot has a default naming an adult; every setting slot has a default", () => {
-    for (const id of REALISM_IDS) {
-      const text = allText(preset("generate-image", id).data)
+    for (const id of [...REALISM_IDS, ...UGC_IDS]) {
+      const text = allText(preset(id.split("/")[0]!, id).data)
       for (const m of text.matchAll(/\{subject([^{}]*)\}/g)) {
         expect(m[1], `${id}: {subject} needs a default`).toMatch(/\|\|/)
         expect(m[1]!.split("||")[1], `${id}: the default names an adult`).toMatch(ADULT)
@@ -362,3 +363,134 @@ describe("Wave 1 — Realism Audit", () => {
     expect(prompt.length).toBeLessThanOrEqual(2000)
   })
 })
+
+/** The prompt as a run sends it with nothing wired: slot defaults applied, reference tokens dropped to their labels. */
+const unwired = (text: string) =>
+  resolveReferenceTokens(resolveNodeRefs(text, new Map([["nothing-wired", ""]])), { image: 0, video: 0, audio: 0 }) ?? ""
+
+const UGC_IDS = [
+  "ugc-talking-head", "ugc-product-closer", "handheld-unboxing", "get-ready-with-me",
+  "street-qa", "reaction-shot", "acts-on-phone",
+].map((s) => `generate-video/${s}`)
+// The action is typing on a phone while looking down at it; its screen faces away.
+const PHONE_CLOSER_SENTENCE = "In the last seconds the person picks up a phone and looks down into its screen while typing on it for a moment, then looks back up at the viewer; the screen faces away from the camera."
+
+describe("Wave 2 — UGC & Creator", () => {
+  const group = () => getFactoryPresets("generate-video").filter((p) => p.group === "UGC & Creator")
+
+  it("ships exactly these seven, in order, on Seedance 2.5 at 9:16 and 720p with audio, 8 s except the 5 s answer and reaction, and no negativePrompt", () => {
+    const SHORT = ["generate-video/street-qa", "generate-video/reaction-shot"]
+    expect(group().map((p) => p.id)).toEqual(UGC_IDS)
+    for (const p of group()) {
+      expect(p.data, p.id).toMatchObject({ provider: "seedance-2-5", aspectRatio: "9:16", resolution: "720p", generateAudio: true })
+      expect(p.data.duration, p.id).toBe(SHORT.includes(p.id) ? 5 : 8)
+      expect(p.data.negativePrompt, p.id).toBeUndefined()
+    }
+  })
+
+  it("every prompt ends with the subtitle-free tail", () => {
+    for (const id of UGC_IDS)
+      expect((preset("generate-video", id).data.prompt as string).endsWith("Keep it subtitle-free, do not generate a watermark."), id).toBe(true)
+  })
+
+  it("names no device outside the one pinned sentence", () => {
+    // The one pinned sentence is the only text the scan skips: the phone closer, in one preset.
+    for (const id of UGC_IDS) {
+      let text = allText(preset("generate-video", id).data)
+      if (id === "generate-video/acts-on-phone") text = text.split(PHONE_CLOSER_SENTENCE).join(" ")
+      expect(text, id).not.toMatch(DEVICE_WORDS)
+    }
+    expect(preset("generate-video", "generate-video/acts-on-phone").data.prompt as string).toContain(PHONE_CLOSER_SENTENCE)
+  })
+
+  it("a default spoken line is one sentence with its numbers in words", () => {
+    let lines = 0
+    for (const id of UGC_IDS) {
+      for (const m of (preset("generate-video", id).data.prompt as string).matchAll(/\{line \|\| ([^{}]*)\}/g)) {
+        lines += 1
+        expect(m[1], id).toMatch(/^[^.!?]*[.!?]$/)
+        expect(m[1], id).not.toMatch(/\d/)
+      }
+    }
+    expect(lines).toBe(5)
+  })
+
+  it("labels every reference token, and reads whole with nothing wired", () => {
+    for (const id of UGC_IDS) {
+      const text = allText(preset("generate-video", id).data)
+      for (const m of text.matchAll(/\{(?:image|video|audio):\d+(:[^{}]*)?\}/gi)) expect(m[1], `${id}: ${m[0]} needs a label`).toBeTruthy()
+      const out = unwired(text)
+      expect(out, id).not.toMatch(/ {2}/)
+      expect(out, id).not.toMatch(/[{}]/)
+      expect(out, id).not.toMatch(/\bfrom\s+[.,;:!?]/)
+    }
+  })
+
+  it("the rows that carry a spoken line tell the user to type it with numbers as words", () => {
+    for (const id of UGC_IDS) {
+      const p = preset("generate-video", id)
+      if (/\{line \|\|/.test(p.data.prompt as string)) expect(p.description, id).toMatch(/numbers as words/)
+    }
+    expect(preset("generate-video", "generate-video/street-qa").description).toContain("staged")
+  })
+})
+
+const WRITER_CLOSER = "closer — the last line. It ends on one simple physical action the speaker can do on camera."
+const closerParts = (s: string) => s.split("\n\n").filter((part) => part.startsWith("closer —"))
+
+describe("Wave 2 — UGC Monologue Writer", () => {
+  const p = () => preset("llm-chat", "llm-chat/ugc-monologue-writer")
+  it("sits in Writing & Marketing after Hook Generator, set to Claude Opus 5.5 at high effort, at temperature 0.8 and 2048 tokens", () => {
+    expect(p().group).toBe("Writing & Marketing")
+    expect(p().data).toMatchObject({ llmModel: "claude-opus-5.5", reasoningEffort: "high", temperature: 0.8, maxTokens: 2048 })
+    const ids = getFactoryPresets("llm-chat").map((x) => x.id)
+    expect(ids[ids.indexOf("llm-chat/hook-generator") + 1]).toBe("llm-chat/ugc-monologue-writer")
+  })
+  it("pins the closer to one simple physical action", () => {
+    const s = p().data.systemPrompt as string
+    expect(s.length).toBeLessThanOrEqual(10_000)
+    expect(s).toContain("at most 8 words")
+    for (const k of ['"hook"', '"beats"', '"closer"']) expect(s).toContain(k)
+    expect(s).not.toMatch(/per second/i)
+    expect(closerParts(s)).toEqual([WRITER_CLOSER])
+  })
+})
+
+describe("UGC Monologue Writer — Hebrew paragraph", () => {
+  it("carries the Hebrew craft paragraph and still passes the Writer's checks", () => {
+    const s = preset("llm-chat", "llm-chat/ugc-monologue-writer").data.systemPrompt as string
+    expect(s).toContain("When the script is in Hebrew:")
+    expect(s.indexOf("When the script is in Hebrew:")).toBeLessThan(s.indexOf("Return only this JSON"))
+    expect(s.match(/at most 8 words/g)?.length).toBe(2)
+    expect(s).not.toMatch(/per second/i)
+    expect(closerParts(s)).toEqual([WRITER_CLOSER])
+    expect(s.length).toBeLessThanOrEqual(10_000)
+  })
+})
+
+describe("Wave 2 — Phone Footage Look", () => {
+  it("is a Restyle Look on Wan 2.7 VideoEdit that keeps the source's own sound and length, whose description warns it is for b-roll, with the finish sentence and no device in its text", () => {
+    const p = preset("video-to-video", "video-to-video/phone-footage-look")
+    expect(p.group).toBe("Restyle Looks")
+    expect(leversOf(p.data, "promptPrefix", "negativePrompt")).toEqual({
+      provider: "wan-videoedit", v2vResolution: "720p", videoEditDuration: "0", audioSetting: "origin", promptExtend: false,
+    })
+    expect(p.description).toContain("b-roll")
+    expect(p.description).toContain("not for talking clips")
+    expect(p.data.promptPrefix as string).toContain(REALISM_FINISH)
+    expect((p.data.negativePrompt as string).length).toBeLessThanOrEqual(500)
+    expect(allText(p.data)).not.toMatch(DEVICE_WORDS)
+  })
+})
+
+describe("Wave 2 — UGC Ad script style guide", () => {
+  it("keeps its name and slot, is set to Claude Opus 5.5 at high effort, and asks for the payload first, spoken texture, the exact brand, digits and only the user's figures — without the JSON shape", () => {
+    const p = preset("generate-script", "generate-script/ugc-ad")
+    expect(p.name).toBe("UGC Ad (Hook–Show–Proof–Opinion)")
+    expect(p.data).toMatchObject({ llmModel: "claude-opus-5.5", reasoningEffort: "high" })
+    const g = p.data.styleGuide as string
+    expect(g).toContain("{product}")
+    for (const s of ["claim the viewer can check", "contractions", "exactly as given", "as digits", "Use only figures the user supplies", "take the Proof from the topic"]) expect(g).toContain(s)
+    expect(g).not.toContain('"hook"')
+  })
+})

package/src/__tests__/factory-presets.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest"
 import { FACTORY_PRESETS, getFactoryPresets, groupFactoryPresets } from "../factory-presets.js"
-import { extractPresetData, PRESET_APPLY_CLEAR_KEYS } from "@nodaro/shared"
+import { extractPresetData, LLM_MODEL_IDS, PRESET_APPLY_CLEAR_KEYS } from "@nodaro/shared"
 import { COMPOSER_PLAN_MAP, COMPOSER_PLAN_FIELDS } from "@nodaro/shared"
 import { STYLE_IDS } from "../index.js"
 import { joinPromptParts } from "../resolve-prompt.js"
@@ -54,6 +54,13 @@ describe("FACTORY_PRESETS", () => {
     }
   })
 
+  it("names an LLM only by an id the routes accept", () => {
+    for (const p of Object.values(FACTORY_PRESETS).flat()) {
+      if (p.data.llmModel === undefined) continue
+      expect(LLM_MODEL_IDS, `${p.id}: llmModel ${String(p.data.llmModel)}`).toContain(p.data.llmModel as never)
+    }
+  })
+
   it("generate-image factory presets use a known image provider", () => {
     for (const p of getFactoryPresets("generate-image")) {
       if (p.data.provider !== undefined) {

package/src/__tests__/node-prompt-fields.test.ts

@@ -16,10 +16,10 @@ describe("nodeSupportsPromptAffixes", () => {
     expect(nodeSupportsPromptAffixes("not-a-node")).toBe(false)
     expect(nodeSupportsPromptAffixes(undefined)).toBe(false)
   })
-  it("PROMPT_AFFIX_NODE_TYPES is exactly the registry minus opt-outs (41 types)", () => {
+  it("PROMPT_AFFIX_NODE_TYPES is exactly the registry minus opt-outs (42 types)", () => {
     const expected = Object.entries(NODE_PROMPT_FIELDS).filter(([, s]) => s.affixes !== false).map(([t]) => t)
     expect([...PROMPT_AFFIX_NODE_TYPES].sort()).toEqual(expected.sort())
-    expect(PROMPT_AFFIX_NODE_TYPES.size).toBe(41)
+    expect(PROMPT_AFFIX_NODE_TYPES.size).toBe(42)
   })
   it("getPromptFields still resolves", () => expect(getPromptFields("generate-image")?.prompt).toBe("prompt"))
 })

package/src/factory-presets/generate-video.ts

@@ -1,5 +1,18 @@
 import type { FactoryPreset } from "./types.js"
 
+// ── UGC & Creator: shared sentences, kept word for word ─────────────────
+const UGC_TAIL = "Keep it subtitle-free, do not generate a watermark."
+const UGC_PAUSE = "A short natural pause before the first word and after the last."
+const ugcSpeech = (line: string): string =>
+  `The person says, in a natural American accent, lively and conversational, quicker on connecting words and slower on numbers: "{line || ${line}}"`
+/** Seedance 2.5, vertical, 8 s, 720p with audio — pinned, so every surface renders and bills the same clip. */
+const UGC_VIDEO = { provider: "seedance-2-5", aspectRatio: "9:16", duration: 8, resolution: "720p", generateAudio: true } as const
+/** The same clip at 5 s, for a one-line answer or a quick reaction that 8 s would leave mostly silent. */
+const UGC_SHORT_VIDEO = { ...UGC_VIDEO, duration: 5 } as const
+const ugcPrompt = (...parts: string[]): string => [...parts, UGC_TAIL].join(" ")
+const TALKING_AT_HOME =
+  "{image:1:person} talks straight to the viewer at eye level at home, face and shoulders close, the framing a little crooked, deep focus, plain colour, a faint natural sway;"
+
 export const GENERATE_VIDEO_PRESETS: readonly FactoryPreset[] = [
   // ── Camera Moves (composable cinematography fragments) ───────────────────
   {
@@ -1135,4 +1148,62 @@ export const GENERATE_VIDEO_PRESETS: readonly FactoryPreset[] = [
         "Keep everything else in the clip unchanged: the same people, motion, framing and timing. Keep it subtitle-free, do not generate a watermark.",
     },
   },
+
+  // ── UGC & Creator (everyday talking-to-camera clips) ──────────────────────
+  {
+    id: "generate-video/ugc-talking-head",
+    name: "UGC Talking Head",
+    description: "Talks to the viewer at home — type the line to be spoken; write numbers as words.",
+    group: "UGC & Creator",
+    data: { ...UGC_VIDEO, prompt: ugcPrompt(`${TALKING_AT_HOME} hands move naturally while talking and hold nothing.`, ugcSpeech("I cut my weekly reporting from three hours to twenty minutes."), UGC_PAUSE) },
+  },
+  {
+    id: "generate-video/ugc-product-closer",
+    name: "UGC Product Closer",
+    description: "Holds your product up while talking — wire a face photo and a product photo; type the line, numbers as words.",
+    group: "UGC & Creator",
+    data: { ...UGC_VIDEO, prompt: ugcPrompt(`${TALKING_AT_HOME} hands move naturally while talking and hold nothing until the first word.`, "As they say the first word, one hand lifts {image:2:product} into view and holds it up beside their face, its front turned to the viewer, while they talk; the other hand keeps moving naturally.", ugcSpeech("Honestly, this is the one I keep coming back to."), UGC_PAUSE, "After the last word, they lower the product with a small smile.") },
+  },
+  {
+    id: "generate-video/handheld-unboxing",
+    name: "Handheld Unboxing",
+    description: "Opens a box with their own hands and reveals your product — wire a face photo and a product photo.",
+    group: "UGC & Creator",
+    data: { ...UGC_VIDEO, prompt: ugcPrompt(
+      "Close on a table at home, seen the whole time through the eyes of {image:1:person} as they look down at it.",
+      "From the first moment their own two hands are on the lid of a plain box, both forearms coming up from the bottom of the frame.",
+      "One adult's left and right hand, no one else's; only their hands and forearms are seen.",
+      "They open the box at once and lift out {image:2:product} with both hands, clear of the box by the middle of the clip.",
+      "Until the end they hold it up in front of them, the whole of it in frame, tilting it slowly in the light with the same side toward them.",
+      "Daylight, deep focus from their hands to the background, plain colour, the framing a little crooked, a faint natural sway.",
+    ) },
+  },
+  {
+    id: "generate-video/get-ready-with-me",
+    name: "Get Ready With Me",
+    description: "Gets ready at a mirror while chatting — type the line, numbers as words.",
+    group: "UGC & Creator",
+    data: { ...UGC_VIDEO, prompt: ugcPrompt("{image:1:person} at a bathroom mirror applies a little makeup while chatting to the viewer, everyday light, deep focus, plain colour.", ugcSpeech("Two minutes and I'm ready to go."), UGC_PAUSE) },
+  },
+  {
+    id: "generate-video/street-qa",
+    name: "Street-Style Q&A",
+    description: "A staged street-interview look — cast it yourself; type a short answer, numbers as words.",
+    group: "UGC & Creator",
+    data: { ...UGC_SHORT_VIDEO, prompt: ugcPrompt("A staged street-interview look: {image:1:person} stands on a sidewalk answering an interviewer who stays out of frame, beside the viewer; only the interviewer's hand is seen, holding a plain microphone out toward them from a lower corner of the frame, passers-by soft in the background.", "Their eyes stay on the interviewer the whole time, off to the side the microphone comes from.", "The answer starts at once, with no wait before the first word.", ugcSpeech("I'd say about twenty minutes a day, tops."), "After the last word, a small laugh and a shrug, eyes still on the interviewer.") },
+  },
+  {
+    id: "generate-video/reaction-shot",
+    name: "Reaction Shot",
+    description: "A quick reaction to something out of frame.",
+    group: "UGC & Creator",
+    data: { ...UGC_SHORT_VIDEO, prompt: ugcPrompt("{image:1:person} sits on a couch at home, a cushion and a lamp behind them, looking off to one side at something just out of frame; at eye level, the framing a little crooked, deep focus, plain colour, a faint natural sway.", "Almost at once, what they see catches them by surprise: their eyes go wide, a hand flies to their mouth and they break into a laugh, their shoulders shaking.", "Still laughing, they glance briefly at the viewer, then look back off to the side, shaking their head.", "A short exclamation at most.") },
+  },
+  {
+    id: "generate-video/acts-on-phone",
+    name: "Acts on Phone, Screen Hidden",
+    description: "Taps a phone whose screen faces away — type the line, numbers as words.",
+    group: "UGC & Creator",
+    data: { ...UGC_VIDEO, prompt: ugcPrompt(`${TALKING_AT_HOME} hands move naturally while talking and hold nothing until the last seconds.`, ugcSpeech("That's the whole setup, and it took me five minutes."), UGC_PAUSE, "In the last seconds the person picks up a phone and looks down into its screen while typing on it for a moment, then looks back up at the viewer; the screen faces away from the camera.") },
+  },
 ]

package/src/factory-presets/text.ts

@@ -98,6 +98,27 @@ export const LLM_CHAT_PRESETS: readonly FactoryPreset[] = [
       temperature: 0.9,
     },
   },
+  {
+    id: "llm-chat/ugc-monologue-writer",
+    name: "UGC Monologue Writer",
+    description: "A talking-to-camera script as JSON: hook, beats, closer.",
+    group: "Writing & Marketing",
+    data: {
+      systemPrompt:
+        "You write the script of a short vertical video in which one person talks straight to the camera about a product, a site or an idea. Return it as JSON with three parts.\n\n" +
+        "hook — the first line: one short spoken clause of at most 8 words. It leads with the payload the viewer can check (a number, a price, a time saved, a before and after, a named result) and opens on the claim itself — no greeting, no filler, no introduction first.\n\n" +
+        "beats — one beat per point the video makes, in order. When the user lists screenshots, write one beat per screenshot, in the same order. The first beat names the product. Every beat is one short spoken sentence a person says in one easy breath; nothing is crammed in.\n\n" +
+        "closer — the last line. It ends on one simple physical action the speaker can do on camera.\n\n" +
+        "Leave room for a short pause at the start and the end of each clip. Sound said, not written: contractions, one connecting word, sentences of mixed length, and one live, imperfect moment such as a small self-correction or an aside. Carry emphasis with word choice and repetition, never with capitals or stage directions. Write only what is spoken: no speaker names, brackets, emoji or sound effects.\n\n" +
+        "Spell the brand exactly as the user gives it, every time. Write numbers as digits, except inside the brand's own name. Use only figures the user supplies. Write in the language the user writes in.\n\n" +
+        "When the script is in Hebrew: write spoken Israeli Hebrew, the way a person talks to their phone, not ad copy. Every first-person verb and adjective agrees with the speaker's gender, and never switches. Speak to the viewer in the plural (\"תנסו\"), so the viewer is not given a gender. Keep sentences short. Write numbers and prices as digits (\"3\", \"₪49\", \"20%\"). Keep the brand exactly as given, usually in Latin letters; when a Hebrew prefix joins it, use a hyphen (\"ב-Planwell\"). Leave out vowel points. The hook is at most 8 words, as in English, a word with a joined prefix counting as one word, and opens on the result, the number or the contrast — never on a greeting or a filler word.\n\n" +
+        "Return only this JSON, no code fences, no commentary:\n{\"hook\": \"…\", \"beats\": [\"…\", \"…\"], \"closer\": \"…\"}",
+      llmModel: "claude-opus-5.5",
+      reasoningEffort: "high",
+      temperature: 0.8,
+      maxTokens: 2048,
+    },
+  },
 
   // ── Utility ──────────────────────────────────────────────────────────────
   {
@@ -216,8 +237,10 @@ export const GENERATE_SCRIPT_PRESETS: readonly FactoryPreset[] = [
       sceneCount: 4,
       targetLength: 30,
       structure: "freeform",
+      llmModel: "claude-opus-5.5",
+      reasoningEffort: "high",
       styleGuide:
-        "Selfie-style UGC testimonial for {product}. Structure: Hook (stop the scroll) → Show (the product in real use) → Proof (a concrete result or detail) → Opinion (a genuine personal take). A real person sharing a real opinion — first-person, natural, unpolished. Short spoken sentences for clean lip-sync; no salesy voiceover.",
+        "Selfie-style UGC testimonial for {product}. Open on the payload: the first spoken line is a short claim the viewer can check — a number, a price, a time saved, a before and after — never a greeting or an introduction. Then Show (the product in real use) → Proof (a concrete result or detail) → Opinion (a genuine personal take). Sound said, not written: contractions, sentences of mixed length, one small aside; carry emphasis with word choice, never capitals or stage directions. Spell the brand exactly as given and write numbers as digits. Use only figures the user supplies, in what is said and what is shown, and take the Proof from the topic. Short spoken sentences for clean lip-sync; no salesy voiceover.",
     },
   },
 

package/src/factory-presets/video-edit.ts

@@ -1,4 +1,5 @@
 import type { FactoryPreset } from "./types.js"
+import { REALISM_FINISH } from "../realism-wording.js"
 
 export const VIDEO_TO_VIDEO_PRESETS: readonly FactoryPreset[] = [
   {
@@ -43,6 +44,21 @@ export const VIDEO_TO_VIDEO_PRESETS: readonly FactoryPreset[] = [
     group: "Restyle Looks",
     data: { provider: "wan", promptPrefix: "Restyle as a flowing watercolor animation with soft washes, bleeding edges, and visible paper texture. Keep the original motion and composition.", negativePrompt: "photorealistic, harsh edges, blurry, flickering" },
   },
+  {
+    id: "video-to-video/phone-footage-look",
+    name: "Phone Footage Look",
+    description: "Everyday handheld look for b-roll — it re-renders faces, so not for talking clips.",
+    group: "Restyle Looks",
+    data: {
+      provider: "wan-videoedit",
+      v2vResolution: "720p",
+      videoEditDuration: "0",
+      audioSetting: "origin",
+      promptExtend: false,
+      promptPrefix: `Keep everything in this clip as it is — the same people, objects, colours and light — and only make it look like everyday handheld digital video, left unedited. ${REALISM_FINISH} The edges of the frame keep the light they have in the clip, and each moment keeps the brightness it has in the clip, from the first frame to the last. Preserve the original motion, composition and timing.`,
+      negativePrompt: "cinematic grade, shallow depth of field, glow, skin smoothing, flickering, light leaks, flare, coloured bands at the edges of the frame, colour cast, shifted colours, oversaturated colours, vintage film look, overexposure, pulsing brightness, heavy grain",
+    },
+  },
 ]
 
 export const ADD_CAPTIONS_PRESETS: readonly FactoryPreset[] = [

package/src/node-prompt-fields.ts

@@ -89,6 +89,8 @@ export const NODE_PROMPT_FIELDS: Readonly<Record<string, PromptFieldSpec>> = {
   "cinematic-avatar": { prompt: "prompt", media: "video", inline: true },
   "video-sfx": { prompt: "prompt", negative: "negativePrompt", promptLabel: "Sound prompt", media: "audio", inline: true },
   "video-retake": { prompt: "prompt", promptLabel: "Retake prompt", media: "video", inline: true },
+  // Video Mask (SAM 3) — the subject to track, like Generate Mask's "what to mask".
+  "video-mask": { prompt: "prompt", promptLabel: "What to mask", media: "video", inline: true },
   // ── Audio / music ──
   "generate-music": { prompt: "prompt", media: "audio", inline: true },
   "suno-generate": { prompt: "prompt", media: "audio", inline: true },